@ai-sdk/harness 1.0.22 → 1.0.23

package/dist/utils/index.d.ts

@@ -52,6 +52,9 @@ interface SandboxChannelOptions<TOut> {
     onDiagnostic?: (event: Extract<TOut, {
         type: 'sandbox-log' | 'debug-event';
     }>) => void;
+    onBridgeError?: (event: Extract<TOut, {
+        type: 'error';
+    }>) => void;
     /**
      * Seed the host-side cursor before the first connect. Pass the
      * `lastSeenEventId` persisted from a prior process so the bridge replays only
@@ -98,6 +101,7 @@ declare class SandboxChannel<TOut extends {
     private readonly outboundSchema;
     private readonly onDebug;
     private readonly onDiagnostic;
+    private readonly onBridgeError;
     private readonly maxElapsedMs;
     private readonly initialDelayMs;
     private readonly maxDelayMs;
@@ -149,6 +153,9 @@ declare class SandboxChannel<TOut extends {
      */
     beginClose(): void;
     close(): void;
+    interrupt(options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
     /**
      * Gracefully suspend at a slice boundary: stop processing inbound frames
      * (so the cursor freezes at the last delivered event), drain any frames
@@ -287,4 +294,36 @@ declare function markBridgeStarting({ sandbox, bridgeStateDir, bridgeType, abort
 }): Promise<void>;
 declare function waitForBridgeReady({ proc, sandbox, bridgeStateDir, bridgeType, timeoutMs, abortSignal, pollIntervalMs, createTimeoutError, createExitError, }: WaitForBridgeReadyOptions): Promise<WaitForBridgeReadyResult>;
 
-export { type BridgeReadyErrorContext, type BridgeReadySource, type DiskLogRecoveryMode, SandboxChannel, type SandboxChannelDebugEvent, type SandboxChannelOptions, type SandboxChannelReconnectOptions, type SkillFilePathMode, type WaitForBridgeReadyOptions, type WaitForBridgeReadyResult, type WriteSkillsOptions, classifyDiskLog, getAiGatewayAuthFromEnv, markBridgeStarting, resolveSandboxHomeDir, shellQuote, waitForBridgeReady, writeSkills };
+type BridgeProcessStreamName = 'stdout' | 'stderr';
+declare function formatBridgeError(error: unknown): string;
+declare function logBridgeError({ harnessId, sessionId, context, error, write, }: {
+    harnessId: string;
+    sessionId?: string;
+    context?: string;
+    error: unknown;
+    write?: (line: string) => void;
+}): void;
+declare function createBridgeErrorHandler({ harnessId, sessionId, }: {
+    harnessId: string;
+    sessionId?: string;
+}): (event: {
+    type: 'error';
+    error: unknown;
+}) => void;
+declare function createBridgeStartupError({ message, proc, stdoutTail, stderrTail, stderrDone, }: {
+    message: string;
+    proc: Experimental_SandboxProcess;
+    stdoutTail: string[];
+    stderrTail: string[];
+    stderrDone?: Promise<void>;
+}): Promise<Error>;
+declare function forwardBridgeProcessStream({ stream, streamName, source, collectTail, tailLimit, }: {
+    stream: ReadableStream<Uint8Array>;
+    streamName: BridgeProcessStreamName;
+    source?: string;
+    collectTail?: string[];
+    tailLimit?: number;
+}): Promise<void>;
+declare function drainBridgeProcessStream(stream: ReadableStream<Uint8Array>): Promise<void>;
+
+export { type BridgeReadyErrorContext, type BridgeReadySource, type DiskLogRecoveryMode, SandboxChannel, type SandboxChannelDebugEvent, type SandboxChannelOptions, type SandboxChannelReconnectOptions, type SkillFilePathMode, type WaitForBridgeReadyOptions, type WaitForBridgeReadyResult, type WriteSkillsOptions, classifyDiskLog, createBridgeErrorHandler, createBridgeStartupError, drainBridgeProcessStream, formatBridgeError, forwardBridgeProcessStream, getAiGatewayAuthFromEnv, logBridgeError, markBridgeStarting, resolveSandboxHomeDir, shellQuote, waitForBridgeReady, writeSkills };

package/dist/utils/index.js

@@ -33,6 +33,7 @@ var SandboxChannel = class {
     this.outboundSchema = options.outboundSchema;
     this.onDebug = options.onDebug;
     this.onDiagnostic = options.onDiagnostic;
+    this.onBridgeError = options.onBridgeError;
     this.maxElapsedMs = (_b = (_a = options.reconnect) == null ? void 0 : _a.maxElapsedMs) != null ? _b : 3e4;
     this.initialDelayMs = (_d = (_c = options.reconnect) == null ? void 0 : _c.initialDelayMs) != null ? _d : 50;
     this.maxDelayMs = (_f = (_e = options.reconnect) == null ? void 0 : _e.maxDelayMs) != null ? _f : 2e3;
@@ -122,6 +123,54 @@ var SandboxChannel = class {
     }
     this.enqueue(() => this.finalizeClose(1e3, "closed"));
   }
+  interrupt(options) {
+    var _a;
+    const timeoutMs = (_a = options == null ? void 0 : options.timeoutMs) != null ? _a : 5e3;
+    return new Promise((resolve, reject) => {
+      var _a2;
+      let settled = false;
+      let unsub = () => {
+      };
+      const timer = setTimeout(() => {
+        complete(
+          new Error(
+            `SandboxChannel: interrupt was not acknowledged within ${timeoutMs}ms.`
+          )
+        );
+      }, timeoutMs);
+      (_a2 = timer.unref) == null ? void 0 : _a2.call(timer);
+      const complete = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        unsub();
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      };
+      unsub = this.on("bridge-interrupted", (event) => {
+        const response = event;
+        if (response.ok) {
+          complete();
+          return;
+        }
+        complete(
+          new Error(
+            `SandboxChannel: interrupt failed: ${formatControlError(
+              response.error
+            )}`
+          )
+        );
+      });
+      try {
+        this.send({ type: "interrupt" });
+      } catch (err) {
+        complete(err);
+      }
+    });
+  }
   /**
    * Gracefully suspend at a slice boundary: stop processing inbound frames
    * (so the cursor freezes at the last delivered event), drain any frames
@@ -276,7 +325,7 @@ var SandboxChannel = class {
     }
   }
   dispatch(message) {
-    var _a;
+    var _a, _b;
     if (message.type === "sandbox-log" || message.type === "debug-event") {
       (_a = this.onDiagnostic) == null ? void 0 : _a.call(
         this,
@@ -284,6 +333,9 @@ var SandboxChannel = class {
       );
       return;
     }
+    if (message.type === "error") {
+      (_b = this.onBridgeError) == null ? void 0 : _b.call(this, message);
+    }
     const type = message.type;
     const set = this.listeners.get(type);
     if (!set || set.size === 0) {
@@ -306,6 +358,15 @@ var SandboxChannel = class {
     for (const h of this.onCloseHandlers) h(code, reason);
   }
 };
+function formatControlError(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object") {
+    const message = error.message;
+    if (typeof message === "string" && message.length > 0) return message;
+  }
+  if (typeof error === "string" && error.length > 0) return error;
+  return "unknown error";
+}
 
 // src/utils/classify-disk-log.ts
 import { safeParseJSON as safeParseJSON2 } from "@ai-sdk/provider-utils";
@@ -707,6 +768,11 @@ var harnessV1BridgeThreadSchema = z3.object({
   type: z3.literal("bridge-thread"),
   threadId: z3.string()
 });
+var harnessV1BridgeInterruptedSchema = z3.object({
+  type: z3.literal("bridge-interrupted"),
+  ok: z3.boolean(),
+  error: z3.unknown().optional()
+});
 var harnessV1BridgeSandboxLogSchema = z3.object({
   type: z3.literal("sandbox-log"),
   source: z3.string(),
@@ -747,6 +813,7 @@ var harnessV1BridgeOutboundMessageSchema = z3.discriminatedUnion(
     harnessV1BridgeHelloSchema,
     harnessV1BridgeDetachSchema,
     harnessV1BridgeThreadSchema,
+    harnessV1BridgeInterruptedSchema,
     harnessV1BridgeSandboxLogSchema,
     harnessV1BridgeDebugEventSchema
   ]
@@ -770,6 +837,9 @@ var harnessV1BridgeUserMessageInboundSchema = z3.object({
 var harnessV1BridgeAbortInboundSchema = z3.object({
   type: z3.literal("abort")
 });
+var harnessV1BridgeInterruptInboundSchema = z3.object({
+  type: z3.literal("interrupt")
+});
 var harnessV1BridgeShutdownInboundSchema = z3.object({
   type: z3.literal("shutdown")
 });
@@ -989,10 +1059,179 @@ function lineDecoder() {
     }
   };
 }
+
+// src/utils/bridge-diagnostics.ts
+var DEFAULT_TAIL_LIMIT = 20;
+function isSerializedError(error) {
+  return typeof error === "object" && error != null && typeof error.message === "string";
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return String(value);
+  }
+}
+function formatBridgeError(error) {
+  var _a, _b;
+  if (error instanceof Error) {
+    return (_a = error.stack) != null ? _a : `${error.name}: ${error.message}`;
+  }
+  if (isSerializedError(error)) {
+    return (_b = error.stack) != null ? _b : `${error.name ? `${error.name}: ` : ""}${error.message}`;
+  }
+  return stringifyUnknown(error);
+}
+function writeToStderr(line) {
+  try {
+    process.stderr.write(line);
+  } catch (e) {
+  }
+}
+function logBridgeError({
+  harnessId,
+  sessionId,
+  context,
+  error,
+  write = writeToStderr
+}) {
+  const prefix = `[harness:${harnessId}:error${sessionId ? ` session=${sessionId}` : ""}]`;
+  const message = context ? `${context}: ${formatBridgeError(error)}` : formatBridgeError(error);
+  for (const line of message.split("\n")) {
+    if (line.trim().length > 0) {
+      write(`${prefix} ${line}
+`);
+    }
+  }
+}
+function createBridgeErrorHandler({
+  harnessId,
+  sessionId
+}) {
+  return (event) => {
+    logBridgeError({
+      harnessId,
+      sessionId,
+      context: "bridge emitted an error frame",
+      error: event.error
+    });
+  };
+}
+async function createBridgeStartupError({
+  message,
+  proc,
+  stdoutTail,
+  stderrTail,
+  stderrDone
+}) {
+  if (stderrDone) {
+    await Promise.race([stderrDone, sleep3(250)]).catch(() => {
+    });
+  }
+  let exitStatus = "";
+  try {
+    const result = await Promise.race([
+      proc.wait(),
+      sleep3(250).then(() => void 0)
+    ]);
+    if ((result == null ? void 0 : result.exitCode) !== void 0) {
+      exitStatus = ` Exit code: ${result.exitCode}.`;
+    }
+  } catch (e) {
+  }
+  const details = [];
+  if (stdoutTail.length > 0) {
+    details.push(`stdout:
+${stdoutTail.join("\n")}`);
+  }
+  if (stderrTail.length > 0) {
+    details.push(`stderr:
+${stderrTail.join("\n")}`);
+  }
+  return new Error(
+    `${message}${exitStatus}${details.length > 0 ? `
+
+${details.join("\n\n")}` : ""}`
+  );
+}
+async function forwardBridgeProcessStream({
+  stream,
+  streamName,
+  source = "bridge",
+  collectTail,
+  tailLimit = DEFAULT_TAIL_LIMIT
+}) {
+  try {
+    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+    const decoder = lineDecoder2();
+    while (true) {
+      const { value, done } = await reader.read();
+      const lines = done ? decoder.flush() : value ? decoder.push(value) : [];
+      for (const line of lines) {
+        recordTail({ lines: collectTail, line, limit: tailLimit });
+        writeToStderr(`[harness:${source}:${streamName}] ${line}
+`);
+      }
+      if (done) return;
+    }
+  } catch (e) {
+  }
+}
+async function drainBridgeProcessStream(stream) {
+  try {
+    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+    while (true) {
+      const { done } = await reader.read();
+      if (done) return;
+    }
+  } catch (e) {
+  }
+}
+function recordTail({
+  lines,
+  line,
+  limit
+}) {
+  if (!lines) return;
+  lines.push(line);
+  while (lines.length > limit) lines.shift();
+}
+function lineDecoder2() {
+  let buffer = "";
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const lines = [];
+      let nl;
+      while ((nl = buffer.indexOf("\n")) !== -1) {
+        const raw = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const line = raw.replace(/\r$/, "").trim();
+        if (line.length > 0) lines.push(line);
+      }
+      return lines;
+    },
+    flush() {
+      const line = buffer.replace(/\r$/, "").trim();
+      buffer = "";
+      return line.length > 0 ? [line] : [];
+    }
+  };
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 export {
   SandboxChannel,
   classifyDiskLog,
+  createBridgeErrorHandler,
+  createBridgeStartupError,
+  drainBridgeProcessStream,
+  formatBridgeError,
+  forwardBridgeProcessStream,
   getAiGatewayAuthFromEnv,
+  logBridgeError,
   markBridgeStarting,
   resolveSandboxHomeDir,
   shellQuote,