@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.10

package/server/lib/session-turn-pages/DOCUMENTATION.md

@@ -4,7 +4,7 @@
 
 OpenChamber-owned turn-window pagination and anchor reconcile for session messages.
 
-1. **Turn pages** — clients request the last N **authored user turns** (default 3) rather than a raw message count. The host loops official OpenCode `session.messages` pages (`limit` / `before` / `x-next-cursor`) until the turn budget is met or history is exhausted.
+1. **Turn pages** — clients request the last N **authored user turns** (default 3) rather than a raw message count. The host loops OpenCode v2 `message.list` pages (first page `limit` + `order=desc`; continuation `limit` + `cursor` from the previous body `cursor.next` — upstream rejects `order` together with `cursor` with 400) until the turn budget is met or history is exhausted.
 2. **Anchor reconcile** — after SSE reconnect, clients request the gap from a stable turn-boundary anchor to the current head. The host scans newest→older, returns chronological gap records (including the anchor's overlap turn), and paginates via host-owned continuation tokens with page/byte/total budgets.
 
 Exposed as:
@@ -16,7 +16,7 @@ Exposed as:
 
 ## Why this exists
 
-Official OpenCode pagination is message-count based and uses **opaque** cursors (not message ids). Each upstream page is chronological **old→new** (including the latest slice). UI prepend/load-more needs a stable turn boundary so synthetic loop messages, subtasks, and compaction rows do not consume the turn budget. This module aggregates upstream pages on the host, returns chronological records, and exposes a continuous **host-owned opaque cursor** that points just before the earliest returned authored user.
+Official OpenCode pagination is message-count based and uses **opaque** cursors (not message ids). v2 pages arrive **newest-first**; `fetchPage` reverses each page to chronological **old→new** before aggregation. UI prepend/load-more needs a stable turn boundary so synthetic loop messages, subtasks, and compaction rows do not consume the turn budget. This module aggregates upstream pages on the host, returns chronological records, and exposes a continuous **host-owned opaque cursor** that points just before the earliest returned authored user.
 
 ## Scope
 
@@ -34,7 +34,7 @@ Official OpenCode pagination is message-count based and uses **opaque** cursors
 | `scanLimit` | **omitted** | `10..200` when present | Optional override only. Host→OpenCode local page size; when omitted it resolves to `_inner_scanLimit`. Clients should omit this. |
 | `before` | omitted | opaque string ≤ 8192 chars | Resume older history: host cursor (`oc1.…`) or raw OpenCode SDK cursor on first page |
 | `directory` | omitted | path string | Forwarded to directory-scoped OpenCode client |
-| `includeReasoning` | omitted (include) | strict `'false'` only disables | OpenChamber projection control. When `'false'`, drop `type=reasoning` parts from turn-page / reconcile / exact responses after other projections. Missing or any other value keeps existing behavior (slim reasoning identity on turn pages; full parts on reconcile/exact). **Never forwarded to OpenCode.** Same contract on transcript-cache reads, official `session.messages` list proxy, and event SSE/WS send boundaries — see `event-stream/reasoning-projection.js`. |
+| `includeReasoning` | omitted (include) | strict `'false'` only disables | OpenChamber projection control. When `'false'`, drop `type=reasoning` parts from turn-page / reconcile / exact responses. Host order is **normalize native SessionMessageInfo → slim/L1 bounds → reasoning strip** so `content`/`text` carriers cannot rebuild filtered parts or leak through `info` expansion. Missing or any other value keeps existing behavior (slim reasoning identity on turn pages; full parts on reconcile/exact). **Never forwarded to OpenCode.** Same contract on transcript-cache reads, official `session.messages` list proxy, and event SSE/WS send boundaries — see `event-stream/reasoning-projection.js`. |
 
 Invalid `turns`, explicit invalid `scanLimit`, or `before` (malformed/stale host token, oversize) → HTTP 400.
 
@@ -66,7 +66,7 @@ Success `200`:
 }
 ```
 
-- `records`: chronological oldest → newest, including intermediate non-boundary rows (synthetic, tools, subtask, compaction) inside the window.
+- `records`: chronological oldest → newest, including intermediate non-boundary rows (synthetic, tools, subtask, compaction) inside the window. Host projection drops v2 **control** SessionMessage rows (`idle`, `model-switched`, `agent-selected`, `agent-switched`, `location-switched`) so they never reach ChatMessage as empty Assistant headers. Native assistants project `content[]` once (never also top-level `text` when `content` is present). Wire `model.id` becomes domain `modelID`; `finish`/`error` on failed assistants (e.g. `provider.auth` 401) are preserved.
 - `turnCount`: count of authored user boundaries in `records`.
 - `cursor`: host-owned opaque token for the next `before=` request; `null` when `complete` is true. The token represents the position **just before** the earliest returned authored user (so the client can load older history without overlap).
 - `complete`: `upstreamComplete && selected.length === accumulated.length`. True when upstream history is exhausted **and** `selectTurnRecords` did not trim any older scanned rows (nothing left for the client). When the scan window held more than N turns and older rows were trimmed, or when upstream stopped on a full page with a missing `nextCursor` (suspicious truncation), `complete` stays `false` with a `cursor` so the client can fetch / retry.
@@ -82,7 +82,7 @@ Every turn-page response summarizes `tool`, `reasoning`, and `file` parts plus m
 |---|---|---|
 | **L1** | Turn pages, reconcile response pages, message/session SSE fan-out, exact `GET /api/session/:sessionID/message/:messageID` | Any `info.summary.diffs` **array** is projected to a **slim file list** `[{ file, status?, additions, deletions }]` plus additive markers `summary.diffCount: number` and `summary.hasDiffs: boolean`. Patch/before/after/from/to and other heavy bodies are stripped. Other lightweight summary fields are preserved. `diffCount` equals the slim array length; `hasDiffs === diffCount > 0`. Consumers may use either the slim array or the markers. |
 | **L2** | `GET /api/openchamber/sessions/:sessionID/changes?messageID=` (no `file`) | Host reads official `session.message` locally, returns only `{ files: [{ file, status?, additions, deletions }] }`. Never returns patch/before/after/from/to or the full message envelope. |
-| **L3** | Same route with `file=` | Host calls official `session.diff({ sessionID, messageID, directory })`, returns `{ diff: SnapshotFileDiff }` for the exact `file` string match (includes that file's patch). No match → HTTP 404 `{ error: 'change file not found', code: 'change_not_found' }`. Older hosts may ignore `file=` and answer 200 `{ files }` (L2 only). Current clients treat a 200 without `{ diff }` as missing L3 and fall back to official `session.diff`. |
+| **L3** | Same route with `file=` | Host currently still reads `info.summary.diffs` from the exact message payload when present. **v2 `SessionMessageInfo` has no `summary.diffs`**, so L3 fails closed with upstream 502 until a parent follow-up lands an authoritative per-message diff source. Do **not** substitute working-tree / `vcs.diff` here. When diffs are available, returns `{ diff: SnapshotFileDiff }` for the exact `file` string match. No match → HTTP 404 `{ error: 'change file not found', code: 'change_not_found' }`. Older hosts may ignore `file=` and answer 200 `{ files }` (L2 only). |
 
 Exact message GET keeps the official `{ info, parts }` response shape and only applies L1 summary projection so materialize/recovery never relays raw multi-megabyte patch bodies through the generic proxy. Abort/45s timeout semantics match the turn-page routes. Global `/api` auth still applies.
 
@@ -126,7 +126,7 @@ On resume:
 1. Strict decode / shape / length validation of the host token.
 2. First `fetchPage` uses the token’s raw upstream `before`.
 3. Locate `boundaryID` in that page; keep only records strictly older than it (`slice(0, index)` in old→new order). Boundary and newer rows are excluded.
-4. If fewer than N turns remain, continue with that raw page’s `x-next-cursor` for older pages.
+4. If fewer than N turns remain, continue with that raw page’s `cursor.next` for older pages.
 5. Each accumulated record records its upstream page’s request-before origin; when `complete=false`, the next host cursor encodes the earliest selected authored user’s origin + id.
 
 A raw OpenCode SDK cursor (no `oc1.` prefix) is still accepted as the first `before` and is passed through unchanged to `fetchPage`.
@@ -146,14 +146,15 @@ A message is an authored user turn boundary when:
 
 ## Aggregation rules
 
-- Upstream pages are chronological **old→new** within each page; **do not reverse**. Older pages are **prepended** while deduping by `info.id` (global order remains old→new).
-- Continues paging with raw upstream `before` until `turns` authored boundaries are collected or upstream reports no next cursor.
-- **Suspicious truncation:** an upstream page whose `records.length >= scanLimit` (full page) but `nextCursor == null` is treated as a non-authoritative cut (observed OpenCode `x-next-cursor` race), not as end-of-history. The host stops scanning that round with `upstreamComplete=false`, so the response stays `complete=false` and still emits a boundary host cursor the client can retry. A short page (`records.length < scanLimit`) with no cursor, an empty page with no cursor, or an explicit `page.complete === true` remain authoritative exhaustion. Client no-growth handling still bounds retries if the upstream view stays truncated.
+- `fetchPage` returns each page chronological **old→new** (v2 `data` is newest-first and is reversed there). Older pages are **prepended** while deduping by `info.id` (global order remains old→new).
+- Continues paging with the raw upstream `cursor.next` (sent as `cursor`, never with `order`) until `turns` authored boundaries are collected or upstream reports no next cursor.
+- **Suspicious truncation:** an upstream page whose `records.length >= scanLimit` (full page) but `nextCursor == null` is treated as a non-authoritative cut (observed OpenCode next-cursor race), not as end-of-history. The host stops scanning that round with `upstreamComplete=false`, so the response stays `complete=false` and still emits a boundary host cursor the client can retry. A short page (`records.length < scanLimit`) with no cursor, an empty page with no cursor, or an explicit `page.complete === true` remain authoritative exhaustion. Client no-growth handling still bounds retries if the upstream view stays truncated.
 - Every upstream record must have a non-empty `info.id`; otherwise structured error, no partial `records`, HTTP 502.
 - Hard scan caps (no partial success): **50 pages** / **5000 messages** → structured error, HTTP 413.
 - Repeated / stalled cursor, or empty page that still carries a next cursor → structured error, no partial `records`, HTTP 502.
 - Malformed upstream payloads and SDK/transport failures → HTTP 502 (`error: "upstream"`).
-- `AbortSignal` is forwarded to each `session.messages` call; route also applies a 45s linked timeout.
+- Native v2 `SessionMessageInfo` rows are projected to the external `{ info, parts }` record contract by `session-message-projection.js` (control rows such as `idle` / `model-switched` are dropped). The VS Code turn-page bridge imports the same module so both runtimes emit identical records.
+- `AbortSignal` is forwarded to each `message.list` call; route also applies a 45s linked timeout.
 - Request abort only when the client disconnects mid-flight: `req` aborted, or `res` `close` while `!res.writableEnded`. A normal GET request `close` after the response has ended must not abort.
 
 ## Anchor reconcile API
@@ -263,7 +264,7 @@ When the per-page budget fills before the gap is complete, the host returns `con
 - `service.js` — `isUserAuthoredTurnBoundary`, `selectTurnRecords`, `encodeHostCursor`, `decodeHostCursor`, `projectMessageDiffSummaries` (L1), `projectSlimParts`, `createSessionTurnPageService({ fetchPage, maxScanPages?, maxScanMessages? })`
 - `reconcile.service.js` — `encodeReconcileContinuation`, `decodeReconcileContinuation`, `createSessionReconcileService({ fetchPage, runtimeKey?, page/total budgets?, continuationSecret?, clock?, continuationTtlMs? })`
 - `changes.service.js` — `createSessionChangesService({ fetchMessage, fetchDiff })` for L2/L3; injectable for unit tests
