@wrongstack/acp 0.295.1 → 0.296.3

package/dist/index.js

@@ -974,6 +974,9 @@ var ClientTransport = class {
       };
       const waitForMarker = (chunk) => {
         this.buffer += chunk;
+        if (this.buffer.length > this.maxFrameChars) {
+          this.buffer = this.buffer.slice(-this.maxFrameChars);
+        }
         const idx = this.buffer.indexOf("[wstack-acp]\n");
         if (idx !== -1) {
           this.buffer = this.buffer.slice(idx + "[wstack-acp]\n".length);
@@ -1203,8 +1206,9 @@ function toolToPriority(tool) {
 
 // src/agent/wrongstack-acp-agent.ts
 import { createServer } from "node:http";
+import { isIP } from "node:net";
 import { fileURLToPath } from "node:url";
-import { writeErr as writeErr2 } from "@wrongstack/core/utils";
+import { expandIPv6, writeErr as writeErr2 } from "@wrongstack/core/utils";
 var WrongStackACPServer = class {
   transport;
   handler;
@@ -1260,7 +1264,10 @@ var WrongStackACPServer = class {
   async startHttp(port) {
     const host = this.options.host ?? "127.0.0.1";
     const handler = this.handler;
-    const authToken = this.options.authToken;
+    const authToken = this.options.authToken?.trim();
+    if (!authToken && !isLoopbackHost(host)) {
+      throw new Error("ACP HTTP transport requires authToken for non-loopback hosts");
+    }
     let httpChain = Promise.resolve();
     this.httpServer = createServer(async (req, res) => {
       if (authToken) {
@@ -1388,6 +1395,16 @@ function headerValue(value) {
 function requestPath(value) {
   return value ?? "/";
 }
+function isLoopbackHost(host) {
+  const normalized = host.trim().toLowerCase();
+  if (normalized === "localhost") return true;
+  const literal = normalized.startsWith("[") && normalized.endsWith("]") ? normalized.slice(1, -1) : normalized;
+  const version = isIP(literal);
+  if (version === 4) return literal.startsWith("127.");
+  if (version !== 6) return false;
+  const groups = expandIPv6(literal);
+  return groups !== null && groups.slice(0, 7).every((group) => group === 0) && groups[7] === 1;
+}
 async function main() {
   const server = new WrongStackACPServer();
   await server.start();
@@ -1401,6 +1418,39 @@ if (isEntrypoint) {
   });
 }
 
+// src/client/acp-session-content.ts
+function textContent(text) {
+  return { type: "text", text };
+}
+function imageContent(mimeType, data) {
+  return { type: "image", mimeType, data };
+}
+function audioContent(mimeType, data) {
+  return { type: "audio", mimeType, data };
+}
+function extractText(block) {
+  if (typeof block !== "object" || block === null) return "";
+  const b = block;
+  if (b.type === "text" && typeof b.text === "string") return b.text;
+  if (b.type === "resource" && b.resource && typeof b.resource === "object" && typeof b.resource.text === "string") {
+    return b.resource.text;
+  }
+  return "";
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function emptyRunResult(stopReason) {
+  return {
+    text: "",
+    stopReason,
+    hasText: false,
+    toolCalls: [],
+    diffs: [],
+    thoughts: ""
+  };
+}
+
 // src/client/file-server.ts
 import { randomBytes } from "node:crypto";
 import { realpathSync } from "node:fs";
@@ -2076,7 +2126,7 @@ function finitePositiveLimit(value, fallback) {
   return value !== void 0 && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
 
-// src/client/acp-session.ts
+// src/client/acp-session-errors.ts
 var ACPSessionError = class extends Error {
   kind;
   cause;
@@ -2090,6 +2140,264 @@ var ACPSessionError = class extends Error {
 function isJsonRpcError(v) {
   return typeof v === "object" && v !== null && typeof v.code === "number" && typeof v.message === "string";
 }
+
+// src/client/acp-session-updates.ts
+function createSessionScratch() {
+  return { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
+}
+function handleAcpSessionUpdate(msg, scratch, emitProgress) {
+  const update = msg.params?.update;
+  if (typeof update !== "object" || update === null) return;
+  const u = update;
+  emitProgress({ type: "raw", update: u });
+  switch (u.sessionUpdate) {
+    case "agent_message_chunk": {
+      const text = extractText(u.content);
+      if (text) {
+        scratch.text += text;
+        emitProgress({ type: "message", text });
+      }
+      return;
+    }
+    case "thought_chunk": {
+      const text = extractText(u.content);
+      if (text) {
+        scratch.thoughts += text;
+        emitProgress({ type: "thought", text });
+      }
+      return;
+    }
+    case "tool_call":
+    case "tool_call_update":
+      captureToolCall(u, u.sessionUpdate === "tool_call", scratch, emitProgress);
+      return;
+    case "plan":
+      if (Array.isArray(u.entries)) {
+        scratch.plan = u.entries;
+        emitProgress({ type: "plan", entries: u.entries });
+      }
+      return;
+    case "usage_update":
+      if (typeof u.used === "number" && typeof u.size === "number") {
+        const usage = {
+          used: u.used,
+          size: u.size,
+          ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
+        };
+        scratch.usage = usage;
+        emitProgress({ type: "usage", usage });
+      }
+      return;
+    case "available_commands_update":
+    case "current_mode_update":
+    case "config_option_update":
+    case "session_info_update":
+    case "user_message_chunk":
+    case "next_edit_suggestions":
+    case "elicitation":
+      return;
+    default:
+      return;
+  }
+}
+function captureToolCall(u, isNew, scratch, emitProgress) {
+  const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : "";
+  if (!toolCallId) return;
+  const prev = scratch.toolCalls.get(toolCallId);
+  const record = {
+    toolCallId,
+    title: typeof u.title === "string" ? u.title : prev?.title ?? toolCallId,
+    kind: typeof u.kind === "string" ? u.kind : prev?.kind,
+    status: typeof u.status === "string" ? u.status : prev?.status ?? (isNew ? "pending" : "in_progress"),
+    rawInput: isRecord(u.rawInput) ? u.rawInput : prev?.rawInput,
+    rawOutput: isRecord(u.rawOutput) ? u.rawOutput : prev?.rawOutput
+  };
+  scratch.toolCalls.set(toolCallId, record);
+  if (Array.isArray(u.content)) {
+    for (const c of u.content) {
+      if (c && typeof c === "object" && c.type === "diff") {
+        const diff = {
+          path: c.path,
+          oldText: c.oldText,
+          newText: c.newText
+        };
+        scratch.diffs.push(diff);
+        emitProgress({ type: "diff", diff });
+      }
+    }
+  }
+  emitProgress({
+    type: isNew ? "tool_call" : "tool_call_update",
+    toolCall: record
+  });
+}
+
+// src/client/acp-session-callbacks.ts
+async function handleAcpPermissionRequest(msg, permissionPolicy, sender) {
+  const id = msg.id;
+  if (id === void 0) return;
+  const params = msg.params;
+  const toolCall = params?.toolCall;
+  const options = Array.isArray(params?.options) ? params.options : [];
+  if (!toolCall) {
+    await sender.sendErrorResponse(id, -32602, "toolCall is required");
+    return;
+  }
+  const policyAbort = new AbortController();
+  try {
+    const outcome = await permissionPolicy({
+      toolCall,
+      options,
+      signal: policyAbort.signal
+    });
+    await sender.sendResult(id, { outcome });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await sender.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
+  }
+}
+async function handleAcpFsRequest(msg, fileServer, permissionPolicy, sender) {
+  const id = msg.id;
+  if (id === void 0) return;
+  const params = msg.params;
+  if (!params?.path) {
+    await sender.sendErrorResponse(id, -32602, "path is required");
+    return;
+  }
+  if (msg.method === "fs/write_text_file") {
+    const allowed = await authorizeAcpCallback(permissionPolicy, {
+      toolCallId: `acp-fs-write-${id}`,
+      title: `Write file: ${params.path}`,
+      kind: "edit",
+      rawInput: { path: params.path, sessionId: params.sessionId }
+    });
+    if (!allowed) {
+      await sender.sendErrorResponse(id, -32602, "filesystem write denied by permission policy");
+      return;
+    }
+  }
+  try {
+    if (msg.method === "fs/read_text_file") {
+      const result = await fileServer.readTextFile({
+        sessionId: params.sessionId ?? "",
+        path: params.path
+      });
+      await sender.sendResult(id, result);
+    } else {
+      await fileServer.writeTextFile({
+        sessionId: params.sessionId ?? "",
+        path: params.path,
+        content: params.content ?? ""
+      });
+      await sender.sendResult(id, {});
+    }
+  } catch (err) {
+    const code = err instanceof FsError ? -32602 : -32603;
+    const message = err instanceof Error ? err.message : String(err);
+    await sender.sendErrorResponse(id, code, message);
+  }
+}
+async function handleAcpTerminalRequest(msg, terminalServer, permissionPolicy, sender) {
+  const id = msg.id;
+  if (id === void 0) return;
+  const params = msg.params ?? {};
+  try {
+    switch (msg.method) {
+      case "terminal/create": {
+        const allowed = await authorizeAcpCallback(permissionPolicy, {
+          toolCallId: `acp-terminal-create-${id}`,
+          title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
+          kind: "execute",
+          rawInput: {
+            command: params.command,
+            args: params.args,
+            cwd: params.cwd,
+            sessionId: params.sessionId
+          }
+        });
+        if (!allowed) {
+          await sender.sendErrorResponse(id, -32602, "terminal create denied by permission policy");
+          return;
+        }
+        const createOpts = {
+          sessionId: String(params.sessionId ?? ""),
+          command: String(params.command ?? ""),
+          args: Array.isArray(params.args) ? params.args : []
+        };
+        if (Array.isArray(params.env)) {
+          createOpts.env = params.env;
+        }
+        if (typeof params.cwd === "string") {
+          createOpts.cwd = params.cwd;
+        }
+        if (typeof params.outputByteLimit === "number") {
+          createOpts.outputByteLimit = params.outputByteLimit;
+        }
+        const result = terminalServer.create(createOpts);
+        await sender.sendResult(id, result);
+        return;
+      }
+      case "terminal/output": {
+        const terminalId = String(params.terminalId ?? "");
+        const out = terminalServer.output(terminalId);
+        await sender.sendResult(id, out);
+        return;
+      }
+      case "terminal/wait_for_exit": {
+        const terminalId = String(params.terminalId ?? "");
+        const exit = await terminalServer.waitForExit(terminalId);
+        await sender.sendResult(id, exit);
+        return;
+      }
+      case "terminal/kill": {
+        const terminalId = String(params.terminalId ?? "");
+        terminalServer.kill(terminalId);
+        await sender.sendResult(id, {});
+        return;
+      }
+      case "terminal/release": {
+        const terminalId = String(params.terminalId ?? "");
+        terminalServer.release(terminalId);
+        await sender.sendResult(id, {});
+        return;
+      }
+      default:
+        await sender.sendErrorResponse(id, -32601, `unknown method: ${msg.method}`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await sender.sendErrorResponse(id, -32603, message);
+  }
+}
+async function authorizeAcpCallback(permissionPolicy, partial) {
+  try {
+    const outcome = await permissionPolicy({
+      toolCall: {
+        sessionUpdate: "tool_call_update",
+        toolCallId: partial.toolCallId,
+        title: partial.title,
+        kind: partial.kind,
+        status: "pending",
+        ...partial.rawInput ? { rawInput: partial.rawInput } : {}
+      },
+      options: [
+        { optionId: "allow", name: "Allow", kind: "allow_once" },
+        { optionId: "reject", name: "Reject", kind: "reject_once" }
+      ],
+      signal: new AbortController().signal
+    });
+    return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always";
+  } catch {
+    return false;
+  }
+}
+
+// src/client/acp-message-routing.ts
+function isBestEffortAckMethod(method) {
+  return method === "mcp/connect" || method === "mcp/message" || method === "mcp/disconnect" || method === "elicitation/create" || method === "elicitation/complete";
+}
+
+// src/client/acp-session.ts
 var ACPSession = class _ACPSession {
   transport;
   fileServer;
@@ -2783,6 +3091,12 @@ var ACPSession = class _ACPSession {
       error: { code, message }
     });
   }
+  responseSender() {
+    return {
+      sendResult: (id, result) => this.sendResult(id, result),
+      sendErrorResponse: (id, code, message) => this.sendErrorResponse(id, code, message)
+    };
+  }
   handleMessage(msg) {
     if (msg.id !== void 0 && (msg.result !== void 0 || msg.error !== void 0)) {
       const pending = this.pending.get(msg.id);
@@ -2797,29 +3111,32 @@ var ACPSession = class _ACPSession {
       return;
     }
     if (msg.method === "session/update") {
-      this.handleUpdate(msg);
+      handleAcpSessionUpdate(msg, this.scratch, (event) => this.emitProgress(event));
       return;
     }
     if (msg.method === "session/request_permission") {
-      void this.handlePermissionRequest(msg);
+      void handleAcpPermissionRequest(msg, this.permissionPolicy, this.responseSender());
       return;
     }
     if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
-      void this.handleFsRequest(msg);
+      void handleAcpFsRequest(
+        msg,
+        this.fileServer,
+        this.permissionPolicy,
+        this.responseSender()
+      );
       return;
     }
     if (msg.method?.startsWith("terminal/")) {
-      void this.handleTerminalRequest(msg);
-      return;
-    }
-    if (msg.method === "mcp/connect" || msg.method === "mcp/message" || msg.method === "mcp/disconnect") {
-      if (msg.id !== void 0) {
-        this.sendResult(msg.id, {}).catch(() => {
-        });
-      }
+      void handleAcpTerminalRequest(
+        msg,
+        this.terminalServer,
+        this.permissionPolicy,
+        this.responseSender()
+      );
       return;
     }
-    if (msg.method === "elicitation/create" || msg.method === "elicitation/complete") {
+    if (isBestEffortAckMethod(msg.method)) {
       if (msg.id !== void 0) {
         this.sendResult(msg.id, {}).catch(() => {
         });
@@ -2840,98 +3157,6 @@ var ACPSession = class _ACPSession {
       );
     }
   }
-  handleUpdate(msg) {
-    const update = msg.params?.update;
-    if (typeof update !== "object" || update === null) return;
-    const u = update;
-    this.emitProgress({ type: "raw", update: u });
-    switch (u.sessionUpdate) {
-      case "agent_message_chunk": {
-        const text = extractText(u.content);
-        if (text) {
-          this.scratch.text += text;
-          this.emitProgress({ type: "message", text });
-        }
-        return;
-      }
-      case "thought_chunk": {
-        const text = extractText(u.content);
-        if (text) {
-          this.scratch.thoughts += text;
-          this.emitProgress({ type: "thought", text });
-        }
-        return;
-      }
-      case "tool_call":
-      case "tool_call_update": {
-        this.captureToolCall(u, u.sessionUpdate === "tool_call");
-        return;
-      }
-      case "plan":
-        if (Array.isArray(u.entries)) {
-          this.scratch.plan = u.entries;
-          this.emitProgress({ type: "plan", entries: u.entries });
-        }
-        return;
-      case "usage_update":
-        if (typeof u.used === "number" && typeof u.size === "number") {
-          const usage = {
-            used: u.used,
-            size: u.size,
-            ...typeof u.cost === "object" && u.cost !== null ? { cost: u.cost } : {}
-          };
-          this.scratch.usage = usage;
-          this.emitProgress({ type: "usage", usage });
-        }
-        return;
-      case "available_commands_update":
-      case "current_mode_update":
-      case "config_option_update":
-      case "session_info_update":
-      case "user_message_chunk":
-      case "next_edit_suggestions":
-      case "elicitation":
-        return;
-      default:
-        return;
-    }
-  }
-  /**
-   * Fold a `tool_call` / `tool_call_update` notification into the scratch
-   * tool-call map (deduped by toolCallId), extract any `diff` content into
-   * the diffs list, and emit live progress.
-   */
-  captureToolCall(u, isNew) {
-    const toolCallId = typeof u.toolCallId === "string" ? u.toolCallId : "";
-    if (!toolCallId) return;
-    const prev = this.scratch.toolCalls.get(toolCallId);
-    const record = {
-      toolCallId,
-      title: typeof u.title === "string" ? u.title : prev?.title ?? toolCallId,
-      kind: typeof u.kind === "string" ? u.kind : prev?.kind,
-      status: typeof u.status === "string" ? u.status : prev?.status ?? (isNew ? "pending" : "in_progress"),
-      rawInput: isRecord(u.rawInput) ? u.rawInput : prev?.rawInput,
-      rawOutput: isRecord(u.rawOutput) ? u.rawOutput : prev?.rawOutput
-    };
-    this.scratch.toolCalls.set(toolCallId, record);
-    if (Array.isArray(u.content)) {
-      for (const c of u.content) {
-        if (c && typeof c === "object" && c.type === "diff") {
-          const diff = {
-            path: c.path,
-            oldText: c.oldText,
-            newText: c.newText
-          };
-          this.scratch.diffs.push(diff);
-          this.emitProgress({ type: "diff", diff });
-        }
-      }
-    }
-    this.emitProgress({
-      type: isNew ? "tool_call" : "tool_call_update",
-      toolCall: record
-    });
-  }
   emitProgress(event) {
     if (!this.progressHandler) return;
     try {
@@ -2942,217 +3167,11 @@ var ACPSession = class _ACPSession {
   /** Live progress handler installed for the duration of a `prompt()` turn. */
   progressHandler = null;
   // Per-prompt scratch state
-  scratch = { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
+  scratch = createSessionScratch();
   resetScratch() {
-    this.scratch = { text: "", thoughts: "", toolCalls: /* @__PURE__ */ new Map(), diffs: [] };
-  }
-  async handlePermissionRequest(msg) {
-    const id = msg.id;
-    if (id === void 0) return;
-    const params = msg.params;
-    const toolCall = params?.toolCall;
-    const options = Array.isArray(params?.options) ? params.options : [];
-    if (!toolCall) {
-      await this.sendErrorResponse(id, -32602, "toolCall is required");
-      return;
-    }
-    const policyAbort = new AbortController();
-    try {
-      const outcome = await this.permissionPolicy({
-        toolCall,
-        options,
-        signal: policyAbort.signal
-      });
-      await this.sendResult(id, { outcome });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      await this.sendErrorResponse(id, -32603, `permission policy failed: ${message}`);
-    }
-  }
-  /**
-   * Enforce authorization at privileged callback sinks (fs/write,
-   * terminal/create). Unlike `handlePermissionRequest` which responds to
-   * agent-initiated `session/request_permission` messages, this method is
-   * called by the handler BEFORE dispatching to FileServer/TerminalServer,
-   * closing the gap where the agent simply skips the voluntary permission
-   * request and sends the privileged callback directly.
-   *
-   * Uses the session's permission policy. The default
-   * (`readOnlyPermissionPolicy`) auto-approves only side-effect-free tool
-   * calls (read/search/fetch/think) and rejects everything else — this is
-   * the safe-by-default posture. For trusted local agents (CLI `acp spawn`,
-   * Director fan-out), inject `defaultPermissionPolicy` to grant
-   * write/execute access.
-   *
-   * Returns true if the callback is authorized, false if denied.
-   */
-  async authorizeCallback(partial) {
-    try {
-      const outcome = await this.permissionPolicy({
-        toolCall: {
-          sessionUpdate: "tool_call_update",
-          toolCallId: partial.toolCallId,
-          title: partial.title,
-          kind: partial.kind,
-          status: "pending",
-          ...partial.rawInput ? { rawInput: partial.rawInput } : {}
-        },
-        options: [
-          { optionId: "allow", name: "Allow", kind: "allow_once" },
-          { optionId: "reject", name: "Reject", kind: "reject_once" }
-        ],
-        signal: new AbortController().signal
-      });
-      return outcome.outcome === "selected" && outcome.optionId !== "reject" && outcome.optionId !== "reject_once" && outcome.optionId !== "reject_always";
-    } catch {
-      return false;
-    }
-  }
-  async handleFsRequest(msg) {
-    const id = msg.id;
-    if (id === void 0) return;
-    const params = msg.params;
-    if (!params?.path) {
-      await this.sendErrorResponse(id, -32602, "path is required");
-      return;
-    }
-    if (msg.method === "fs/write_text_file") {
-      const allowed = await this.authorizeCallback({
-        toolCallId: `acp-fs-write-${id}`,
-        title: `Write file: ${params.path}`,
-        kind: "edit",
-        rawInput: { path: params.path, sessionId: params.sessionId }
-      });
-      if (!allowed) {
-        await this.sendErrorResponse(id, -32602, "filesystem write denied by permission policy");
-        return;
-      }
-    }
-    try {
-      if (msg.method === "fs/read_text_file") {
-        const result = await this.fileServer.readTextFile({
-          sessionId: params.sessionId ?? "",
-          path: params.path
-        });
-        await this.sendResult(id, result);
-      } else {
-        await this.fileServer.writeTextFile({
-          sessionId: params.sessionId ?? "",
-          path: params.path,
-          content: params.content ?? ""
-        });
-        await this.sendResult(id, {});
-      }
-    } catch (err) {
-      const code = err instanceof FsError ? -32602 : -32603;
-      const message = err instanceof Error ? err.message : String(err);
-      await this.sendErrorResponse(id, code, message);
-    }
-  }
-  async handleTerminalRequest(msg) {
-    const id = msg.id;
-    if (id === void 0) return;
-    const params = msg.params ?? {};
-    try {
-      switch (msg.method) {
-        case "terminal/create": {
-          const allowed = await this.authorizeCallback({
-            toolCallId: `acp-terminal-create-${id}`,
-            title: `Run command: ${String(params.command ?? "")} ${(Array.isArray(params.args) ? params.args : []).join(" ")}`.trim(),
-            kind: "execute",
-            rawInput: {
-              command: params.command,
-              args: params.args,
-              cwd: params.cwd,
-              sessionId: params.sessionId
-            }
-          });
-          if (!allowed) {
-            await this.sendErrorResponse(id, -32602, "terminal create denied by permission policy");
-            return;
-          }
-          const createOpts = {
-            sessionId: String(params.sessionId ?? ""),
-            command: String(params.command ?? ""),
-            args: Array.isArray(params.args) ? params.args : []
-          };
-          if (Array.isArray(params.env)) {
-            createOpts.env = params.env;
-          }
-          if (typeof params.cwd === "string") {
-            createOpts.cwd = params.cwd;
-          }
-          if (typeof params.outputByteLimit === "number") {
-            createOpts.outputByteLimit = params.outputByteLimit;
-          }
-          const result = this.terminalServer.create(createOpts);
-          await this.sendResult(id, result);
-          return;
-        }
-        case "terminal/output": {
-          const terminalId = String(params.terminalId ?? "");
-          const out = this.terminalServer.output(terminalId);
-          await this.sendResult(id, out);
-          return;
-        }
-        case "terminal/wait_for_exit": {
-          const terminalId = String(params.terminalId ?? "");
-          const exit = await this.terminalServer.waitForExit(terminalId);
-          await this.sendResult(id, exit);
-          return;
-        }
-        case "terminal/kill": {
-          const terminalId = String(params.terminalId ?? "");
-          this.terminalServer.kill(terminalId);
-          await this.sendResult(id, {});
-          return;
-        }
-        case "terminal/release": {
-          const terminalId = String(params.terminalId ?? "");
-          this.terminalServer.release(terminalId);
-          await this.sendResult(id, {});
-          return;
-        }
-        default:
-          await this.sendErrorResponse(id, -32601, `unknown method: ${msg.method}`);
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      await this.sendErrorResponse(id, -32603, message);
-    }
+    this.scratch = createSessionScratch();
   }
 };
-function textContent(text) {
-  return { type: "text", text };
-}
-function imageContent(mimeType, data) {
-  return { type: "image", mimeType, data };
-}
-function audioContent(mimeType, data) {
-  return { type: "audio", mimeType, data };
-}
-function extractText(block) {
-  if (typeof block !== "object" || block === null) return "";
-  const b = block;
-  if (b.type === "text" && typeof b.text === "string") return b.text;
-  if (b.type === "resource" && b.resource && typeof b.resource === "object" && typeof b.resource.text === "string") {
-    return b.resource.text;
-  }
-  return "";
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function emptyRunResult(stopReason) {
-  return {
-    text: "",
-    stopReason,
-    hasText: false,
-    toolCalls: [],
-    diffs: [],
-    thoughts: ""
-  };
-}
 
 // src/client/tool-translator.ts
 import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";