@ai-sdk/harness-opencode 1.0.78 → 1.0.80

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @ai-sdk/harness-opencode
 
+## 1.0.80
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.79
+
+## 1.0.79
+
+### 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.78
 
 ### 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;
@@ -456,7 +591,7 @@ function serialiseError(err) {
 }
 
 // src/bridge/index.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { mkdirSync } from "fs";
 import path2 from "path";
 import { argv, env as procEnv2 } from "process";
@@ -536,9 +671,6 @@ function getOpenCodeEventSessionId(event) {
   if (typeof partObject?.sessionID === "string") return partObject.sessionID;
   return void 0;
 }
-function isStepSettlementEvent(event) {
-  return event.type === "session.next.step.ended" || event.type === "session.next.step.failed" || event.type === "session.error";
-}
 function emitMissingFinalDelta({
   id,
   fullText,
@@ -1545,6 +1677,7 @@ async function runTurn(start, turn) {
   } catch (err) {
     turn.emitError({ error: err, message: "OpenCode turn failed" });
   } finally {
+    turn.experimental_userMessages.close();
     emit({
       type: "finish",
       finishReason: { unified: "stop", raw: "stop" },
@@ -1741,11 +1874,12 @@ async function legacySessionCreate({
 async function legacySessionPrompt({
   client,
   sessionId,
-  start
+  start,
+  prompt: promptText
 }) {
   const session = client.session;
-  const prompt = session.promptAsync ?? session.prompt;
-  return prompt.call(session, {
+  const submitPrompt = session.promptAsync ?? session.prompt;
+  return submitPrompt.call(session, {
     sessionID: sessionId,
     ...start.instructions ? { system: start.instructions } : {},
     ...start.variant ? { variant: start.variant } : {},
@@ -1755,7 +1889,7 @@ async function legacySessionPrompt({
         schema: start.responseFormat.schema
       }
     } : {},
-    parts: [{ type: "text", text: start.prompt }]
+    parts: [{ type: "text", text: promptText ?? start.prompt }]
   });
 }
 async function legacySessionSummarize({
@@ -1856,7 +1990,9 @@ async function runPrompt({
   let sawContent = false;
   let sawFinishStep = false;
   let sawBusy = false;
+  let sawStructuredOutput = false;
   let terminalError;
+  let submittingUserMessage = false;
   const state = createTranslationState();
   const initialSessionTokens = await readSessionTokens({
     client,
@@ -1899,7 +2035,7 @@ async function runPrompt({
         });
         const info = asOpenCodeObject(event.properties?.info);
         if (start.responseFormat?.type === "json" && info?.structured !== void 0) {
-          const id = String(info.id ?? randomUUID());
+          const id = String(info.id ?? randomUUID2());
           emit({ type: "text-start", id });
           emit({
             type: "text-delta",
@@ -1913,20 +2049,23 @@ async function runPrompt({
             usage: defaultUsage()
           });
           sawFinishStep = true;
-          turnSettled.resolve("event");
-          return true;
+          sawStructuredOutput = true;
+          if (!submittingUserMessage && turn.experimental_userMessages.pendingCount === 0) {
+            turn.experimental_userMessages.close();
+            turnSettled.resolve("event");
+            return true;
+          }
         }
       }
       if (event.type === "session.updated") {
         latestSessionTokens = extractSessionTokens(event.properties) ?? latestSessionTokens;
       }
-      if (isStepSettlementEvent(event)) {
+      if (event.type === "session.next.step.failed" || event.type === "session.error") {
+        const error = formatError(event.properties?.error ?? event);
         if (event.type === "session.error") {
-          terminalError = formatError(event.properties?.error ?? event);
-        }
-        if (start.responseFormat?.type === "json" && event.type === "session.next.step.ended") {
-          return;
+          terminalError = error;
         }
+        turn.experimental_userMessages.close(new Error(error));
         turnSettled.resolve("event");
         return true;
       }
@@ -1937,7 +2076,9 @@ async function runPrompt({
         sawBusy = true;
         turn.emitWarning({ message: legacyRetryStatusMessage(event) });
       } else if (sawBusy && status === "idle") {
-        if (start.responseFormat?.type !== "json") {
+        sawBusy = false;
+        if (!submittingUserMessage && turn.experimental_userMessages.pendingCount === 0 && (start.responseFormat?.type !== "json" || sawStructuredOutput)) {
+          turn.experimental_userMessages.close();
           turnSettled.resolve("event");
           return true;
         }
@@ -1945,9 +2086,36 @@ async function runPrompt({
     }
   }).finally(() => {
     eventsReady.resolve(void 0);
+    turn.experimental_userMessages.close(
+      new Error("OpenCode event stream ended before the turn settled.")
+    );
     turnSettled.resolve("stream-ended");
   });
   await eventsReady.promise;
+  const userMessageLoop = (async () => {
+    for await (const message of turn.experimental_userMessages) {
+      submittingUserMessage = true;
+      try {
+        const prompted2 = await legacySessionPrompt({
+          client,
+          sessionId,
+          start,
+          prompt: message.text
+        });
+        if (prompted2.error) {
+          message.reject(
+            new Error(`OpenCode prompt failed: ${formatError(prompted2.error)}`)
+          );
+          continue;
+        }
+        message.accept();
+      } catch (error) {
+        message.reject(error);
+      } finally {
+        submittingUserMessage = false;
+      }
+    }
+  })();
   const prompted = await legacySessionPrompt({
     client,
     sessionId,
@@ -1955,12 +2123,17 @@ async function runPrompt({
   });
   if (prompted.error) {
     eventsAbort.abort();
+    turn.experimental_userMessages.close(
+      new Error(`OpenCode prompt failed: ${formatError(prompted.error)}`)
+    );
     throw new Error(`OpenCode prompt failed: ${formatError(prompted.error)}`);
   }
   const settlement = await turnSettled.promise;
   eventsAbort.abort();
   await eventLoop.catch(() => {
   });
+  await userMessageLoop.catch(() => {
+  });
   if (settlement === "stream-ended") {
     throw new Error("OpenCode event stream ended before the turn settled.");
   }
@@ -2394,7 +2567,7 @@ function emitAssistantContentPart(part, emit) {
   if (!part || typeof part !== "object") return;
   const value = part;
   if (value.type !== "text" && value.type !== "reasoning") return;
-  const id = typeof value.id === "string" && value.id.length > 0 ? value.id : `${value.type}-${randomUUID()}`;
+  const id = typeof value.id === "string" && value.id.length > 0 ? value.id : `${value.type}-${randomUUID2()}`;
   const text = typeof value.text === "string" ? value.text : "";
   if (value.type === "text") {
     emit({ type: "text-start", id });