@ai-sdk/harness-claude-code 1.0.21 → 1.0.23

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @ai-sdk/harness-claude-code
 
+## 1.0.23
+
+### Patch Changes
+
+- 39c8276: fix(harness): improve opaque sandbox bridge error handling
+- 91fe6d8: fix(harness): emit `finish-step` stream parts correctly per the underlying model steps
+- dcc7ecd: fix(harness-claude-code): fix Claude Code not displaying its reasoning by default
+- Updated dependencies [39c8276]
+- Updated dependencies [91fe6d8]
+- Updated dependencies [0be5014]
+  - @ai-sdk/harness@1.0.23
+
+## 1.0.22
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.22
+- @ai-sdk/provider-utils@5.0.7
+
 ## 1.0.21
 
 ### Patch Changes

package/README.md

@@ -42,7 +42,9 @@ const agent = new HarnessAgent({
     }),
   },
   harnessOptions: {
-    'claude-code': { thinking: 'adaptive' },
+    'claude-code': {
+      thinking: { type: 'adaptive', display: 'summarized' },
+    },
   },
 });
 

package/dist/bridge/index.mjs

@@ -20,6 +20,15 @@ function formatBridgeError(err) {
   if (err instanceof Error) {
     return { name: err.name, message: err.message, stack: err.stack };
   }
+  if (typeof err === "string") {
+    return { message: err };
+  }
+  if (err !== null && typeof err === "object") {
+    try {
+      return { message: JSON.stringify(err) };
+    } catch {
+    }
+  }
   return { message: String(err) };
 }
 function parseEnvList(value) {
@@ -47,6 +56,7 @@ async function runBridge(options) {
   let isFirstTurn = true;
   let turnAbort;
   let currentUserMessages;
+  let currentInterruptHandler;
   let debugConfig;
   let consoleCaptureInstalled = false;
   const envDebugEnabled = ENV_TRUTHY.has(
@@ -164,6 +174,38 @@ async function runBridge(options) {
   };
   const rawStdoutWrite = process.stdout.write.bind(process.stdout);
   const rawStderrWrite = process.stderr.write.bind(process.stderr);
+  const writeErrorToStderr = (input) => {
+    try {
+      const formatted = formatBridgeError(input.error);
+      rawStderrWrite(
+        `[harness:${bridgeType}:error] ${input.message}: ${formatted.message}
+`
+      );
+      if (formatted.stack) {
+        rawStderrWrite(`${formatted.stack}
+`);
+      }
+    } catch {
+    }
+  };
+  const emitWarning = (input) => {
+    try {
+      for (const line of input.message.split("\n")) {
+        if (line.trim().length > 0) {
+          rawStderrWrite(`[harness:${bridgeType}:warn] ${line}
+`);
+        }
+      }
+    } catch {
+    }
+  };
+  const emitError = (input) => {
+    writeErrorToStderr({
+      message: input.message ?? "bridge error",
+      error: input.error
+    });
+    emit({ type: "error", error: serialiseError(input.error) });
+  };
   const installConsoleCapture = () => {
     if (consoleCaptureInstalled) return;
     consoleCaptureInstalled = true;
@@ -221,6 +263,7 @@ async function runBridge(options) {
         });
         turnAbort = new AbortController();
         currentTurnState = "running";
+        currentInterruptHandler = void 0;
         void writeStartConfig(msg);
         void writeBridgeMeta("running");
         const startDebug = msg.debug;
@@ -242,6 +285,9 @@ async function runBridge(options) {
           }),
           pendingUserMessages: [],
           abortSignal: turnAbort.signal,
+          onInterrupt: (handler) => {
+            currentInterruptHandler = handler;
+          },
           firstTurn,
           bridgeLog: (input) => {
             const level = input.level ?? "debug";
@@ -254,14 +300,17 @@ async function runBridge(options) {
               ...input.attrs ? { attrs: input.attrs } : {},
               ...input.error !== void 0 ? { error: formatBridgeError(input.error) } : {}
             });
-          }
+          },
+          emitWarning,
+          emitError
         };
         currentUserMessages = turn.pendingUserMessages;
         try {
           await onStart(msg, turn);
         } catch (err) {
-          emit({ type: "error", error: serialiseError(err) });
+          emitError({ error: err, message: "bridge turn failed" });
         } finally {
+          currentInterruptHandler = void 0;
           currentTurnState = "waiting";
           void writeBridgeMeta("waiting");
         }
