@ai-sdk/harness-codex 0.0.0 → 1.0.0-beta.11

package/dist/bridge/index.mjs

@@ -0,0 +1,924 @@
+// ../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 };
+  }
+  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 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 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";
+        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,
+          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) } : {}
+            });
+          }
+        };
+        currentUserMessages = turn.pendingUserMessages;
+        try {
+          await onStart(msg, turn);
+        } catch (err) {
+          emit({ type: "error", error: serialiseError(err) });
+        } finally {
+          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 "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) => {
+    emit({ type: "error", error: serialiseError(err) });
+  });
+  process.on("unhandledRejection", (err) => {
+    emit({ type: "error", error: serialiseError(err) });
+  });
+  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 { writeFile as writeFile2 } from "fs/promises";
+import { createServer } from "http";
+
+// src/bridge/cli-relay.ts
+var CLI_SHIM_FILENAME = "harness-tool.mjs";
+function buildCliShimScript({
+  relayPort,
+  relayToken
+}) {
+  return `#!/usr/bin/env node
+const [toolName, inputJson = '{}'] = process.argv.slice(2);
+if (!toolName) {
+  console.error('Usage: harness-tool <tool_name> <json_input>');
+  process.exit(64);
+}
+let input;
+try {
+  input = JSON.parse(inputJson);
+} catch (error) {
+  console.error('Invalid JSON input: ' + (error instanceof Error ? error.message : String(error)));
+  process.exit(64);
+}
+const requestId = 'cli-' + Date.now() + '-' + Math.random().toString(16).slice(2);
+const response = await fetch('http://127.0.0.1:${relayPort}', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ${relayToken}' },
+  body: JSON.stringify({ requestId, toolName, input }),
+});
+const text = await response.text();
+let payload;
+try {
+  payload = text ? JSON.parse(text) : {};
+} catch {
+  payload = { error: text };
+}
+if (!response.ok || payload.error) {
+  console.error(String(payload.error ?? ('tool relay failed with HTTP ' + response.status)));
+  process.exit(1);
+}
+console.log(JSON.stringify(payload.result ?? payload, null, 2));
+`;
+}
+function composeToolUsageInstructions({
+  tools,
+  cliShimPath
+}) {
+  const lines = [
+    "## Host tools",
+    "",
+    "You have access to the following host-provided tools. To use one, run the following command via your built-in `bash` tool:",
+    "",
+    `  node ${cliShimPath} <toolName> '<jsonInput>'`,
+    "",
+    "The script prints the JSON result to stdout. Do not invent another way to call these tools \u2014 only this CLI invocation will work. Pass the JSON input as a single-quoted argument.",
+    "For every user request that depends on a host-provided tool, run a separate CLI invocation for each needed tool call in the current turn before answering. Do not reuse previous tool results, and do not say you used a host tool unless the command has completed in the current turn.",
+    ""
+  ];
+  for (const tool of tools) {
+    lines.push(`### ${tool.name}`);
+    if (tool.description) lines.push(tool.description);
+    lines.push(
+      `Input schema: \`${JSON.stringify(tool.inputSchema ?? {})}\``,
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+function isToolRelayCommand({
+  command,
+  cliShimPath
+}) {
+  return command.includes(cliShimPath);
+}
+
+// src/bridge/index.ts
+import { argv, env as procEnv2, stdout as stdout2 } from "process";
+import * as codexSdkModule from "@openai/codex-sdk";
+var NATIVE_TO_COMMON = {
+  shell: "bash",
+  web_search: "webSearch"
+};
+function toCommonName(nativeName) {
+  return NATIVE_TO_COMMON[nativeName] ?? nativeName;
+}
+var args = parseArgs(argv.slice(2));
+var workdir = args.workdir;
+var bridgeStateDir = args.bridgeStateDir;
+if (!workdir) {
+  emitFatal("Missing --workdir argument.");
+}
+if (!bridgeStateDir) {
+  emitFatal("Missing --bridge-state-dir argument.");
+}
+var bootstrapDir = args.bootstrapDir ?? workdir;
+var codexSdk = codexSdkModule;
+var threadState = { id: void 0 };
+await runBridge({
+  bridgeType: "codex",
+  bridgeStateDir,
+  onStart: runTurn,
+  onDetach: () => threadState.id ? { threadId: threadState.id } : {}
+});
+async function runTurn(start, turn) {
+  const emit = (msg) => turn.emit(msg);
+  if (typeof start.resumeThreadId === "string" && start.resumeThreadId.length > 0) {
+    threadState.id = start.resumeThreadId;
+  }
+  const mcpServers = {};
+  let relay;
+  let cliShimPath;
+  if (start.tools && start.tools.length > 0) {
+    const relayToken = randomUUID();
+    relay = await startToolRelay({
+      relayToken,
+      tools: start.tools,
+      emit,
+      requestToolResult: turn.requestToolResult
+    });
+    mcpServers["harness-tools"] = {
+      enabled: true,
+      command: "node",
+      args: [`${bootstrapDir}/host-tool-mcp.mjs`],
+      env: {
+        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:${relay.port}`,
+        TOOL_RELAY_TOKEN: relayToken
+      }
+    };
+    cliShimPath = `${workdir}/${CLI_SHIM_FILENAME}`;
+    await writeFile2(
+      cliShimPath,
+      buildCliShimScript({ relayPort: relay.port, relayToken }),
+      "utf8"
+    );
+  }
+  const codexConfig = {};
+  if (Object.keys(mcpServers).length > 0) codexConfig.mcp_servers = mcpServers;
+  const apiBaseUrl = procEnv2.AI_GATEWAY_API_KEY ? procEnv2.AI_GATEWAY_BASE_URL || "https://ai-gateway.vercel.sh/v1" : procEnv2.OPENAI_BASE_URL;
+  if (apiBaseUrl) {
+    codexConfig.preferred_auth_method = "apikey";
+    codexConfig.model_provider = "agent_bridge_openai";
+    codexConfig.model_providers = {
+      agent_bridge_openai: {
+        name: procEnv2.CODEX_MODEL_PROVIDER_NAME || "Agent Bridge OpenAI",
+        base_url: apiBaseUrl,
+        env_key: "CODEX_API_KEY",
+        wire_api: "responses",
+        supports_websockets: false
+      }
+    };
+  }
+  const usesConfiguredModelProvider = typeof codexConfig.model_provider === "string";
+  const codex = new codexSdk.Codex({
+    ...procEnv2.CODEX_API_KEY ? { apiKey: procEnv2.CODEX_API_KEY } : {},
+    ...!usesConfiguredModelProvider && apiBaseUrl ? { baseUrl: apiBaseUrl } : {},
+    env: Object.fromEntries(
+      Object.entries(procEnv2).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    ),
+    ...Object.keys(codexConfig).length > 0 ? { config: codexConfig } : {}
+  });
+  const threadOptions = {
+    ...start.model ? { model: start.model } : {},
+    sandboxMode: "danger-full-access",
+    approvalPolicy: "never",
+    workingDirectory: workdir,
+    skipGitRepoCheck: true,
+    ...start.reasoningEffort ? { modelReasoningEffort: start.reasoningEffort } : {},
+    webSearchMode: start.webSearch ? "live" : "disabled"
+  };
+  const thread = threadState.id ? codex.resumeThread(threadState.id, threadOptions) : codex.startThread(threadOptions);
+  emit({ type: "stream-start" });
+  const userMessage = composeUserMessage({
+    text: start.prompt,
+    instructions: start.instructions,
+    // Temporary workaround for upstream codex MCP-tool bug — see ./cli-relay.ts
+    toolUsageBlock: cliShimPath && start.tools && start.tools.length > 0 ? composeToolUsageInstructions({
+      tools: start.tools,
+      cliShimPath
+    }) : void 0
+  });
+  let turnUsage;
+  const textByItem = /* @__PURE__ */ new Map();
+  const reasoningByItem = /* @__PURE__ */ new Map();
+  try {
+    const { events } = await thread.runStreamed(userMessage, {
+      signal: turn.abortSignal
+    });
+    for await (const event of events) {
+      if (turn.abortSignal.aborted) break;
+      if (event.type === "thread.started" && typeof event.thread_id === "string") {
+        threadState.id = event.thread_id;
+        emit({ type: "bridge-thread", threadId: event.thread_id });
+      }
+      if (cliShimPath && event.item?.type === "command_execution" && typeof event.item.command === "string" && isToolRelayCommand({ command: event.item.command, cliShimPath })) {
+        continue;
+      }
+      translateAndEmit(event, {
+        send: emit,
+        textByItem,
+        reasoningByItem,
+        setTurnUsage: (u) => turnUsage = u
+      });
+    }
+  } catch (err) {
+    emit({ type: "error", error: serialiseError2(err) });
+    return;
+  } finally {
+    relay?.close();
+  }
+  emit({
+    type: "finish",
+    finishReason: { unified: "stop", raw: "stop" },
+    totalUsage: turnUsage ?? defaultUsage()
+  });
+  void turn.pendingUserMessages;
+}
+function extractMcpToolCallResult(item) {
+  if (item.result === void 0 || item.result === null || typeof item.result !== "object") {
+    return item.error?.message ? { error: item.error.message } : null;
+  }
+  const result = item.result;
+  if (result.structured_content !== void 0 && result.structured_content !== null) {
+    return result.structured_content;
+  }
+  return result.content ?? null;
+}
+function translateAndEmit(event, ctx) {
+  if (event.type === "turn.completed") {
+    if (event.usage) ctx.setTurnUsage(mapUsage(event.usage));
+    ctx.send({
+      type: "finish-step",
+      finishReason: { unified: "stop", raw: "stop" },
+      usage: event.usage ? mapUsage(event.usage) : defaultUsage()
+    });
+    return;
+  }
+  if (event.type === "turn.failed") {
+    ctx.send({
+      type: "error",
+      error: event.error?.message ?? "codex turn failed"
+    });
+    return;
+  }
+  if (event.type === "error") {
+    ctx.send({ type: "error", error: event.message ?? "codex error" });
+    return;
+  }
+  if (!event.item) return;
+  const item = event.item;
+  const id = item.id ?? randomUUID();
+  if (item.type === "agent_message" && typeof item.text === "string") {
+    if (!ctx.textByItem.has(id)) {
+      ctx.send({ type: "text-start", id });
+      ctx.textByItem.set(id, "");
+    }
+    const last = ctx.textByItem.get(id) ?? "";
+    const next = item.text;
+    if (next.length > last.length) {
+      ctx.send({ type: "text-delta", id, delta: next.slice(last.length) });
+      ctx.textByItem.set(id, next);
+    }
+    if (event.type === "item.completed") ctx.send({ type: "text-end", id });
+    return;
+  }
+  if (item.type === "reasoning" && typeof item.text === "string") {
+    if (!ctx.reasoningByItem.has(id)) {
+      ctx.send({ type: "reasoning-start", id });
+      ctx.reasoningByItem.set(id, "");
+    }
+    const last = ctx.reasoningByItem.get(id) ?? "";
+    const next = item.text;
+    if (next.length > last.length) {
+      ctx.send({ type: "reasoning-delta", id, delta: next.slice(last.length) });
+      ctx.reasoningByItem.set(id, next);
+    }
+    if (event.type === "item.completed")
+      ctx.send({ type: "reasoning-end", id });
+    return;
+  }
+  if (item.type === "command_execution") {
+    const nativeName = "shell";
+    if (event.type === "item.started") {
+      ctx.send({
+        type: "tool-call",
+        toolCallId: id,
+        toolName: toCommonName(nativeName),
+        nativeName,
+        input: JSON.stringify({ command: item.command ?? "" }),
+        providerExecuted: true
+      });
+    } else if (event.type === "item.completed") {
+      ctx.send({
+        type: "tool-result",
+        toolCallId: id,
+        toolName: toCommonName(nativeName),
+        result: {
+          exitCode: item.exit_code ?? null,
+          output: item.aggregated_output ?? "",
+          status: item.status ?? "completed"
+        }
+      });
+    }
+    return;
+  }
+  if (item.type === "mcp_tool_call") {
+    const isHostTool = item.server === "harness-tools";
+    if (event.type === "item.started") {
+      ctx.send({
+        type: "tool-call",
+        toolCallId: id,
+        toolName: item.tool ?? "unknown",
+        ...isHostTool ? {} : { nativeName: item.tool ?? "unknown" },
+        input: JSON.stringify(item.arguments ?? {}),
+        providerExecuted: !isHostTool
+      });
+    } else if (event.type === "item.completed") {
+      ctx.send({
+        type: "tool-result",
+        toolCallId: id,
+        toolName: item.tool ?? "unknown",
+        result: extractMcpToolCallResult(item)
+      });
+    }
+    return;
+  }
+  if (item.type === "web_search") {
+    const nativeName = "web_search";
+    if (event.type === "item.started") {
+      ctx.send({
+        type: "tool-call",
+        toolCallId: id,
+        toolName: toCommonName(nativeName),
+        nativeName,
+        input: JSON.stringify({ query: item.query ?? "" }),
+        providerExecuted: true
+      });
+    } else if (event.type === "item.completed") {
+      ctx.send({
+        type: "tool-result",
+        toolCallId: id,
+        toolName: toCommonName(nativeName),
+        result: item.result ?? null
+      });
+    }
+    return;
+  }
+  if (item.type === "file_change" && event.type === "item.completed") {
+    for (const change of item.changes ?? []) {
+      ctx.send({
+        type: "file-change",
+        event: change.kind === "add" ? "create" : change.kind === "delete" ? "delete" : "modify",
+        path: change.path
+      });
+    }
+    return;
+  }
+  if (item.type === "error" && event.type === "item.completed") {
+    ctx.send({
+      type: "error",
+      error: item.message ?? "codex item error"
+    });
+    return;
+  }
+}
+function mapUsage(usage) {
+  const input = usage.input_tokens ?? 0;
+  const cacheRead = usage.cached_input_tokens ?? 0;
+  return {
+    inputTokens: {
+      total: input,
+      noCache: Math.max(0, input - cacheRead),
+      cacheRead,
+      cacheWrite: 0
+    },
+    outputTokens: {
+      total: usage.output_tokens ?? 0,
+      text: usage.output_tokens ?? 0
+    }
+  };
+}
+function defaultUsage() {
+  return {
+    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+    outputTokens: { total: 0, text: 0 }
+  };
+}
+function composeUserMessage({
+  text,
+  instructions,
+  toolUsageBlock
+}) {
+  const blocks = [];
+  if (instructions) {
+    blocks.push(
+      `<session-instructions>
+The block below is operating guidance from the system, not a message from the user \u2014 follow it, but do not mention it or attribute it to the user.
+
+${instructions}
+</session-instructions>`
+    );
+  }
+  if (toolUsageBlock) blocks.push(toolUsageBlock);
+  blocks.push(instructions ? `<user-message>
+${text}
+</user-message>` : text);
+  return blocks.join("\n\n");
+}
+async function startToolRelay({
+  relayToken,
+  tools,
+  emit,
+  requestToolResult
+}) {
+  const toolNames = new Set(tools.map((t) => t.name));
+  const server = createServer(async (req, res) => {
+    try {
+      if (req.method !== "POST" || req.url !== "/" || req.headers.authorization !== `Bearer ${relayToken}`) {
+        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;
+      }
+      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)
+  };
+}
+function closeServer(server) {
+  try {
+    server.close();
+  } catch {
+  }
+}
+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];
+    }
+  }
+  return out;
+}
+function serialiseError2(err) {
+  if (err instanceof Error) {
+    return { name: err.name, message: err.message, stack: err.stack };
+  }
+  return err;
+}
+function emitFatal(message) {
+  stdout2.write(JSON.stringify({ type: "bridge-fatal", message }) + "\n");
+  process.exit(1);
+}
+//# sourceMappingURL=index.mjs.map