-- `routes.js` — Express registration for turn-page, reconcile, Changes, and exact message GET; optional injected `sessionTurnPageService` / `sessionReconcileService` / `sessionChangesService` / `fetchExactMessage` for tests; default wires SDK `session.messages` / `session.message` / `session.diff` via `buildOpenCodeUrl` + `getOpenCodeAuthHeaders`
+- `routes.js` — Express registration for turn-page, reconcile, Changes, and exact message GET; optional injected `sessionTurnPageService` / `sessionReconcileService` / `sessionChangesService` / `fetchExactMessage` for tests; default wires `@opencode/client` `OpenCode.make` (`message.list` / `session.message`) via `buildOpenCodeUrl` + `getOpenCodeAuthHeaders`. Exact/not-found classification honors real client `_tag` (`MessageNotFoundError` / `SessionNotFoundError`) and preserves abort → HTTP 499 (never folds abort into 502).
 - `service.test.js` / `routes.test.js` / `reconcile.service.test.js` / `reconcile.routes.test.js` / `changes.service.test.js` — unit contracts
 
 ## Registration

package/server/lib/session-turn-pages/reconcile.service.js

@@ -47,7 +47,7 @@ const PROCESS_CONTINUATION_SECRET = randomBytes(32);
 const fail = (error) => ({ ok: false, error });
 
 const recordId = (record) => {
-  const id = record?.info?.id;
+  const id = record?.info?.id ?? record?.id;
   return typeof id === 'string' && id.length > 0 ? id : null;
 };
 

