@ai-sdk/harness-codex 1.0.79 → 1.0.80

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @ai-sdk/harness-codex
 
+## 1.0.80
+
+### 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.79
 
 ### 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;
@@ -705,7 +840,7 @@ function defaultUsage() {
 }
 
 // src/bridge/create-emit-stream-event.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 var NATIVE_TO_COMMON = {
   shell: "bash",
   web_search: "webSearch"
@@ -749,7 +884,7 @@ function createEmitStreamEvent({
     }
     if (!event.item) return;
     const item = event.item;
-    const id = item.id ?? randomUUID();
+    const id = item.id ?? randomUUID2();
     const observeStep = () => {
       stepTracker.observeEvent({ event, itemId: id });
     };
@@ -1265,7 +1400,6 @@ async function runTurn(start, turn) {
     finishReason: { unified: "stop", raw: "stop" },
     totalUsage: turnUsage ?? defaultUsage()
   });
-  void turn.pendingUserMessages;
 }
 async function startToolRelay({
   tools,