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

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @ai-sdk/harness-claude-code
 
+## 1.0.98
+
+### Patch Changes
+
+- e79bc7a: fix(harness-claude-code): resume the exact conversation instead of the most recent one in the working directory
+- 8961fde: feat(harness): allow changing `model` between turns via call options
+- eb59f2a: fix(harness): ensure harness adapters can stream tool input deltas before the complete tool call arrives
+- Updated dependencies [8961fde]
+- Updated dependencies [eb59f2a]
+  - @ai-sdk/harness@1.0.94
+  - @ai-sdk/provider-utils@5.0.34
+
+## 1.0.97
+
+### Patch Changes
+
+- cc9f6ce: fix(harness): stop diagnosing caller-initiated aborts as bridge errors, and serialize bridge turns so a start racing an aborted turn's teardown no longer overlaps it (bounded by a teardown grace period, after which the start proceeds as before)
+- 7608210: feat(harness): add `model` parameter to `HarnessAgent` instead of having each harness adapter support it on their own constructor functions
+- f7bd978: chore(harness): update underlying adapter SDKs to their latest versions
+- 14d4fc0: feat(harness): allow changing harness settings between turns via `prepareCall()` support on `HarnessAgent`
+- Updated dependencies [cc9f6ce]
+- Updated dependencies [7608210]
+- Updated dependencies [6f8a2d7]
+- Updated dependencies [14d4fc0]
+- Updated dependencies [90192f1]
+  - @ai-sdk/harness@1.0.93
+  - @ai-sdk/provider-utils@5.0.33
+
 ## 1.0.96
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -141,6 +141,7 @@ var ENV_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
 var WS_OPEN = 1;
 async function runBridge(options) {
   const { bridgeType, bridgeStateDir: bridgeStateDir2, onStart, onStop, onDestroy } = options;
+  const teardownGraceMs = options.turnTeardownGraceMs ?? 1e4;
   const expectedToken = options.token ?? procEnv.BRIDGE_CHANNEL_TOKEN ?? "";
   const bridgeWsPort = options.port ?? parseInt(procEnv.BRIDGE_WS_PORT ?? "0", 10);
   const bridgeMetaPath = `${bridgeStateDir2}/bridge-meta.json`;
@@ -157,6 +158,7 @@ async function runBridge(options) {
   let isFirstTurn = true;
   let turnAbort;
   let currentUserMessages;
+  let activeTurn;
   let debugConfig;
   let consoleCaptureInstalled = false;
   const envDebugEnabled = ENV_TRUTHY.has(
@@ -347,10 +349,28 @@ async function runBridge(options) {
   const handleInbound = async (msg, ws) => {
     switch (msg.type) {
       case "start": {
+        for (; ; ) {
+          const pendingTurn = activeTurn;
+          if (pendingTurn == null) break;
+          turnAbort?.abort();
+          currentUserMessages?.close(
+            new Error("A new bridge turn replaced the active turn.")
+          );
+          let graceTimer;
+          const settled = await Promise.race([
+            pendingTurn.then(() => true),
+            new Promise((resolve) => {
+              graceTimer = setTimeout(() => resolve(false), teardownGraceMs);
+              graceTimer.unref?.();
+            })
+          ]);
+          clearTimeout(graceTimer);
+          if (!settled) break;
+        }
+        let turnFinished;
+        const thisTurn = new Promise((resolve) => turnFinished = resolve);
+        activeTurn = thisTurn;
         activeSocket = ws;
-        currentUserMessages?.close(
-          new Error("A new bridge turn replaced the active turn.")
-        );
         const firstTurn = isFirstTurn;
         isFirstTurn = false;
         eventLog = [];
@@ -407,8 +427,12 @@ async function runBridge(options) {
           if (currentUserMessages === userMessages) {
             currentUserMessages = void 0;
           }
-          currentTurnState = "waiting";
-          void writeBridgeMeta("waiting");
+          if (activeTurn === thisTurn) {
+            activeTurn = void 0;
+            currentTurnState = "waiting";
+            void writeBridgeMeta("waiting");
+          }
+          turnFinished();
         }
         return;
       }
@@ -711,7 +735,12 @@ function createEmitStreamEvent({
       return;
     }
     if (type === "stream_event") {
-      handleStreamEvent(msg.event, state.partialBlocks, emit);
+      handleStreamEvent({
+        event: msg.event,
+        state,
+        send: emit,
+        toCommonName: toCommonName2
+      });
       return;
     }
     if (type === "assistant" && msg.message?.content) {
@@ -839,9 +868,16 @@ function formatApiRetryWarning(msg) {
   if (msg.error) details.push(msg.error);
   return details.length > 0 ? `Claude Code API retry: ${details.join("; ")}` : "Claude Code API retry";
 }
-function handleStreamEvent(event, partialBlocks, send) {
+var HOST_TOOL_PREFIX = "mcp__harness-tools__";
+function handleStreamEvent({
+  event,
+  state,
+  send,
+  toCommonName: toCommonName2
+}) {
   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;
     if (blockType === "text") {
@@ -852,6 +888,22 @@ function handleStreamEvent(event, partialBlocks, send) {
       const id = randomUUID2();
       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) : void 0;
+      const dynamic = hostToolName === void 0 && nativeName.startsWith("mcp__");
+      partialBlocks.set(index, { id, kind: "tool-input" });
+      send({
+        type: "tool-input-start",
+        id,
+        toolName: hostToolName ?? toCommonName2(nativeName),
+        providerExecuted: hostToolName === void 0,
+        ...dynamic ? { dynamic: true } : {}
+      });
     }
     return;
   }
@@ -866,6 +918,12 @@ function handleStreamEvent(event, partialBlocks, send) {
         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;
   }
@@ -875,8 +933,10 @@ function handleStreamEvent(event, partialBlocks, send) {
     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 });
     }
   }
 }
@@ -1102,13 +1162,15 @@ if (!bridgeStateDir) {
 }
 var claudeSdk = claudeAgentSdk;
 var mcpModule = mcpServerModule;
+var lastClaudeSessionId;
 await runBridge({
   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 }
 });
 function createPermissionOptions(input) {
   const permissionMode = input.start.permissionMode ?? "allow-all";
@@ -1185,12 +1247,19 @@ function nativeToolRequiresApproval(input) {
 async function runTurn(start, turn) {
   const emit = (msg) => turn.emit(msg);
   const abortCtl = new AbortController();
+  let gracefulAbort;
+  let hardAbortTimer;
+  const onHostAbort = () => {
+    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();
   const mcpServers = { ...start.mcpServers ?? {} };
@@ -1205,8 +1274,10 @@ async function runTurn(start, turn) {
         tool.name,
         tool.description ?? "",
         shape,
-        async (input) => {
-          const toolCallId = randomUUID3();
+        async (...handlerArgs) => {
+          const [input, extra] = handlerArgs;
+          const metadataToolCallId = extra._meta?.["claudecode/toolUseId"];
+          const toolCallId = typeof metadataToolCallId === "string" ? metadataToolCallId : randomUUID3();
           emit({
             type: "tool-call",
             toolCallId,
@@ -1293,17 +1364,31 @@ async function runTurn(start, turn) {
           }
         ]
       },
-      // 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 = () => {
+    hardAbortTimer = setTimeout(() => abortCtl.abort(), 5e3);
+    hardAbortTimer.unref?.();
+    void Promise.resolve().then(() => q.interrupt()).catch(() => abortCtl.abort());
+  };
   let turnUsage;
   let totalCostUsd;
   let emittedTerminalError = false;
@@ -1313,10 +1398,12 @@ async function runTurn(start, turn) {
     if (!normalized || emittedTerminalError || emittedTerminalFinish) return;
     streamEventState.observedTerminalError = normalized;
     emittedTerminalError = true;
-    turn.emitError({
-      error: normalized,
-      message: "claude-code terminal error"
-    });
+    if (!turn.abortSignal.aborted) {
+      turn.emitError({
+        error: normalized,
+        message: "claude-code terminal error"
+      });
+    }
     queryInput.close();
     abortCtl.abort();
   };
@@ -1335,6 +1422,10 @@ async function runTurn(start, turn) {
       if (type === "command_lifecycle") {
         queryInput.handleLifecycle(msg);
       }
+      const sessionId = msg.session_id;
+      if (typeof sessionId === "string" && sessionId.length > 0) {
+        lastClaudeSessionId = sessionId;
+      }
       emitStreamEvent(msg);
       if (type === "result") {
         if (msg.subtype === "success") {
@@ -1385,12 +1476,21 @@ async function runTurn(start, turn) {
       }
     }
   } catch (err) {
-    if (!(abortCtl.signal.aborted && emittedTerminalError)) {
+    if (!turn.abortSignal.aborted && !(abortCtl.signal.aborted && emittedTerminalError)) {
       turn.emitError({ error: err, message: "claude-code turn failed" });
     }
     return;
   } finally {
+    gracefulAbort = void 0;
+    if (hardAbortTimer != null) clearTimeout(hardAbortTimer);
+    turn.abortSignal.removeEventListener("abort", onHostAbort);
     queryInput.close();
+    try {
+      await q.return?.(
+        void 0
+      );
+    } catch {
+    }
   }
   if (emittedTerminalError) return;
   emittedTerminalFinish = true;
@@ -1399,7 +1499,17 @@ async function runTurn(start, turn) {
     type: "finish",
     finishReason: { unified: "stop", raw: "stop" },
     totalUsage: turnUsage ?? streamEventState.stepUsage ?? defaultUsage(),
-    ...totalCostUsd !== void 0 ? { harnessMetadata: { "claude-code": { costUsd: totalCostUsd } } } : {}
+    ...totalCostUsd !== void 0 || lastClaudeSessionId !== void 0 ? {
+      harnessMetadata: {
+        "claude-code": {
+          ...totalCostUsd !== void 0 ? { 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 !== void 0 ? { sessionId: lastClaudeSessionId } : {}
+        }
+      }
+    } : {}
   });
 }
 function createQueryInput({