@ai-sdk/harness 1.0.133 → 1.0.135

package/dist/bridge/index.js

@@ -1,669 +1,598 @@
-// src/bridge/index.ts
-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 { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { env, pid, stdout } from "node:process";
 import { WebSocketServer } from "ws";
-
-// src/bridge/harness-bridge-capability-unsupported-error.ts
-var name = "AI_HarnessBridgeCapabilityUnsupportedError";
+//#region src/bridge/harness-bridge-capability-unsupported-error.ts
+const name = "AI_HarnessBridgeCapabilityUnsupportedError";
+/**
+* Signals an unsupported capability discovered inside a sandbox bridge.
+* `isInstance` also recognizes the serialized error shape received by the
+* host, where it can be translated to `HarnessCapabilityUnsupportedError`.
+*/
 var HarnessBridgeCapabilityUnsupportedError = class extends Error {
-  constructor({
-    message,
-    harnessId,
-    cause
-  }) {
-    super(message);
-    Object.defineProperty(this, "name", { value: name });
-    this.harnessId = harnessId;
-    this.cause = cause;
-  }
-  static isInstance(error) {
-    return error != null && typeof error === "object" && "name" in error && error.name === name && "message" in error && typeof error.message === "string";
-  }
+	constructor({ message, harnessId, cause }) {
+		super(message);
+		Object.defineProperty(this, "name", { value: name });
+		this.harnessId = harnessId;
+		this.cause = cause;
+	}
+	static isInstance(error) {
+		return error != null && typeof error === "object" && "name" in error && error.name === name && "message" in error && typeof error.message === "string";
+	}
 };
-
-// src/bridge/index.ts
-var DEBUG_LEVEL_WEIGHT = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4
+//#endregion
+//#region src/bridge/index.ts
+const DEBUG_LEVEL_WEIGHT = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3,
+	trace: 4
 };
+/** Exact-or-dotted-prefix subsystem match (`'bridge'` matches `'bridge.turn'`). */
 function subsystemMatches(filters, subsystem) {
-  if (!filters || filters.length === 0) return true;
-  return filters.some(
-    (filter) => subsystem === filter || subsystem.startsWith(`${filter}.`)
-  );
+	if (!filters || filters.length === 0) return true;
+	return filters.some((filter) => subsystem === filter || subsystem.startsWith(`${filter}.`));
 }
 function formatBridgeError(err) {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  if (typeof err === "string") {
-    return { message: err };
-  }
-  if (err !== null && typeof err === "object") {
-    try {
-      return { message: JSON.stringify(err) };
-    } catch {
-    }
-  }
-  return { message: String(err) };
+	if (err instanceof Error) return {
+		name: err.name,
+		message: err.message,
+		stack: err.stack
+	};
+	if (typeof err === "string") return { message: err };
+	if (err !== null && typeof err === "object") try {
+		return { message: JSON.stringify(err) };
+	} catch {}
+	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);
-            }
-          );
-        }
-      };
-    }
-  };
+	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(/* @__PURE__ */ 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 ?? /* @__PURE__ */ 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);
-  return items.length > 0 ? items : void 0;
+	if (!value) return void 0;
+	const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+	return items.length > 0 ? items : void 0;
 }
