@ai-sdk/harness-acp 1.0.15 → 1.0.17

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ai-sdk/harness-acp
 
+## 1.0.17
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.79
+
+## 1.0.16
+
+### 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.15
 
 ### Patch Changes

package/dist/bridge/host-tool-mcp.mjs

@@ -12,7 +12,7 @@ import {
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-var VERSION = true ? "1.0.15" : "0.0.0-test";
+var VERSION = true ? "1.0.17" : "0.0.0-test";
 function createHostToolMCPServer({
   tools: tools2,
   revision = 1,

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 name = "AI_HarnessBridgeCapabilityUnsupportedError";
@@ -47,6 +48,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);
@@ -263,6 +364,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 = [];
@@ -282,6 +386,7 @@ async function runBridge(options) {
         if (debugConfig.enabled) {
           installConsoleCapture();
         }
+        const userMessages = createBridgeUserMessageQueue({ respond: emit });
         const turn = {
           emit,
           requestToolResult: (toolCallId) => new Promise((resolve) => {
@@ -290,7 +395,7 @@ async function runBridge(options) {
           requestToolApproval: (approvalId) => new Promise((resolve) => {
             pendingToolApprovals.set(approvalId, resolve);
           }),
-          pendingUserMessages: [],
+          experimental_userMessages: userMessages,
           abortSignal: turnAbort.signal,
           firstTurn,
           bridgeLog: (input) => {
@@ -308,12 +413,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");
         }
@@ -335,9 +444,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;
@@ -411,7 +545,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;