@oar-sh/oar 0.9.4 → 0.9.6

package/server/claude-worker/claude-turn-failure.mjs

@@ -0,0 +1,92 @@
+// Why a Claude turn failed: the code the relay prints, and the advice that
+// fits the failure.
+//
+// A turn the API refused ends with a `result` of subtype 'success' and
+// `is_error: true`: the subtype says how the turn ended, not whether it
+// worked, so it names nothing. What names the failure, in this order:
+//
+//   1. the `error` field of the turn's last assistant message (the SDK's
+//      SDKAssistantMessageError: 'billing_error', 'oauth_org_not_allowed', …);
+//   2. the `api_error_status` of the result;
+//   3. the words of the refusal, for an account failure that came with
+//      neither;
+//   4. a subtype other than 'success' ('error_max_turns', …);
+//   5. the `terminal_reason` of the result.
+//
+// The relay prints `claude.<code>` as `relay.claude-<code>`, dashes for
+// underscores.
+
+// The user has to sign in again: a retry cannot succeed before that.
+const SIGN_IN_ERRORS = new Set(['authentication_failed']);
+// The account itself refuses: billing, or access its organisation withholds.
+const ACCOUNT_ERRORS = new Set([
+  'billing_error',
+  'oauth_org_not_allowed',
+  'account_on_hold',
+  'verification_required',
+  'account-access',
+]);
+
+const STATUS_CODES = new Map([
+  [401, 'authentication_failed'],
+  [402, 'billing_error'],
+  [429, 'rate_limit'],
+  [529, 'overloaded'],
+]);
+
+// Checked before the sign-in words: the organisation's refusal mentions an
+// API key too.
+const ACCOUNT_ACCESS_TEXT = /organi[sz]ation has disabled|subscription access|does not have access to claude/i;
+const BILLING_TEXT = /credit balance|billing|payment/i;
+const SIGN_IN_TEXT = /failed to authenticate|authentication_error|invalid api key|not logged in|please run \/login/i;
+
+export const CLAUDE_SIGN_IN_GUIDANCE =
+  'Sign in to Claude again in Settings → Providers → Claude → Relogin (or run `claude` on the relay host), '
+  + 'then send the message again.';
+export const CLAUDE_ACCOUNT_GUIDANCE =
+  'Check the Claude account the relay host is signed in to: its subscription, its payment method, and whether '
+  + 'its organisation allows Claude Code. Settings → Providers → Claude shows the account and signs in to '
+  + 'another one. Then send the message again.';
+export const CLAUDE_MODEL_GUIDANCE = 'Choose another model for this conversation, then send the message again.';
+
+function codeFromText(text) {
+  if (ACCOUNT_ACCESS_TEXT.test(text)) return 'account-access';
+  if (BILLING_TEXT.test(text)) return 'billing_error';
+  if (SIGN_IN_TEXT.test(text)) return 'authentication_failed';
+  return null;
+}
+
+/** The advice for a code, or null where the relay's own default fits. */
+export function claudeFailureGuidance(code) {
+  const token = String(code || '').trim().toLowerCase();
+  if (SIGN_IN_ERRORS.has(token)) return CLAUDE_SIGN_IN_GUIDANCE;
+  if (ACCOUNT_ERRORS.has(token)) return CLAUDE_ACCOUNT_GUIDANCE;
+  if (token === 'model_not_found') return CLAUDE_MODEL_GUIDANCE;
+  return null;
+}
+
+/**
+ * `result` is the normalized result payload of the turn (sdk-message-
+ * normalizer): `{ text, subtype, assistantError, apiErrorStatus,
+ * terminalReason }`. Returns `{ code, stableCode, guidance }`; `guidance` is
+ * null where the relay's default fits.
+ */
+export function classifyClaudeResultFailure(result = {}) {
+  const subtype = String(result?.subtype || '').trim();
+  const assistantError = String(result?.assistantError || '').trim().toLowerCase();
+  const status = Number(result?.apiErrorStatus);
+  const hasStatus = Number.isFinite(status) && status >= 400;
+  const terminalReason = String(result?.terminalReason || '').trim().toLowerCase();
+
+  let code = null;
+  if (assistantError && assistantError !== 'unknown') code = assistantError;
+  else if (hasStatus && STATUS_CODES.has(status)) code = STATUS_CODES.get(status);
+  else code = codeFromText(String(result?.text || ''));
+
+  if (!code && subtype && subtype !== 'success') code = subtype;
+  if (!code && (hasStatus || assistantError === 'unknown' || terminalReason === 'api_error')) code = 'api-error';
+  if (!code && terminalReason && terminalReason !== 'completed') code = terminalReason;
+  if (!code) code = 'turn-error';
+
+  return { code, stableCode: `claude.${code}`, guidance: claudeFailureGuidance(code) };
+}

