@ai-sdk/harness-deepagents 1.0.77 → 1.0.79

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ai-sdk/harness-deepagents
 
+## 1.0.79
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.79
+
+## 1.0.78
+
+### 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.77
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -1,10 +1,11 @@
 // src/bridge/index.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { argv, env as procEnv2 } from "process";
 
 // ../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 = {
@@ -35,6 +36,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);
@@ -251,6 +352,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 = [];
@@ -270,6 +374,7 @@ async function runBridge(options) {
         if (debugConfig.enabled) {
           installConsoleCapture();
         }
+        const userMessages = createBridgeUserMessageQueue({ respond: emit });
         const turn = {
           emit,
           requestToolResult: (toolCallId) => new Promise((resolve) => {
@@ -278,7 +383,7 @@ async function runBridge(options) {
           requestToolApproval: (approvalId) => new Promise((resolve) => {
             pendingToolApprovals.set(approvalId, resolve);
           }),
-          pendingUserMessages: [],
+          experimental_userMessages: userMessages,
           abortSignal: turnAbort.signal,
           firstTurn,
           bridgeLog: (input) => {
@@ -296,12 +401,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");
         }
@@ -323,9 +432,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;
@@ -399,7 +533,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;
@@ -1423,7 +1558,7 @@ function collectActionRequests(interrupts) {
 }
 
 // src/bridge/create-emit-stream-event.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function createDeepAgentsStreamEventState() {
   return {
     streamStarted: false,
@@ -1607,7 +1742,7 @@ function ensureTextBlock({
   emit
 }) {
   if (!state.textBlockId) {
-    state.textBlockId = `text-${randomUUID()}`;
+    state.textBlockId = `text-${randomUUID2()}`;
     emit({ type: "text-start", id: state.textBlockId });
   }
   return state.textBlockId;
@@ -1627,7 +1762,7 @@ function emitReasoning({
 }) {
   endTextBlock({ state, emit });
   if (!state.reasoningBlockId) {
-    state.reasoningBlockId = `reasoning-${randomUUID()}`;
+    state.reasoningBlockId = `reasoning-${randomUUID2()}`;
     emit({ type: "reasoning-start", id: state.reasoningBlockId });
   }
   emit({ type: "reasoning-delta", id: state.reasoningBlockId, delta });
@@ -1883,7 +2018,7 @@ function buildHostTools(toolSchemas) {
       async (input) => {
         const turn = currentTurn;
         if (!turn) throw new Error("no active turn");
-        const toolCallId = `${schema.name}-${randomUUID2()}`;
+        const toolCallId = `${schema.name}-${randomUUID3()}`;
         turn.emit({
           type: "tool-call",
           toolCallId,
@@ -2001,7 +2136,7 @@ async function runTurn(start, turn) {
       const namespace = streamEvent.metadata?.langgraph_checkpoint_ns ?? "";
       const output = streamEvent.data?.output;
       if (!emittedStructuredOutput && streamEvent.event === "on_chain_end" && !namespace.includes("|") && output?.structuredResponse !== void 0) {
-        const id = `structured-output-${randomUUID2()}`;
+        const id = `structured-output-${randomUUID3()}`;
         emit({ type: "text-start", id });
         emit({
           type: "text-delta",
@@ -2016,7 +2151,7 @@ async function runTurn(start, turn) {
     if (actionRequests.length === 0) break;
     const decisions = [];
     for (const action of actionRequests) {
-      const approvalId = `approval-${randomUUID2()}`;
+      const approvalId = `approval-${randomUUID3()}`;
       endTextBlock({ state: streamEventState, emit });
       endReasoningBlock({ state: streamEventState, emit });
       emit({