Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@cmd/gomodel/docs/swagger.json`:
- Around line 135-138: The OpenAPI parameter definition for "stream" is declared
as "type": "string" but the backend uses LogQueryParams with Stream *bool;
update the swagger parameter for name "stream" (in: query) to use "type":
"boolean" so the spec matches the LogQueryParams boolean field and generated
clients will send boolean values.

In `@internal/admin/dashboard/static/css/dashboard.css`:
- Around line 1207-1211: Replace the deprecated usage of "word-break:
break-word" in the .audit-json-body selector by removing that property and
relying on "overflow-wrap: anywhere" (already present) to achieve the same
behavior; update the .audit-json-body rule to drop "word-break: break-word" and
keep only "white-space: pre-wrap" and "overflow-wrap: anywhere" so you eliminate
the deprecated property while preserving intended wrapping.
- Around line 1377-1384: Update the .chat-content CSS: remove the unnecessary
quotes around the Inter font name in the font-family list and replace the
deprecated property word-break: break-word with overflow-wrap: break-word (keep
other properties like white-space and line-height intact); locate these changes
in the .chat-content rule to ensure font-family becomes Inter, -apple-system,
BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif and word wrapping is handled
via overflow-wrap: break-word.

In `@internal/admin/dashboard/static/js/modules/audit-list.js`:
- Around line 70-75: statusCodeClass currently treats null/undefined/non-numeric
inputs as success; update the statusCodeClass function to first detect invalid
or non-numeric statusCode (e.g., using Number.isFinite or typeof checks) and
return a distinct class like 'status-unknown' (or 'status-neutral') for those
cases before the numeric comparisons for 500/400/300, so unknown states are not
rendered as 'status-success'.

In `@internal/admin/dashboard/templates/index.html`:
- Around line 347-350: The filter inputs rely only on placeholders and lack
accessible names; add explicit labels or aria-label attributes and corresponding
ids to each control (the inputs bound to auditSearch, auditModel, auditProvider,
auditPath and any similar controls in the 354-379 range) so screen readers and
voice-control tools can identify them, ensuring you either add <label for="...">
elements pointing to new id attributes or set descriptive aria-label values
(e.g., "Search by request ID", "Model filter", "Provider filter", "Path filter")
and keep the existing x-model and `@input.debounce.300ms`="fetchAuditLog(true)"
bindings intact.
- Around line 397-404: The icon-only button with class
"audit-conversation-trigger" relies on title for accessibility but needs an
explicit accessible name; add an aria-label (e.g., aria-label="Open
conversation") to the button element alongside the existing title, ensuring it
is present on the element that calls openConversation(entry,
$el.closest('details'), true) and visible when canShowConversation(entry) is
true; keep the same descriptive text as the title (or use your localization
helper) so screen readers have a clear name for the control.

In `@internal/admin/handler.go`:
- Around line 407-444: AuditConversation currently parses limit with
strconv.Atoi and passes it to h.auditReader.GetConversation without validating
bounds; update AuditConversation to validate the parsed limit (after
strconv.Atoi) and return a core.NewInvalidRequestError for out-of-range values
(e.g., enforce limit >= 1 and <= 1000 or another agreed-upon max) before calling
h.auditReader.GetConversation, mentioning the parameter name "limit" in the
error; reference the AuditConversation function, the limit variable,
strconv.Atoi, and the GetConversation call when making the change.

In `@internal/auditlog/reader_mongodb.go`:
- Around line 317-403: The three functions GetLogByID, findByResponseID, and
findByPreviousResponseID repeat the same anonymous scan struct; extract that
into a shared named type (e.g., mongoLogRow) with the existing bson tags and add
a helper method (e.g., toLogEntry) to convert mongoLogRow -> *LogEntry, then
replace the inline struct declarations in GetLogByID, findByResponseID, and
findByPreviousResponseID with the new mongoLogRow type and call toLogEntry
before returning.

In `@internal/auditlog/reader_sqlite.go`:
- Around line 258-275: The JSON extraction in findByResponseID (and any
analogous lookup such as the method that queries json_extract(data,
'$.request_body.previous_response_id')) will cause full table scans on large
datasets; add SQLite expression indexes for these JSON paths (e.g., an index on
json_extract(data, '$.response_body.id') and one on json_extract(data,
'$.request_body.previous_response_id')) to speed lookups, and include their
CREATE INDEX statements in your migration or DB initialization so the queries in
SQLiteReader (findByResponseID and the previous-response lookup) use the
indexes.
- Around line 167-190: The loop that builds the thread currently prepends
entries using append([]*LogEntry{parent}, thread...), causing O(n²) behavior;
change it to append parents at the end (thread = append(thread, parent)) while
still marking seen[parent.ID] and advancing current = parent, and then rely on
the existing sort-by-timestamp step (or reverse once after the loop) to produce
the final chronological order; update any logic that assumes the list was built
front-to-back (e.g., usages of thread, extractPreviousResponseID,
findByResponseID, anchor, limit) to accommodate the new append-then-sort/reverse
approach.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@cmd/gomodel/docs/swagger.json`:
- Around line 715-727: Update the OpenAPI 2.0 declarations: for the
/v1/chat/completions operation replace the single invalid produces entry "json
text/event-stream" with two separate produces entries "application/json" and
"text/event-stream"; for the /v1/files/{id}/content response change the response
schema type from "string" to "file" so the binary download is correctly
declared; and for the POST operation on /v1/batches/{id}/cancel add an
appropriate consumes array (e.g., "application/json" or the actual request
content type) to the operation object so it conforms to Swagger 2.0
requirements.