-var ENV_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
-var WS_OPEN = 1;
+const ENV_TRUTHY = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"yes",
+	"on"
+]);
+const WS_OPEN = 1;
 async function runBridge(options) {
-  const { bridgeType, bridgeStateDir, onStart, onStop, onDestroy } = options;
-  const teardownGraceMs = options.turnTeardownGraceMs ?? 1e4;
-  const expectedToken = options.token ?? procEnv.BRIDGE_CHANNEL_TOKEN ?? "";
-  const bridgeWsPort = options.port ?? parseInt(procEnv.BRIDGE_WS_PORT ?? "0", 10);
-  const bridgeMetaPath = `${bridgeStateDir}/bridge-meta.json`;
-  const startConfigPath = `${bridgeStateDir}/start-config.json`;
-  const rerunStartConfigPath = `${bridgeStateDir}/rerun-start-config.json`;
-  const eventLogPath = `${bridgeStateDir}/event-log.ndjson`;
-  try {
-    await mkdir(bridgeStateDir, { recursive: true });
-  } catch {
-  }
-  let currentBoundPort = 0;
-  let currentTurnState = "init";
-  let activeSocket;
-  let isFirstTurn = true;
-  let turnAbort;
-  let currentUserMessages;
-  let activeTurn;
-  let debugConfig;
-  let consoleCaptureInstalled = false;
-  const envDebugEnabled = ENV_TRUTHY.has(
-    (procEnv.HARNESS_DEBUG ?? "").toLowerCase()
-  );
-  let seqCounter = 0;
-  let eventLog = [];
-  let diskBuffer = "";
-  let flushPromise = null;
-  const flushEventsToDisk = async () => {
-    while (diskBuffer.length > 0) {
-      const buf = diskBuffer;
-      diskBuffer = "";
-      await appendFile(eventLogPath, buf).catch(() => {
-      });
-    }
-  };
-  const scheduleEventFlush = () => {
-    if (flushPromise) return;
-    flushPromise = new Promise((resolve) => {
-      setImmediate(() => {
-        void flushEventsToDisk().finally(resolve);
-      });
-    }).finally(() => {
-      flushPromise = null;
-      if (diskBuffer.length > 0) {
-        scheduleEventFlush();
-      }
-    });
-  };
-  const flushPendingEventsToDisk = async () => {
-    if (diskBuffer.length > 0 && !flushPromise) {
-      scheduleEventFlush();
-    }
-    let inFlight = flushPromise;
-    while (inFlight) {
-      await inFlight;
-      inFlight = flushPromise;
-    }
-  };
-  const replayFromDisk = procEnv.BRIDGE_REPLAY_FROM_DISK === "1";
-  if (replayFromDisk && existsSync(eventLogPath)) {
-    try {
-      const lines = readFileSync(eventLogPath, "utf8").split("\n").map((line) => line.trim()).filter(Boolean);
-      eventLog = lines.map((line) => ({
-        seq: JSON.parse(line).seq,
-        line
-      }));
-      seqCounter = eventLog.at(-1)?.seq ?? 0;
-    } catch {
-      eventLog = [];
-      seqCounter = 0;
-    }
-  }
-  const pendingToolResults = /* @__PURE__ */ new Map();
-  const bufferedToolResults = [];
-  const pendingToolApprovals = /* @__PURE__ */ new Map();
-  const writeBridgeMeta = async (state) => {
-    try {
-      await writeFile(
-        bridgeMetaPath,
-        JSON.stringify({
-          type: bridgeType,
-          port: currentBoundPort,
-          state,
-          pid
-        })
-      );
-    } catch {
-    }
-  };
-  const writeStartConfig = async (start) => {
-    try {
-      const serialized = JSON.stringify(start);
-      await writeFile(startConfigPath, serialized);
-      if (!existsSync(rerunStartConfigPath)) {
-        await writeFile(rerunStartConfigPath, serialized);
-      }
-    } catch {
-    }
-  };
-  const emit = (event) => {
-    const seq = ++seqCounter;
-    const line = JSON.stringify({ ...event, seq });
-    eventLog.push({ seq, line });
-    diskBuffer += `${line}
-`;
-    scheduleEventFlush();
-    if (activeSocket?.readyState === WS_OPEN) {
-      try {
-        activeSocket.send(line);
-      } catch {
-      }
-    }
-  };
-  const replay = (ws, afterSeq) => {
-    for (const entry of eventLog) {
-      if (entry.seq > afterSeq && ws.readyState === WS_OPEN) {
-        ws.send(entry.line);
-      }
-    }
-  };
-  const shouldEmitDebugEvent = (level, subsystem) => {
-    if (!debugConfig?.enabled) return false;
-    const threshold = debugConfig.level ?? "debug";
-    if (DEBUG_LEVEL_WEIGHT[level] > DEBUG_LEVEL_WEIGHT[threshold]) return false;
-    return subsystemMatches(debugConfig.subsystems, subsystem);
-  };
-  const rawStdoutWrite = process.stdout.write.bind(process.stdout);
-  const rawStderrWrite = process.stderr.write.bind(process.stderr);
-  const writeErrorToStderr = (input) => {
-    try {
-      const formatted = formatBridgeError(input.error);
-      rawStderrWrite(
-        `[harness:${bridgeType}:error] ${input.message}: ${formatted.message}
-`
-      );
-      if (formatted.stack) {
-        rawStderrWrite(`${formatted.stack}
-`);
-      }
-    } catch {
-    }
-  };
-  const emitWarning = (input) => {
-    try {
-      for (const line of input.message.split("\n")) {
-        if (line.trim().length > 0) {
-          rawStderrWrite(`[harness:${bridgeType}:warn] ${line}
-`);
-        }
-      }
-    } catch {
-    }
-  };
-  const emitError = (input) => {
-    writeErrorToStderr({
-      message: input.message ?? "bridge error",
-      error: input.error
-    });
-    emit({ type: "error", error: serialiseError(input.error) });
-  };
-  const installConsoleCapture = () => {
-    if (consoleCaptureInstalled) return;
-    consoleCaptureInstalled = true;
-    const buffers = {
-      stdout: "",
-      stderr: ""
-    };
-    const patch = (stream, raw) => (chunk, encoding, cb) => {
-      if (debugConfig?.enabled) {
-        try {
-          const enc = typeof encoding === "string" ? encoding : "utf8";
-          const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(
-            enc
-          );
-          const combined = buffers[stream] + text.replace(/\r\n/g, "\n");
-          const parts = combined.split("\n");
-          buffers[stream] = parts.pop() ?? "";
-          for (const line of parts) {
-            const trimmed = line.replace(/\s+$/, "");
-            if (trimmed) {
-              emit({
-                type: "sandbox-log",
-                source: bridgeType,
-                stream,
-                line: trimmed
-              });
-            }
-          }
-        } catch {
-        }
-      }
-      return raw(
-        chunk,
-        encoding,
-        cb
-      );
-    };
-    process.stdout.write = patch(
-      "stdout",
-      rawStdoutWrite
-    );
-    process.stderr.write = patch(
-      "stderr",
-      rawStderrWrite
-    );
-  };
-  const handleInbound = async (msg, ws) => {
-    switch (msg.type) {
-      case "start": {
-        for (; ; ) {
-          const pendingTurn = activeTurn;
-          if (pendingTurn == null) break;
-          turnAbort?.abort();
-          currentUserMessages?.close(
-            new Error("A new bridge turn replaced the active turn.")
-          );
-          let graceTimer;
-          const settled = await Promise.race([
-            pendingTurn.then(() => true),
-            new Promise((resolve) => {
-              graceTimer = setTimeout(() => resolve(false), teardownGraceMs);
-              graceTimer.unref?.();
-            })
-          ]);
-          clearTimeout(graceTimer);
-          if (!settled) break;
-        }
-        let turnFinished;
-        const thisTurn = new Promise((resolve) => turnFinished = resolve);
-        activeTurn = thisTurn;
-        activeSocket = ws;
-        const firstTurn = isFirstTurn;
-        isFirstTurn = false;
-        eventLog = [];
-        diskBuffer = "";
-        void writeFile(eventLogPath, "").catch(() => {
-        });
-        turnAbort = new AbortController();
-        currentTurnState = "running";
-        void writeStartConfig(msg);
-        void writeBridgeMeta("running");
-        const startDebug = msg.debug;
-        debugConfig = {
-          enabled: startDebug?.enabled ?? envDebugEnabled,
-          level: startDebug?.level ?? procEnv.HARNESS_DEBUG_LEVEL,
-          subsystems: startDebug?.subsystems ?? parseEnvList(procEnv.HARNESS_DEBUG_SUBSYSTEMS)
-        };
-        if (debugConfig.enabled) {
-          installConsoleCapture();
-        }
-        const userMessages = createBridgeUserMessageQueue({ respond: emit });
-        const turn = {
-          emit,
-          requestToolResult: (requestInput) => {
-            const request = typeof requestInput === "string" ? { toolCallId: requestInput } : requestInput;
-            const bufferedIndex = bufferedToolResults.findIndex(
-              (buffered) => buffered.toolCallId === request.toolCallId || request.matches?.(buffered.result) === true
-            );
-            if (bufferedIndex >= 0) {
-              return Promise.resolve(
-                bufferedToolResults.splice(bufferedIndex, 1)[0].result
-              );
-            }
-            return new Promise((resolve) => {
-              pendingToolResults.set(request.toolCallId, {
-                resolve,
-                matches: request.matches
-              });
-            });
-          },
-          requestToolApproval: (approvalId) => new Promise((resolve) => {
-            pendingToolApprovals.set(approvalId, resolve);
-          }),
-          experimental_userMessages: userMessages,
-          abortSignal: turnAbort.signal,
-          firstTurn,
-          bridgeLog: (input) => {
-            const level = input.level ?? "debug";
-            if (!shouldEmitDebugEvent(level, input.subsystem)) return;
-            emit({
-              type: "debug-event",
-              level,
-              subsystem: input.subsystem,
-              message: input.message,
-              ...input.attrs ? { attrs: input.attrs } : {},
-              ...input.error !== void 0 ? { error: formatBridgeError(input.error) } : {}
-            });
-          },
-          emitWarning,
-          emitError
-        };
-        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;
-          }
-          if (activeTurn === thisTurn) {
-            activeTurn = void 0;
-            currentTurnState = "waiting";
-            void writeBridgeMeta("waiting");
-          }
-          turnFinished();
-        }
-        return;
-      }
-      case "tool-result": {
-        const result = {
-          output: msg.output,
-          isError: msg.isError,
-          toolResult: msg.toolResult
-        };
-        const exactPending = pendingToolResults.get(msg.toolCallId);
-        const matchingPending = exactPending == null ? Array.from(pendingToolResults.entries()).find(
-          ([, pending2]) => pending2.matches?.(result) === true
-        ) : void 0;
-        const pending = exactPending ?? matchingPending?.[1];
-        const pendingId = exactPending != null ? msg.toolCallId : matchingPending?.[0];
-        if (pending != null && pendingId != null) {
-          pendingToolResults.delete(pendingId);
-          pending.resolve(result);
-        } else {
-          bufferedToolResults.push({
-            toolCallId: msg.toolCallId,
-            result
-          });
-        }
-        return;
-      }
-      case "tool-approval-response": {
-        const resolver = pendingToolApprovals.get(msg.approvalId);
-        if (resolver) {
-          pendingToolApprovals.delete(msg.approvalId);
-          resolver({ approved: msg.approved, reason: msg.reason });
-        }
-        return;
-      }
-      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;
-      case "resume":
-        activeSocket = ws;
-        replay(ws, msg.lastSeenEventId);
-        return;
-      case "destroy":
-        currentTurnState = "done";
-        void writeBridgeMeta("done");
-        await onDestroy?.();
-        drainThenExit(ws, 1e3, "destroy");
-        return;
-      case "stop": {
-        currentTurnState = "done";
-        void writeBridgeMeta("done");
-        const data = await onStop?.() ?? {};
-        sendControl(ws, { type: "bridge-stop", data });
-        drainThenExit(ws, 1e3, "stop");
-      }
-    }
-  };
-  void writeBridgeMeta("init");
-  const wss = new WebSocketServer({ port: bridgeWsPort, host: "0.0.0.0" });
-  const exit = () => {
-    if (options.onExit) {
-      options.onExit();
-      return;
-    }
-    wss.close(() => process.exit(0));
-    setTimeout(() => process.exit(0), 1e3).unref();
-  };
-  const drainThenExit = (ws, code, reason) => {
-    const start = Date.now();
-    const tick = () => {
-      const drained = ws.bufferedAmount === 0 || ws.readyState !== WS_OPEN;
-      if (drained || Date.now() - start >= 5e3) {
-        void flushPendingEventsToDisk().finally(() => {
-          try {
-            ws.close(code, reason);
-          } finally {
-            exit();
-          }
-        });
-        return;
-      }
-      setTimeout(tick, 10).unref();
-    };
-    tick();
-  };
-  wss.on("listening", () => {
-    const addr = wss.address();
-    currentBoundPort = typeof addr === "object" && addr ? addr.port : 0;
-    currentTurnState = "waiting";
-    void writeBridgeMeta("waiting");
-    stdout.write(
-      JSON.stringify({
-        type: "bridge-ready",
-        port: currentBoundPort
-      }) + "\n"
-    );
-    options.onListening?.(currentBoundPort);
-  });
-  wss.on("connection", (ws, req) => {
-    const url = new URL(req.url ?? "/", "http://localhost");
-    if (url.searchParams.get("agent_bridge_token") !== expectedToken) {
-      ws.close(1008, "unauthorized");
-      return;
-    }
-    sendControl(ws, {
-      type: "bridge-hello",
-      state: currentTurnState,
-      lastSeq: seqCounter,
-      capabilities: { experimental_userMessageResponses: true }
-    });
-    ws.on("message", (raw) => {
-      let parsed;
-      try {
-        const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
-        parsed = JSON.parse(text);
-      } catch (err) {
-        sendControl(ws, {
-          type: "error",
-          error: `protocol parse error: ${err.message}`
-        });
-        return;
-      }
-      void handleInbound(parsed, ws);
-    });
-    ws.on("close", () => {
-      if (activeSocket === ws) {
-        activeSocket = void 0;
-      }
-    });
-    ws.on("error", () => {
-    });
-  });
-  process.on("uncaughtException", (err) => {
-    emitError({ error: err, message: "uncaught exception" });
-  });
-  process.on("unhandledRejection", (err) => {
-    emitError({ error: err, message: "unhandled rejection" });
-  });
-  await new Promise((resolve, reject) => {
-    if (wss.address() != null) {
-      resolve();
-      return;
-    }
-    wss.once("listening", resolve);
-    wss.once("error", reject);
-  });
-  return {
-    port: currentBoundPort,
-    close: () => new Promise((resolve) => {
-      wss.close(() => resolve());
-    })
-  };
+	const { bridgeType, bridgeStateDir, onStart, onStop, onDestroy } = options;
+	const teardownGraceMs = options.turnTeardownGraceMs ?? 1e4;
+	const expectedToken = options.token ?? env.BRIDGE_CHANNEL_TOKEN ?? "";
+	const bridgeWsPort = options.port ?? parseInt(env.BRIDGE_WS_PORT ?? "0", 10);
+	const bridgeMetaPath = `${bridgeStateDir}/bridge-meta.json`;
+	const startConfigPath = `${bridgeStateDir}/start-config.json`;
+	const rerunStartConfigPath = `${bridgeStateDir}/rerun-start-config.json`;
+	const eventLogPath = `${bridgeStateDir}/event-log.ndjson`;
+	try {
+		await mkdir(bridgeStateDir, { recursive: true });
+	} catch {}
+	let currentBoundPort = 0;
+	let currentTurnState = "init";
+	let activeSocket;
+	let isFirstTurn = true;
+	let turnAbort;
+	let currentUserMessages;
+	/**
+	* Settles when the in-flight turn has fully wound down — `onStart`
+	* returned or threw AND its completion state was recorded. `undefined`
+	* between turns. A new `start` fences on this so turns never overlap.
+	*/
+	let activeTurn;
+	let debugConfig;
+	let consoleCaptureInstalled = false;
+	const envDebugEnabled = ENV_TRUTHY.has((env.HARNESS_DEBUG ?? "").toLowerCase());
+	let seqCounter = 0;
+	let eventLog = [];
+	let diskBuffer = "";
+	let flushPromise = null;
+	const flushEventsToDisk = async () => {
+		while (diskBuffer.length > 0) {
+			const buf = diskBuffer;
+			diskBuffer = "";
+			await appendFile(eventLogPath, buf).catch(() => {});
+		}
+	};
+	const scheduleEventFlush = () => {
+		if (flushPromise) return;
+		flushPromise = new Promise((resolve) => {
+			setImmediate(() => {
+				flushEventsToDisk().finally(resolve);
+			});
+		}).finally(() => {
+			flushPromise = null;
+			if (diskBuffer.length > 0) scheduleEventFlush();
+		});
+	};
+	const flushPendingEventsToDisk = async () => {
+		if (diskBuffer.length > 0 && !flushPromise) scheduleEventFlush();
+		let inFlight = flushPromise;
+		while (inFlight) {
+			await inFlight;
+			inFlight = flushPromise;
+		}
+	};
+	if (env.BRIDGE_REPLAY_FROM_DISK === "1" && existsSync(eventLogPath)) try {
+		eventLog = readFileSync(eventLogPath, "utf8").split("\n").map((line) => line.trim()).filter(Boolean).map((line) => ({
+			seq: JSON.parse(line).seq,
+			line
+		}));
+		seqCounter = eventLog.at(-1)?.seq ?? 0;
+	} catch {
+		eventLog = [];
+		seqCounter = 0;
+	}
+	const pendingToolResults = /* @__PURE__ */ new Map();
+	const bufferedToolResults = [];
+	const pendingToolApprovals = /* @__PURE__ */ new Map();
+	const writeBridgeMeta = async (state) => {
+		try {
+			await writeFile(bridgeMetaPath, JSON.stringify({
+				type: bridgeType,
+				port: currentBoundPort,
+				state,
+				pid
+			}));
+		} catch {}
+	};
+	const writeStartConfig = async (start) => {
+		try {
+			const serialized = JSON.stringify(start);
+			await writeFile(startConfigPath, serialized);
+			if (!existsSync(rerunStartConfigPath)) await writeFile(rerunStartConfigPath, serialized);
+		} catch {}
+	};
+	const emit = (event) => {
+		const seq = ++seqCounter;
+		const line = JSON.stringify({
+			...event,
+			seq
+		});
+		eventLog.push({
+			seq,
+			line
+		});
+		diskBuffer += `${line}\n`;
+		scheduleEventFlush();
+		if (activeSocket?.readyState === WS_OPEN) try {
+			activeSocket.send(line);
+		} catch {}
+	};
+	const replay = (ws, afterSeq) => {
+		for (const entry of eventLog) if (entry.seq > afterSeq && ws.readyState === WS_OPEN) ws.send(entry.line);
+	};
+	const shouldEmitDebugEvent = (level, subsystem) => {
+		if (!debugConfig?.enabled) return false;
+		const threshold = debugConfig.level ?? "debug";
+		if (DEBUG_LEVEL_WEIGHT[level] > DEBUG_LEVEL_WEIGHT[threshold]) return false;
+		return subsystemMatches(debugConfig.subsystems, subsystem);
+	};
+	const rawStdoutWrite = process.stdout.write.bind(process.stdout);
+	const rawStderrWrite = process.stderr.write.bind(process.stderr);
+	const writeErrorToStderr = (input) => {
+		try {
+			const formatted = formatBridgeError(input.error);
+			rawStderrWrite(`[harness:${bridgeType}:error] ${input.message}: ${formatted.message}\n`);
+			if (formatted.stack) rawStderrWrite(`${formatted.stack}\n`);
+		} catch {}
+	};
+	const emitWarning = (input) => {
+		try {
+			for (const line of input.message.split("\n")) if (line.trim().length > 0) rawStderrWrite(`[harness:${bridgeType}:warn] ${line}\n`);
+		} catch {}
+	};
+	const emitError = (input) => {
+		writeErrorToStderr({
+			message: input.message ?? "bridge error",
+			error: input.error
+		});
+		emit({
+			type: "error",
+			error: serialiseError(input.error)
+		});
+	};
+	const installConsoleCapture = () => {
+		if (consoleCaptureInstalled) return;
+		consoleCaptureInstalled = true;
+		const buffers = {
+			stdout: "",
+			stderr: ""
+		};
+		const patch = (stream, raw) => (chunk, encoding, cb) => {
+			if (debugConfig?.enabled) try {
+				const enc = typeof encoding === "string" ? encoding : "utf8";
+				const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(enc);
+				const parts = (buffers[stream] + text.replace(/\r\n/g, "\n")).split("\n");
+				buffers[stream] = parts.pop() ?? "";
+				for (const line of parts) {
+					const trimmed = line.replace(/\s+$/, "");
+					if (trimmed) emit({
+						type: "sandbox-log",
+						source: bridgeType,
+						stream,
+						line: trimmed
+					});
+				}
+			} catch {}
+			return raw(chunk, encoding, cb);
+		};
+		process.stdout.write = patch("stdout", rawStdoutWrite);
+		process.stderr.write = patch("stderr", rawStderrWrite);
+	};
+	const handleInbound = async (msg, ws) => {
+		switch (msg.type) {
+			case "start": {
+				for (;;) {
+					const pendingTurn = activeTurn;
+					if (pendingTurn == null) break;
+					turnAbort?.abort();
+					currentUserMessages?.close(/* @__PURE__ */ new Error("A new bridge turn replaced the active turn."));
+					let graceTimer;
+					const settled = await Promise.race([pendingTurn.then(() => true), new Promise((resolve) => {
+						graceTimer = setTimeout(() => resolve(false), teardownGraceMs);
+						graceTimer.unref?.();
+					})]);
+					clearTimeout(graceTimer);
+					if (!settled) break;
+				}
+				let turnFinished;
+				const thisTurn = new Promise((resolve) => turnFinished = resolve);
+				activeTurn = thisTurn;
+				activeSocket = ws;
+				const firstTurn = isFirstTurn;
+				isFirstTurn = false;
+				eventLog = [];
+				diskBuffer = "";
+				writeFile(eventLogPath, "").catch(() => {});
+				turnAbort = new AbortController();
+				currentTurnState = "running";
+				writeStartConfig(msg);
+				writeBridgeMeta("running");
+				const startDebug = msg.debug;
+				debugConfig = {
+					enabled: startDebug?.enabled ?? envDebugEnabled,
+					level: startDebug?.level ?? env.HARNESS_DEBUG_LEVEL,
+					subsystems: startDebug?.subsystems ?? parseEnvList(env.HARNESS_DEBUG_SUBSYSTEMS)
+				};
+				if (debugConfig.enabled) installConsoleCapture();
+				const userMessages = createBridgeUserMessageQueue({ respond: emit });
+				const turn = {
+					emit,
+					requestToolResult: (requestInput) => {
+						const request = typeof requestInput === "string" ? { toolCallId: requestInput } : requestInput;
+						const bufferedIndex = bufferedToolResults.findIndex((buffered) => buffered.toolCallId === request.toolCallId || request.matches?.(buffered.result) === true);
+						if (bufferedIndex >= 0) return Promise.resolve(bufferedToolResults.splice(bufferedIndex, 1)[0].result);
+						return new Promise((resolve) => {
+							pendingToolResults.set(request.toolCallId, {
+								resolve,
+								matches: request.matches
+							});
+						});
+					},
+					requestToolApproval: (approvalId) => new Promise((resolve) => {
+						pendingToolApprovals.set(approvalId, resolve);
+					}),
+					experimental_userMessages: userMessages,
+					abortSignal: turnAbort.signal,
+					firstTurn,
+					bridgeLog: (input) => {
+						const level = input.level ?? "debug";
+						if (!shouldEmitDebugEvent(level, input.subsystem)) return;
+						emit({
+							type: "debug-event",
+							level,
+							subsystem: input.subsystem,
+							message: input.message,
+							...input.attrs ? { attrs: input.attrs } : {},
+							...input.error !== void 0 ? { error: formatBridgeError(input.error) } : {}
+						});
+					},
+					emitWarning,
+					emitError
+				};
+				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;
+					if (activeTurn === thisTurn) {
+						activeTurn = void 0;
+						currentTurnState = "waiting";
+						writeBridgeMeta("waiting");
+					}
+					turnFinished();
+				}
+				return;
+			}
+			case "tool-result": {
+				const result = {
+					output: msg.output,
+					isError: msg.isError,
+					toolResult: msg.toolResult
+				};
+				const exactPending = pendingToolResults.get(msg.toolCallId);
+				const matchingPending = exactPending == null ? Array.from(pendingToolResults.entries()).find(([, pending]) => pending.matches?.(result) === true) : void 0;
+				const pending = exactPending ?? matchingPending?.[1];
+				const pendingId = exactPending != null ? msg.toolCallId : matchingPending?.[0];
+				if (pending != null && pendingId != null) {
+					pendingToolResults.delete(pendingId);
+					pending.resolve(result);
+				} else bufferedToolResults.push({
+					toolCallId: msg.toolCallId,
+					result
+				});
+				return;
+			}
+			case "tool-approval-response": {
+				const resolver = pendingToolApprovals.get(msg.approvalId);
+				if (resolver) {
+					pendingToolApprovals.delete(msg.approvalId);
+					resolver({
+						approved: msg.approved,
+						reason: msg.reason
+					});
+				}
+				return;
+			}
+			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;
+			case "resume":
+				activeSocket = ws;
+				replay(ws, msg.lastSeenEventId);
+				return;
+			case "destroy":
+				currentTurnState = "done";
+				writeBridgeMeta("done");
+				await onDestroy?.();
+				drainThenExit(ws, 1e3, "destroy");
+				return;
+			case "stop":
+				currentTurnState = "done";
+				writeBridgeMeta("done");
+				sendControl(ws, {
+					type: "bridge-stop",
+					data: await onStop?.() ?? {}
+				});
+				drainThenExit(ws, 1e3, "stop");
+		}
+	};
+	writeBridgeMeta("init");
+	const wss = new WebSocketServer({
+		port: bridgeWsPort,
+		host: "0.0.0.0"
+	});
+	const exit = () => {
+		if (options.onExit) {
+			options.onExit();
+			return;
+		}
+		wss.close(() => process.exit(0));
+		setTimeout(() => process.exit(0), 1e3).unref();
+	};
+	const drainThenExit = (ws, code, reason) => {
+		const start = Date.now();
+		const tick = () => {
+			if (ws.bufferedAmount === 0 || ws.readyState !== WS_OPEN || Date.now() - start >= 5e3) {
+				flushPendingEventsToDisk().finally(() => {
+					try {
+						ws.close(code, reason);
+					} finally {
+						exit();
+					}
+				});
+				return;
+			}
+			setTimeout(tick, 10).unref();
+		};
+		tick();
+	};
+	wss.on("listening", () => {
+		const addr = wss.address();
+		currentBoundPort = typeof addr === "object" && addr ? addr.port : 0;
+		currentTurnState = "waiting";
+		writeBridgeMeta("waiting");
+		stdout.write(JSON.stringify({
+			type: "bridge-ready",
+			port: currentBoundPort
+		}) + "\n");
+		options.onListening?.(currentBoundPort);
+	});
+	wss.on("connection", (ws, req) => {
+		if (new URL(req.url ?? "/", "http://localhost").searchParams.get("agent_bridge_token") !== expectedToken) {
+			ws.close(1008, "unauthorized");
+			return;
+		}
+		sendControl(ws, {
+			type: "bridge-hello",
+			state: currentTurnState,
+			lastSeq: seqCounter,
+			capabilities: { experimental_userMessageResponses: true }
+		});
+		ws.on("message", (raw) => {
+			let parsed;
+			try {
+				const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
+				parsed = JSON.parse(text);
+			} catch (err) {
+				sendControl(ws, {
+					type: "error",
+					error: `protocol parse error: ${err.message}`
+				});
+				return;
+			}
+			handleInbound(parsed, ws);
+		});
+		ws.on("close", () => {
+			if (activeSocket === ws) activeSocket = void 0;
+		});
+		ws.on("error", () => {});
+	});
+	process.on("uncaughtException", (err) => {
+		emitError({
+			error: err,
+			message: "uncaught exception"
+		});
+	});
+	process.on("unhandledRejection", (err) => {
+		emitError({
+			error: err,
+			message: "unhandled rejection"
+		});
+	});
+	await new Promise((resolve, reject) => {
+		if (wss.address() != null) {
+			resolve();
+			return;
+		}
+		wss.once("listening", resolve);
+		wss.once("error", reject);
+	});
+	return {
+		port: currentBoundPort,
+		close: () => new Promise((resolve) => {
+			wss.close(() => resolve());
+		})
+	};
 }
 function sendControl(socket, message) {
-  if (socket?.readyState === WS_OPEN) {
-    try {
-      socket.send(JSON.stringify(message));
-    } catch {
-    }
-  }
+	if (socket?.readyState === WS_OPEN) try {
+		socket.send(JSON.stringify(message));
+	} catch {}
 }
 function serialiseError(err) {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  return err;
+	if (err instanceof Error) return {
+		name: err.name,
+		message: err.message,
+		stack: err.stack
+	};
+	return err;
 }
-export {
-  HarnessBridgeCapabilityUnsupportedError,
-  runBridge
-};
+//#endregion
+export { HarnessBridgeCapabilityUnsupportedError, runBridge };
+
 //# sourceMappingURL=index.js.map