@ai-sdk/harness-opencode 0.0.0-6b196531-20260710185421

package/dist/bridge/index.mjs

@@ -0,0 +1,2345 @@
+// ../harness/dist/bridge/index.js
+import { appendFile, mkdir, writeFile } from "fs/promises";
+import { existsSync, readFileSync } from "fs";
+import { env as procEnv, pid, stdout } from "process";
+import { WebSocketServer } from "ws";
+var DEBUG_LEVEL_WEIGHT = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+function subsystemMatches(filters, subsystem) {
+  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) };
+}
+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;
+}
+var ENV_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
+var WS_OPEN = 1;
+async function runBridge(options) {
+  const { bridgeType, bridgeStateDir: bridgeStateDir2, onStart, onDetach } = options;
+  const expectedToken = options.token ?? procEnv.BRIDGE_CHANNEL_TOKEN ?? "";
+  const bridgeWsPort = options.port ?? parseInt(procEnv.BRIDGE_WS_PORT ?? "0", 10);
+  const bridgeMetaPath = `${bridgeStateDir2}/bridge-meta.json`;
+  const startConfigPath = `${bridgeStateDir2}/start-config.json`;
+  const rerunStartConfigPath = `${bridgeStateDir2}/rerun-start-config.json`;
+  const eventLogPath = `${bridgeStateDir2}/event-log.ndjson`;
+  try {
+    await mkdir(bridgeStateDir2, { recursive: true });
+  } catch {
+  }
+  let currentBoundPort = 0;
+  let currentTurnState = "init";
+  let activeSocket;
+  let isFirstTurn = true;
+  let turnAbort;
+  let currentUserMessages;
+  let currentInterruptHandler;
+  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 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 sendControl = (msg) => {
+    if (activeSocket?.readyState === WS_OPEN) {
+      try {
+        activeSocket.send(JSON.stringify(msg));
+      } 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": {
+        const firstTurn = isFirstTurn;
+        isFirstTurn = false;
+        eventLog = [];
+        diskBuffer = "";
+        void writeFile(eventLogPath, "").catch(() => {
+        });
+        turnAbort = new AbortController();
+        currentTurnState = "running";
+        currentInterruptHandler = void 0;
+        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 turn = {
+          emit,
+          requestToolResult: (toolCallId) => new Promise((resolve) => {
+            pendingToolResults.set(toolCallId, resolve);
+          }),
+          requestToolApproval: (approvalId) => new Promise((resolve) => {
+            pendingToolApprovals.set(approvalId, resolve);
+          }),
+          pendingUserMessages: [],
+          abortSignal: turnAbort.signal,
+          onInterrupt: (handler) => {
+            currentInterruptHandler = handler;
+          },
+          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 = turn.pendingUserMessages;
+        try {
+          await onStart(msg, turn);
+        } catch (err) {
+          emitError({ error: err, message: "bridge turn failed" });
+        } finally {
+          currentInterruptHandler = void 0;
+          currentTurnState = "waiting";
+          void writeBridgeMeta("waiting");
+        }
+        return;
+      }
+      case "tool-result": {
+        const resolver = pendingToolResults.get(msg.toolCallId);
+        if (resolver) {
+          pendingToolResults.delete(msg.toolCallId);
+          resolver({ output: msg.output, isError: msg.isError });
+        }
+        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":
+        currentUserMessages?.push(msg.text);
+        return;
+      case "abort":
+        turnAbort?.abort();
+        return;
+      case "interrupt":
+        try {
+          if (pendingToolResults.size === 0 && pendingToolApprovals.size === 0) {
+            if (currentInterruptHandler) {
+              await currentInterruptHandler();
+            } else {
+              turnAbort?.abort();
+            }
+          }
+          sendControl({ type: "bridge-interrupted", ok: true });
+        } catch (err) {
+          sendControl({
+            type: "bridge-interrupted",
+            ok: false,
+            error: serialiseError(err)
+          });
+        }
+        return;
+      case "resume":
+        replay(ws, msg.lastSeenEventId);
+        return;
+      case "shutdown":
+        currentTurnState = "done";
+        void writeBridgeMeta("done");
+        drainThenExit(ws, 1e3, "shutdown");
+        return;
+      case "detach": {
+        currentTurnState = "done";
+        void writeBridgeMeta("done");
+        const data = await onDetach?.() ?? {};
+        sendControl({ type: "bridge-detach", data });
+        drainThenExit(ws, 1e3, "detach");
+        return;
+      }
+    }
+  };
+  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;
+    }
+    activeSocket = ws;
+    sendControl({
+      type: "bridge-hello",
+      state: currentTurnState,
+      lastSeq: seqCounter
+    });
+    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({
+          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());
+    })
+  };
+}
+function serialiseError(err) {
+  if (err instanceof Error) {
+    return { name: err.name, message: err.message, stack: err.stack };
+  }
+  return err;
+}
+
+// src/bridge/index.ts
+import { randomUUID } from "crypto";
+import { mkdirSync } from "fs";
+import { createServer } from "http";
+import path2 from "path";
+import { argv, env as procEnv2 } from "process";
+import {
+  createOpencodeClient,
+  createOpencodeServer
+} from "@opencode-ai/sdk/v2";
+
+// src/bridge/opencode-events.ts
+function unwrapOpenCodeEvent(rawEvent) {
+  if (!rawEvent || typeof rawEvent !== "object") return void 0;
+  const raw = rawEvent;
+  if (raw.type === "sync" && raw.syncEvent) {
+    const sync = raw.syncEvent;
+    return {
+      id: String(sync.id ?? raw.id ?? ""),
+      type: stripSyncVersion(String(sync.type ?? "")),
+      properties: asRecord(sync.data) ?? {}
+    };
+  }
+  return {
+    id: typeof raw.id === "string" ? raw.id : void 0,
+    type: typeof raw.type === "string" ? stripSyncVersion(raw.type) : void 0,
+    properties: asRecord(raw.properties) ?? asRecord(raw.data) ?? {}
+  };
+}
+function getOpenCodeEventSessionId(event) {
+  const props = event.properties;
+  if (!props) return void 0;
+  if (typeof props.sessionID === "string") return props.sessionID;
+  if (typeof props.sessionId === "string") return props.sessionId;
+  if (event.type?.startsWith("session.") && typeof props.id === "string") {
+    return props.id;
+  }
+  const part = props.part;
+  if (part && typeof part === "object" && !Array.isArray(part) && typeof part.sessionID === "string") {
+    return part.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,
+  emittedText,
+  emit,
+  type
+}) {
+  if (!fullText || fullText === emittedText || !fullText.startsWith(emittedText)) {
+    return;
+  }
+  emit({ type, id, delta: fullText.slice(emittedText.length) });
+}
+function stripSyncVersion(type) {
+  return type.replace(/\.\d+$/, "");
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  return value;
+}
+
+// src/bridge/opencode-usage.ts
+function mapUsage(tokens) {
+  const value = extractOpenCodeTokens(tokens) ?? zeroOpenCodeTokens();
+  const cacheRead = value.cache.read;
+  return {
+    inputTokens: {
+      total: value.input,
+      noCache: Math.max(0, value.input - cacheRead),
+      cacheRead,
+      cacheWrite: value.cache.write
+    },
+    outputTokens: {
+      total: value.output + value.reasoning,
+      text: value.output,
+      reasoning: value.reasoning
+    }
+  };
+}
+function defaultUsage() {
+  return mapUsage(zeroOpenCodeTokens());
+}
+function extractSessionTokens(value) {
+  const record = asRecord2(value);
+  if (!record) return void 0;
+  const tokens = extractOpenCodeTokens(record.tokens) ?? extractOpenCodeTokens(asRecord2(record.info)?.tokens) ?? extractOpenCodeTokens(asRecord2(record.data)?.tokens) ?? extractOpenCodeTokens(asRecord2(asRecord2(record.data)?.data)?.tokens);
+  return tokens;
+}
+function subtractSessionTokens({
+  before,
+  after
+}) {
+  return {
+    input: diff({ before: before.input, after: after.input }),
+    output: diff({ before: before.output, after: after.output }),
+    reasoning: diff({ before: before.reasoning, after: after.reasoning }),
+    cache: {
+      read: diff({ before: before.cache.read, after: after.cache.read }),
+      write: diff({ before: before.cache.write, after: after.cache.write })
+    }
+  };
+}
+function addUsage({
+  left,
+  right
+}) {
+  if (left == null) return right;
+  const leftInput = asTokenGroup(left.inputTokens);
+  const rightInput = asTokenGroup(right.inputTokens);
+  const leftOutput = asTokenGroup(left.outputTokens);
+  const rightOutput = asTokenGroup(right.outputTokens);
+  return {
+    inputTokens: {
+      total: add({ left: leftInput.total, right: rightInput.total }),
+      noCache: add({ left: leftInput.noCache, right: rightInput.noCache }),
+      cacheRead: add({
+        left: leftInput.cacheRead,
+        right: rightInput.cacheRead
+      }),
+      cacheWrite: add({
+        left: leftInput.cacheWrite,
+        right: rightInput.cacheWrite
+      })
+    },
+    outputTokens: {
+      total: add({ left: leftOutput.total, right: rightOutput.total }),
+      text: add({ left: leftOutput.text, right: rightOutput.text }),
+      reasoning: add({
+        left: leftOutput.reasoning,
+        right: rightOutput.reasoning
+      })
+    }
+  };
+}
+function extractOpenCodeTokens(value) {
+  const record = asRecord2(value);
+  const cache = asRecord2(record?.cache);
+  if (!record || !cache) return void 0;
+  return {
+    input: numberValue(record.input),
+    output: numberValue(record.output),
+    reasoning: numberValue(record.reasoning),
+    cache: {
+      read: numberValue(cache.read),
+      write: numberValue(cache.write)
+    }
+  };
+}
+function zeroOpenCodeTokens() {
+  return {
+    input: 0,
+    output: 0,
+    reasoning: 0,
+    cache: { read: 0, write: 0 }
+  };
+}
+function asTokenGroup(value) {
+  return asRecord2(value) ?? {};
+}
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  return value;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function diff({ before, after }) {
+  return Math.max(0, after - before);
+}
+function add({
+  left,
+  right
+}) {
+  const leftNumber = typeof left === "number" ? left : void 0;
+  const rightNumber = typeof right === "number" ? right : void 0;
+  return leftNumber == null && rightNumber == null ? void 0 : (leftNumber ?? 0) + (rightNumber ?? 0);
+}
+
+// src/bridge/opencode-finish-step.ts
+function mapOpenCodeFinishReason(reason) {
+  const normalized = reason.toLowerCase();
+  if (normalized.includes("length")) return "length";
+  if (normalized.includes("filter")) return "content-filter";
+  if (normalized.includes("tool")) return "tool-calls";
+  if (normalized.includes("error") || normalized.includes("fail"))
+    return "error";
+  if (normalized === "stop" || normalized === "end") return "stop";
+  return "other";
+}
+function legacyStepFinishPartToFinishStep(part) {
+  if (!isRecord(part) || part.type !== "step-finish") return void 0;
+  const rawFinish = typeof part.reason === "string" ? part.reason : "stop";
+  return {
+    type: "finish-step",
+    finishReason: {
+      unified: mapOpenCodeFinishReason(rawFinish),
+      raw: rawFinish
+    },
+    usage: mapUsage(part.tokens),
+    ...typeof part.cost === "number" ? { harnessMetadata: { opencode: { cost: part.cost } } } : {}
+  };
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/bridge/opencode-path.ts
+import path from "path";
+var fallbackPath = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+function prependOpenCodeBinToPath({
+  bootstrapDir: bootstrapDir2,
+  env
+}) {
+  env.PATH = [
+    path.join(bootstrapDir2, "node_modules", ".bin"),
+    env.PATH || fallbackPath
+  ].join(path.delimiter);
+}
+
+// src/bridge/tool-relay-auth.ts
+import { readdir, readFile, readlink } from "fs/promises";
+var ToolRelayAuthorizer = class {
+  constructor({
+    ttlMs = 1e4,
+    now = Date.now
+  } = {}) {
+    this.authorizations = [];
+    this.ttlMs = ttlMs;
+    this.now = now;
+  }
+  authorizeToolCall(call) {
+    this.pruneExpired();
+    this.authorizations.push({
+      key: toolRelayCallKey(call),
+      expiresAt: this.now() + this.ttlMs
+    });
+  }
+  consumeToolCall(call) {
+    this.pruneExpired();
+    const key = toolRelayCallKey(call);
+    const index = this.authorizations.findIndex((auth) => auth.key === key);
+    if (index === -1) return false;
+    this.authorizations.splice(index, 1);
+    return true;
+  }
+  pruneExpired() {
+    const now = this.now();
+    for (let i = this.authorizations.length - 1; i >= 0; i--) {
+      if (this.authorizations[i].expiresAt <= now) {
+        this.authorizations.splice(i, 1);
+      }
+    }
+  }
+};
+function toolRelayCallKey({ toolName, input }) {
+  return `${toolName}\0${canonicalJson(input ?? {})}`;
+}
+function canonicalJson(value) {
+  return JSON.stringify(normalizeJsonValue(value));
+}
+function normalizeJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeJsonValue);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => [key, normalizeJsonValue(entryValue)])
+    );
+  }
+  return value;
+}
+async function isToolRelayRequestFromAllowedProcess({
+  socket,
+  allowedScriptPaths
+}) {
+  if (process.platform !== "linux") return false;
+  if (!socket.remotePort || !socket.localPort) return false;
+  const inode = await findTcpSocketInode({
+    clientPort: socket.remotePort,
+    serverPort: socket.localPort
+  });
+  if (!inode) return false;
+  const cmdline = await findProcessCmdlineForSocketInode({ inode });
+  return cmdline?.some((arg) => allowedScriptPaths.has(arg)) ?? false;
+}
+async function findTcpSocketInode({
+  clientPort,
+  serverPort
+}) {
+  for (const tablePath of ["/proc/net/tcp", "/proc/net/tcp6"]) {
+    const table = await readFile(tablePath, "utf8").catch(() => void 0);
+    if (!table) continue;
+    for (const line of table.split("\n").slice(1)) {
+      const columns = line.trim().split(/\s+/);
+      if (columns.length < 10) continue;
+      const local = parseProcNetAddress(columns[1]);
+      const remote = parseProcNetAddress(columns[2]);
+      if (local?.port === clientPort && remote?.port === serverPort && columns[9] !== "0") {
+        return columns[9];
+      }
+    }
+  }
+  return void 0;
+}
+function parseProcNetAddress(value) {
+  const [, portHex] = value.split(":");
+  if (!portHex) return void 0;
+  return { port: Number.parseInt(portHex, 16) };
+}
+async function findProcessCmdlineForSocketInode({
+  inode
+}) {
+  const procEntries = await readdir("/proc", { withFileTypes: true }).catch(
+    () => []
+  );
+  for (const entry of procEntries) {
+    if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) continue;
+    const fdDir = `/proc/${entry.name}/fd`;
+    const fds = await readdir(fdDir).catch(() => []);
+    for (const fd of fds) {
+      const target = await readlink(`${fdDir}/${fd}`).catch(() => void 0);
+      if (target !== `socket:[${inode}]`) continue;
+      const cmdline = await readFile(`/proc/${entry.name}/cmdline`, "utf8").then((value) => value.split("\0").filter(Boolean)).catch(() => void 0);
+      if (cmdline) return cmdline;
+    }
+  }
+  return void 0;
+}
+
+// src/bridge/index.ts
+var NATIVE_TO_COMMON = {
+  view: "read",
+  read: "read",
+  write: "write",
+  edit: "edit",
+  bash: "bash",
+  glob: "glob",
+  grep: "grep"
+};
+var OPENCODE_TO_WIRE = {
+  list: "ls",
+  ls: "ls",
+  webfetch: "webfetch",
+  task: "agent",
+  agent: "agent",
+  subtask: "agent"
+};
+var PUBLIC_TO_NATIVE = {
+  read: "view",
+  write: "write",
+  edit: "edit",
+  bash: "bash",
+  glob: "glob",
+  grep: "grep",
+  ls: "list",
+  webfetch: "webfetch",
+  skill: "skill",
+  todowrite: "todowrite",
+  agent: "agent"
+};
+var TOOL_KIND = {
+  read: "readonly",
+  glob: "readonly",
+  grep: "readonly",
+  ls: "readonly",
+  webfetch: "readonly",
+  write: "edit",
+  edit: "edit",
+  bash: "bash",
+  agent: "bash",
+  skill: "edit",
+  todowrite: "edit"
+};
+var HARNESS_CLIENT_APP = procEnv2.AI_SDK_HARNESS_CLIENT_APP;
+var args = parseArgs(argv.slice(2));
+var workdir = args.workdir ?? emitFatal("Missing --workdir argument.");
+var bridgeStateDir = args.bridgeStateDir ?? emitFatal("Missing --bridge-state-dir argument.");
+var bootstrapDir = args.bootstrapDir ?? workdir;
+var skillsDir = args.skillsDir;
+var runtime = { toolNames: /* @__PURE__ */ new Set() };
+prependOpenCodeBinToPath({ bootstrapDir, env: procEnv2 });
+mkdirSync(process.env.HOME ?? "/tmp/opencode-home", { recursive: true });
+await runBridge({
+  bridgeType: "opencode",
+  bridgeStateDir,
+  onStart: runTurn,
+  onDetach: () => runtime.sessionId ? { openCodeSessionId: runtime.sessionId } : {}
+});
+async function runTurn(start, turn) {
+  const emit = (msg) => turn.emit(msg);
+  let totalUsage;
+  try {
+    await ensureRuntime({ start, turn, emit });
+    const client = runtime.client;
+    const sessionId = await ensureSession({ client, start, emit });
+    if (start.operation === "compact") {
+      await runCompaction({ client, sessionId, start, turn, emit });
+    } else {
+      totalUsage = await runPrompt({ client, sessionId, start, turn, emit });
+    }
+  } catch (err) {
+    turn.emitError({ error: err, message: "OpenCode turn failed" });
+  } finally {
+    emit({
+      type: "finish",
+      finishReason: { unified: "stop", raw: "stop" },
+      totalUsage: totalUsage ?? defaultUsage()
+    });
+  }
+}
+async function ensureRuntime({
+  start,
+  turn,
+  emit
+}) {
+  if (runtime.client) return;
+  if (start.tools && start.tools.length > 0) {
+    runtime.toolNames = new Set(start.tools.map((tool) => tool.name));
+    runtime.relay = await startToolRelay({
+      allowedScriptPaths: [`${bootstrapDir}/host-tool-mcp.mjs`],
+      tools: start.tools,
+      emit,
+      requestToolResult: turn.requestToolResult
+    });
+  }
+  const server = await createOpencodeServer({
+    hostname: "127.0.0.1",
+    port: 0,
+    timeout: 3e4,
+    config: buildOpenCodeConfig({
+      start,
+      relayPort: runtime.relay?.port
+    })
+  });
+  runtime.server = server;
+  runtime.client = createOpencodeClient({
+    baseUrl: server.url,
+    directory: workdir
+  });
+}
+function buildOpenCodeConfig({
+  start,
+  relayPort
+}) {
+  const config = {
+    share: "disabled",
+    autoupdate: false,
+    permission: {
+      read: "allow",
+      glob: "allow",
+      grep: "allow",
+      list: "allow",
+      edit: "ask",
+      bash: "ask",
+      external_directory: "ask",
+      webfetch: "ask",
+      doom_loop: "ask",
+      task: "ask"
+    }
+  };
+  if (start.model) config.model = start.model;
+  if (skillsDir) config.skills = { paths: [skillsDir] };
+  const inactiveToolNames = resolveInactiveBuiltinToolNames(start);
+  const permission = config.permission;
+  for (const toolName of inactiveToolNames) {
+    const permissionName = toPermissionToolName(
+      PUBLIC_TO_NATIVE[toolName] ?? toolName
+    );
+    if (permissionName === "ls") {
+      permission.list = "ask";
+    } else {
+      permission[permissionName] = "ask";
+    }
+  }
+  const provider = buildProviderConfig(start);
+  if (provider) config.provider = provider;
+  if (relayPort && start.tools && start.tools.length > 0) {
+    config.mcp = {
+      "harness-tools": {
+        type: "local",
+        enabled: true,
+        command: ["node", `${bootstrapDir}/host-tool-mcp.mjs`],
+        environment: {
+          TOOL_SCHEMAS: JSON.stringify(
+            start.tools.map((t) => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema
+            }))
+          ),
+          TOOL_RELAY_URL: `http://127.0.0.1:${relayPort}`
+        }
+      }
+    };
+  }
+  return config;
+}
+function buildProviderConfig(start) {
+  const model = splitModel(start.model, start.provider);
+  const providerID = model.providerID ?? start.provider ?? procEnv2.OPENAI_NAME ?? "anthropic";
+  const modelID = model.modelID;
+  if (procEnv2.AI_GATEWAY_API_KEY && procEnv2.AI_GATEWAY_BASE_URL) {
+    return {
+      [providerID]: {
+        options: {
+          apiKey: procEnv2.AI_GATEWAY_API_KEY,
+          baseURL: toOpenCodeGatewayBaseUrl(procEnv2.AI_GATEWAY_BASE_URL),
+          ...HARNESS_CLIENT_APP ? { headers: { "x-client-app": HARNESS_CLIENT_APP } } : {}
+        },
+        ...modelID ? {
+          models: {
+            [modelID]: { id: modelID, name: modelID }
+          }
+        } : {}
+      }
+    };
+  }
+  if ((procEnv2.OPENAI_NAME || providerID !== "anthropic" && providerID !== "openai") && (procEnv2.OPENAI_API_KEY || procEnv2.OPENAI_BASE_URL)) {
+    const openAICompatibleProviderID = procEnv2.OPENAI_NAME ?? providerID;
+    return {
+      [openAICompatibleProviderID]: {
+        options: {
+          ...procEnv2.OPENAI_API_KEY ? { apiKey: procEnv2.OPENAI_API_KEY } : {},
+          ...procEnv2.OPENAI_BASE_URL ? { baseURL: procEnv2.OPENAI_BASE_URL } : {},
+          ...parseOpenAIQueryParams()
+        },
+        ...modelID ? {
+          models: {
+            [modelID]: { id: modelID, name: modelID }
+          }
+        } : {}
+      }
+    };
+  }
+  if (providerID === "anthropic" && (procEnv2.ANTHROPIC_API_KEY || procEnv2.ANTHROPIC_AUTH_TOKEN || procEnv2.ANTHROPIC_BASE_URL)) {
+    return {
+      anthropic: {
+        options: {
+          ...procEnv2.ANTHROPIC_API_KEY ? { apiKey: procEnv2.ANTHROPIC_API_KEY } : {},
+          ...procEnv2.ANTHROPIC_AUTH_TOKEN ? { authToken: procEnv2.ANTHROPIC_AUTH_TOKEN } : {},
+          ...procEnv2.ANTHROPIC_BASE_URL ? { baseURL: procEnv2.ANTHROPIC_BASE_URL } : {}
+        }
+      }
+    };
+  }
+  if (providerID === "openai" && (procEnv2.OPENAI_API_KEY || procEnv2.OPENAI_BASE_URL)) {
+    return {
+      openai: {
+        options: {
+          ...procEnv2.OPENAI_API_KEY ? { apiKey: procEnv2.OPENAI_API_KEY } : {},
+          ...procEnv2.OPENAI_BASE_URL ? { baseURL: procEnv2.OPENAI_BASE_URL } : {},
+          ...procEnv2.OPENAI_ORGANIZATION ? { organization: procEnv2.OPENAI_ORGANIZATION } : {},
+          ...procEnv2.OPENAI_PROJECT ? { project: procEnv2.OPENAI_PROJECT } : {},
+          ...parseOpenAIQueryParams()
+        }
+      }
+    };
+  }
+  return void 0;
+}
+function parseOpenAIQueryParams() {
+  if (!procEnv2.OPENAI_QUERY_PARAMS_JSON) return {};
+  try {
+    const parsed = JSON.parse(procEnv2.OPENAI_QUERY_PARAMS_JSON);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { queryParams: parsed };
+    }
+  } catch {
+  }
+  return {};
+}
+function toOpenCodeGatewayBaseUrl(baseUrl) {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+async function legacySessionGet({
+  client,
+  sessionId
+}) {
+  const session = client.session;
+  if (!session?.get) return client.v2.session.get({ sessionID: sessionId });
+  return session.get({ sessionID: sessionId });
+}
+async function legacySessionCreate({
+  client
+}) {
+  return client.session.create({});
+}
+async function legacySessionPrompt({
+  client,
+  sessionId,
+  start
+}) {
+  const session = client.session;
+  const prompt = session.promptAsync ?? session.prompt;
+  return prompt.call(session, {
+    sessionID: sessionId,
+    ...start.instructions ? { system: start.instructions } : {},
+    ...start.variant ? { variant: start.variant } : {},
+    parts: [{ type: "text", text: start.prompt }]
+  });
+}
+async function legacySessionSummarize({
+  client,
+  sessionId,
+  model
+}) {
+  return client.session.summarize({
+    sessionID: sessionId,
+    auto: false,
+    providerID: model.providerID,
+    modelID: model.modelID
+  });
+}
+async function subscribeLegacyEvents({
+  client,
+  signal
+}) {
+  const subscribed = await client.event.subscribe(void 0, {
+    signal,
+    sseMaxRetryAttempts: 0
+  });
+  return getEventStream(subscribed);
+}
+function readSessionId(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const record = data;
+  if (typeof record.id === "string") return record.id;
+  if (typeof record.data?.id === "string") return record.data.id;
+  return void 0;
+}
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+function getEventStream(source) {
+  if (!source || typeof source !== "object") return null;
+  const candidate = source;
+  if (isAsyncIterable(candidate.stream)) return candidate.stream;
+  if (isAsyncIterable(candidate.data)) return candidate.data;
+  return null;
+}
+function legacyStatusType(event) {
+  const status = event.properties?.status;
+  return status && typeof status === "object" ? String(status.type ?? "") : void 0;
+}
+function legacyRetryStatusMessage(event) {
+  const status = event.properties?.status;
+  const details = [];
+  if (status && typeof status === "object") {
+    const retryStatus = status;
+    if (typeof retryStatus.attempt === "number") {
+      details.push(`attempt ${retryStatus.attempt}`);
+    }
+    if (typeof retryStatus.message === "string" && retryStatus.message.trim()) {
+      details.push(retryStatus.message.trim());
+    }
+  }
+  return details.length > 0 ? `OpenCode session retry: ${details.join("; ")}` : "OpenCode session retry";
+}
+function nextRetryEventMessage(event) {
+  const props = event.properties ?? {};
+  const details = [];
+  if (typeof props.attempt === "number") {
+    details.push(`attempt ${props.attempt}`);
+  }
+  const error = props.error;
+  if (isRecord2(error)) {
+    const message = stringValue(error.message) ?? (isRecord2(error.data) ? stringValue(error.data.message) : void 0);
+    const statusCode = error.statusCode;
+    if (typeof statusCode === "number") {
+      details.push(`HTTP ${statusCode}`);
+    }
+    if (message) details.push(message);
+  } else if (error != null) {
+    details.push(formatError(error));
+  }
+  return details.length > 0 ? `OpenCode session retry: ${details.join("; ")}` : "OpenCode session retry";
+}
+async function ensureSession({
+  client,
+  start,
+  emit
+}) {
+  if (runtime.sessionId) return runtime.sessionId;
+  if (start.resumeSessionId) {
+    const existing = await legacySessionGet({
+      client,
+      sessionId: start.resumeSessionId
+    }).catch(() => void 0);
+    if (existing && !existing.error) {
+      runtime.sessionId = start.resumeSessionId;
+      emit({ type: "bridge-thread", threadId: runtime.sessionId });
+      return runtime.sessionId;
+    }
+  }
+  const created = await legacySessionCreate({ client });
+  if (created.error) {
+    throw new Error(
+      `OpenCode session create failed: ${formatError(created.error)}`
+    );
+  }
+  const id = readSessionId(created.data);
+  if (!id) throw new Error("OpenCode session create returned no id.");
+  runtime.sessionId = id;
+  emit({ type: "bridge-thread", threadId: id });
+  return id;
+}
+async function runPrompt({
+  client,
+  sessionId,
+  start,
+  turn,
+  emit
+}) {
+  const eventsAbort = new AbortController();
+  const turnSettled = createDeferred();
+  let sawContent = false;
+  let sawFinishStep = false;
+  let sawBusy = false;
+  let terminalError;
+  const initialSessionTokens = await readSessionTokens({
+    client,
+    sessionId
+  }).catch(() => void 0);
+  const eventsReady = createDeferred();
+  let stepUsage;
+  let latestSessionTokens;
+  const eventLoop = consumeEvents({
+    client,
+    sessionId,
+    permissionMode: start.permissionMode,
+    builtinToolFiltering: start.builtinToolFiltering,
+    turn,
+    emit: (msg) => {
+      if (msg.type === "text-delta" || msg.type === "reasoning-delta") {
+        sawContent = true;
+      }
+      if (msg.type === "finish-step") {
+        sawFinishStep = true;
+        stepUsage = addUsage({
+          left: stepUsage,
+          right: msg.usage
+        });
+      }
+      emit(msg);
+    },
+    signal: eventsAbort.signal,
+    onSubscribed: () => eventsReady.resolve(void 0),
+    onEvent: (event) => {
+      if (event.type === "session.updated") {
+        latestSessionTokens = extractSessionTokens(event.properties) ?? latestSessionTokens;
+      }
+      if (isStepSettlementEvent(event)) {
+        turnSettled.resolve();
+        return true;
+      }
+      const status = legacyStatusType(event);
+      if (status === "busy") {
+        sawBusy = true;
+      } else if (status === "retry") {
+        sawBusy = true;
+        turn.emitWarning({ message: legacyRetryStatusMessage(event) });
+      } else if (sawBusy && status === "idle") {
+        turnSettled.resolve();
+        return true;
+      }
+      if (event.type === "session.error") {
+        terminalError = formatError(event.properties?.error ?? event);
+        turnSettled.resolve();
+        return true;
+      }
+    }
+  }).finally(() => {
+    eventsReady.resolve(void 0);
+    turnSettled.resolve();
+  });
+  emit({
+    type: "stream-start",
+    ...start.model ? { modelId: start.model } : {}
+  });
+  await eventsReady.promise;
+  const prompted = await legacySessionPrompt({
+    client,
+    sessionId,
+    start
+  });
+  if (prompted.error) {
+    eventsAbort.abort();
+    throw new Error(`OpenCode prompt failed: ${formatError(prompted.error)}`);
+  }
+  await turnSettled.promise;
+  eventsAbort.abort();
+  await eventLoop.catch(() => {
+  });
+  if (terminalError) throw new Error(terminalError);
+  if (!sawFinishStep) {
+    const emittedFallback = await emitContextFallback({
+      client,
+      sessionId,
+      emit,
+      emitContent: !sawContent
+    }).catch(() => false);
+    if (!emittedFallback) {
+      emit({
+        type: "finish-step",
+        finishReason: { unified: "stop", raw: "stop" },
+        usage: defaultUsage(),
+        harnessMetadata: { opencode: { fallback: true, missingContext: true } }
+      });
+    }
+  }
+  const finalSessionTokens = await readSessionTokens({ client, sessionId }).catch(() => void 0) ?? latestSessionTokens;
+  if (initialSessionTokens && finalSessionTokens) {
+    return mapUsage(
+      subtractSessionTokens({
+        before: initialSessionTokens,
+        after: finalSessionTokens
+      })
+    );
+  }
+  return stepUsage;
+}
+async function runCompaction({
+  client,
+  sessionId,
+  start,
+  turn,
+  emit
+}) {
+  const eventsAbort = new AbortController();
+  const compactionSettled = createDeferred();
+  let sawCompaction = false;
+  let sawBusy = false;
+  let terminalError;
+  const model = await resolveCompactionModel({
+    client,
+    sessionId,
+    start
+  });
+  if (!model) {
+    throw new Error(
+      "OpenCode compaction requires a previous turn or an explicit model."
+    );
+  }
+  const eventLoop = consumeEvents({
+    client,
+    sessionId,
+    permissionMode: start.permissionMode,
+    builtinToolFiltering: start.builtinToolFiltering,
+    turn,
+    emit: (msg) => {
+      if (msg.type === "compaction") sawCompaction = true;
+      emit(msg);
+    },
+    signal: eventsAbort.signal,
+    onEvent: (event) => {
+      if (event.type === "session.next.compaction.ended" || event.type === "session.compacted") {
+        compactionSettled.resolve();
+        return true;
+      }
+      const status = legacyStatusType(event);
+      if (status === "busy") {
+        sawBusy = true;
+      } else if (status === "retry") {
+        sawBusy = true;
+        turn.emitWarning({ message: legacyRetryStatusMessage(event) });
+      } else if (sawBusy && status === "idle") {
+        compactionSettled.resolve();
+        return true;
+      }
+      if (event.type === "session.error") {
+        terminalError = formatError(event.properties?.error ?? event);
+        compactionSettled.resolve();
+        return true;
+      }
+    }
+  });
+  const compacted = await legacySessionSummarize({
+    client,
+    sessionId,
+    model
+  });
+  if (compacted.error) {
+    eventsAbort.abort();
+    throw new Error(
+      `OpenCode compaction failed: ${formatError(compacted.error)}`
+    );
+  }
+  await Promise.race([compactionSettled.promise, sleep(250)]);
+  eventsAbort.abort();
+  await eventLoop.catch(() => {
+  });
+  if (terminalError) throw new Error(terminalError);
+  if (!sawCompaction) {
+    emit({
+      type: "compaction",
+      trigger: "manual",
+      summary: "",
+      harnessMetadata: {
+        opencode: { missingSummary: true }
+      }
+    });
+  }
+}
+async function consumeEvents({
+  client,
+  sessionId,
+  permissionMode,
+  builtinToolFiltering,
+  turn,
+  emit,
+  signal,
+  onSubscribed,
+  onEvent
+}) {
+  const stream = await subscribeLegacyEvents({ client, signal });
+  onSubscribed?.();
+  if (!stream) return;
+  const state = createTranslationState();
+  for await (const rawEvent of stream) {
+    if (signal.aborted || turn.abortSignal.aborted) break;
+    const event = unwrapOpenCodeEvent(rawEvent);
+    const eventSessionId = event ? getOpenCodeEventSessionId(event) : void 0;
+    if (!event || eventSessionId && eventSessionId !== sessionId) continue;
+    await translateAndEmit({
+      event,
+      state,
+      sessionId,
+      permissionMode,
+      builtinToolFiltering,
+      client,
+      turn,
+      emit
+    });
+    if (onEvent?.(event)) break;
+  }
+}
+function createTranslationState() {
+  return {
+    textDeltas: /* @__PURE__ */ new Map(),
+    reasoningDeltas: /* @__PURE__ */ new Map(),
+    toolInputs: /* @__PURE__ */ new Map(),
+    toolNames: /* @__PURE__ */ new Map(),
+    toolCallsEmitted: /* @__PURE__ */ new Set(),
+    toolResultsEmitted: /* @__PURE__ */ new Set(),
+    hostToolCallsAuthorized: /* @__PURE__ */ new Set(),
+    shellCommands: /* @__PURE__ */ new Map(),
+    messageRoles: /* @__PURE__ */ new Map(),
+    turnUsage: void 0,
+    legacyTextPartIds: /* @__PURE__ */ new Set(),
+    legacyReasoningPartIds: /* @__PURE__ */ new Set(),
+    legacyStepFinishPartIds: /* @__PURE__ */ new Set()
+  };
+}
+async function translateAndEmit({
+  event,
+  state,
+  sessionId,
+  permissionMode,
+  builtinToolFiltering,
+  client,
+  turn,
+  emit
+}) {
+  const type = event.type;
+  const props = event.properties ?? {};
+  if (type === "message.updated") {
+    const info = props.info;
+    if (isRecord2(info)) {
+      const id = stringValue(info.id);
+      const role = stringValue(info.role);
+      if (id && role) state.messageRoles.set(id, role);
+    }
+    return;
+  }
+  if (type === "message.part.delta") {
+    const field = String(props.field ?? "");
+    const delta = String(props.delta ?? "");
+    if (!delta) return;
+    const messageID = stringValue(props.messageID);
+    if (messageID && state.messageRoles.get(messageID) === "user") return;
+    if (field === "text") {
+      const id = legacyPartId({ value: props, fallback: "legacy-text" });
+      startLegacyPart({ ids: state.legacyTextPartIds, id, emit, type: "text" });
+      state.textDeltas.set(id, `${state.textDeltas.get(id) ?? ""}${delta}`);
+      emit({ type: "text-delta", id, delta });
+      return;
+    }
+    if (field === "reasoning") {
+      const id = legacyPartId({ value: props, fallback: "legacy-reasoning" });
+      startLegacyPart({
+        ids: state.legacyReasoningPartIds,
+        id,
+        emit,
+        type: "reasoning"
+      });
+      state.reasoningDeltas.set(
+        id,
+        `${state.reasoningDeltas.get(id) ?? ""}${delta}`
+      );
+      emit({ type: "reasoning-delta", id, delta });
+    }
+    return;
+  }
+  if (type === "message.part.updated") {
+    if (emitLegacyTextPartUpdate({ part: props.part, state, emit })) return;
+    if (emitLegacyStepFinishPart({ part: props.part, state, emit })) return;
+    emitLegacyToolPart({ part: props.part, state, emit });
+    return;
+  }
+  if (type === "session.next.text.started") {
+    emit({ type: "text-start", id: String(props.textID ?? event.id) });
+    return;
+  }
+  if (type === "session.next.text.delta") {
+    const id = String(props.textID ?? event.id);
+    state.textDeltas.set(
+      id,
+      `${state.textDeltas.get(id) ?? ""}${String(props.delta ?? "")}`
+    );
+    emit({
+      type: "text-delta",
+      id,
+      delta: String(props.delta ?? "")
+    });
+    return;
+  }
+  if (type === "session.next.text.ended") {
+    const id = String(props.textID ?? event.id);
+    emitMissingFinalDelta({
+      id,
+      fullText: typeof props.text === "string" ? props.text : void 0,
+      emittedText: state.textDeltas.get(id) ?? "",
+      emit,
+      type: "text-delta"
+    });
+    emit({ type: "text-end", id });
+    return;
+  }
+  if (type === "session.next.reasoning.started") {
+    emit({
+      type: "reasoning-start",
+      id: String(props.reasoningID ?? event.id)
+    });
+    return;
+  }
+  if (type === "session.next.reasoning.delta") {
+    const id = String(props.reasoningID ?? event.id);
+    state.reasoningDeltas.set(
+      id,
+      `${state.reasoningDeltas.get(id) ?? ""}${String(props.delta ?? "")}`
+    );
+    emit({
+      type: "reasoning-delta",
+      id,
+      delta: String(props.delta ?? "")
+    });
+    return;
+  }
+  if (type === "session.next.reasoning.ended") {
+    const id = String(props.reasoningID ?? event.id);
+    emitMissingFinalDelta({
+      id,
+      fullText: typeof props.text === "string" ? props.text : void 0,
+      emittedText: state.reasoningDeltas.get(id) ?? "",
+      emit,
+      type: "reasoning-delta"
+    });
+    emit({ type: "reasoning-end", id });
+    return;
+  }
+  if (type === "session.next.shell.started") {
+    const callID = String(props.callID ?? event.id);
+    const command = String(props.command ?? "");
+    state.shellCommands.set(callID, command);
+    emit({
+      type: "tool-call",
+      toolCallId: callID,
+      toolName: "bash",
+      nativeName: "bash",
+      input: JSON.stringify({ command }),
+      providerExecuted: true
+    });
+    return;
+  }
+  if (type === "session.next.shell.ended") {
+    const callID = String(props.callID ?? event.id);
+    emit({
+      type: "tool-result",
+      toolCallId: callID,
+      toolName: "bash",
+      result: {
+        command: state.shellCommands.get(callID) ?? "",
+        output: String(props.output ?? "")
+      }
+    });
+    return;
+  }
+  if (type === "session.next.tool.input.delta") {
+    const callID = String(props.callID ?? event.id);
+    state.toolInputs.set(
+      callID,
+      `${state.toolInputs.get(callID) ?? ""}${String(props.delta ?? "")}`
+    );
+    return;
+  }
+  if (type === "session.next.tool.input.ended") {
+    state.toolInputs.set(
+      String(props.callID ?? event.id),
+      String(props.text ?? "")
+    );
+    return;
+  }
+  if (type === "session.next.tool.called") {
+    const callID = String(props.callID ?? event.id);
+    const rawToolName = String(props.tool ?? "unknown");
+    const toolName = toWireToolName(rawToolName);
+    state.toolNames.set(callID, { rawToolName, toolName });
+    const hostToolName = getHostToolName(toolName, props.tool);
+    if (hostToolName) {
+      authorizeHostToolCall({
+        callID,
+        toolName: hostToolName,
+        input: props.input ?? parseToolInput(state, props),
+        state
+      });
+      return;
+    }
+    emit({
+      type: "tool-call",
+      toolCallId: callID,
+      toolName,
+      ...nativeNameField({ nativeName: rawToolName, toolName }),
+      input: JSON.stringify(props.input ?? parseToolInput(state, props)),
+      providerExecuted: true,
+      ...props.provider?.metadata ? { providerMetadata: props.provider.metadata } : {}
+    });
+    return;
+  }
+  if (type === "session.next.tool.success" || type === "session.next.tool.failed") {
+    const callID = String(props.callID ?? event.id);
+    const cachedTool = state.toolNames.get(callID);
+    const rawToolName = cachedTool?.rawToolName ?? String(props.tool ?? "");
+    const toolName = cachedTool?.toolName ?? toWireToolName(rawToolName || "unknown");
+    if (getHostToolName(toolName, rawToolName)) return;
+    emit({
+      type: "tool-result",
+      toolCallId: callID,
+      toolName,
+      result: props.result ?? props.structured ?? ("content" in props ? props.content : null) ?? null,
+      ...type === "session.next.tool.failed" ? { isError: true } : {}
+    });
+    return;
+  }
+  if (type === "session.next.retried") {
+    const error = props.error ?? event;
+    if (isRecord2(error) && error.isRetryable === false) {
+      turn.emitError({
+        error,
+        message: "OpenCode session retry failed"
+      });
+    } else {
+      turn.emitWarning({ message: nextRetryEventMessage(event) });
+    }
+    return;
+  }
+  if (type === "session.next.step.ended") {
+    closeLegacyOpenParts({ state, emit });
+    state.turnUsage = mapUsage(props.tokens);
+    emit({
+      type: "finish-step",
+      finishReason: {
+        unified: mapOpenCodeFinishReason(String(props.finish ?? "stop")),
+        raw: String(props.finish ?? "stop")
+      },
+      usage: state.turnUsage,
+      ...typeof props.cost === "number" ? { harnessMetadata: { opencode: { cost: props.cost } } } : {}
+    });
+    return;
+  }
+  if (type === "session.next.compaction.ended") {
+    emit({
+      type: "compaction",
+      trigger: props.reason === "auto" ? "auto" : "manual",
+      summary: String(props.text ?? ""),
+      harnessMetadata: {
+        opencode: {
+          recent: String(props.recent ?? "")
+        }
+      }
+    });
+    return;
+  }
+  if (type === "file.edited") {
+    emit({
+      type: "file-change",
+      event: "modify",
+      path: stripWorkDir(String(props.file ?? ""))
+    });
+    return;
+  }
+  if (type === "session.error" || type === "session.next.step.failed") {
+    const error = props.error ?? event;
+    turn.emitError({
+      error,
+      message: type === "session.error" ? "OpenCode session error" : "OpenCode step failed"
+    });
+    return;
+  }
+  if (type === "permission.v2.asked") {
+    await handlePermissionV2({
+      client,
+      sessionId,
+      permissionMode,
+      builtinToolFiltering,
+      turn,
+      emit,
+      event
+    });
+    return;
+  }
+  if (type === "permission.asked") {
+    await handlePermission({
+      client,
+      sessionId,
+      permissionMode,
+      builtinToolFiltering,
+      turn,
+      emit,
+      event
+    });
+  }
+}
+function legacyPartId({
+  value,
+  fallback
+}) {
+  return stringValue(value.partID) ?? stringValue(value.id) ?? fallback;
+}
+function startLegacyPart({
+  ids,
+  id,
+  emit,
+  type
+}) {
+  if (ids.has(id)) return;
+  ids.add(id);
+  emit({ type: `${type}-start`, id });
+}
+function emitLegacyTextPartUpdate({
+  part,
+  state,
+  emit
+}) {
+  if (!isRecord2(part)) return false;
+  if (part.type !== "text" && part.type !== "reasoning") return false;
+  const id = stringValue(part.id);
+  if (!id) return true;
+  const messageID = stringValue(part.messageID);
+  if (messageID && state.messageRoles.get(messageID) === "user") return true;
+  const isReasoning = part.type === "reasoning";
+  const ids = isReasoning ? state.legacyReasoningPartIds : state.legacyTextPartIds;
+  const deltaMap = isReasoning ? state.reasoningDeltas : state.textDeltas;
+  const deltaType = isReasoning ? "reasoning-delta" : "text-delta";
+  const text = typeof part.text === "string" ? part.text : void 0;
+  startLegacyPart({
+    ids,
+    id,
+    emit,
+    type: isReasoning ? "reasoning" : "text"
+  });
+  if (text !== void 0) {
+    emitMissingFinalDelta({
+      id,
+      fullText: text,
+      emittedText: deltaMap.get(id) ?? "",
+      emit,
+      type: deltaType
+    });
+    deltaMap.set(id, text);
+  }
+  if (legacyPartEnded(part)) {
+    ids.delete(id);
+    deltaMap.delete(id);
+    emit({ type: isReasoning ? "reasoning-end" : "text-end", id });
+  }
+  return true;
+}
+function legacyPartEnded(part) {
+  return isRecord2(part.time) && part.time.end != null;
+}
+function closeLegacyOpenParts({
+  state,
+  emit
+}) {
+  for (const id of state.legacyReasoningPartIds) {
+    emit({ type: "reasoning-end", id });
+    state.reasoningDeltas.delete(id);
+  }
+  state.legacyReasoningPartIds.clear();
+  for (const id of state.legacyTextPartIds) {
+    emit({ type: "text-end", id });
+    state.textDeltas.delete(id);
+  }
+  state.legacyTextPartIds.clear();
+}
+function emitLegacyStepFinishPart({
+  part,
+  state,
+  emit
+}) {
+  const event = legacyStepFinishPartToFinishStep(part);
+  if (!event) return false;
+  const id = isRecord2(part) ? stringValue(part.id) : void 0;
+  if (id) {
+    if (state.legacyStepFinishPartIds.has(id)) return true;
+    state.legacyStepFinishPartIds.add(id);
+  }
+  closeLegacyOpenParts({ state, emit });
+  state.turnUsage = event.usage;
+  emit(event);
+  return true;
+}
+function emitLegacyToolPart({
+  part,
+  state,
+  emit
+}) {
+  if (!part || typeof part !== "object") return;
+  const toolPart = part;
+  if (toolPart.type !== "tool") return;
+  const status = legacyToolPartStatus(toolPart);
+  if (status !== "running" && status !== "completed" && status !== "error") {
+    return;
+  }
+  if (typeof toolPart.tool !== "string" || typeof toolPart.callID !== "string") {
+    return;
+  }
+  const callID = toolPart.callID;
+  const rawToolName = toolPart.tool;
+  const toolName = toWireToolName(rawToolName);
+  state.toolNames.set(callID, { rawToolName, toolName });
+  const hostToolName = getHostToolName(toolName, rawToolName);
+  if (hostToolName) {
+    if (status === "running") {
+      authorizeHostToolCall({
+        callID,
+        toolName: hostToolName,
+        input: legacyToolPartInput(toolPart),
+        state
+      });
+    }
+    return;
+  }
+  if (!state.toolCallsEmitted.has(callID)) {
+    state.toolCallsEmitted.add(callID);
+    emit({
+      type: "tool-call",
+      toolCallId: callID,
+      toolName,
+      ...nativeNameField({ nativeName: rawToolName, toolName }),
+      input: JSON.stringify(legacyToolPartInput(toolPart)),
+      providerExecuted: true,
+      ...toolPart.provider?.metadata ? { providerMetadata: toolPart.provider.metadata } : {}
+    });
+  }
+  if ((status === "completed" || status === "error") && !state.toolResultsEmitted.has(callID)) {
+    state.toolResultsEmitted.add(callID);
+    emit({
+      type: "tool-result",
+      toolCallId: callID,
+      toolName,
+      result: legacyToolPartOutput(toolPart),
+      ...status === "error" ? { isError: true } : {}
+    });
+  }
+}
+function legacyToolPartStatus(part) {
+  return typeof part.state === "string" ? part.state : typeof part.state === "object" && part.state !== null ? String(part.state.status ?? "") : void 0;
+}
+function legacyToolPartInput(part) {
+  const state = typeof part.state === "object" && part.state !== null ? part.state : void 0;
+  return {
+    ...isRecord2(part.metadata) ? part.metadata : {},
+    ...isRecord2(state?.metadata) ? state.metadata : {},
+    ...isRecord2(state?.input) ? state.input : {}
+  };
+}
+function legacyToolPartOutput(part) {
+  const state = typeof part.state === "object" && part.state !== null ? part.state : void 0;
+  if (state?.status === "error") {
+    return state.error ?? part.error ?? state.result ?? "tool failed";
+  }
+  return state?.output ?? state?.result ?? state?.structured ?? state?.content ?? null;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function parseToolInput(state, props) {
+  const text = state.toolInputs.get(String(props.callID ?? ""));
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { input: text };
+  }
+}
+async function handlePermissionV2({
+  client,
+  sessionId,
+  permissionMode,
+  builtinToolFiltering,
+  turn,
+  emit,
+  event
+}) {
+  const props = event.properties ?? {};
+  const requestID = String(props.id ?? "");
+  if (!requestID) return;
+  const reply = await selectPermissionReply({
+    action: String(props.action ?? ""),
+    resources: Array.isArray(props.resources) ? props.resources.map(String) : [],
+    requestID,
+    toolCallId: typeof props.source === "object" && props.source !== null && "callID" in props.source ? String(props.source.callID) : requestID,
+    permissionMode,
+    builtinToolFiltering,
+    turn,
+    emit
+  });
+  await client.v2.session.permission.reply({
+    sessionID: sessionId,
+    requestID,
+    reply: reply.reply,
+    ...reply.message ? { message: reply.message } : {}
+  });
+}
+async function handlePermission({
+  client,
+  sessionId,
+  permissionMode,
+  builtinToolFiltering,
+  turn,
+  emit,
+  event
+}) {
+  const props = event.properties ?? {};
+  const requestID = String(props.id ?? "");
+  if (!requestID) return;
+  const reply = await selectPermissionReply({
+    action: String(props.permission ?? ""),
+    resources: Array.isArray(props.patterns) ? props.patterns.map(String) : [],
+    requestID,
+    toolCallId: typeof props.tool === "object" && props.tool !== null && "callID" in props.tool ? String(props.tool.callID) : requestID,
+    permissionMode,
+    builtinToolFiltering,
+    turn,
+    emit
+  });
+  await client.permission.reply({
+    requestID,
+    directory: workdir,
+    reply: reply.reply,
+    ...reply.message ? { message: reply.message } : {}
+  });
+  void sessionId;
+}
+async function selectPermissionReply({
+  action,
+  resources,
+  requestID,
+  toolCallId,
+  permissionMode,
+  builtinToolFiltering,
+  turn,
+  emit
+}) {
+  const toolName = toPermissionToolName(action);
+  if (resources.some((resource) => isExternalPath(resource))) {
+    return { reply: "reject", message: "External directory access rejected." };
+  }
+  if (isBuiltinToolInactive({ toolName, toolFiltering: builtinToolFiltering })) {
+    emit({
+      type: "tool-approval-request",
+      approvalId: requestID,
+      toolCallId
+    });
+    const decision2 = await turn.requestToolApproval(requestID);
+    return decision2.approved ? { reply: "once" } : {
+      reply: "reject",
+      ...decision2.reason ? { message: decision2.reason } : {}
+    };
+  }
+  if (!permissionMode || permissionMode === "allow-all") {
+    return { reply: "always" };
+  }
+  const kind = TOOL_KIND[toolName] ?? "bash";
+  const allowed = permissionMode === "allow-edits" ? kind === "readonly" || kind === "edit" : kind === "readonly";
+  if (allowed) return { reply: "always" };
+  emit({
+    type: "tool-approval-request",
+    approvalId: requestID,
+    toolCallId
+  });
+  const decision = await turn.requestToolApproval(requestID);
+  return decision.approved ? { reply: "once" } : {
+    reply: "reject",
+    ...decision.reason ? { message: decision.reason } : {}
+  };
+}
+function toPermissionToolName(action) {
+  const normalized = action.toLowerCase();
+  if (normalized.includes("bash") || normalized.includes("shell"))
+    return "bash";
+  if (normalized.includes("edit")) return "edit";
+  if (normalized.includes("write")) return "write";
+  if (normalized.includes("webfetch")) return "webfetch";
+  if (normalized.includes("task") || normalized.includes("agent"))
+    return "agent";
+  if (normalized.includes("list")) return "ls";
+  if (normalized.includes("grep")) return "grep";
+  if (normalized.includes("glob")) return "glob";
+  if (normalized.includes("read")) return "read";
+  return toWireToolName(normalized);
+}
+function resolveInactiveBuiltinToolNames(start) {
+  const toolFiltering = start.builtinToolFiltering;
+  if (toolFiltering == null) return [];
+  return toolFiltering.mode === "allow" ? Object.keys(PUBLIC_TO_NATIVE).filter(
+    (name) => !toolFiltering.toolNames.includes(name)
+  ) : toolFiltering.toolNames;
+}
+function isBuiltinToolInactive(input) {
+  if (input.toolFiltering == null) return false;
+  return input.toolFiltering.mode === "allow" ? !input.toolFiltering.toolNames.includes(input.toolName) : input.toolFiltering.toolNames.includes(input.toolName);
+}
+function isExternalPath(resource) {
+  if (!path2.isAbsolute(resource)) return false;
+  const normalized = path2.resolve(resource);
+  return !isPathInsideOrEqual(normalized, workdir) && (!skillsDir || !isPathInsideOrEqual(normalized, skillsDir));
+}
+function isPathInsideOrEqual(file, root) {
+  const normalizedRoot = path2.resolve(root);
+  return file === normalizedRoot || file.startsWith(`${normalizedRoot}/`);
+}
+function toWireToolName(nativeName) {
+  return NATIVE_TO_COMMON[nativeName] ?? OPENCODE_TO_WIRE[nativeName] ?? nativeName;
+}
+function nativeNameField({
+  nativeName,
+  toolName
+}) {
+  if (!nativeName || nativeName === toolName || toolName === "agent") return {};
+  return { nativeName };
+}
+function getHostToolName(toolName, rawToolName) {
+  if (runtime.toolNames.has(toolName)) return toolName;
+  if (typeof rawToolName === "string" && runtime.toolNames.has(rawToolName)) {
+    return rawToolName;
+  }
+  if (typeof rawToolName === "string" && rawToolName.startsWith("harness-tools_") && runtime.toolNames.has(rawToolName.slice("harness-tools_".length))) {
+    return rawToolName.slice("harness-tools_".length);
+  }
+  return void 0;
+}
+function authorizeHostToolCall({
+  callID,
+  toolName,
+  input,
+  state
+}) {
+  if (state.hostToolCallsAuthorized.has(callID)) return;
+  state.hostToolCallsAuthorized.add(callID);
+  runtime.relay?.authorizeToolCall({ toolName, input });
+}
+async function emitContextFallback({
+  client,
+  sessionId,
+  emit,
+  emitContent
+}) {
+  const assistant = await latestAssistantSnapshot({ client, sessionId });
+  if (!assistant) return false;
+  if (emitContent && Array.isArray(assistant.contentParts)) {
+    for (const part of assistant.contentParts) {
+      emitAssistantContentPart(part, emit);
+    }
+  }
+  const rawFinish = typeof assistant.finish === "string" ? assistant.finish : assistant.error ? "error" : "stop";
+  emit({
+    type: "finish-step",
+    finishReason: {
+      unified: mapOpenCodeFinishReason(rawFinish),
+      raw: rawFinish
+    },
+    usage: mapUsage(assistant.tokens),
+    ...typeof assistant.cost === "number" ? {
+      harnessMetadata: {
+        opencode: { cost: assistant.cost, fallback: true }
+      }
+    } : { harnessMetadata: { opencode: { fallback: true } } }
+  });
+  return true;
+}
+async function readSessionTokens({
+  client,
+  sessionId
+}) {
+  const session = await legacySessionGet({ client, sessionId });
+  if (session.error) return void 0;
+  return extractSessionTokens(session.data);
+}
+async function latestAssistantSnapshot({
+  client,
+  sessionId
+}) {
+  const legacy = await client.session.messages({ sessionID: sessionId, limit: 20 }).catch(() => void 0);
+  const legacyAssistant = latestLegacyAssistantMessage(legacy?.data);
+  if (legacyAssistant) return legacyAssistant;
+  const context = await client.v2.session.context({ sessionID: sessionId }).catch(() => void 0);
+  if (!context || context.error) return void 0;
+  return latestV2AssistantMessage(context.data);
+}
+function latestLegacyAssistantMessage(data) {
+  const messages = Array.isArray(data) ? data : [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const item = messages[i];
+    if (!item || typeof item !== "object") continue;
+    const record = item;
+    const info = record.info;
+    if (info && typeof info === "object" && info.role === "assistant") {
+      return {
+        ...info,
+        contentParts: Array.isArray(record.parts) ? record.parts : void 0
+      };
+    }
+  }
+  return void 0;
+}
+function latestV2AssistantMessage(data) {
+  const messages = data && typeof data === "object" && Array.isArray(data.data) ? data.data : Array.isArray(data) ? data : [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message && typeof message === "object" && message.type === "assistant") {
+      const record = message;
+      return {
+        ...record,
+        contentParts: Array.isArray(record.content) ? record.content : void 0
+      };
+    }
+  }
+  return void 0;
+}
+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 text = typeof value.text === "string" ? value.text : "";
+  if (value.type === "text") {
+    emit({ type: "text-start", id });
+    if (text) emit({ type: "text-delta", id, delta: text });
+    emit({ type: "text-end", id });
+    return;
+  }
+  emit({ type: "reasoning-start", id });
+  if (text) emit({ type: "reasoning-delta", id, delta: text });
+  emit({ type: "reasoning-end", id });
+}
+async function startToolRelay({
+  allowedScriptPaths,
+  tools,
+  emit,
+  requestToolResult
+}) {
+  const toolNames = new Set(tools.map((t) => t.name));
+  const allowedScriptPathSet = new Set(allowedScriptPaths);
+  const authorizer = new ToolRelayAuthorizer();
+  const server = createServer(async (req, res) => {
+    try {
+      if (req.method !== "POST" || req.url !== "/") {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "unauthorized tool relay request" }));
+        return;
+      }
+      const chunks = [];
+      for await (const chunk of req) {
+        chunks.push(chunk);
+      }
+      const body = Buffer.concat(chunks).toString("utf8");
+      const { requestId, toolName, input } = JSON.parse(body);
+      if (!toolNames.has(toolName)) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({ error: `Tool "${toolName}" is not available` })
+        );
+        return;
+      }
+      const authorized = authorizer.consumeToolCall({ toolName, input }) || await isToolRelayRequestFromAllowedProcess({
+        socket: req.socket,
+        allowedScriptPaths: allowedScriptPathSet
+      });
+      if (!authorized) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "unauthorized tool relay request" }));
+        return;
+      }
+      emit({
+        type: "tool-call",
+        toolCallId: requestId,
+        toolName,
+        input: JSON.stringify(input ?? {}),
+        providerExecuted: false
+      });
+      const { output, isError } = await requestToolResult(requestId);
+      emit({
+        type: "tool-result",
+        toolCallId: requestId,
+        toolName,
+        result: output ?? null,
+        isError: !!isError
+      });
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ result: output }));
+    } catch (error) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        })
+      );
+    }
+  });
+  await new Promise(
+    (resolve) => server.listen(0, "127.0.0.1", () => resolve())
+  );
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("tool relay did not expose a numeric port");
+  }
+  return {
+    port: address.port,
+    close: () => closeServer(server),
+    authorizeToolCall: (call) => authorizer.authorizeToolCall(call)
+  };
+}
+function closeServer(server) {
+  try {
+    server.close();
+  } catch {
+  }
+}
+function createDeferred() {
+  let resolve;
+  const promise = new Promise((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function splitModel(model, provider) {
+  if (!model) return {};
+  if (model.includes("/")) {
+    const [providerID, ...rest] = model.split("/");
+    return { providerID, modelID: rest.join("/") };
+  }
+  return { providerID: provider, modelID: model };
+}
+async function resolveCompactionModel({
+  client,
+  sessionId,
+  start
+}) {
+  const assistant = await latestAssistantSnapshot({ client, sessionId }).catch(
+    () => void 0
+  );
+  const assistantModel = modelRefFromAssistantSnapshot(assistant);
+  if (assistantModel) return assistantModel;
+  const session = await legacySessionGet({ client, sessionId }).catch(
+    () => void 0
+  );
+  const sessionModel = modelRefFromSessionInfo(session?.data);
+  if (sessionModel) return sessionModel;
+  return modelRefFromStart(start);
+}
+function modelRefFromAssistantSnapshot(assistant) {
+  if (!assistant) return void 0;
+  const model = modelRefFromValue(assistant.model);
+  if (model) return model;
+  const direct = modelRefFromValue(assistant);
+  if (direct) return direct;
+  if (isRecord2(assistant.metadata)) {
+    return modelRefFromValue(assistant.metadata.assistant);
+  }
+  return void 0;
+}
+function modelRefFromSessionInfo(data) {
+  if (!isRecord2(data)) return void 0;
+  return modelRefFromValue(data.model) ?? modelRefFromValue(data);
+}
+function modelRefFromStart(start) {
+  const model = splitModel(start.model, start.provider);
+  if (!model.modelID) return void 0;
+  return {
+    providerID: model.providerID ?? start.provider ?? procEnv2.OPENAI_NAME ?? "anthropic",
+    modelID: model.modelID
+  };
+}
+function modelRefFromValue(value) {
+  if (!isRecord2(value)) return void 0;
+  const providerID = stringValue(value.providerID);
+  const modelID = stringValue(value.modelID ?? value.id);
+  if (!providerID || !modelID) return void 0;
+  return { providerID, modelID };
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function stripWorkDir(file) {
+  if (!file) return file;
+  const normalized = path2.resolve(file);
+  const root = path2.resolve(workdir);
+  return normalized.startsWith(`${root}/`) ? normalized.slice(root.length + 1) : file;
+}
+function parseArgs(args2) {
+  const out = {};
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === "--workdir" && i + 1 < args2.length) {
+      out.workdir = args2[++i];
+    } else if (args2[i] === "--bridge-state-dir" && i + 1 < args2.length) {
+      out.bridgeStateDir = args2[++i];
+    } else if (args2[i] === "--bootstrap-dir" && i + 1 < args2.length) {
+      out.bootstrapDir = args2[++i];
+    } else if (args2[i] === "--skills-dir" && i + 1 < args2.length) {
+      out.skillsDir = args2[++i];
+    }
+  }
+  return out;
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    const cause = "cause" in error ? error.cause : void 0;
+    if (cause === void 0) return error.message;
+    return `${error.message}: ${formatError(cause)}`;
+  }
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function emitFatal(message) {
+  process.stderr.write(`[OpenCode bridge] ${message}
+`);
+  process.exit(1);
+}
+//# sourceMappingURL=index.mjs.map