In `@internal/admin/dashboard/static/css/dashboard.css`:
- Around line 1135-1150: The stylesheet uses a hardcoded max-height: 2200px for
.audit-entry[open] .audit-entry-details which can make the expand animation
jumpy for taller content; replace this by removing the arbitrary large
max-height and either (a) set a reasonable bounded value on .audit-entry-details
and document the limitation, or (b) implement a JS-driven height transition: on
open, measure the element's scrollHeight and apply that value as an inline
max-height, then remove or reset it after the transition to allow natural
sizing; update the logic around the .audit-entry-details and .audit-entry[open]
.audit-entry-details selectors to use the JS-managed inline style for smooth
animations on large entries.

In `@internal/admin/dashboard/static/js/modules/audit-list.js`:
- Around line 102-110: The copyAuditJSON function currently only logs errors to
the console; update its catch block to provide brief user-visible feedback on
failure by either (a) changing the originating button text/icon temporarily
(e.g., set button.innerText = 'Copy failed' then restore after ~2s) or (b)
invoking an existing toast/notification helper (e.g., call showToast or dispatch
a custom 'notify' event) so the user sees the failure; keep the console.error
for debugging, ensure you reference copyAuditJSON and formatJSON in your change,
and restore any temporary UI change after a short timeout.
- Around line 63-68: The condition in formatDurationNs redundantly checks both
ns == null and ns === undefined; replace the two-part check with a single loose
equality check (ns == null) to cover null and undefined, keeping the rest of the
function intact so it still returns '-' for missing values and formats values
for µs/ms/s as before; update the method name formatDurationNs accordingly.

In `@internal/admin/dashboard/templates/index.html`:
- Line 479: The overlay div with class "conversation-overlay" (the element using
x-show="conversationOpen" and `@click`="closeConversation()") should be marked as
non‑interactive for assistive tech; add aria-hidden="true" to that element so
screen readers ignore the visual backdrop while preserving its click behavior to
close the conversation.
- Around line 480-505: Add ARIA attributes to the conversation drawer element
and its controls to treat it as an accessible dialog: on the aside with class
"conversation-drawer" (which uses conversationOpen and closeConversation()) add
role="dialog", aria-modal="true" and bind aria-hidden based on conversationOpen;
add aria-labelledby pointing to the <h3> header (or give the header an id) and
aria-describedby pointing to the main content container (the conversation-thread
or the appropriate empty-state elements) so screen readers announce the title
and contents; ensure the Close button has an accessible name (aria-label) and
that focus management is implemented when opening/closing the drawer (set
initial focus to the dialog or first focusable element and return focus to the
trigger on close) while keeping existing bindings like conversationMessages,
conversationError, conversationLoading and conversationAnchorID intact.