@@ -289,6 +338,22 @@ async function runBridge(options) {
       case "abort":
         turnAbort?.abort();
         return;
+      case "interrupt":
+        try {
+          if (currentInterruptHandler) {
+            await currentInterruptHandler();
+          } else {
+            turnAbort?.abort();
+          }
+          sendControl({ type: "bridge-interrupted", ok: true });
+        } catch (err) {
+          sendControl({
+            type: "bridge-interrupted",
+            ok: false,
+            error: serialiseError(err)
+          });
+        }
+        return;
       case "resume":
         replay(ws, msg.lastSeenEventId);
         return;
@@ -383,10 +448,10 @@ async function runBridge(options) {
     });
   });
   process.on("uncaughtException", (err) => {
-    emit({ type: "error", error: serialiseError(err) });
+    emitError({ error: err, message: "uncaught exception" });
   });
   process.on("unhandledRejection", (err) => {
-    emit({ type: "error", error: serialiseError(err) });
+    emitError({ error: err, message: "unhandled rejection" });
   });
   await new Promise((resolve, reject) => {
     if (wss.address() != null) {
@@ -488,6 +553,7 @@ var PUBLIC_TO_NATIVE = {
   Skill: "Skill"
 };
 var PUBLIC_TOOL_NAMES = Object.keys(PUBLIC_TO_NATIVE);
+var UNRECOVERABLE_API_RETRY_STATUSES = /* @__PURE__ */ new Set([401, 403, 404]);
 var NATIVE_TOOL_KINDS = {
   Read: "readonly",
   Glob: "readonly",
@@ -536,18 +602,6 @@ function resolveInactiveNativeTools(start) {
   ) : toolFiltering.toolNames;
   return inactiveToolNames.map((name) => toNativeName(name));
 }
-function toThinkingConfig(thinking) {
-  switch (thinking) {
-    case "adaptive":
-      return { type: "adaptive", display: "summarized" };
-    case "on":
-      return { type: "enabled", display: "summarized" };
-    case "off":
-      return { type: "disabled" };
-    default:
-      return void 0;
-  }
-}
 var args = parseArgs(argv.slice(2));
 var workdir = args.workdir;
 var bridgeStateDir = args.bridgeStateDir;
@@ -610,6 +664,7 @@ function createPermissionOptions(input) {
         approvalId,
         toolCallId: approvalId
       });
+      input.finishApprovalStep(approvalId);
       const decision = await input.turn.requestToolApproval(approvalId);
       return decision.approved ? { behavior: "allow", updatedInput: toolInput, toolUseID: approvalId } : {
         behavior: "deny",
@@ -650,6 +705,28 @@ async function runTurn(start, turn) {
   }
   const nativeToolCallNames = /* @__PURE__ */ new Map();
   const approvalRequestedToolUseIds = /* @__PURE__ */ new Set();
+  const partialBlocks = /* @__PURE__ */ new Map();
+  let stepUsage;
+  let pendingStepToolUseIds = /* @__PURE__ */ new Set();
+  let pendingStepUsage;
+  let stepOpen = false;
+  const emitFinishStep = (usage) => {
+    emit({
+      type: "finish-step",
+      finishReason: { unified: "stop", raw: "stop" },
+      usage: usage ?? defaultUsage()
+    });
+    stepUsage = usage ?? stepUsage;
+    pendingStepUsage = void 0;
+    pendingStepToolUseIds = /* @__PURE__ */ new Set();
+    stepOpen = false;
+  };
+  const closeStepIfReady = () => {
+    if (!stepOpen || pendingStepToolUseIds.size > 0 || partialBlocks.size > 0) {
+      return;
+    }
+    emitFinishStep(pendingStepUsage);
+  };
   const mcpToolUseIds = /* @__PURE__ */ new Set();
   const mcpServers = {};
   if (start.tools && start.tools.length > 0) {
@@ -707,6 +784,11 @@ async function runTurn(start, turn) {
     inactiveNativeTools,
     turn,
     emit,
+    finishApprovalStep: (approvalId) => {
+      stepOpen = true;
+      pendingStepToolUseIds.delete(approvalId);
+      closeStepIfReady();
+    },
     nativeToolCallNames,
     approvalRequestedToolUseIds
   });
@@ -718,7 +800,7 @@ async function runTurn(start, turn) {
       ...skillsOption ? { skills: skillsOption } : {},
       ...nativeTools !== void 0 ? { tools: nativeTools } : {},
       ...inactiveNativeTools.length > 0 ? { disallowedTools: inactiveNativeTools } : {},
-      ...toThinkingConfig(start.thinking) ? { thinking: toThinkingConfig(start.thinking) } : {},
+      thinking: start.thinking,
       includePartialMessages: true,
       // The `PostCompact` hook carries the compaction summary, which the
       // `compact_boundary` system message does not. Latch it for the unified
@@ -748,28 +830,28 @@ async function runTurn(start, turn) {
       abortSignal: abortCtl.signal
     }
   });
-  let stepUsage;
+  turn.onInterrupt(() => q.interrupt());
+  let turnUsage;
   let totalCostUsd;
   let observedTerminalError;
   let emittedTerminalError = false;
   let emittedTerminalFinish = false;
   let streamStarted = false;
-  const partialBlocks = /* @__PURE__ */ new Map();
   const emitTerminalError = (message) => {
     const normalized = message?.trim();
     if (!normalized || emittedTerminalError || emittedTerminalFinish) return;
     observedTerminalError = normalized;
     emittedTerminalError = true;
-    emit({ type: "error", error: normalized });
+    turn.emitError({
+      error: normalized,
+      message: "claude-code terminal error"
+    });
     queryInput.close();
     abortCtl.abort();
   };
   try {
     for await (const msg of q) {
       if (abortCtl.signal.aborted) break;
-      if (typeof msg.error === "string" && msg.error.trim()) {
-        observedTerminalError = msg.error.trim();
-      }
       const type = msg.type;
       if (!streamStarted) {
         const initModel = type === "system" && msg.subtype === "init" && typeof msg.model === "string" ? msg.model : void 0;
@@ -779,14 +861,21 @@ async function runTurn(start, turn) {
         });
         streamStarted = true;
       }
-      if (type === "auth_status" && typeof msg.error === "string" && msg.error.trim()) {
-        emitTerminalError(msg.error);
+      if (type === "system" && msg.subtype === "api_retry") {
+        if (typeof msg.error_status === "number" && UNRECOVERABLE_API_RETRY_STATUSES.has(msg.error_status)) {
+          emitTerminalError(
+            `HTTP ${msg.error_status}: ${msg.error ?? "provider request failed"}`
+          );
+          continue;
+        }
+        turn.emitWarning({ message: formatApiRetryWarning(msg) });
         continue;
       }
-      if (type === "system" && msg.subtype === "api_retry" && typeof msg.error_status === "number" && [401, 403, 404].includes(msg.error_status)) {
-        emitTerminalError(
-          `HTTP ${msg.error_status}: ${msg.error ?? "provider request failed"}`
-        );
+      if (typeof msg.error === "string" && msg.error.trim()) {
+        observedTerminalError = msg.error.trim();
+      }
+      if (type === "auth_status" && typeof msg.error === "string" && msg.error.trim()) {
+        emitTerminalError(msg.error);
         continue;
       }
       if (type === "system" && msg.subtype === "task_updated" && msg.patch?.status === "failed" && typeof msg.patch.error === "string") {
@@ -809,17 +898,25 @@ async function runTurn(start, turn) {
         continue;
       }
       if (type === "assistant" && msg.message?.content) {
+        const usage = mapUsage(msg.message.usage);
+        const toolUseIds = [];
+        let opensStep = false;
         for (const block of msg.message.content) {
           if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+            toolUseIds.push(block.id);
             const mcpPrefix = "mcp__harness-tools__";
             if (block.name.startsWith(mcpPrefix)) {
+              pendingStepToolUseIds.add(block.id);
               mcpToolUseIds.add(block.id);
+              opensStep = true;
               continue;
             }
             nativeToolCallNames.set(block.id, block.name);
             if (approvalRequestedToolUseIds.has(block.id)) {
               continue;
             }
+            pendingStepToolUseIds.add(block.id);
+            opensStep = true;
             emit({
               type: "tool-call",
               toolCallId: block.id,
@@ -830,6 +927,10 @@ async function runTurn(start, turn) {
             });
           }
         }
+        if (opensStep || toolUseIds.length === 0) {
+          stepOpen = true;
+          if (usage) pendingStepUsage = usage;
+        }
         continue;
       }
       if (type === "user" && msg.message?.content) {
@@ -837,6 +938,7 @@ async function runTurn(start, turn) {
           if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
             if (mcpToolUseIds.has(block.tool_use_id)) {
               mcpToolUseIds.delete(block.tool_use_id);
+              pendingStepToolUseIds.delete(block.tool_use_id);
               continue;
             }
             approvalRequestedToolUseIds.delete(block.tool_use_id);
@@ -853,8 +955,10 @@ async function runTurn(start, turn) {
               result,
               isError
             });
+            pendingStepToolUseIds.delete(block.tool_use_id);
           }
         }
+        closeStepIfReady();
         continue;
       }
       if (type === "result") {
@@ -866,17 +970,11 @@ async function runTurn(start, turn) {
           }
           const usage = msg.usage ?? msg.message?.usage;
           const harnessUsage = mapUsage(usage);
-          if (harnessUsage) stepUsage = harnessUsage;
+          if (harnessUsage) turnUsage = harnessUsage;
           if (typeof msg.total_cost_usd === "number") {
             totalCostUsd = (totalCostUsd ?? 0) + msg.total_cost_usd;
           }
-          const metadata = typeof msg.total_cost_usd === "number" ? { "claude-code": { costUsd: msg.total_cost_usd } } : void 0;
-          emit({
-            type: "finish-step",
-            finishReason: { unified: "stop", raw: "stop" },
-            usage: harnessUsage ?? defaultUsage(),
-            ...metadata ? { harnessMetadata: metadata } : {}
-          });
+          if (stepOpen) emitFinishStep(harnessUsage ?? pendingStepUsage);
           queryInput.close();
           break;
         } else {
@@ -889,7 +987,7 @@ async function runTurn(start, turn) {
     }
   } catch (err) {
     if (!(abortCtl.signal.aborted && emittedTerminalError)) {
-      emit({ type: "error", error: serialiseError2(err) });
+      turn.emitError({ error: err, message: "claude-code turn failed" });
     }
     return;
   } finally {
@@ -901,10 +999,25 @@ async function runTurn(start, turn) {
   emit({
     type: "finish",
     finishReason: { unified: "stop", raw: "stop" },
-    totalUsage: stepUsage ?? defaultUsage(),
+    totalUsage: turnUsage ?? stepUsage ?? defaultUsage(),
     ...totalCostUsd !== void 0 ? { harnessMetadata: { "claude-code": { costUsd: totalCostUsd } } } : {}
   });
 }
+function formatApiRetryWarning(msg) {
+  const details = [];
+  if (typeof msg.attempt === "number") {
+    const maxRetries = typeof msg.max_retries === "number" ? `/${msg.max_retries}` : "";
+    details.push(`attempt ${msg.attempt}${maxRetries}`);
+  }
+  if (typeof msg.error_status === "number") {
+    details.push(`HTTP ${msg.error_status}`);
+  }
+  if (typeof msg.retry_delay_ms === "number") {
+    details.push(`retrying in ${msg.retry_delay_ms}ms`);
+  }
+  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) {
   if (!event || typeof event.index !== "number") return;
   const index = event.index;
@@ -1071,12 +1184,6 @@ function parseArgs(args2) {
   }
   return out;
 }
-function serialiseError2(err) {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  return err;
-}
 function emitFatal(message) {
   stdout2.write(JSON.stringify({ type: "bridge-fatal", message }) + "\n");
   process.exit(1);