@ai-sdk/harness-opencode 1.0.78 → 1.0.80

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _ai_sdk_provider_utils from '@ai-sdk/provider-utils';
 import * as _ai_sdk_harness from '@ai-sdk/harness';
-import { HarnessV1, HarnessV1BuiltinTool } from '@ai-sdk/harness';
+import { HarnessV1PortEndpoint, HarnessV1, HarnessV1BuiltinTool } from '@ai-sdk/harness';
 
 type OpenCodeResolvedAuthenticationMode = 'anthropic' | 'openai' | 'ai-gateway';
 type OpenCodeAuthenticationMode = OpenCodeResolvedAuthenticationMode | 'auto';
@@ -48,6 +48,11 @@ type OpenCodeHarnessSettings = {
      */
     readonly reasoningVariant?: string;
     readonly port?: number;
+    /**
+     * Override the host endpoint used to connect to the sandbox bridge. Required
+     * together with `port` when using a basic sandbox session.
+     */
+    readonly portEndpoint?: HarnessV1PortEndpoint;
     readonly startupTimeoutMs?: number;
     /**
      * Creates the authentication token used by the sandbox bridge. Defaults to

package/dist/index.js

@@ -8,12 +8,15 @@ import {
 } from "@ai-sdk/harness";
 import {
   classifyDiskLog,
+  experimental_createBridgeUserMessageSubmitter,
   createBridgeErrorHandler,
   createBridgeStartupError,
   drainBridgeProcessStream,
   forwardBridgeProcessStream,
+  getRestrictedSandboxSession,
   markBridgeStarting,
   maskSandboxCredentials,
+  resolveSandboxDefaultWorkingDirectory,
   resolveSandboxHomeDir,
   SandboxChannel,
   shellQuote,
@@ -22,6 +25,7 @@ import {
   writeSkills as writeHarnessSkills
 } from "@ai-sdk/harness/utils";
 import {
+  safeParseJSON,
   tool
 } from "@ai-sdk/provider-utils";
 import { WebSocket } from "ws";
@@ -317,7 +321,7 @@ var inboundMessageSchema = z.discriminatedUnion("type", [
 ]);
 
 // src/version.ts
-var VERSION = true ? "1.0.78" : "0.0.0-test";
+var VERSION = true ? "1.0.80" : "0.0.0-test";
 
 // src/opencode-harness.ts
 var OPENCODE_CLIENT_APP = `ai-sdk/harness-opencode/${VERSION}`;
@@ -445,6 +449,23 @@ function createOpenCode(settings = {}) {
     getBootstrap: getOpenCodeBootstrap,
     doStart: async (startOpts) => {
       const sandboxSession = startOpts.sandboxSession;
+      const toolSafeSandboxSession = getRestrictedSandboxSession(sandboxSession);
+      const sandboxId = "id" in sandboxSession ? sandboxSession.id : void 0;
+      validateBasicSandboxSettings({
+        sandboxSession,
+        port: settings.port,
+        portEndpoint: settings.portEndpoint
+      });
+      if (settings.mintBridgeToken != null && sandboxId == null) {
+        throw new HarnessCapabilityUnsupportedError({
+          harnessId: "opencode",
+          message: "The OpenCode harness cannot use `mintBridgeToken` with a sandbox session that does not expose an id."
+        });
+      }
+      const defaultWorkingDirectory = await resolveSandboxDefaultWorkingDirectory({
+        sandboxSession,
+        abortSignal: startOpts.abortSignal
+      });
       const authenticationMode = resolveOpenCodeAuthenticationMode({
         auth: settings.auth,
         model: settings.model,
@@ -456,7 +477,7 @@ function createOpenCode(settings = {}) {
         provider: settings.provider
       });
       let sandboxAuthEnvironment = resolvedAuthEnvironment;
-      if (sandboxSession.addRequestTransformations != null) {
+      if ("addRequestTransformations" in sandboxSession && sandboxSession.addRequestTransformations != null) {
         const requestTransformations = createOpenCodeRequestTransformations(
           resolvedAuthEnvironment,
           authenticationMode
@@ -473,10 +494,8 @@ function createOpenCode(settings = {}) {
       } else {
         warnCredentialBrokeringUnavailable();
       }
-      const session = sandboxSession.restricted();
-      const sandboxId = sandboxSession.id;
       const bootstrapDir = path.posix.resolve(
-        sandboxSession.defaultWorkingDirectory,
+        defaultWorkingDirectory,
         OPENCODE_BOOTSTRAP_DIR
       );
       const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
@@ -486,7 +505,7 @@ function createOpenCode(settings = {}) {
       const resumeSessionId = typeof resumeData?.openCodeSessionId === "string" && resumeData.openCodeSessionId.length > 0 ? resumeData.openCodeSessionId : void 0;
       const coords = resumeData?.bridge;
       const workDir = startOpts.sessionWorkDir;
-      const sessionDataDir = `${sandboxSession.defaultWorkingDirectory}/.agent-runs/${startOpts.sessionId}`;
+      const sessionDataDir = `${defaultWorkingDirectory}/.agent-runs/${startOpts.sessionId}`;
       const bridgeStateDir = `${sessionDataDir}/bridge`;
       const timeoutMs = settings.startupTimeoutMs ?? 12e4;
       const model = splitOpenCodeModel(settings.model, settings.provider).model;
@@ -503,16 +522,24 @@ function createOpenCode(settings = {}) {
       });
       if (coords) {
         try {
-          const endpoint2 = await sandboxSession.getPortEndpoint({
-            port: coords.port,
-            protocol: "ws"
+          const endpoint2 = await resolveBridgeEndpoint({
+            sandboxSession,
+            override: settings.portEndpoint,
+            port: coords.port
           });
           const attachEndpoint = withBridgeToken({
             endpoint: endpoint2,
             token: coords.token
           });
+          let supportsUserMessageResponses2 = false;
           const attachChannel = new SandboxChannel({
-            connect: () => openWebSocket(attachEndpoint),
+            connect: () => openWebSocket({
+              endpoint: attachEndpoint,
+              helloTimeoutMs: Math.min(timeoutMs, 5e3),
+              onHello: (supported) => {
+                supportsUserMessageResponses2 = supported;
+              }
+            }),
             outboundSchema: outboundMessageSchema,
             initialLastSeenEventId: coords.lastSeenEventId,
             onDiagnostic,
@@ -536,7 +563,8 @@ function createOpenCode(settings = {}) {
             sandboxId,
             debug: startOpts.observability?.debug,
             permissionMode: startOpts.permissionMode,
-            builtinToolFiltering: startOpts.builtinToolFiltering
+            builtinToolFiltering: startOpts.builtinToolFiltering,
+            supportsUserMessageResponses: () => supportsUserMessageResponses2
           });
         } catch {
         }
@@ -544,7 +572,7 @@ function createOpenCode(settings = {}) {
       let respawnStrategy = isResume ? "rerun" : void 0;
       if (coords && isContinue) {
         const logRaw = await Promise.resolve(
-          session.readTextFile({
+          toolSafeSandboxSession.readTextFile({
             path: `${bridgeStateDir}/event-log.ndjson`,
             abortSignal: startOpts.abortSignal
           })
@@ -553,10 +581,13 @@ function createOpenCode(settings = {}) {
           respawnStrategy = "replay";
         }
       }
-      const port = resolveBridgePort(sandboxSession, settings.port);
+      const port = resolveBridgePort({
+        sandboxSession,
+        override: settings.port
+      });
       const token = settings.mintBridgeToken == null ? randomBytes(32).toString("hex") : settings.mintBridgeToken(sandboxId);
       const sandboxHomeDir = await resolveSandboxHomeDir({
-        sandbox: session,
+        sandbox: toolSafeSandboxSession,
         abortSignal: startOpts.abortSignal
       });
       const xdgConfigHome = `${sandboxHomeDir}/.config`;
@@ -564,7 +595,7 @@ function createOpenCode(settings = {}) {
       const xdgDataHome = `${sandboxHomeDir}/.local/share`;
       const xdgStateHome = `${sandboxHomeDir}/.local/state`;
       const skillSetup = startOpts.skills && startOpts.skills.length > 0 ? await writeOpenCodeSkills({
-        sandbox: session,
+        sandbox: toolSafeSandboxSession,
         skills: startOpts.skills,
         homeDir: sandboxHomeDir,
         abortSignal: startOpts.abortSignal
@@ -583,18 +614,18 @@ function createOpenCode(settings = {}) {
         ...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
       };
       if (respawnStrategy === void 0) {
-        await session.run({
+        await toolSafeSandboxSession.run({
           command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)} ${shellQuote(xdgConfigHome)} ${shellQuote(xdgCacheHome)} ${shellQuote(xdgDataHome)} ${shellQuote(xdgStateHome)}`,
           abortSignal: startOpts.abortSignal
         });
       }
       await markBridgeStarting({
-        sandbox: session,
+        sandbox: toolSafeSandboxSession,
         bridgeStateDir,
         bridgeType: "opencode",
         abortSignal: startOpts.abortSignal
       });
-      const proc = await session.spawn({
+      const proc = await toolSafeSandboxSession.spawn({
         command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)} --bootstrap-dir ${shellQuote(bootstrapDir)}${skillSetup ? ` --skills-dir ${shellQuote(skillSetup.skillsDir)}` : ""}`,
         env,
         abortSignal: startOpts.abortSignal
@@ -608,7 +639,7 @@ function createOpenCode(settings = {}) {
       });
       const { port: boundPort } = await waitForBridgeReady({
         proc,
-        sandbox: session,
+        sandbox: toolSafeSandboxSession,
         bridgeStateDir,
         bridgeType: "opencode",
         timeoutMs,
@@ -629,13 +660,21 @@ function createOpenCode(settings = {}) {
         })
       });
       void drainBridgeProcessStream(proc.stdout);
-      const endpoint = await sandboxSession.getPortEndpoint({
-        port: boundPort,
-        protocol: "ws"
+      const endpoint = await resolveBridgeEndpoint({
+        sandboxSession,
+        override: settings.portEndpoint,
+        port: boundPort
       });
       const bridgeEndpoint = withBridgeToken({ endpoint, token });
+      let supportsUserMessageResponses = false;
       const channel = new SandboxChannel({
-        connect: () => openWebSocket(bridgeEndpoint),
+        connect: () => openWebSocket({
+          endpoint: bridgeEndpoint,
+          helloTimeoutMs: Math.min(timeoutMs, 5e3),
+          onHello: (supported) => {
+            supportsUserMessageResponses = supported;
+          }
+        }),
         outboundSchema: outboundMessageSchema,
         onDiagnostic,
         onBridgeError,
@@ -661,19 +700,58 @@ function createOpenCode(settings = {}) {
         sandboxId,
         debug: startOpts.observability?.debug,
         permissionMode: startOpts.permissionMode,
-        builtinToolFiltering: startOpts.builtinToolFiltering
+        builtinToolFiltering: startOpts.builtinToolFiltering,
+        supportsUserMessageResponses: () => supportsUserMessageResponses
       });
     }
   };
 }
-function resolveBridgePort(sandboxSession, override) {
+function resolveBridgePort({
+  sandboxSession,
+  override
+}) {
   if (override !== void 0) return override;
-  if (sandboxSession.ports.length > 0) return sandboxSession.ports[0];
+  if ("ports" in sandboxSession && sandboxSession.ports.length > 0) {
+    return sandboxSession.ports[0];
+  }
   throw new HarnessCapabilityUnsupportedError({
     harnessId: "opencode",
     message: "The OpenCode harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createOpenCode({ port })`."
   });
 }
+function validateBasicSandboxSettings({
+  sandboxSession,
+  port,
+  portEndpoint
+}) {
+  if ("getPortEndpoint" in sandboxSession) return;
+  if (port == null) {
+    throw new HarnessCapabilityUnsupportedError({
+      harnessId: "opencode",
+      message: "The OpenCode harness requires an explicit `port` when using a basic sandbox session."
+    });
+  }
+  if (portEndpoint == null) {
+    throw new HarnessCapabilityUnsupportedError({
+      harnessId: "opencode",
+      message: "The OpenCode harness requires an explicit `portEndpoint` when using a basic sandbox session."
+    });
+  }
+}
+async function resolveBridgeEndpoint({
+  sandboxSession,
+  override,
+  port
+}) {
+  if (override != null) return override;
+  if ("getPortEndpoint" in sandboxSession) {
+    return sandboxSession.getPortEndpoint({ port, protocol: "ws" });
+  }
+  throw new HarnessCapabilityUnsupportedError({
+    harnessId: "opencode",
+    message: "The OpenCode harness requires an explicit `portEndpoint` when using a basic sandbox session."
+  });
+}
 async function writeOpenCodeSkills({
   sandbox,
   skills,
@@ -692,25 +770,88 @@ async function writeOpenCodeSkills({
   return { skillsDir };
 }
 function openWebSocket({
-  url,
-  headers
+  endpoint,
+  helloTimeoutMs,
+  onHello
 }) {
   return new Promise((resolve, reject) => {
-    const ws = new WebSocket(url, {
-      headers: headers == null ? void 0 : { ...headers }
+    const ws = new WebSocket(endpoint.url, {
+      headers: endpoint.headers == null ? void 0 : { ...endpoint.headers }
     });
-    const onOpen = () => {
+    let opened = false;
+    let receivedHello = false;
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(helloTimer);
+      ws.off("open", onOpen);
+      ws.off("message", onMessage);
+      ws.off("close", onClose);
       ws.off("error", onError);
-      resolve(ws);
     };
+    const settle = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error == null) {
+        resolve(ws);
+      } else {
+        reject(error);
+      }
+    };
+    const tryResolve = () => {
+      if (opened && receivedHello) settle();
+    };
+    const onOpen = () => {
+      opened = true;
+      tryResolve();
+    };
+    const onMessage = (raw) => {
+      void (async () => {
+        const parsed = await safeParseJSON({
+          text: webSocketMessageToString(raw)
+        });
+        if (!parsed.success) return;
+        const value = parsed.value;
+        if (typeof value !== "object" || value == null || Array.isArray(value) || value.type !== "bridge-hello") {
+          return;
+        }
+        const capabilities = value.capabilities;
+        onHello(capabilities?.experimental_userMessageResponses === true);
+        receivedHello = true;
+        tryResolve();
+      })();
+    };
+    const onClose = () => settle(new Error("OpenCode bridge closed before sending bridge-hello."));
     const onError = (err) => {
-      ws.off("open", onOpen);
-      reject(err);
+      settle(err);
     };
-    ws.once("open", onOpen);
-    ws.once("error", onError);
+    ws.on("open", onOpen);
+    ws.on("message", onMessage);
+    ws.on("close", onClose);
+    ws.on("error", onError);
+    const helloTimer = setTimeout(
+      () => settle(
+        new Error(
+          `OpenCode bridge did not send bridge-hello within ${helloTimeoutMs}ms.`
+        )
+      ),
+      helloTimeoutMs
+    );
+    helloTimer.unref?.();
   });
 }
+function webSocketMessageToString(raw) {
+  if (typeof raw === "string") return raw;
+  if (Buffer.isBuffer(raw)) return raw.toString("utf8");
+  if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf8");
+  if (raw instanceof ArrayBuffer) return Buffer.from(raw).toString("utf8");
+  if (ArrayBuffer.isView(raw)) {
+    return Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength).toString(
+      "utf8"
+    );
+  }
+  return String(raw);
+}
 function withBridgeToken({
   endpoint,
   token
@@ -736,7 +877,8 @@ function createSession({
   sandboxId,
   debug,
   permissionMode,
-  builtinToolFiltering
+  builtinToolFiltering,
+  supportsUserMessageResponses
 }) {
   let stopped = false;
   let stopPromise;
@@ -755,6 +897,11 @@ function createSession({
       pendingResolve = resolve;
       pendingReject = reject;
     });
+    const userMessageSubmitter = supportsUserMessageResponses() ? experimental_createBridgeUserMessageSubmitter({
+      send: (message) => channel.send(message),
+      onResponse: (listener) => channel.on("user-message-response", listener),
+      onReconnect: (listener) => channel.onReconnect(listener)
+    }) : void 0;
     const unsubs = [];
     const forward = (event) => {
       try {
@@ -783,6 +930,7 @@ function createSession({
       if (isSettled) return;
       isSettled = true;
       activeTurn = false;
+      userMessageSubmitter?.close();
       for (const u of unsubs) u();
       pendingResolve();
     };
@@ -790,6 +938,7 @@ function createSession({
       if (isSettled) return;
       isSettled = true;
       activeTurn = false;
+      userMessageSubmitter?.close(err);
       for (const u of unsubs) u();
       pendingReject(err);
     };
@@ -862,8 +1011,10 @@ function createSession({
           reason: input.reason
         });
       },
-      submitUserMessage: async (text) => {
-        channel.send({ type: "user-message", text });
+      ...userMessageSubmitter == null ? {} : {
+        submitUserMessage: async (text) => {
+          await userMessageSubmitter.submit(text);
+        }
       },
       done
     };
@@ -980,7 +1131,7 @@ function createSession({
             port: bridgePort,
             token: bridgeToken,
             lastSeenEventId,
-            sandboxId
+            ...sandboxId == null ? {} : { sandboxId }
           }
         }
       };
@@ -1094,7 +1245,7 @@ function createSession({
             port: bridgePort,
             token: bridgeToken,
             lastSeenEventId,
-            sandboxId
+            ...sandboxId == null ? {} : { sandboxId }
           }
         }
       };