@ai-sdk/harness-claude-code 1.0.80 → 1.0.81

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @ai-sdk/harness-claude-code
 
+## 1.0.81
+
+### Patch Changes
+
+- eace6fb: feat(harness): add experimental support for steering agent conversations mid-turn
+- c0595b4: feat(harness): support passing a filesystem and process restricted sandbox session to `HarnessAgentSession`, using fallbacks in favor of the preferred network sandbox session methods
+- Updated dependencies [eace6fb]
+- Updated dependencies [c0595b4]
+  - @ai-sdk/harness@1.0.78
+
 ## 1.0.80
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -1,6 +1,7 @@
 // ../harness/dist/bridge/index.js
 import { appendFile, mkdir, writeFile } from "fs/promises";
 import { existsSync, readFileSync } from "fs";
+import { randomUUID } from "crypto";
 import { env as procEnv, pid, stdout } from "process";
 import { WebSocketServer } from "ws";
 var DEBUG_LEVEL_WEIGHT = {
@@ -31,6 +32,106 @@ function formatBridgeError(err) {
   }
   return { message: String(err) };
 }
+function createBridgeUserMessageQueue(options) {
+  const messages = [];
+  const waiters = [];
+  const entries = /* @__PURE__ */ new Map();
+  let closed = false;
+  let pendingCount = 0;
+  const enqueue = (input) => {
+    const existing = entries.get(input.messageId);
+    if (existing != null) {
+      if (existing.response != null) {
+        options.respond(existing.response);
+      }
+      return;
+    }
+    let settled = false;
+    const settle = (response) => {
+      if (settled) return;
+      settled = true;
+      pendingCount--;
+      const entry = entries.get(input.messageId);
+      if (entry != null) entry.response = response;
+      options.respond(response);
+    };
+    const message = {
+      messageId: input.messageId,
+      text: input.text,
+      accept: () => {
+        settle({
+          type: "user-message-response",
+          messageId: input.messageId,
+          accepted: true
+        });
+      },
+      reject: (error) => {
+        settle({
+          type: "user-message-response",
+          messageId: input.messageId,
+          accepted: false,
+          error: { message: formatBridgeError(error).message }
+        });
+      }
+    };
+    entries.set(input.messageId, {
+      reject: message.reject
+    });
+    pendingCount++;
+    if (closed) {
+      message.reject(
+        new Error("The bridge turn is no longer accepting user messages.")
+      );
+      return;
+    }
+    const waiter = waiters.shift();
+    if (waiter != null) {
+      waiter({ done: false, value: message });
+    } else {
+      messages.push(message);
+    }
+  };
+  const close = (error) => {
+    if (closed) return;
+    closed = true;
+    const reason = error ?? new Error("The bridge turn ended before accepting the user message.");
+    for (const entry of entries.values()) {
+      if (entry.response == null) entry.reject(reason);
+    }
+    messages.length = 0;
+    while (waiters.length > 0) {
+      waiters.shift()({ done: true, value: void 0 });
+    }
+  };
+  return {
+    get pendingCount() {
+      return pendingCount;
+    },
+    enqueue,
+    close,
+    [Symbol.asyncIterator]() {
+      return {
+        next: () => {
+          const message = messages.shift();
+          if (message != null) {
+            return Promise.resolve({ done: false, value: message });
+          }
+          if (closed) {
+            return Promise.resolve({
+              done: true,
+              value: void 0
+            });
+          }
+          return new Promise(
+            (resolve) => {
+              waiters.push(resolve);
+            }
+          );
+        }
+      };
+    }
+  };
+}
 function parseEnvList(value) {
   if (!value) return void 0;
   const items = value.split(",").map((item) => item.trim()).filter(Boolean);
@@ -247,6 +348,9 @@ async function runBridge(options) {
     switch (msg.type) {
       case "start": {
         activeSocket = ws;
+        currentUserMessages?.close(
+          new Error("A new bridge turn replaced the active turn.")
+        );
         const firstTurn = isFirstTurn;
         isFirstTurn = false;
         eventLog = [];
@@ -266,6 +370,7 @@ async function runBridge(options) {
         if (debugConfig.enabled) {
           installConsoleCapture();
         }
+        const userMessages = createBridgeUserMessageQueue({ respond: emit });
         const turn = {
           emit,
           requestToolResult: (toolCallId) => new Promise((resolve) => {
@@ -274,7 +379,7 @@ async function runBridge(options) {
           requestToolApproval: (approvalId) => new Promise((resolve) => {
             pendingToolApprovals.set(approvalId, resolve);
           }),
-          pendingUserMessages: [],
+          experimental_userMessages: userMessages,
           abortSignal: turnAbort.signal,
           firstTurn,
           bridgeLog: (input) => {
@@ -292,12 +397,16 @@ async function runBridge(options) {
           emitWarning,
           emitError
         };
-        currentUserMessages = turn.pendingUserMessages;
+        currentUserMessages = userMessages;
         try {
           await onStart(msg, turn);
         } catch (err) {
           emitError({ error: err, message: "bridge turn failed" });
         } finally {
+          userMessages.close();
+          if (currentUserMessages === userMessages) {
+            currentUserMessages = void 0;
+          }
           currentTurnState = "waiting";
           void writeBridgeMeta("waiting");
         }
@@ -319,9 +428,34 @@ async function runBridge(options) {
         }
         return;
       }
-      case "user-message":
-        currentUserMessages?.push(msg.text);
+      case "user-message": {
+        const messageId = msg.messageId ?? randomUUID();
+        if (currentUserMessages == null) {
+          sendControl(ws, {
+            type: "user-message-response",
+            messageId,
+            accepted: false,
+            error: { message: "The bridge has no active turn to steer." }
+          });
+          return;
+        }
+        if (ws !== activeSocket) {
+          sendControl(ws, {
+            type: "user-message-response",
+            messageId,
+            accepted: false,
+            error: {
+              message: "The connection does not own the active bridge turn."
+            }
+          });
+          return;
+        }
+        currentUserMessages.enqueue({
+          messageId,
+          text: msg.text
+        });
         return;
+      }
       case "abort":
         turnAbort?.abort();
         return;
@@ -395,7 +529,8 @@ async function runBridge(options) {
     sendControl(ws, {
       type: "bridge-hello",
       state: currentTurnState,
-      lastSeq: seqCounter
+      lastSeq: seqCounter,
+      capabilities: { experimental_userMessageResponses: true }
     });
     ws.on("message", (raw) => {
       let parsed;
@@ -484,7 +619,7 @@ function createCompactionLatch(emit) {
 }
 
 // src/bridge/index.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { argv, env as procEnv2, stdout as stdout2 } from "process";
 import * as claudeAgentSdk from "@anthropic-ai/claude-agent-sdk";
 import * as mcpServerModule from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -504,7 +639,7 @@ function toClaudeSkillsOption(skills) {
 }
 
 // src/bridge/create-emit-stream-event.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function createClaudeStreamEventState() {
   return {
     nativeToolCallNames: /* @__PURE__ */ new Map(),
@@ -710,11 +845,11 @@ function handleStreamEvent(event, partialBlocks, send) {
   if (event.type === "content_block_start") {
     const blockType = event.content_block?.type;
     if (blockType === "text") {
-      const id = randomUUID();
+      const id = randomUUID2();
       partialBlocks.set(index, { id, kind: "text" });
       send({ type: "text-start", id });
     } else if (blockType === "thinking") {
-      const id = randomUUID();
+      const id = randomUUID2();
       partialBlocks.set(index, { id, kind: "thinking" });
       send({ type: "reasoning-start", id });
     }
@@ -1071,7 +1206,7 @@ async function runTurn(start, turn) {
         tool.description ?? "",
         shape,
         async (input) => {
-          const toolCallId = randomUUID2();
+          const toolCallId = randomUUID3();
           emit({
             type: "tool-call",
             toolCallId,
@@ -1103,7 +1238,7 @@ async function runTurn(start, turn) {
   const compaction = createCompactionLatch((event) => emit(event));
   const queryInput = createQueryInput({
     initialUserMessage: start.prompt,
-    pendingUserMessages: turn.pendingUserMessages,
+    userMessages: turn.experimental_userMessages,
     abortSignal: abortCtl.signal
   });
   const skillsOption = toClaudeSkillsOption(start.skills);
@@ -1197,6 +1332,9 @@ async function runTurn(start, turn) {
     for await (const msg of q) {
       if (abortCtl.signal.aborted) break;
       const type = msg.type;
+      if (type === "command_lifecycle") {
+        queryInput.handleLifecycle(msg);
+      }
       emitStreamEvent(msg);
       if (type === "result") {
         if (msg.subtype === "success") {
@@ -1207,12 +1345,12 @@ async function runTurn(start, turn) {
           }
           const usage = msg.usage ?? msg.message?.usage;
           const harnessUsage = mapUsage(usage);
-          if (harnessUsage) turnUsage = harnessUsage;
+          if (harnessUsage) turnUsage = addUsage(turnUsage, harnessUsage);
           if (typeof msg.total_cost_usd === "number") {
             totalCostUsd = (totalCostUsd ?? 0) + msg.total_cost_usd;
           }
           if (start.responseFormat?.type === "json" && msg.structured_output !== void 0) {
-            const id = randomUUID2();
+            const id = randomUUID3();
             emit({ type: "text-start", id });
             emit({
               type: "text-delta",
@@ -1229,8 +1367,11 @@ async function runTurn(start, turn) {
               usage: harnessUsage ?? streamEventState.pendingStepUsage
             });
           }
-          queryInput.close();
-          break;
+          queryInput.observeResult();
+          if (!queryInput.hasActiveUserMessages()) {
+            queryInput.close();
+            break;
+          }
         } else {
           emitTerminalError(
             (Array.isArray(msg.errors) ? msg.errors.join("\n") : void 0) || streamEventState.observedTerminalError || msg.result || "Unknown error"
@@ -1238,6 +1379,10 @@ async function runTurn(start, turn) {
         }
         continue;
       }
+      if (queryInput.hasObservedResult && !queryInput.hasActiveUserMessages()) {
+        queryInput.close();
+        break;
+      }
     }
   } catch (err) {
     if (!(abortCtl.signal.aborted && emittedTerminalError)) {
@@ -1259,55 +1404,124 @@ async function runTurn(start, turn) {
 }
 function createQueryInput({
   initialUserMessage,
-  pendingUserMessages,
+  userMessages,
   abortSignal
 }) {
   let closed = false;
-  const close = () => {
+  let observedResult = false;
+  const submittedMessages = /* @__PURE__ */ new Map();
+  const close = (error) => {
+    if (closed) return;
     closed = true;
+    userMessages.close(error);
   };
   if (abortSignal.aborted) {
-    close();
+    close(abortSignal.reason);
   } else {
-    abortSignal.addEventListener("abort", close, { once: true });
+    abortSignal.addEventListener("abort", () => close(abortSignal.reason), {
+      once: true
+    });
   }
-  const toUserMessage = (text) => ({
+  const toUserMessage = (options) => ({
     type: "user",
     message: {
       role: "user",
-      content: [{ type: "text", text }]
-    }
+      content: [{ type: "text", text: options.text }]
+    },
+    parent_tool_use_id: null,
+    uuid: options.messageId,
+    ...options.priority == null ? {} : { priority: options.priority }
   });
+  const messageIterator = userMessages[Symbol.asyncIterator]();
   return {
     close,
+    handleLifecycle: (message) => {
+      const lifecycle = message;
+      if (lifecycle.command_uuid == null || lifecycle.state == null) return;
+      const submitted = submittedMessages.get(lifecycle.command_uuid);
+      if (submitted == null) return;
+      if (lifecycle.state === "queued" || lifecycle.state === "started") {
+        submitted.accept();
+        return;
+      }
+      if (lifecycle.state === "cancelled" || lifecycle.state === "discarded") {
+        submitted.reject(
+          new Error(`Claude Code ${lifecycle.state} the user message.`)
+        );
+      }
+      submittedMessages.delete(lifecycle.command_uuid);
+    },
+    hasActiveUserMessages: () => submittedMessages.size > 0 || userMessages.pendingCount > 0,
+    observeResult: () => {
+      observedResult = true;
+    },
+    get hasObservedResult() {
+      return observedResult;
+    },
     input: {
       [Symbol.asyncIterator]() {
         let sentInitial = false;
         return {
           async next() {
-            while (!closed && !abortSignal.aborted) {
-              if (!sentInitial) {
-                sentInitial = true;
-                return {
-                  value: toUserMessage(initialUserMessage),
-                  done: false
-                };
-              }
-              if (pendingUserMessages.length > 0) {
-                return {
-                  value: toUserMessage(pendingUserMessages.shift()),
-                  done: false
-                };
-              }
-              await new Promise((resolve) => setTimeout(resolve, 50));
+            if (closed || abortSignal.aborted) {
+              return {
+                value: void 0,
+                done: true
+              };
+            }
+            if (!sentInitial) {
+              sentInitial = true;
+              return {
+                value: toUserMessage({
+                  text: initialUserMessage,
+                  messageId: randomUUID3()
+                }),
+                done: false
+              };
             }
-            return { value: void 0, done: true };
+            const nextMessage = await messageIterator.next();
+            if (nextMessage.done) {
+              return {
+                value: void 0,
+                done: true
+              };
+            }
+            submittedMessages.set(
+              nextMessage.value.messageId,
+              nextMessage.value
+            );
+            return {
+              value: toUserMessage({
+                text: nextMessage.value.text,
+                messageId: nextMessage.value.messageId,
+                priority: "next"
+              }),
+              done: false
+            };
           }
         };
       }
     }
   };
 }
+function addUsage(total, usage) {
+  if (total == null) return usage;
+  const result = { ...total };
+  for (const [key, value] of Object.entries(usage)) {
+    const previous = result[key];
+    if (typeof value === "number" && typeof previous === "number") {
+      result[key] = previous + value;
+    } else if (value != null && previous != null && typeof value === "object" && typeof previous === "object" && !Array.isArray(value) && !Array.isArray(previous)) {
+      result[key] = addUsage(
+        previous,
+        value
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 function parseArgs(args2) {
   const out = {};
   for (let i = 0; i < args2.length; i++) {