@ai-sdk/harness-deepagents 0.0.0 → 1.0.1

package/dist/bridge/index.mjs

@@ -0,0 +1,843 @@
+// src/bridge/index.ts
+import { randomUUID } from "crypto";
+import { argv } from "process";
+
+// ../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 { ChatAnthropic } from "@langchain/anthropic";
+import { tool } from "@langchain/core/tools";
+import { Command, MemorySaver } from "@langchain/langgraph";
+import { createDeepAgent } from "deepagents";
+
+// src/bridge/approvals.ts
+var NATIVE_TOOL_KIND = {
+  read_file: "readonly",
+  write_file: "edit",
+  edit_file: "edit",
+  execute: "bash",
+  grep: "readonly",
+  glob: "readonly",
+  ls: "readonly"
+};
+function builtinToolRequiresApproval(kind, permissionMode) {
+  if (permissionMode === "allow-all") return false;
+  if (permissionMode === "allow-edits") return kind === "bash";
+  return kind === "edit" || kind === "bash";
+}
+function buildInterruptOn(permissionMode) {
+  if (!permissionMode || permissionMode === "allow-all") return void 0;
+  const config = {};
+  for (const [nativeName, kind] of Object.entries(NATIVE_TOOL_KIND)) {
+    if (builtinToolRequiresApproval(kind, permissionMode)) {
+      config[nativeName] = { allowedDecisions: ["approve", "reject"] };
+    }
+  }
+  return Object.keys(config).length > 0 ? config : void 0;
+}
+function collectActionRequests(interrupts) {
+  const out = [];
+  for (const interrupt of interrupts) {
+    const value = interrupt.value;
+    for (const action of value?.actionRequests ?? []) {
+      out.push({ name: action.name, args: action.args ?? {} });
+    }
+  }
+  return out;
+}
+
+// src/bridge/json-schema-to-zod.ts
+import { z } from "zod/v4";
+function jsonSchemaToZodObject(input) {
+  const schema = input && typeof input === "object" ? input : {};
+  return z.object(toZodShape(schema));
+}
+function toZodShape(schema) {
+  if (!schema.properties) return {};
+  const required = new Set(schema.required ?? []);
+  const shape = {};
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const propType = toZodType(propSchema);
+    shape[key] = required.has(key) ? propType : propType.optional();
+  }
+  return shape;
+}
+function toZodType(schema) {
+  if (!schema) return z.any();
+  const types = Array.isArray(schema.type) ? schema.type.filter((t) => t !== "null") : [schema.type].filter(Boolean);
+  let zType;
+  switch (types[0]) {
+    case "string":
+      zType = z.string();
+      break;
+    case "number":
+      zType = z.number();
+      break;
+    case "integer":
+      zType = z.number().int();
+      break;
+    case "boolean":
+      zType = z.boolean();
+      break;
+    case "array":
+      zType = z.array(toZodType(schema.items));
+      break;
+    case "object":
+      zType = z.object(toZodShape(schema));
+      break;
+    case "null":
+      zType = z.null();
+      break;
+    default:
+      zType = z.any();
+  }
+  if (schema.description) zType = zType.describe(schema.description);
+  if (schema.nullable) zType = zType.nullable();
+  return zType;
+}
+
+// src/bridge/local-shell-backend.ts
+import { LocalShellBackend } from "deepagents";
+var SANDBOX_PATH_FALLBACK = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+function createLocalShellBackend({
+  rootDir,
+  env = process.env
+}) {
+  return new LocalShellBackend({
+    rootDir,
+    env: {
+      PATH: env.PATH ?? SANDBOX_PATH_FALLBACK
+    }
+  });
+}
+
+// src/bridge/index.ts
+var NATIVE_TO_COMMON = {
+  read_file: "read",
+  write_file: "write",
+  edit_file: "edit",
+  execute: "bash"
+};
+function toCommonName(nativeName) {
+  return NATIVE_TO_COMMON[nativeName] ?? nativeName;
+}
+function parseArgs(rawArgs) {
+  const out = {};
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      out[key] = rawArgs[i + 1];
+      i++;
+    }
+  }
+  return out;
+}
+function buildModel(rawModel) {
+  if (!rawModel) return void 0;
+  const baseUrl = process.env.ANTHROPIC_BASE_URL;
+  const model = baseUrl ? rawModel : rawModel.replace(/^anthropic[/:]/, "");
+  return new ChatAnthropic({
+    model,
+    ...process.env.ANTHROPIC_API_KEY ? { apiKey: process.env.ANTHROPIC_API_KEY } : {},
+    ...baseUrl ? { anthropicApiUrl: baseUrl } : {}
+  });
+}
+function toToolCallInput(raw) {
+  if (raw && typeof raw === "object" && !Array.isArray(raw) && Object.keys(raw).length === 1 && typeof raw.input === "string") {
+    const inner = raw.input;
+    if (/^\s*[[{]/.test(inner)) return inner;
+  }
+  return JSON.stringify(raw ?? {});
+}
+var args = parseArgs(argv.slice(2));
+var workdir = args.workdir;
+var bridgeStateDir = args.bridgeStateDir;
+if (!workdir || !bridgeStateDir) {
+  console.error("deepagents bridge: missing --workdir / --bridge-state-dir");
+  process.exit(1);
+}
+var agent;
+var currentTurn;
+function buildHostTools(toolSchemas) {
+  return (toolSchemas ?? []).map(
+    (schema) => tool(
+      async (input) => {
+        const turn = currentTurn;
+        if (!turn) throw new Error("no active turn");
+        const toolCallId = `${schema.name}-${randomUUID()}`;
+        turn.emit({
+          type: "tool-call",
+          toolCallId,
+          toolName: schema.name,
+          input: JSON.stringify(input),
+          providerExecuted: false
+        });
+        const { output } = await turn.requestToolResult(toolCallId);
+        return typeof output === "string" ? output : JSON.stringify(output);
+      },
+      {
+        name: schema.name,
+        description: schema.description ?? "",
+        schema: jsonSchemaToZodObject(schema.inputSchema)
+      }
+    )
+  );
+}
+async function runTurn(start, turn) {
+  currentTurn = turn;
+  const emit = (event) => turn.emit(event);
+  const interruptOn = buildInterruptOn(start.permissionMode);
+  if (!agent) {
+    const model = buildModel(start.model);
+    agent = createDeepAgent({
+      // Defer to Deep Agents's own default when the host configured no model.
+      ...model ? { model } : {},
+      tools: buildHostTools(start.tools),
+      backend: createLocalShellBackend({ rootDir: workdir }),
+      systemPrompt: start.instructions || void 0,
+      // Native skills loaded from the source dirs ($HOME-materialized + <workDir> for repo-provided skills).
+      ...start.skillsPaths?.length ? { skills: start.skillsPaths } : {},
+      // Gate built-in tools behind HITL approval when the permission mode requires it.
+      ...interruptOn ? { interruptOn } : {},
+      // Real instance (LangGraph rejects `true` for root graphs); gives multi-turn memory.
+      checkpointer: new MemorySaver()
+    });
+  }
+  emit({
+    type: "stream-start",
+    ...start.model ? { modelId: start.model } : {}
+  });
+  const hostToolNames = new Set((start.tools ?? []).map((t) => t.name));
+  let textBlockId;
+  let reasoningBlockId;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let streamedStepInput = 0;
+  let streamedStepOutput = 0;
+  let pendingStep;
+  const approvedToolQueue = /* @__PURE__ */ new Map();
+  const approvedRunIds = /* @__PURE__ */ new Map();
+  const ensureTextBlock = () => {
+    if (!textBlockId) {
+      textBlockId = `text-${randomUUID()}`;
+      emit({ type: "text-start", id: textBlockId });
+    }
+    return textBlockId;
+  };
+  const endTextBlock = () => {
+    if (textBlockId) {
+      emit({ type: "text-end", id: textBlockId });
+      textBlockId = void 0;
+    }
+  };
+  const endReasoningBlock = () => {
+    if (reasoningBlockId) {
+      emit({ type: "reasoning-end", id: reasoningBlockId });
+      reasoningBlockId = void 0;
+    }
+  };
+  const emitText = (delta) => {
+    endReasoningBlock();
+    emit({ type: "text-delta", id: ensureTextBlock(), delta });
+  };
+  const emitReasoning = (delta) => {
+    endTextBlock();
+    if (!reasoningBlockId) {
+      reasoningBlockId = `reasoning-${randomUUID()}`;
+      emit({ type: "reasoning-start", id: reasoningBlockId });
+    }
+    emit({ type: "reasoning-delta", id: reasoningBlockId, delta });
+  };
+  const flushStep = () => {
+    if (!pendingStep) return;
+    emit({
+      type: "finish-step",
+      finishReason: { unified: "stop" },
+      usage: {
+        inputTokens: { total: pendingStep.input },
+        outputTokens: { total: pendingStep.output }
+      }
+    });
+    pendingStep = void 0;
+  };
+  const config = {
+    version: "v2",
+    configurable: { thread_id: "bridge-session" },
+    recursionLimit: start.recursionLimit ?? 100,
+    signal: turn.abortSignal
+  };
+  const readPendingApprovals = async () => {
+    try {
+      const state = await agent.getState({
+        configurable: { thread_id: "bridge-session" }
+      });
+      return collectActionRequests(
+        (state.tasks ?? []).flatMap((t) => t.interrupts ?? [])
+      );
+    } catch {
+      return [];
+    }
+  };
+  let resumeInput = {
+    messages: [{ role: "user", content: start.prompt }]
+  };
+  while (true) {
+    const stream = await agent.streamEvents(resumeInput, config);
+    for await (const event of stream) {
+      const kind = event.event;
+      const data = event.data ?? {};
+      const ns = event.metadata?.langgraph_checkpoint_ns ?? "";
+      const nested = ns.includes("|");
+      if (kind === "on_chat_model_start") {
+        if (!nested) flushStep();
+      } else if (kind === "on_chat_model_stream") {
+        if (nested) continue;
+        const chunk = data.chunk;
+        if (!chunk) continue;
+        const content = chunk.content;
+        if (typeof content === "string" && content) {
+          emitText(content);
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block && typeof block === "object") {
+              const b = block;
+              if (b.type === "text" && b.text) emitText(b.text);
+              else if (b.type === "thinking" && b.thinking)
+                emitReasoning(b.thinking);
+            }
+          }
+        }
+        const usage = chunk.usage_metadata;
+        if (usage) {
+          streamedStepInput = Math.max(
+            streamedStepInput,
+            usage.input_tokens ?? 0
+          );
+          streamedStepOutput = Math.max(
+            streamedStepOutput,
+            usage.output_tokens ?? 0
+          );
+        }
+      } else if (kind === "on_chat_model_end") {
+        const output = data.output;
+        const usage = output?.usage_metadata;
+        const stepInput = usage?.input_tokens ?? streamedStepInput;
+        const stepOutput = usage?.output_tokens ?? streamedStepOutput;
+        inputTokens += stepInput;
+        outputTokens += stepOutput;
+        streamedStepInput = 0;
+        streamedStepOutput = 0;
+        if (!nested) {
+          endTextBlock();
+          endReasoningBlock();
+          pendingStep = { input: stepInput, output: stepOutput };
+        }
+      } else if (kind === "on_tool_start") {
+        const toolName = event.name ?? "unknown";
+        const runId = event.run_id ?? "";
+        if (!nested && !hostToolNames.has(toolName)) {
+          const queued = approvedToolQueue.get(toolName);
+          if (queued && queued.length > 0) {
+            const approvalId = queued.shift();
+            if (runId) approvedRunIds.set(runId, approvalId);
+          } else {
+            endTextBlock();
+            endReasoningBlock();
+            emit({
+              type: "tool-call",
+              toolCallId: runId,
+              toolName: toCommonName(toolName),
+              input: toToolCallInput(data.input),
+              providerExecuted: true,
+              nativeName: toolName
+            });
+          }
+        }
+      } else if (kind === "on_tool_end") {
+        const toolName = event.name ?? "unknown";
+        const runId = event.run_id ?? "";
+        if (!nested && !hostToolNames.has(toolName)) {
+          let output = data.output ?? "";
+          if (output && typeof output === "object" && "content" in output) {
+            output = output.content;
+          }
+          emit({
+            type: "tool-result",
+            toolCallId: approvedRunIds.get(runId) ?? runId,
+            toolName: toCommonName(toolName),
+            result: output ?? null
+          });
+          approvedRunIds.delete(runId);
+        }
+      }
+    }
+    const actionRequests = await readPendingApprovals();
+    if (actionRequests.length === 0) break;
+    const decisions = [];
+    for (const action of actionRequests) {
+      const approvalId = `approval-${randomUUID()}`;
+      endTextBlock();
+      endReasoningBlock();
+      emit({
+        type: "tool-call",
+        toolCallId: approvalId,
+        toolName: toCommonName(action.name),
+        input: JSON.stringify(action.args ?? {}),
+        providerExecuted: true,
+        nativeName: action.name
+      });
+      emit({
+        type: "tool-approval-request",
+        approvalId,
+        toolCallId: approvalId
+      });
+      const decision = await turn.requestToolApproval(approvalId);
+      if (decision.approved) {
+        const queue = approvedToolQueue.get(action.name) ?? [];
+        queue.push(approvalId);
+        approvedToolQueue.set(action.name, queue);
+        decisions.push({ type: "approve" });
+      } else {
+        emit({
+          type: "tool-result",
+          toolCallId: approvalId,
+          toolName: toCommonName(action.name),
+          result: decision.reason ?? "Rejected by user."
+        });
+        decisions.push({
+          type: "reject",
+          ...decision.reason ? { message: decision.reason } : {}
+        });
+      }
+    }
+    resumeInput = new Command({ resume: { decisions } });
+  }
+  endTextBlock();
+  endReasoningBlock();
+  flushStep();
+  emit({
+    type: "finish",
+    finishReason: { unified: "stop" },
+    totalUsage: {
+      inputTokens: { total: inputTokens },
+      outputTokens: { total: outputTokens }
+    }
+  });
+}
+await runBridge({
+  bridgeType: "deepagents",
+  bridgeStateDir,
+  onStart: runTurn
+});
+//# sourceMappingURL=index.mjs.map