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

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ai-sdk/harness-claude-code
 
+## 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;
       }
@@ -1185,12 +1209,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 ?? {} };
@@ -1304,6 +1335,11 @@ async function runTurn(start, turn) {
       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 +1349,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();
   };
@@ -1385,12 +1423,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;