package/server/lib/session-turn-pages/reconcile.service.test.js

@@ -686,4 +686,20 @@ describe('createSessionReconcileService', () => {
     expect(result.ok).toBe(true);
     expect(result.resetRequired).toBe(true);
   });
+
+  it('locates a SessionMessageInfo anchor by top-level id', async () => {
+    const fetchPage = vi.fn(async () => pageResult([
+      { id: 'msg_u1', type: 'user', time: { created: 1 }, text: 'hi' },
+      { id: 'msg_a1', type: 'assistant', time: { created: 2, completed: 3 }, content: [{ type: 'text', text: 'ok' }] },
+    ], null));
+    const service = createSessionReconcileService(serviceOptions(fetchPage));
+    const result = await service.reconcile({
+      sessionID: 'ses_1',
+      directory: '/repo',
+      anchor: 'msg_u1',
+    });
+    expect(result.ok).toBe(true);
+    expect(result.anchorFound).toBe(true);
+    expect(result.records.map((entry) => entry.id)).toEqual(['msg_u1', 'msg_a1']);
+  });
 });

package/server/lib/session-turn-pages/routes.js

@@ -1,4 +1,4 @@
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { makeOpenCodeV2Client } from '../opencode/v2-client.js';
 import { projectMessageSummaryDiffCounts } from '../event-stream/diff-summary.js';
 import {
   projectMessagesPayloadForReasoning,
@@ -18,6 +18,10 @@ import {
   projectSlimParts,
   SLIM_PARTS_PROJECTION,
 } from './service.js';
+import {
+  projectSessionMessage,
+  projectSessionMessageRecords as projectRecords,
+} from './session-message-projection.js';
 
 const TURNS_MIN = 1;
 const TURNS_MAX = 10;
@@ -210,10 +214,57 @@ const requestSignal = (req, res) => {
   return controller.signal;
 };
 
+/**
+ * Host outbound order: normalize → slim/L1 bounds → reasoning strip.
+ * Slim/reasoning must run on `{info, parts}` so native `content` cannot
+ * rebuild filtered parts or leak through info expansion.
+ */
+const projectTurnPageRecords = (records, includeReasoning) =>
+  projectMessagesPayloadForReasoning(projectSlimParts(projectRecords(records)), includeReasoning);
+
+const projectReconcileRecords = (records, includeReasoning) =>
+  projectMessagesPayloadForReasoning(
+    projectMessageDiffSummaries(projectRecords(records)),
+    includeReasoning,
+  );
+
+const createV2FetchPage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger }) => {
+  return async ({ sessionID, before, limit, signal }) => {
+    const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
+    const headers = typeof getOpenCodeAuthHeaders === 'function' ? getOpenCodeAuthHeaders() : {};
+    const client = makeOpenCodeV2Client({ baseUrl, authHeaders: headers });
+
+    // Upstream rejects `order` together with `cursor` (400); the cursor
+    // already encodes the desc direction of the first page.
+    const result = await client.message.list({
+      sessionID,
+      ...(Number.isFinite(limit) ? { limit } : {}),
+      ...(typeof before === 'string' && before.length > 0 ? { cursor: before } : { order: 'desc' }),
+    }, { signal });
+
+    const items = Array.isArray(result?.data) ? result.data : null;
+    if (!items) {
+      logger?.warn?.('[session-turn-pages] message.list malformed payload');
+      const error = new Error('upstream');
+      error.code = 'upstream';
+      throw error;
+    }
+
+    const next = result?.cursor?.next;
+    const nextCursor = typeof next === 'string' && next.length > 0 ? next : null;
+
+    return {
+      records: items.slice().reverse(),
+      nextCursor,
+      complete: nextCursor == null,
+    };
+  };
+};
+
 const createSdkClient = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders }) => {
   const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
   const headers = typeof getOpenCodeAuthHeaders === 'function' ? getOpenCodeAuthHeaders() : {};
-  return createOpencodeClient({ baseUrl, headers });
+  return makeOpenCodeV2Client({ baseUrl, authHeaders: headers });
 };
 
 const throwUpstream = (logger, label) => {
@@ -223,89 +274,86 @@ const throwUpstream = (logger, label) => {
   throw error;
 };
 
-const createSdkFetchPage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger }) => {
-  return async ({ sessionID, directory, before, limit, signal }) => {
-    const client = createSdkClient({ buildOpenCodeUrl, getOpenCodeAuthHeaders });
-
-    const result = await client.session.messages({
-      sessionID,
-      ...(typeof directory === 'string' && directory.length > 0 ? { directory } : {}),
-      ...(Number.isFinite(limit) ? { limit } : {}),
-      ...(typeof before === 'string' && before.length > 0 ? { before } : {}),
-    }, { signal });
-
-    if (result?.error) {
-      throwUpstream(logger, '[session-turn-pages] session.messages SDK error');
-    }
-
-    const data = result?.data;
-    const records = Array.isArray(data)
-      ? data
-      : Array.isArray(data?.items)
-        ? data.items
-        : null;
-    if (!records) {
-      throwUpstream(logger, '[session-turn-pages] session.messages malformed payload');
-    }
-
-    const headerCursor = result?.response?.headers?.get?.('x-next-cursor');
-    const nextCursor = typeof headerCursor === 'string' && headerCursor.length > 0
-      ? headerCursor
-      : null;
+const getHttpStatus = (error) => {
+  const candidates = [error?.cause?.status, error?.status, error?.response?.status, error?.statusCode];
+  for (const value of candidates) {
+    if (Number.isFinite(value)) return value;
+  }
+  return undefined;
+};
 
-    return {
-      records,
-      nextCursor,
-      complete: nextCursor == null,
-    };
-  };
+/**
+ * Real `@opencode/client` throws declared JSON bodies with `_tag`
+ * (e.g. MessageNotFoundError) — no HTTP status on the object. Also accept
+ * legacy status/code shapes from tests and older surfaces.
+ */
+const isNotFoundError = (error) => {
+  if (!error || typeof error !== 'object') return false;
+  const tag = error._tag ?? error.name;
+  if (tag === 'MessageNotFoundError' || tag === 'SessionNotFoundError') return true;
+  if (getHttpStatus(error) === 404) return true;
+  const code = error.code ?? error.type ?? error.error?.code ?? error.error?.type ?? error.error?._tag;
+  return code === 'not_found'
+    || code === 'NotFound'
+    || code === 'MessageNotFoundError'
+    || code === 'SessionNotFoundError';
 };
 
+const isAbortError = (error) => (
+  error?.name === 'AbortError'
+  || error?.code === 'aborted'
+  || error?.cause?.name === 'AbortError'
+);
+
 const createSdkFetchMessage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger }) => {
-  return async ({ sessionID, messageID, directory, signal }) => {
+  return async ({ sessionID, messageID, signal }) => {
     const client = createSdkClient({ buildOpenCodeUrl, getOpenCodeAuthHeaders });
-    const result = await client.session.message({
-      sessionID,
-      messageID,
-      ...(typeof directory === 'string' && directory.length > 0 ? { directory } : {}),
-    }, { signal });
-
-    if (result?.error) {
-      const status = result?.response?.status;
-      if (status === 404) {
-        const error = new Error('not_found');
-        error.code = 'not_found';
-        throw error;
+    let result;
+    try {
+      result = await client.session.message({ sessionID, messageID }, { signal });
+    } catch (error) {
+      // Preserve abort so routes map 499; never fold into upstream 502.
+      if (isAbortError(error) || signal?.aborted) throw error;
+      if (isNotFoundError(error)) {
+        const notFound = new Error('not_found');
+        notFound.code = 'not_found';
+        throw notFound;
       }
       throwUpstream(logger, '[session-turn-pages] session.message SDK error');
     }
 
-    const data = result?.data;
+    const data = result?.data ?? result;
     if (!data || typeof data !== 'object' || Array.isArray(data)) {
       throwUpstream(logger, '[session-turn-pages] session.message malformed payload');
     }
-    return data;
+    const projected = projectSessionMessage(data);
+    // Control rows (idle / model-switched) are not chat messages.
+    if (!projected || !projected.info) {
+      const notFound = new Error('not_found');
+      notFound.code = 'not_found';
+      throw notFound;
+    }
+    return projected;
   };
 };
 
+/**
+ * L3 diff source. v2 SessionMessageInfo has no summary.diffs; keep failure
+ * explicit until the parent lands an authoritative per-message diff API.
+ * Do not substitute working-tree / vcs.diff here.
+ */
 const createSdkFetchDiff = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger }) => {
   return async ({ sessionID, messageID, directory, signal }) => {
-    const client = createSdkClient({ buildOpenCodeUrl, getOpenCodeAuthHeaders });
-    const result = await client.session.diff({
-      sessionID,
-      messageID,
-      ...(typeof directory === 'string' && directory.length > 0 ? { directory } : {}),
-    }, { signal });
-
-    if (result?.error) {
-      throwUpstream(logger, '[session-changes] session.diff SDK error');
-    }
-
-    const data = result?.data;
-    if (!Array.isArray(data)) {
-      throwUpstream(logger, '[session-changes] session.diff malformed payload');
+    const payload = await createSdkFetchMessage({
+      buildOpenCodeUrl,
+      getOpenCodeAuthHeaders,
+      logger,
+    })({ sessionID, messageID, directory, signal });
+    const diffs = payload?.info?.summary?.diffs;
+    if (!Array.isArray(diffs)) {
+      throwUpstream(logger, '[session-changes] session.message summary.diffs unavailable (L3 source pending)');
     }
-    return data;
+    return diffs;
   };
 };
 
@@ -441,7 +489,7 @@ export const registerSessionTurnPageRoutes = (app, dependencies = {}) => {
 
   const needsDefaultFetch = !injectedService || !injectedReconcileService;
   const defaultFetchPage = needsDefaultFetch
-    ? createSdkFetchPage({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger })
+    ? createV2FetchPage({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger })
     : null;
 
   const service = injectedService ?? createSessionTurnPageService({
@@ -514,8 +562,8 @@ export const registerSessionTurnPageRoutes = (app, dependencies = {}) => {
       }
 
       const includeReasoning = readIncludeReasoningQuery(req.query);
-      const records = projectMessagesPayloadForReasoning(
-        projectMessageDiffSummaries(Array.isArray(result.records) ? result.records : []),
+      const records = projectReconcileRecords(
+        Array.isArray(result.records) ? result.records : [],
         includeReasoning,
       );
 
@@ -609,10 +657,10 @@ export const registerSessionTurnPageRoutes = (app, dependencies = {}) => {
 
       // Turn-page responses (first packet and prepend) share slim-v1.
       // Reconcile stays on the other route and keeps full parts.
-      // includeReasoning=false drops type=reasoning parts after slim projection.
+      // Normalize native SessionMessageInfo first, then slim, then reasoning strip.
       const includeReasoning = readIncludeReasoningQuery(req.query);
-      const records = projectMessagesPayloadForReasoning(
-        projectSlimParts(result.records),
+      const records = projectTurnPageRecords(
+        Array.isArray(result.records) ? result.records : [],
         includeReasoning,
       );
       return res.status(200).json({
@@ -673,13 +721,13 @@ export const registerSessionTurnPageRoutes = (app, dependencies = {}) => {
         projectMessagesPayloadForReasoning(projectExactMessagePayload(payload), includeReasoning),
       );
     } catch (error) {
-      if (error?.name === 'AbortError' || error?.code === 'aborted') {
+      if (isAbortError(error) || error?.code === 'aborted') {
         if (!res.headersSent) {
           return res.status(499).json({ error: SAFE_ERRORS.aborted });
         }
         return undefined;
       }
-      if (error?.code === 'not_found') {
+      if (error?.code === 'not_found' || isNotFoundError(error)) {
         if (!res.headersSent) {
           return res.status(404).json({ error: 'not found', code: 'not_found' });
         }