package/server/claude-worker/claude-turn-publisher.mjs

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
+import { classifyClaudeResultFailure, claudeFailureGuidance } from './claude-turn-failure.mjs';
 import { countPlanLikeLines } from '../../shared/plan-lines.mjs';
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { buildSteerSettleFailure, steerSettleFailureText } from '../../shared/steer-settle-failure.mjs';
+import { buildUsageLimitFailure } from '../../shared/claude-usage-limit.mjs';
 
 const PLAN_BOARD_ACTIONS = [
   { id: 'autopilot', label: 'Implement in autopilot', mode: 'autopilot' },
@@ -178,6 +180,18 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
     });
   }
 
+  /**
+   * Ship what the CLI reported about the subscription's usage limit: the
+   * relay warns before the limit and shows the reset once it is reached.
+   * Advisory, and fired without waiting: it must not hold up the stream.
+   */
+  function publishUsageLimitReport({ conversationId, sdkSessionId, report }) {
+    if (!report) return;
+    api('POST', '/api/claude-usage-limit', { conversationId, sdkSessionId, report }).catch((error) => {
+      dbg('usage limit report publish failed', error?.message || String(error));
+    });
+  }
+
   async function publishFinalStream(message, text) {
     await api('POST', '/api/stream', {
       messageId: message.id,
@@ -204,6 +218,9 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
     text,
     model,
     terminalError = null,
+    // What the turn had written before it failed; the relay keeps it above
+    // the failure or pause note.
+    partialText = '',
     modelOrigin,
     absorbed = false,
     kind = null,
@@ -244,6 +261,7 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
           || (String(message?.model || '').trim().toLowerCase() === 'auto' ? 'auto' : 'manual'),
         ...(Array.isArray(workflowRuns) && workflowRuns.length ? { workflowRuns } : {}),
         ...(terminalError ? { terminalError } : {}),
+        ...(terminalError && String(partialText || '').trim() ? { partialText: String(partialText).trim() } : {}),
         // The relay stamps the assistant message's kind from these: 'absorbed'
         // renders as merged into the next (steered) user message, 'folded' as
         // a compact marker on its own message, 'stopped' as a steer the
@@ -333,13 +351,34 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
     const errorText = result.text
       || `Claude turn failed (${result.subtype || 'unknown error'}).`;
     await publishFinalStream(message, state.lastStreamedText);
+    // Refused at the usage limit: a relay that knows the kind pauses the turn
+    // until the reset instead of failing it.
+    if (result.usageLimit) {
+      // What the turn had written before it was refused, without the CLI's
+      // own line about the limit, which is the last thing in the stream. The
+      // relay keeps it above its note: a turn cut off in the middle has
+      // usually said what it was doing.
+      const refusalText = String(result.usageLimit.text || '').trim();
+      let written = String(state.lastStreamedText || '').trim();
+      if (refusalText && written.endsWith(refusalText)) written = written.slice(0, -refusalText.length).trim();
+      await publishResponse(message, {
+        text: errorText,
+        model: responseModel,
+        terminalError: buildUsageLimitFailure(message, result.usageLimit),
+        partialText: written,
+        consumedSteerIds,
+      });
+      return;
+    }
     await publishResponse(message, {
       text: errorText,
       model: responseModel,
       terminalError: {
         kind: 'claude-turn-failed',
-        code: result.subtype || 'unknown',
-        stableCode: `claude.${result.subtype || 'unknown'}`,
+        // Never built from the subtype alone: a refused turn ends with
+        // subtype 'success'. An account failure brings its own advice, since
+        // sending the message again cannot help before the account is fixed.
+        ...classifyClaudeResultFailure(result),
         message: errorText,
         failedAt: new Date().toISOString(),
         queueMessageId: String(message.id || '') || null,
@@ -348,7 +387,15 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
     });
   }
 
-  async function publishTurnException({ message, errorText }) {
+  async function publishTurnException({ message, errorText, usageLimit = null }) {
+    if (usageLimit) {
+      await publishResponse(message, {
+        text: usageLimit.text || errorText,
+        model: null,
+        terminalError: buildUsageLimitFailure(message, usageLimit),
+      });
+      return;
+    }
     const isAuthError = /authentication|logged in|login|credential|api key/i.test(errorText);
     await publishResponse(message, {
       text: isAuthError
@@ -360,6 +407,7 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
         code: isAuthError ? 'authentication_failed' : 'turn-error',
         stableCode: isAuthError ? 'claude.authentication_failed' : 'claude.turn-error',
         message: errorText,
+        ...(isAuthError ? { guidance: claudeFailureGuidance('authentication_failed') } : {}),
         failedAt: new Date().toISOString(),
         queueMessageId: String(message.id || '') || null,
       },
@@ -372,6 +420,7 @@ export function createClaudeTurnPublisher({ api, dbg = () => {}, takeWorkflowRun
     dispatchAction,
     publishContextUsage,
     publishPlanUsage,
+    publishUsageLimitReport,
     publishFinalStream,
     publishResponse,
     publishPlanBoard,

package/server/claude-worker/sdk-message-normalizer.mjs

@@ -142,13 +142,17 @@ export { shouldEmitStreamUpdate };
  * - `background_tasks` → `{ tasks: [{ taskId, taskType, description }] }`
  *   (REPLACE semantics: the full live set after each membership change)
  * - `background_task_settled` → `{ taskId, status }`
- * - `result`   → `{ text, isError, subtype, sessionId, model, usage }`
+ * - `result`   → `{ text, isError, subtype, sessionId, model, usage }`, and what
+ *   names a failure: `{ assistantError, apiErrorStatus, terminalReason }`
  */
 export function createSdkMessageNormalizer() {
   const threads = new Map(); // threadKey -> per-thread stream/thinking bookkeeping
   const knownSubagentRuns = new Map(); // toolUseId -> { displayName, parentSubagentId }
   let initSessionId = '';
   let initModel = '';
+  // The `error` of the turn's last main-thread assistant message: the SDK's
+  // name for the failure a refused turn ended on.
+  let lastAssistantError = '';
 
   function threadKeyFor(parentToolUseId) {
     return String(parentToolUseId || '').trim() || 'main';
@@ -532,6 +536,7 @@ export function createSdkMessageNormalizer() {
       const parentToolUseId = sdkMessage?.parent_tool_use_id || null;
       const content = Array.isArray(sdkMessage?.message?.content) ? sdkMessage.message.content : [];
       const messageId = String(sdkMessage?.message?.id || '').trim();
+      if (!parentToolUseId) lastAssistantError = String(sdkMessage?.error || '').trim();
       return actionsForAssistantMessage(content, parentToolUseId, messageId);
     }
 
@@ -599,12 +604,19 @@ export function createSdkMessageNormalizer() {
         && Number(sdkMessage.duration_api_ms) === 0;
       if (isPhantom) return [];
       const isError = sdkMessage.subtype !== 'success' || sdkMessage.is_error === true;
+      // The next turn's result must not inherit this turn's failure.
+      const assistantError = lastAssistantError;
+      lastAssistantError = '';
+      const apiErrorStatus = Number(sdkMessage.api_error_status ?? NaN);
       return [{
         channel: 'result',
         payload: {
           text: String(sdkMessage.result || '').trim(),
           isError,
           subtype: String(sdkMessage.subtype || ''),
+          assistantError,
+          apiErrorStatus: Number.isFinite(apiErrorStatus) ? apiErrorStatus : null,
+          terminalReason: String(sdkMessage.terminal_reason || ''),
           sessionId: String(sdkMessage.session_id || initSessionId || '').trim(),
           model: initModel,
           usage: sdkMessage.usage || null,

package/server/copilot-worker/copilot-model-switch.mjs

@@ -112,6 +112,22 @@ export function createModelSwitchUnconfirmedError({
   return error;
 }
 
+// JSON-RPC reserved codes the SDK's transport uses for a connection that went
+// away (`MessageWriteError` … `ConnectionInactive`), as opposed to a server
+// handler that threw.
+const TRANSPORT_ERROR_CODES = new Set([-32099, -32098, -32097, -32096]);
+
+/**
+ * The request failed because the connection to the runtime is gone, not
+ * because the runtime refused it.
+ */
+export function isRuntimeTransportError(error) {
+  const code = Number(error?.code);
+  if (Number.isFinite(code) && TRANSPORT_ERROR_CODES.has(code)) return true;
+  if (error?.name === 'ConnectionError') return true;
+  return /\bconnection (?:got |is |was )?(?:disposed|closed)\b/i.test(String(error?.message || ''));
+}
+
 export function isModelSwitchUnconfirmedError(error) {
   return error?.modelSwitchUnconfirmed === true;
 }
@@ -272,6 +288,16 @@ export function createCopilotModelSwitcher({
       });
     };
 
+    // A request that failed because the connection to the runtime is gone says
+    // nothing about the model: "pick an available model and resend it" sent
+    // the user to the model picker over a dead runtime, and because an
+    // unconfirmed switch keeps the runtime, every retry failed the same way.
+    // Thrown as it is, it fails the turn and the runtime is rebuilt.
+    const failOrRethrow = (error, requestedEffort = targetEffortRaw) => {
+      if (isRuntimeTransportError(error)) throw error;
+      return fail(error?.message || String(error), requestedEffort);
+    };
+
     // ---- resolve the effort actually sent on the wire -----------------------
     // `null` target = "the model's default": mapped to the catalog's
     // `defaultReasoningEffort` when known, otherwise omitted entirely (and the
@@ -347,7 +373,7 @@ export function createCopilotModelSwitcher({
         // the only signal left. Hosted trusts it; BYOK falls back to rebuild.
         if (byok || typeof session?.setModel !== 'function') return fail('the runtime exposes no model-switch RPC');
         await session.setModel(targetModel, effortToSend ? { reasoningEffort: effortToSend } : undefined)
-          .catch((error) => fail(error?.message || String(error)));
+          .catch((error) => failOrRethrow(error));
         applied = { model: targetModel, effort: trackedEffort };
         return { ok: true, changed: true };
       }
@@ -363,7 +389,7 @@ export function createCopilotModelSwitcher({
         });
       } catch (error) {
         drain.cancel();
-        return fail(error?.message || String(error));
+        return failOrRethrow(error);
       }
       if (result?.confirmation) {
         // A compaction preflight wants an interactive decision; a headless
@@ -404,7 +430,7 @@ export function createCopilotModelSwitcher({
     try {
       effortResult = await setEffort.call(session.rpc.model, { reasoningEffort: effortToSend });
     } catch (error) {
-      return fail(error?.message || String(error), effortToSend);
+      return failOrRethrow(error, effortToSend);
     }
     const recorded = String(effortResult?.reasoningEffort || '').trim().toLowerCase();
     if (recorded && recorded !== effortToSend) {

package/server/copilot-worker/copilot-question-bridge.mjs

@@ -23,6 +23,7 @@
 // question array. Composing the waiter instead of copying it keeps one
 // implementation of the abort semantics.
 import { createAskUserBridge } from '../../shared/ask-user-bridge.mjs';
+import { createRelayQuestion } from '../../shared/question-wait.mjs';
 import { looksLikeMultiSelectQuestion } from '../../shared/question-multi-select.mjs';
 import {
   DEFAULT_QUESTION_TIMEOUT_MS,
@@ -139,10 +140,7 @@ export function createCopilotQuestionBridge({
         ...extra,
       },
     };
-    const created = await api('POST', '/api/relay-question', payload);
-    const questionId = created?.question?.id;
-    if (!questionId) throw new Error('Relay question could not be created');
-    return questionId;
+    return createRelayQuestion({ api, payload, dbg });
   }
 
   async function ask(spec, { signal, message } = {}) {

package/server/copilot-worker/copilot-runtime-tree.mjs

@@ -0,0 +1,91 @@
+// The commands of this worker's Copilot runtime, and when they are stopped.
+//
+// The runtime ends its own commands when it ends in good order. When it is
+// killed, or dies, they run on with nobody left to read their result (the
+// measurements are in shared/worker-runtime/process-tree.mjs). The worker
+// therefore keeps the runtime's process tree while the runtime lives and
+// stops what is left of it after a runtime that failed is gone.
+import { createProcessTreeWatch } from '../../shared/worker-runtime/process-tree.mjs';
+import { createProcessLister } from '../services/process-list-service.mjs';
+import { readRuntimePid } from './copilot-sdk-adapter.mjs';
+
+/**
+ * The reasons of `stopRuntime` after which the tree is stopped: the runtime
+ * exited, it no longer answers, or it is torn down because its turn failed.
+ * An idle runtime and a worker that shuts down stop in good order, and the
+ * runtime ends its commands itself.
+ */
+const TREE_STOP_REASONS = new Set(['runtime-exit', 'runtime-gone', 'turn-failure']);
+
+export function runtimeStopLeavesCommands(reason) {
+  return TREE_STOP_REASONS.has(String(reason || ''));
+}
+
+/**
+ * The wrapper the runtime puts around a command that was started with
+ * `detach: true`. Such a command is meant to outlive the session ("only set
+ * this when the user explicitly requires the process to survive"), and the
+ * runtime leaves it running when it stops in good order. So does the worker.
+ *
+ * On Linux and macOS (runtime 1.0.89) the wrapper is a shell that keeps the
+ * pid and exit paths in variables. On Windows (1.0.88, seen live) it is a
+ * PowerShell that starts the command with Start-Process; the command itself
+ * is a child of the wrapper and is kept with it. The wrapper's text is the
+ * mark: the names of its files (`copilot-detached-…`) would also match a
+ * command that merely mentions one.
+ */
+const DETACHED_COMMAND_MARKERS = Object.freeze([
+  '__copilot_pid_path=',
+  '$__copilotProcess = Start-Process',
+]);
+
+export function isDetachedRuntimeCommand(proc) {
+  const commandLine = String(proc?.commandLine || '');
+  return DETACHED_COMMAND_MARKERS.some((marker) => commandLine.includes(marker));
+}
+
+/**
+ * The sentence of the failure note. "is being stopped", not "was": the note
+ * is published before the runtime is torn down, and the commands are stopped
+ * after it.
+ */
+export function describeCommandsBeingStopped(count) {
+  const commands = Number(count) || 0;
+  if (commands <= 0) return '';
+  if (commands === 1) return 'A command that was still running is being stopped.';
+  return `${commands} commands that were still running are being stopped.`;
+}
+
+/**
+ * Watch the process tree of `client`'s runtime. Returns null where the pid of
+ * the runtime is not known: nothing is signalled on a guess.
+ */
+export function watchCopilotRuntimeTree({
+  client,
+  isBusy = () => true,
+  dbg = () => {},
+  platform = process.platform,
+  lister = null,
+  signal = (pid, name) => process.kill(pid, name),
+  // Never signalled, whatever the process list says.
+  selfPid = process.pid,
+  parentPid = process.ppid,
+  ...timing
+} = {}) {
+  const rootPid = readRuntimePid(client);
+  if (!rootPid) {
+    dbg('the pid of the copilot runtime is not known; its commands are not watched');
+    return null;
+  }
+  return createProcessTreeWatch({
+    rootPid,
+    lister: lister || createProcessLister({ platform }),
+    signal,
+    protectedPids: [selfPid, parentPid],
+    keepSubtree: isDetachedRuntimeCommand,
+    isBusy,
+    label: 'copilot runtime',
+    dbg,
+    ...timing,
+  });
+}

package/server/copilot-worker/copilot-sdk-adapter.mjs

@@ -28,8 +28,10 @@ import {
   MODEL_SWITCH_UNCONFIRMED_CODE,
   MODEL_SWITCH_UNCONFIRMED_STABLE_CODE,
   isModelSwitchUnconfirmedError,
+  isRuntimeTransportError,
 } from './copilot-model-switch.mjs';
 import { copilotRuntimeEntry } from '../copilot-sdk-runtime.mjs';
+import { describeTurnStall, isTurnStalledError } from '../../shared/worker-runtime/turn-liveness.mjs';
 
 const VERSION_DIR_RE = /^\d+\.\d+\.\d+$/;
 
@@ -162,6 +164,22 @@ export function observeRuntimeExit(client, onExit) {
   return () => { live = false; };
 }
 
+/**
+ * The pid of the runtime process, or 0.
+ *
+ * Like `processExitPromise` this reaches past the public API: the SDK starts
+ * the runtime itself (`spawn` without `detached`, no option for a spawn
+ * function of our own, verified against 1.0.89 and the npm package 1.0.14) and
+ * keeps the child in `cliProcess`, a TS-private, runtime-visible field that
+ * `stop()` and `forceStop()` clear. It is read once, right after the start. A
+ * bundle without the field reads as "not known", and the runtime's commands
+ * are then not watched.
+ */
+export function readRuntimePid(client) {
+  const pid = Number(client?.cliProcess?.pid);
+  return Number.isInteger(pid) && pid > 1 ? pid : 0;
+}
+
 /**
  * Import the installed SDK and start a client against the matching runtime.
  *
@@ -402,6 +420,8 @@ export function classifyCopilotSessionError(data) {
     code,
     stableCode: `copilot.${code}`,
     text: `System note: the Copilot turn failed (${detail}). Retry or send a new message.`,
+    // Without one the relay adds its default, which advises a retry.
+    guidance: COPILOT_TURN_FAILURE_GUIDANCE,
     detail,
     quota: false,
   };
@@ -469,6 +489,20 @@ export function isCopilotAuthError(error) {
   return AUTH_ERROR_RE.test(String(error?.message || error || ''));
 }
 
+/**
+ * What the relay appends to a failed Copilot turn in place of its own default
+ * (which advises a retry). The worker deals with its runtime itself: a delivered
+ * turn that failed tore it down and the next message starts a fresh one, so a
+ * relay restart repairs nothing here and costs every other running session.
+ * That holds for a failure the runtime reports as a session error too.
+ * Sign-in and quota failures keep the wording of their own.
+ */
+export const COPILOT_TURN_FAILURE_GUIDANCE =
+  'If this keeps failing, include the error code when you report it; the relay does not need a restart.';
+export const COPILOT_TURN_RETRY_GUIDANCE = 'Send the message again to retry.';
+export const COPILOT_TURN_CONTINUE_GUIDANCE =
+  'Send a message to continue: the session keeps the work so far, so the agent carries on from there.';
+
 /**
  * Classify a thrown error (client start, session create/resume, `send`) rather
  * than a `session.error` event. Auth gets its own branch because the fix is a
@@ -503,19 +537,27 @@ export function classifyCopilotTurnException(error) {
   if (isCopilotAuthError(error)) {
     return copilotAuthClassification(detail);
   }
+  // The stall watchdog's failure: the turn is not known to be broken, only
+  // silent, and the user is told that — and what the runtime was doing —
+  // rather than "the turn failed".
+  if (isTurnStalledError(error)) {
+    return {
+      code: 'turn-stalled',
+      stableCode: 'copilot.turn-stalled',
+      text: describeTurnStall(error),
+      guidance: COPILOT_TURN_RETRY_GUIDANCE,
+      detail,
+    };
+  }
   return {
     code: 'turn-error',
     stableCode: 'copilot.turn-error',
     text: `System note: the Copilot turn failed (${detail}). Retry or send a new message.`,
+    guidance: COPILOT_TURN_FAILURE_GUIDANCE,
     detail,
   };
 }
 
-// JSON-RPC reserved codes the SDK's transport uses for a connection that went
-// away (`MessageWriteError` … `ConnectionInactive`), as opposed to a server
-// handler that threw.
-const TRANSPORT_ERROR_CODES = new Set([-32099, -32098, -32097, -32096]);
-
 /**
  * Did `resumeSession` fail because the session does not exist, or because the
  * call itself failed?
@@ -530,9 +572,7 @@ const TRANSPORT_ERROR_CODES = new Set([-32099, -32098, -32097, -32096]);
  * conversation history.
  */
 export function isSessionNotFoundError(error) {
-  const code = Number(error?.code);
-  if (Number.isFinite(code) && TRANSPORT_ERROR_CODES.has(code)) return false;
-  if (error?.name === 'ConnectionError') return false;
+  if (isRuntimeTransportError(error)) return false;
   const detail = String(error?.message || error || '').toLowerCase();
   if (!detail) return false;
   if (/\b(?:session|conversation)\b[^.]{0,40}\bnot found\b/.test(detail)) return true;