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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-claude-code",
-  "version": "1.0.96",
+  "version": "1.0.98",
   "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.94",
+    "@ai-sdk/provider-utils": "5.0.34",
     "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/create-emit-stream-event.ts

@@ -21,8 +21,17 @@ export type ClaudeMessage = {
   event?: {
     type?: string;
     index?: number;
-    content_block?: { type?: string };
-    delta?: { type?: string; text?: string; thinking?: string };
+    content_block?: {
+      type?: string;
+      id?: string;
+      name?: string;
+    };
+    delta?: {
+      type?: string;
+      text?: string;
+      thinking?: string;
+      partial_json?: string;
+    };
   };
   message?: {
     content?: ReadonlyArray<MessageBlock>;
@@ -56,7 +65,7 @@ export type ClaudeStreamEventState = {
    */
   nativeToolCallNames: Map<string, string>;
   approvalRequestedToolUseIds: Set<string>;
-  partialBlocks: Map<number, { id: string; kind: 'text' | 'thinking' }>;
+  partialBlocks: Map<number, PartialBlock>;
   stepUsage: Record<string, unknown> | undefined;
   pendingStepToolUseIds: Set<string>;
   pendingStepUsage: Record<string, unknown> | undefined;
@@ -64,9 +73,8 @@ export type ClaudeStreamEventState = {
   /*
    * Tool-use ids that originated from the MCP server hosting user-supplied
    * tools. The MCP handler emits its own `tool-call`/`tool-result` pair with
-   * the user-facing tool name and a synthetic id, so the duplicate
-   * `tool_result` block Claude reports for the underlying native id must be
-   * suppressed.
+   * the user-facing tool name, so the duplicate `tool_result` block Claude
+   * reports for the underlying native id must be suppressed.
    */
   mcpToolUseIds: Set<string>;
   externalMcpToolUseIds: Set<string>;
@@ -74,6 +82,10 @@ export type ClaudeStreamEventState = {
   observedTerminalError: string | undefined;
 };
 
+type PartialBlock =
+  | { id: string; kind: 'text' | 'thinking' }
+  | { id: string; kind: 'tool-input' };
+
 export function createClaudeStreamEventState(): ClaudeStreamEventState {
   return {
     nativeToolCallNames: new Map(),
@@ -195,7 +207,12 @@ export function createEmitStreamEvent({
     }
 
     if (type === 'stream_event') {
-      handleStreamEvent(msg.event, state.partialBlocks, emit);
+      handleStreamEvent({
+        event: msg.event,
+        state,
+        send: emit,
+        toCommonName,
+      });
       return;
     }
 
@@ -371,13 +388,22 @@ function formatApiRetryWarning(msg: ClaudeMessage): string {
     : 'Claude Code API retry';
 }
 
-function handleStreamEvent(
-  event: ClaudeMessage['event'] | undefined,
-  partialBlocks: Map<number, { id: string; kind: 'text' | 'thinking' }>,
-  send: Emit,
-): void {
+const HOST_TOOL_PREFIX = 'mcp__harness-tools__';
+
+function handleStreamEvent({
+  event,
+  state,
+  send,
+  toCommonName,
+}: {
+  event: ClaudeMessage['event'] | undefined;
+  state: ClaudeStreamEventState;
+  send: Emit;
+  toCommonName: (nativeName: string) => string;
+}): void {
   if (!event || typeof event.index !== 'number') return;
   const index = event.index;
+  const partialBlocks = state.partialBlocks;
 
   if (event.type === 'content_block_start') {
     const blockType = event.content_block?.type;
@@ -389,6 +415,29 @@ function handleStreamEvent(
       const id = randomUUID();
       partialBlocks.set(index, { id, kind: 'thinking' });
       send({ type: 'reasoning-start', id });
+    } else if (
+      blockType === 'tool_use' &&
+      typeof event.content_block?.id === 'string' &&
+      typeof event.content_block.name === 'string'
+    ) {
+      const id = event.content_block.id;
+      const nativeName = event.content_block.name;
+      if (nativeName === 'StructuredOutput') {
+        return;
+      }
+      const hostToolName = nativeName.startsWith(HOST_TOOL_PREFIX)
+        ? nativeName.slice(HOST_TOOL_PREFIX.length)
+        : undefined;
+      const dynamic =
+        hostToolName === undefined && nativeName.startsWith('mcp__');
+      partialBlocks.set(index, { id, kind: 'tool-input' });
+      send({
+        type: 'tool-input-start',
+        id,
+        toolName: hostToolName ?? toCommonName(nativeName),
+        providerExecuted: hostToolName === undefined,
+        ...(dynamic ? { dynamic: true } : {}),
+      });
     }
     return;
   }
@@ -412,6 +461,16 @@ function handleStreamEvent(
         id: block.id,
         delta: event.delta.thinking,
       });
+    } else if (
+      block.kind === 'tool-input' &&
+      event.delta?.type === 'input_json_delta' &&
+      typeof event.delta.partial_json === 'string'
+    ) {
+      send({
+        type: 'tool-input-delta',
+        id: block.id,
+        delta: event.delta.partial_json,
+      });
     }
     return;
   }
@@ -422,8 +481,10 @@ function handleStreamEvent(
     partialBlocks.delete(index);
     if (block.kind === 'text') {
       send({ type: 'text-end', id: block.id });
-    } else {
+    } else if (block.kind === 'thinking') {
       send({ type: 'reasoning-end', id: block.id });
+    } else {
+      send({ type: 'tool-input-end', id: block.id });
     }
   }
 }

package/src/bridge/index.ts

@@ -125,13 +125,23 @@ const claudeSdk = claudeAgentSdk as any;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const mcpModule = mcpServerModule as any;
 
+/**
+ * The Claude session id most recently reported by the SDK, captured from the
+ * message stream. Every turn in this bridge process may fork a new id (the
+ * SDK's `continue`/`resume` create a new session linked to the previous one),
+ * so the latest observation is the one a later resume must name.
+ */
+let lastClaudeSessionId: string | undefined;
+
 await runBridge<StartMessage>({
   bridgeType: 'claude-code',
   bridgeStateDir,
   onStart: runTurn,
-  // Claude Code's session state lives in the workdir on the sandbox filesystem
-  // (captured by the sandbox snapshot on stop); the resume payload is empty.
-  onStop: () => ({}),
+  // Claude Code's conversation state lives in the runtime's own store, keyed
+  // by working directory. The resume payload names the exact conversation so a
+  // later resume does not have to fall back to "most recent in this workdir".
+  onStop: () =>
+    lastClaudeSessionId == null ? {} : { claudeSessionId: lastClaudeSessionId },
 });
 
 type Emit = (msg: Record<string, unknown>) => void;
@@ -253,12 +263,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();
@@ -275,8 +300,18 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
         tool.name,
         tool.description ?? '',
         shape,
-        async (input: Record<string, unknown>) => {
-          const toolCallId = randomUUID();
+        async (
+          ...handlerArgs: [
+            Record<string, unknown>,
+            { requestId: string | number; _meta?: Record<string, unknown> },
+          ]
+        ) => {
+          const [input, extra] = handlerArgs;
+          const metadataToolCallId = extra._meta?.['claudecode/toolUseId'];
+          const toolCallId =
+            typeof metadataToolCallId === 'string'
+              ? metadataToolCallId
+              : randomUUID();
           emit({
             type: 'tool-call',
             toolCallId,
@@ -377,17 +412,43 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
           },
         ],
       },
-      // Continuation rule: the host can force-continue (resume after a
-      // cross-process detach) by setting `start.continue: true`; otherwise
-      // we continue every subsequent turn after the first one in this
-      // bridge process.
-      ...(start.continue === true || !turn.firstTurn ? { continue: true } : {}),
+      // Continuation rule, most specific first.
+      //
+      // `resumeSessionId` names the exact conversation and is what a
+      // cross-process resume should use: `continue` means "most recent thread
+      // in this workdir", which silently picks the wrong one once anything
+      // else has run there. The bridge also retains the id observed during its
+      // previous query, so every later query stays pinned to that conversation
+      // even when the host detached and reattached between turns. `resume` and
+      // `continue` are mutually exclusive in the SDK.
+      //
+      // Otherwise the host can force-continue by setting `start.continue`,
+      // and turns after the first fall back to the legacy cwd-based behavior
+      // when no exact id was observed.
+      ...((start.resumeSessionId ?? lastClaudeSessionId)
+        ? { resume: start.resumeSessionId ?? lastClaudeSessionId }
+        : start.continue === true || !turn.firstTurn
+          ? { continue: true }
+          : {}),
       ...permissionOptions,
       mcpServers,
       cwd: workdir,
       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 +459,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();
   };
@@ -425,6 +493,14 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
         queryInput.handleLifecycle(msg);
       }
 
+      // Every SDK message carries the session id of the conversation it
+      // belongs to. Track the latest so the stop payload and the terminal
+      // finish metadata name the exact conversation.
+      const sessionId = (msg as { session_id?: unknown }).session_id;
+      if (typeof sessionId === 'string' && sessionId.length > 0) {
+        lastClaudeSessionId = sessionId;
+      }
+
       emitStreamEvent(msg);
 
       if (type === 'result') {
@@ -483,12 +559,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;
@@ -498,8 +600,20 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
     type: 'finish',
     finishReason: { unified: 'stop', raw: 'stop' },
     totalUsage: turnUsage ?? streamEventState.stepUsage ?? defaultUsage(),
-    ...(totalCostUsd !== undefined
-      ? { harnessMetadata: { 'claude-code': { costUsd: totalCostUsd } } }
+    ...(totalCostUsd !== undefined || lastClaudeSessionId !== undefined
+      ? {
+          harnessMetadata: {
+            'claude-code': {
+              ...(totalCostUsd !== undefined ? { costUsd: totalCostUsd } : {}),
+              // The conversation this turn belongs to, resumable outside the
+              // SDK with `claude --resume <sessionId>` and captured by the
+              // adapter for exact cross-process resume.
+              ...(lastClaudeSessionId !== undefined
+                ? { sessionId: lastClaudeSessionId }
+                : {}),
+            },
+          },
+        }
       : {}),
   });
 }

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"
   }