@ai-sdk/harness-claude-code 1.0.96 → 1.0.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-claude-code",
-  "version": "1.0.96",
+  "version": "1.0.97",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,16 +26,16 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.92",
-    "@ai-sdk/provider-utils": "5.0.32",
+    "@ai-sdk/harness": "1.0.93",
+    "@ai-sdk/provider-utils": "5.0.33",
     "ws": "^8.21.0"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"
   },
   "devDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.213",
-    "@modelcontextprotocol/sdk": "1.29.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.245",
+    "@modelcontextprotocol/sdk": "1.30.0",
     "@types/node": "22.19.19",
     "@types/ws": "^8.5.13",
     "@vercel/ai-tsconfig": "0.0.0",

package/src/bridge/index.ts

@@ -253,12 +253,27 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   // Local controller for the Claude query. Aborted either by the host (via the
   // shared runtime's `turn.abortSignal`) or by us on a terminal error.
   const abortCtl = new AbortController();
+  // A host abort prefers the SDK's graceful `interrupt()` — Esc semantics: the
+  // in-flight turn is persisted to the session transcript and settles with an
+  // interrupted result, so a later resume (including the user's own
+  // `claude --resume`) still sees the work done before the interrupt. The hard
+  // abort kills the CLI process and loses that turn's records, so it is only
+  // the fallback — armed unconditionally, because aborting an already-settled
+  // query is a no-op — and the immediate path when the abort arrives before
+  // the query exists.
+  let gracefulAbort: (() => void) | undefined;
+  let hardAbortTimer: ReturnType<typeof setTimeout> | undefined;
+  const onHostAbort = (): void => {
+    if (gracefulAbort) {
+      gracefulAbort();
+    } else {
+      abortCtl.abort();
+    }
+  };
   if (turn.abortSignal.aborted) {
     abortCtl.abort();
   } else {
-    turn.abortSignal.addEventListener('abort', () => abortCtl.abort(), {
-      once: true,
-    });
+    turn.abortSignal.addEventListener('abort', onHostAbort, { once: true });
   }
 
   const streamEventState = createClaudeStreamEventState();
@@ -388,6 +403,19 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       abortSignal: abortCtl.signal,
     },
   });
+
+  gracefulAbort = () => {
+    // Backstop for the whole teardown, not just the interrupt call: if the
+    // stream has not settled five seconds after a graceful interrupt was
+    // requested, fall back to the hard abort. Aborting an already-settled
+    // query is a no-op, and `unref` keeps the timer from pinning the bridge
+    // process open on its own.
+    hardAbortTimer = setTimeout(() => abortCtl.abort(), 5000);
+    hardAbortTimer.unref?.();
+    void Promise.resolve()
+      .then(() => q.interrupt())
+      .catch(() => abortCtl.abort());
+  };
   let turnUsage: Record<string, unknown> | undefined;
   let totalCostUsd: number | undefined;
   let emittedTerminalError = false;
@@ -398,10 +426,17 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     if (!normalized || emittedTerminalError || emittedTerminalFinish) return;
     streamEventState.observedTerminalError = normalized;
     emittedTerminalError = true;
-    turn.emitError({
-      error: normalized,
-      message: 'claude-code terminal error',
-    });
+    // A turn the host itself stopped ends with an error-shaped result by
+    // construction (an interrupted query reports a diagnostic, not success);
+    // reporting the host's own stop as a terminal error makes every clean
+    // interrupt look like a malfunction. The host has already settled the
+    // turn on its side.
+    if (!turn.abortSignal.aborted) {
+      turn.emitError({
+        error: normalized,
+        message: 'claude-code terminal error',
+      });
+    }
     queryInput.close();
     abortCtl.abort();
   };
@@ -483,12 +518,38 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       }
     }
   } catch (err) {
-    if (!(abortCtl.signal.aborted && emittedTerminalError)) {
+    // Same reasoning as `emitTerminalError`: a throw after the host's own
+    // abort (e.g. the hard-abort fallback killing the CLI mid-iteration, or
+    // a rejected `interrupt()`) is the stop the host asked for, not a
+    // malfunction. The host has already settled the turn on its side.
+    if (
+      !turn.abortSignal.aborted &&
+      !(abortCtl.signal.aborted && emittedTerminalError)
+    ) {
       turn.emitError({ error: err, message: 'claude-code turn failed' });
     }
     return;
   } finally {
+    // The turn is over; disarm the host-abort path first. An abort of this
+    // turn's signal arriving after this point (e.g. an `abort` message racing
+    // the next `start`) must not interrupt the disposed query or arm the
+    // hard-abort fallback timer for it.
+    gracefulAbort = undefined;
+    if (hardAbortTimer != null) clearTimeout(hardAbortTimer);
+    turn.abortSignal.removeEventListener('abort', onHostAbort);
     queryInput.close();
+    // Dispose the query explicitly: with streaming input the SDK keeps its
+    // CLI subprocess alive for more user messages, and a turn that ended
+    // through an interrupt or error path can otherwise leak that process —
+    // observed as orphaned `claude` processes holding the very conversation
+    // the next turn continues.
+    try {
+      await (q as { return?: (value?: unknown) => Promise<unknown> }).return?.(
+        undefined,
+      );
+    } catch {
+      // Best effort; the abort controller tears the process down otherwise.
+    }
   }
 
   if (emittedTerminalError) return;

package/src/bridge/package.json

@@ -4,9 +4,9 @@
   "private": true,
   "type": "module",
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.213",
-    "@anthropic-ai/claude-code": "2.1.213",
-    "@modelcontextprotocol/sdk": "1.29.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.245",
+    "@anthropic-ai/claude-code": "2.1.245",
+    "@modelcontextprotocol/sdk": "1.30.0",
     "ws": "8.21.0",
     "zod": "4.4.3"
   }