In `@internal/auditlog/reader_mongodb.go`:
- Around line 36-51: The toLogEntry mapping in mongoLogRow returns LogEntry.Data
verbatim, risking leakage of sensitive headers; update mongoLogRow.toLogEntry to
run a redaction pass over Data's "request_headers" and "response_headers" keys
before returning (e.g., call a helper like redactSensitiveHeaders or similar) to
remove/obfuscate Authorization, Cookie, X-API-Key and other sensitive header
names while leaving other fields intact; ensure the helper is deterministic and
handles nil/missing keys and non-map values gracefully so all legacy/untrusted
rows are sanitized prior to creating the LogEntry.

---

Duplicate comments:
In `@internal/auditlog/reader_sqlite.go`:
- Around line 258-294: The JSON path lookups in findByResponseID and
findByPreviousResponseID cause full table scans; add persistent expression
indexes for json_extract(data, '$.response_body.id') and json_extract(data,
'$.request_body.previous_response_id') in your DB initialization/migration so
those queries use indexes (create indexes if not exists, e.g.,
idx_audit_logs_response_id and idx_audit_logs_prev_response_id) and ensure the
migration runs before these reader methods are used.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@internal/admin/dashboard/static/js/modules/audit-list.js`:
- Around line 12-35: fetchAuditLog can be subject to race conditions where a
slower earlier response overwrites a newer one; add a simple in-flight ordering
guard by introducing a monotonically-incremented request token (e.g.
this.auditFetchToken or this._auditRequestId) that you increment at the start of
fetchAuditLog, capture into a local variable, and only apply the response (and
error fallback) to this.auditLog if the captured token still matches the
instance token; implement the check before assigning this.auditLog in both the
success and catch paths so out-of-order responses are ignored.

In `@internal/auditlog/reader_mongodb.go`:
- Around line 198-214: GetLogs is returning row.Data directly from
facetResult.Data which bypasses redaction and can leak sensitive headers; update
the construction of LogEntry in GetLogs to pass row.Data through the existing
redaction helpers (e.g., call sanitizeLogData(row.Data) or use toLogEntry(row)
so the Data field is the sanitized result) before assigning to LogEntry.Data,
ensuring sensitive headers (Authorization, Cookie, X-API-Key, etc.) are removed.

---

Outside diff comments:
In `@internal/admin/dashboard/static/js/dashboard.js`:
- Around line 79-107: The init() routine parses the current route but only
triggers fetchAuditLog(true) on popstate, so a direct first-load to the "audit"
route shows no data; after parsing the route (using this._parseRoute) and
setting this.page, add a call to this.fetchAuditLog(true) when page === 'audit'
(similar to how usageMode and renderChart are handled) so initial loads of the
audit route fetch data immediately before returning from init().

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@internal/auditlog/reader_mongodb.go`:
- Around line 215-290: GetConversation currently walks parent/child links with
repeated DB calls (via findByResponseID and findByPreviousResponseID) which is
correct but can be optimized; replace or add an alternative implementation that
uses a single MongoDB aggregation with $graphLookup to fetch the full thread
around the anchor ID (using the same link fields extracted by
extractPreviousResponseID/extractResponseID) up to
clampConversationLimit(limit), then sort and map results into the same
ConversationResult shape, preserving cycle-safety and redaction by reusing
toLogEntry() or existing mapping logic.
- Around line 204-210: The code currently compares mongo.ErrNoDocuments using
`err == mongo.ErrNoDocuments` after calling
r.collection.FindOne(...).Decode(&row); change these to use errors.Is(err,
mongo.ErrNoDocuments) for robust error matching (import the "errors" package if
not already). Update the same pattern wherever similar checks occur (the other
occurrences in the file around the code handling queries at the spots
referenced, e.g., the checks near lines 315 and 331) so all mongo.ErrNoDocuments
comparisons use errors.Is.

---

Duplicate comments:
In `@internal/admin/dashboard/static/js/modules/audit-list.js`:
- Around line 26-35: Move the staleness guard so you check "if (requestToken !==
this.auditFetchToken) return;" immediately after the fetch and before calling
this.handleFetchResponse, to avoid an older response changing auth state; keep
calling this.handleFetchResponse only for non-stale responses. After parsing
payload (const payload = await res.json()), set "if (requestToken !==
this.auditFetchToken) return;" again and then assign this.auditLog = payload ||
{}; and ensure this.auditLog.entries = Array.isArray(this.auditLog.entries) ?
this.auditLog.entries : []; so entries is normalized to an array and stale
responses never flip authError/needsAuth in handleFetchResponse.