fourmis-agents-sdk 0.1.0

package/dist/agents/index.js

@@ -0,0 +1,2309 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/tools/mcp-resources.ts
+var exports_mcp_resources = {};
+__export(exports_mcp_resources, {
+  createReadMcpResourceTool: () => createReadMcpResourceTool,
+  createListMcpResourcesTool: () => createListMcpResourcesTool
+});
+function createListMcpResourcesTool(mcpClient) {
+  return {
+    name: "mcp__list_resources",
+    description: "List available resources from MCP servers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "Optional server name to filter by. If omitted, lists resources from all servers."
+        }
+      }
+    },
+    async execute(input) {
+      const { server } = input ?? {};
+      try {
+        const resources = await mcpClient.listResources(server);
+        if (resources.length === 0) {
+          return { content: "No resources available." };
+        }
+        const lines = resources.map((r) => `[${r.server}] ${r.uri} - ${r.name}${r.description ? `: ${r.description}` : ""}`);
+        return { content: lines.join(`
+`) };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error listing resources: ${message}`, isError: true };
+      }
+    }
+  };
+}
+function createReadMcpResourceTool(mcpClient) {
+  return {
+    name: "mcp__read_resource",
+    description: "Read a specific resource from an MCP server by URI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: {
+          type: "string",
+          description: "The MCP server name that hosts the resource."
+        },
+        uri: {
+          type: "string",
+          description: "The resource URI to read."
+        }
+      },
+      required: ["server", "uri"]
+    },
+    async execute(input) {
+      const { server, uri } = input;
+      if (!server || !uri) {
+        return { content: "Both 'server' and 'uri' are required.", isError: true };
+      }
+      try {
+        const content = await mcpClient.readResource(server, uri);
+        return { content };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Error reading resource: ${message}`, isError: true };
+      }
+    }
+  };
+}
+
+// src/auth/openai-oauth.ts
+var exports_openai_oauth = {};
+__export(exports_openai_oauth, {
+  login: () => login,
+  loadTokens: () => loadTokens,
+  isLoggedIn: () => isLoggedIn,
+  getValidToken: () => getValidToken,
+  generateCodeVerifier: () => generateCodeVerifier,
+  generateCodeChallenge: () => generateCodeChallenge,
+  extractAccountId: () => extractAccountId,
+  decodeJwtPayload: () => decodeJwtPayload
+});
+import { randomBytes, createHash } from "crypto";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+function tokenDir() {
+  return join(process.env.HOME ?? "/root", ".fourmis");
+}
+function tokenPath() {
+  return join(tokenDir(), "openai-auth.json");
+}
+function codexFallbackPath() {
+  return join(process.env.HOME ?? "/root", ".codex", "auth.json");
+}
+function loadTokens() {
+  for (const p of [tokenPath(), codexFallbackPath()]) {
+    try {
+      const raw = readFileSync(p, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.access_token && data.account_id) {
+        return data;
+      }
+    } catch {}
+  }
+  return null;
+}
+function saveTokens(tokens) {
+  const dir = tokenDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(tokenPath(), JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+function generateCodeVerifier() {
+  return randomBytes(64).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length < 2)
+    throw new Error("Invalid JWT");
+  const payload = Buffer.from(parts[1], "base64url").toString("utf-8");
+  return JSON.parse(payload);
+}
+function extractAccountId(accessToken) {
+  const payload = decodeJwtPayload(accessToken);
+  const authClaim = payload["https://api.openai.com/auth"];
+  if (!authClaim?.chatgpt_account_id) {
+    throw new Error("JWT missing chatgpt_account_id claim");
+  }
+  return authClaim.chatgpt_account_id;
+}
+async function exchangeCode(code, codeVerifier) {
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      code,
+      redirect_uri: REDIRECT_URI,
+      code_verifier: codeVerifier
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Token exchange failed (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+async function refreshAccessToken(refreshToken) {
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID,
+      refresh_token: refreshToken
+    })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Token refresh failed (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+async function getValidToken() {
+  const tokens = loadTokens();
+  if (!tokens)
+    return null;
+  if (tokens.expires_at <= Date.now() + 300000) {
+    try {
+      const fresh = await refreshAccessToken(tokens.refresh_token);
+      const accountId = extractAccountId(fresh.access_token);
+      const updated = {
+        access_token: fresh.access_token,
+        refresh_token: fresh.refresh_token ?? tokens.refresh_token,
+        expires_at: Date.now() + fresh.expires_in * 1000,
+        account_id: accountId
+      };
+      saveTokens(updated);
+      return { accessToken: updated.access_token, accountId };
+    } catch {
+      return { accessToken: tokens.access_token, accountId: tokens.account_id };
+    }
+  }
+  return { accessToken: tokens.access_token, accountId: tokens.account_id };
+}
+function isLoggedIn() {
+  return loadTokens() !== null;
+}
+async function login(opts) {
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  const state = randomBytes(16).toString("hex");
+  const authUrl = new URL(AUTHORIZE_URL);
+  authUrl.searchParams.set("client_id", CLIENT_ID);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("redirect_uri", REDIRECT_URI);
+  authUrl.searchParams.set("scope", SCOPE);
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("code_challenge", codeChallenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("audience", "https://api.openai.com/v1");
+  const forceHeadless = opts?.headless ?? false;
+  if (!forceHeadless) {
+    let serverWorked = false;
+    try {
+      const result = await loginWithServer(authUrl.toString(), state, codeVerifier);
+      return result;
+    } catch {}
+  }
+  return loginHeadless(authUrl.toString(), state, codeVerifier);
+}
+async function loginWithServer(authUrlStr, state, codeVerifier) {
+  let authCode = null;
+  let authError = null;
+  let resolveCallback;
+  const callbackPromise = new Promise((resolve) => {
+    resolveCallback = resolve;
+  });
+  const server = Bun.serve({
+    port: CALLBACK_PORT,
+    fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/auth/callback") {
+        const receivedState = url.searchParams.get("state");
+        const code = url.searchParams.get("code");
+        const error = url.searchParams.get("error");
+        if (error) {
+          authError = error;
+        } else if (receivedState !== state) {
+          authError = "State mismatch";
+        } else if (code) {
+          authCode = code;
+        } else {
+          authError = "No code received";
+        }
+        resolveCallback();
+        return new Response("<html><body><h1>Authentication complete</h1><p>You can close this window.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+      }
+      return new Response("Not found", { status: 404 });
+    }
+  });
+  try {
+    await openBrowser(authUrlStr);
+  } catch {
+    server.stop(true);
+    throw new Error("Cannot open browser");
+  }
+  console.log("Waiting for authentication...");
+  const timeout = setTimeout(() => {
+    authError = "Timeout waiting for callback (120s)";
+    resolveCallback();
+  }, 120000);
+  await callbackPromise;
+  clearTimeout(timeout);
+  server.stop(true);
+  if (authError) {
+    return { success: false, error: authError };
+  }
+  if (!authCode) {
+    return { success: false, error: "No authorization code received" };
+  }
+  return finishLogin(authCode, codeVerifier);
+}
+async function loginHeadless(authUrlStr, state, codeVerifier) {
+  console.log(`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510`);
+  console.log("\u2502  Headless login (VPS / SSH mode)                        \u2502");
+  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+  console.log(`
+1. Open this URL in your local browser:
+`);
+  console.log(`   ${authUrlStr}
+`);
+  console.log("2. Log in with your ChatGPT account.");
+  console.log("3. After login, your browser will try to redirect to");
+  console.log("   localhost:1455 \u2014 this will FAIL (that's expected).");
+  console.log("4. Copy the FULL URL from the browser's address bar");
+  console.log("   (it starts with http://localhost:1455/auth/callback?code=...)");
+  console.log(`5. Paste it here and press Enter:
+`);
+  process.stdout.write("> ");
+  const pastedUrl = await readLine();
+  if (!pastedUrl.trim()) {
+    return { success: false, error: "No URL pasted" };
+  }
+  try {
+    const url = new URL(pastedUrl.trim());
+    const code = url.searchParams.get("code");
+    const receivedState = url.searchParams.get("state");
+    const error = url.searchParams.get("error");
+    if (error) {
+      return { success: false, error: `OAuth error: ${error}` };
+    }
+    if (receivedState !== state) {
+      return { success: false, error: "State mismatch \u2014 did you use the right URL?" };
+    }
+    if (!code) {
+      return { success: false, error: "No authorization code in URL" };
+    }
+    return finishLogin(code, codeVerifier);
+  } catch (err) {
+    return { success: false, error: `Invalid URL: ${err.message}` };
+  }
+}
+async function finishLogin(authCode, codeVerifier) {
+  try {
+    const tokenResponse = await exchangeCode(authCode, codeVerifier);
+    const accountId = extractAccountId(tokenResponse.access_token);
+    const stored = {
+      access_token: tokenResponse.access_token,
+      refresh_token: tokenResponse.refresh_token,
+      expires_at: Date.now() + tokenResponse.expires_in * 1000,
+      account_id: accountId
+    };
+    saveTokens(stored);
+    return { success: true, accountId };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+function readLine() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.resume();
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+      if (data.includes(`
+`)) {
+        process.stdin.pause();
+        resolve(data.split(`
+`)[0]);
+      }
+    });
+  });
+}
+async function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? ["open", url] : platform === "win32" ? ["cmd", "/c", "start", url] : ["xdg-open", url];
+  const proc = Bun.spawn(cmd, { stdout: "ignore", stderr: "ignore" });
+  await proc.exited;
+  if (proc.exitCode !== 0) {
+    throw new Error(`Failed to open browser (exit code ${proc.exitCode})`);
+  }
+}
+var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann", AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize", TOKEN_URL = "https://auth.openai.com/oauth/token", REDIRECT_URI = "http://localhost:1455/auth/callback", SCOPE = "openid profile email offline_access", CALLBACK_PORT = 1455;
+var init_openai_oauth = () => {};
+
+// src/types.ts
+function uuid() {
+  return crypto.randomUUID();
+}
+function emptyTokenUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0
+  };
+}
+function mergeUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadInputTokens: a.cacheReadInputTokens + b.cacheReadInputTokens,
+    cacheCreationInputTokens: a.cacheCreationInputTokens + b.cacheCreationInputTokens
+  };
+}
+
+// src/agent-loop.ts
+async function* agentLoop(prompt, options) {
+  const {
+    provider,
+    model,
+    systemPrompt,
+    tools,
+    permissions,
+    cwd,
+    sessionId,
+    maxTurns,
+    maxBudgetUsd,
+    includeStreamEvents,
+    signal,
+    env,
+    debug,
+    hooks,
+    mcpClient
+  } = options;
+  const startTime = Date.now();
+  let apiTimeMs = 0;
+  let turns = 0;
+  let totalUsage = emptyTokenUsage();
+  let costUsd = 0;
+  const modelUsage = {};
+  if (mcpClient) {
+    await mcpClient.connectAll();
+    for (const tool of mcpClient.getTools()) {
+      tools.register(tool);
+    }
+    const { createListMcpResourcesTool: createListMcpResourcesTool2, createReadMcpResourceTool: createReadMcpResourceTool2 } = await Promise.resolve().then(() => exports_mcp_resources);
+    tools.register(createListMcpResourcesTool2(mcpClient));
+    tools.register(createReadMcpResourceTool2(mcpClient));
+  }
+  const messages = [
+    { role: "user", content: prompt }
+  ];
+  yield {
+    type: "init",
+    sessionId,
+    model,
+    provider: provider.name,
+    tools: tools.list(),
+    cwd,
+    uuid: uuid()
+  };
+  if (hooks) {
+    await hooks.fire("SessionStart", { event: "SessionStart", session_id: sessionId }, undefined, { signal });
+  }
+  while (true) {
+    if (signal.aborted) {
+      yield makeError("error_execution", ["Aborted"], turns, costUsd, sessionId, startTime);
+      return;
+    }
+    if (turns >= maxTurns) {
+      yield makeError("error_max_turns", [`Reached maximum turns (${maxTurns})`], turns, costUsd, sessionId, startTime);
+      return;
+    }
+    if (maxBudgetUsd > 0 && costUsd >= maxBudgetUsd) {
+      yield makeError("error_max_budget", [`Reached budget limit ($${maxBudgetUsd})`], turns, costUsd, sessionId, startTime);
+      return;
+    }
+    const toolDefs = tools.getDefinitions();
+    const apiStart = Date.now();
+    let assistantTextParts = [];
+    let toolCalls = [];
+    let turnUsage = emptyTokenUsage();
+    try {
+      const chunks = provider.chat({
+        model,
+        messages,
+        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        systemPrompt,
+        signal
+      });
+      for await (const chunk of chunks) {
+        switch (chunk.type) {
+          case "text_delta":
+            assistantTextParts.push(chunk.text);
+            if (includeStreamEvents) {
+              yield { type: "stream", subtype: "text_delta", text: chunk.text, uuid: uuid() };
+            }
+            break;
+          case "thinking_delta":
+            if (includeStreamEvents) {
+              yield { type: "stream", subtype: "thinking_delta", text: chunk.text, uuid: uuid() };
+            }
+            break;
+          case "tool_call":
+            toolCalls.push({ id: chunk.id, name: chunk.name, input: chunk.input });
+            break;
+          case "usage":
+            turnUsage = mergeUsage(turnUsage, chunk.usage);
+            break;
+          case "done":
+            break;
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      yield makeError("error_execution", [`API error: ${message}`], turns, costUsd, sessionId, startTime);
+      return;
+    }
+    apiTimeMs += Date.now() - apiStart;
+    turns++;
+    totalUsage = mergeUsage(totalUsage, turnUsage);
+    const turnCost = provider.calculateCost(model, turnUsage);
+    costUsd += turnCost;
+    if (!modelUsage[model]) {
+      modelUsage[model] = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        totalCostUsd: 0
+      };
+    }
+    modelUsage[model].inputTokens += turnUsage.inputTokens;
+    modelUsage[model].outputTokens += turnUsage.outputTokens;
+    modelUsage[model].cacheReadInputTokens += turnUsage.cacheReadInputTokens;
+    modelUsage[model].cacheCreationInputTokens += turnUsage.cacheCreationInputTokens;
+    modelUsage[model].totalCostUsd += turnCost;
+    const assistantText = assistantTextParts.join("");
+    const assistantContent = [];
+    if (assistantText) {
+      assistantContent.push({ type: "text", text: assistantText });
+    }
+    for (const call of toolCalls) {
+      assistantContent.push({
+        type: "tool_use",
+        id: call.id,
+        name: call.name,
+        input: call.input
+      });
+    }
+    messages.push({ role: "assistant", content: assistantContent });
+    if (assistantText) {
+      yield { type: "text", text: assistantText, uuid: uuid() };
+    }
+    if (toolCalls.length === 0) {
+      if (hooks) {
+        await hooks.fire("Stop", { event: "Stop", session_id: sessionId, text: assistantText || undefined }, undefined, { signal });
+      }
+      if (hooks) {
+        await hooks.fire("SessionEnd", { event: "SessionEnd", session_id: sessionId }, undefined, { signal });
+      }
+      yield {
+        type: "result",
+        subtype: "success",
+        text: assistantText || null,
+        turns,
+        costUsd,
+        durationMs: Date.now() - startTime,
+        durationApiMs: apiTimeMs,
+        sessionId,
+        usage: totalUsage,
+        modelUsage,
+        uuid: uuid()
+      };
+      return;
+    }
+    const toolResults = [];
+    for (const call of toolCalls) {
+      let hookDenied = false;
+      let hookUpdatedInput;
+      if (hooks) {
+        const hookResult = await hooks.fire("PreToolUse", { event: "PreToolUse", tool_name: call.name, tool_input: call.input, session_id: sessionId }, call.id, { signal });
+        if (hookResult) {
+          if (hookResult.permissionDecision === "deny") {
+            hookDenied = true;
+          }
+          if (hookResult.updatedInput !== undefined) {
+            hookUpdatedInput = hookResult.updatedInput;
+          }
+        }
+      }
+      if (hookDenied) {
+        const denyContent = "Denied by hook";
+        yield {
+          type: "tool_result",
+          id: call.id,
+          name: call.name,
+          content: denyContent,
+          isError: true,
+          uuid: uuid()
+        };
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          content: denyContent,
+          is_error: true
+        });
+        if (hooks) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+        }
+        continue;
+      }
+      const inputAfterHook = hookUpdatedInput !== undefined ? hookUpdatedInput : call.input;
+      const permResult = await permissions.check(call.name, inputAfterHook ?? {}, { signal, toolUseId: call.id });
+      if (permResult.behavior === "deny") {
+        const denyContent = `Permission denied: ${permResult.message}`;
+        yield {
+          type: "tool_result",
+          id: call.id,
+          name: call.name,
+          content: denyContent,
+          isError: true,
+          uuid: uuid()
+        };
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          content: denyContent,
+          is_error: true
+        });
+        if (hooks) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: denyContent, tool_error: true, session_id: sessionId }, call.id, { signal });
+        }
+        continue;
+      }
+      const toolInput = permResult.behavior === "allow" && permResult.updatedInput ? permResult.updatedInput : inputAfterHook;
+      yield {
+        type: "tool_use",
+        id: call.id,
+        name: call.name,
+        input: toolInput,
+        uuid: uuid()
+      };
+      const toolCtx = {
+        cwd,
+        signal,
+        sessionId,
+        env
+      };
+      const result = await tools.execute(call.name, toolInput, toolCtx);
+      if (debug) {
+        console.error(`[debug] Tool ${call.name}: ${result.isError ? "ERROR" : "OK"} (${result.content.length} chars)`);
+      }
+      if (hooks) {
+        if (result.isError) {
+          await hooks.fire("PostToolUseFailure", { event: "PostToolUseFailure", tool_name: call.name, tool_result: result.content, tool_error: true, session_id: sessionId }, call.id, { signal });
+        } else {
+          const postResult = await hooks.fire("PostToolUse", { event: "PostToolUse", tool_name: call.name, tool_result: result.content, session_id: sessionId }, call.id, { signal });
+          if (postResult?.additionalContext) {
+            result.content += `
+${postResult.additionalContext}`;
+          }
+        }
+      }
+      yield {
+        type: "tool_result",
+        id: call.id,
+        name: call.name,
+        content: result.content,
+        isError: result.isError,
+        uuid: uuid()
+      };
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: call.id,
+        content: result.content,
+        is_error: result.isError
+      });
+    }
+    messages.push({ role: "user", content: toolResults });
+  }
+}
+function makeError(subtype, errors, turns, costUsd, sessionId, startTime) {
+  return {
+    type: "result",
+    subtype,
+    errors,
+    turns,
+    costUsd,
+    durationMs: Date.now() - startTime,
+    sessionId,
+    uuid: uuid()
+  };
+}
+
+// src/utils/cost.ts
+var ANTHROPIC_PRICING = {
+  "claude-opus-4-6": {
+    inputPerMillion: 15,
+    outputPerMillion: 75,
+    cacheReadPerMillion: 1.5,
+    cacheWritePerMillion: 18.75
+  },
+  "claude-sonnet-4-5-20250929": {
+    inputPerMillion: 3,
+    outputPerMillion: 15,
+    cacheReadPerMillion: 0.3,
+    cacheWritePerMillion: 3.75
+  },
+  "claude-haiku-4-5-20251001": {
+    inputPerMillion: 0.8,
+    outputPerMillion: 4,
+    cacheReadPerMillion: 0.08,
+    cacheWritePerMillion: 1
+  },
+  "claude-3-5-sonnet-20241022": {
+    inputPerMillion: 3,
+    outputPerMillion: 15,
+    cacheReadPerMillion: 0.3,
+    cacheWritePerMillion: 3.75
+  },
+  "claude-3-5-haiku-20241022": {
+    inputPerMillion: 0.8,
+    outputPerMillion: 4,
+    cacheReadPerMillion: 0.08,
+    cacheWritePerMillion: 1
+  }
+};
+var ANTHROPIC_CONTEXT_WINDOWS = {
+  "claude-opus-4-6": 200000,
+  "claude-sonnet-4-5-20250929": 200000,
+  "claude-haiku-4-5-20251001": 200000,
+  "claude-3-5-sonnet-20241022": 200000,
+  "claude-3-5-haiku-20241022": 200000
+};
+var ANTHROPIC_MAX_OUTPUT = {
+  "claude-opus-4-6": 32000,
+  "claude-sonnet-4-5-20250929": 16384,
+  "claude-haiku-4-5-20251001": 8192,
+  "claude-3-5-sonnet-20241022": 8192,
+  "claude-3-5-haiku-20241022": 8192
+};
+function calculateAnthropicCost(model, usage) {
+  const pricing = findPricing(model);
+  if (!pricing)
+    return 0;
+  const inputCost = usage.inputTokens / 1e6 * pricing.inputPerMillion;
+  const outputCost = usage.outputTokens / 1e6 * pricing.outputPerMillion;
+  const cacheReadCost = usage.cacheReadInputTokens / 1e6 * (pricing.cacheReadPerMillion ?? pricing.inputPerMillion);
+  const cacheWriteCost = usage.cacheCreationInputTokens / 1e6 * (pricing.cacheWritePerMillion ?? pricing.inputPerMillion);
+  return inputCost + outputCost + cacheReadCost + cacheWriteCost;
+}
+function findPricing(model) {
+  if (ANTHROPIC_PRICING[model])
+    return ANTHROPIC_PRICING[model];
+  for (const [key, pricing] of Object.entries(ANTHROPIC_PRICING)) {
+    if (key.startsWith(model) || model.startsWith(key.split("-2025")[0])) {
+      return pricing;
+    }
+  }
+  return;
+}
+var OPENAI_PRICING = {
+  "gpt-4.1": {
+    inputPerMillion: 2,
+    outputPerMillion: 8,
+    cacheReadPerMillion: 0.5
+  },
+  "gpt-4.1-mini": {
+    inputPerMillion: 0.4,
+    outputPerMillion: 1.6,
+    cacheReadPerMillion: 0.1
+  },
+  "gpt-4.1-nano": {
+    inputPerMillion: 0.1,
+    outputPerMillion: 0.4,
+    cacheReadPerMillion: 0.025
+  },
+  "gpt-4o": {
+    inputPerMillion: 2.5,
+    outputPerMillion: 10,
+    cacheReadPerMillion: 1.25
+  },
+  "gpt-4o-mini": {
+    inputPerMillion: 0.15,
+    outputPerMillion: 0.6,
+    cacheReadPerMillion: 0.075
+  },
+  o3: {
+    inputPerMillion: 2,
+    outputPerMillion: 8,
+    cacheReadPerMillion: 0.5
+  },
+  "o3-mini": {
+    inputPerMillion: 1.1,
+    outputPerMillion: 4.4,
+    cacheReadPerMillion: 0.275
+  },
+  "o4-mini": {
+    inputPerMillion: 1.1,
+    outputPerMillion: 4.4,
+    cacheReadPerMillion: 0.275
+  }
+};
+var OPENAI_CONTEXT_WINDOWS = {
+  "gpt-4.1": 1047576,
+  "gpt-4.1-mini": 1047576,
+  "gpt-4.1-nano": 1047576,
+  "gpt-4o": 128000,
+  "gpt-4o-mini": 128000,
+  o3: 200000,
+  "o3-mini": 200000,
+  "o4-mini": 200000
+};
+var OPENAI_MAX_OUTPUT = {
+  "gpt-4.1": 32768,
+  "gpt-4.1-mini": 32768,
+  "gpt-4.1-nano": 32768,
+  "gpt-4o": 16384,
+  "gpt-4o-mini": 16384,
+  o3: 1e5,
+  "o3-mini": 1e5,
+  "o4-mini": 1e5
+};
+function calculateOpenAICost(model, usage) {
+  const pricing = findOpenAIPricing(model);
+  if (!pricing)
+    return 0;
+  const inputCost = usage.inputTokens / 1e6 * pricing.inputPerMillion;
+  const outputCost = usage.outputTokens / 1e6 * pricing.outputPerMillion;
+  const cacheReadCost = usage.cacheReadInputTokens / 1e6 * (pricing.cacheReadPerMillion ?? pricing.inputPerMillion);
+  return inputCost + outputCost + cacheReadCost;
+}
+function findOpenAIPricing(model) {
+  if (OPENAI_PRICING[model])
+    return OPENAI_PRICING[model];
+  let bestKey = "";
+  let bestPricing;
+  for (const [key, pricing] of Object.entries(OPENAI_PRICING)) {
+    if (model.startsWith(key) && key.length > bestKey.length) {
+      bestKey = key;
+      bestPricing = pricing;
+    }
+  }
+  return bestPricing;
+}
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+function isOAuthToken(key) {
+  return key.includes("sk-ant-oat");
+}
+var CLAUDE_CODE_VERSION = "2.1.2";
+
+class AnthropicAdapter {
+  name = "anthropic";
+  client;
+  oauthMode;
+  constructor(options) {
+    const key = options?.apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
+    this.oauthMode = isOAuthToken(key);
+    if (this.oauthMode) {
+      this.client = new Anthropic({
+        apiKey: null,
+        authToken: key,
+        baseURL: options?.baseUrl,
+        defaultHeaders: {
+          "anthropic-beta": "claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14",
+          "user-agent": `claude-cli/${CLAUDE_CODE_VERSION} (external, cli)`,
+          "x-app": "cli"
+        }
+      });
+    } else {
+      this.client = new Anthropic({
+        apiKey: key || undefined,
+        baseURL: options?.baseUrl
+      });
+    }
+  }
+  async* chat(request) {
+    const messages = this.convertMessages(request.messages);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    const maxTokens = request.maxTokens ?? ANTHROPIC_MAX_OUTPUT[request.model] ?? 16384;
+    const params = {
+      model: request.model,
+      messages,
+      max_tokens: maxTokens,
+      stream: true
+    };
+    if (this.oauthMode) {
+      const systemBlocks = [
+        { type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." }
+      ];
+      if (request.systemPrompt) {
+        systemBlocks.push({ type: "text", text: request.systemPrompt });
+      }
+      params.system = systemBlocks;
+    } else if (request.systemPrompt) {
+      params.system = request.systemPrompt;
+    }
+    if (tools && tools.length > 0) {
+      params.tools = tools;
+    }
+    if (request.temperature !== undefined) {
+      params.temperature = request.temperature;
+    }
+    const stream = this.client.messages.stream(params, {
+      signal: request.signal
+    });
+    const toolInputBuffers = new Map;
+    for await (const event of stream) {
+      switch (event.type) {
+        case "content_block_start": {
+          const block = event.content_block;
+          if (block.type === "tool_use") {
+            toolInputBuffers.set(event.index, {
+              id: block.id,
+              name: block.name,
+              json: ""
+            });
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const delta = event.delta;
+          if (delta.type === "text_delta") {
+            yield { type: "text_delta", text: delta.text };
+          } else if (delta.type === "input_json_delta") {
+            const buffer = toolInputBuffers.get(event.index);
+            if (buffer) {
+              buffer.json += delta.partial_json;
+            }
+          } else if (delta.type === "thinking_delta" && "thinking" in delta) {
+            yield { type: "thinking_delta", text: delta.thinking };
+          }
+          break;
+        }
+        case "content_block_stop": {
+          const buffer = toolInputBuffers.get(event.index);
+          if (buffer) {
+            let input;
+            try {
+              input = buffer.json ? JSON.parse(buffer.json) : {};
+            } catch {
+              input = {};
+            }
+            yield {
+              type: "tool_call",
+              id: buffer.id,
+              name: buffer.name,
+              input
+            };
+            toolInputBuffers.delete(event.index);
+          }
+          break;
+        }
+        case "message_delta": {
+          const stopReason = this.mapStopReason(event.delta.stop_reason);
+          if (event.usage) {
+            yield {
+              type: "usage",
+              usage: {
+                inputTokens: 0,
+                outputTokens: event.usage.output_tokens ?? 0,
+                cacheReadInputTokens: 0,
+                cacheCreationInputTokens: 0
+              }
+            };
+          }
+          yield { type: "done", stopReason };
+          break;
+        }
+        case "message_start": {
+          if (event.message.usage) {
+            yield {
+              type: "usage",
+              usage: {
+                inputTokens: event.message.usage.input_tokens ?? 0,
+                outputTokens: event.message.usage.output_tokens ?? 0,
+                cacheReadInputTokens: event.message.usage.cache_read_input_tokens ?? 0,
+                cacheCreationInputTokens: event.message.usage.cache_creation_input_tokens ?? 0
+              }
+            };
+          }
+          break;
+        }
+      }
+    }
+  }
+  calculateCost(model, usage) {
+    return calculateAnthropicCost(model, usage);
+  }
+  getContextWindow(model) {
+    return ANTHROPIC_CONTEXT_WINDOWS[model] ?? 200000;
+  }
+  supportsFeature(feature) {
+    switch (feature) {
+      case "streaming":
+      case "tool_calling":
+      case "image_input":
+      case "pdf_input":
+      case "thinking":
+      case "structured_output":
+        return true;
+      default:
+        return false;
+    }
+  }
+  convertMessages(messages) {
+    return messages.map((msg) => {
+      if (typeof msg.content === "string") {
+        return { role: msg.role, content: msg.content };
+      }
+      const content = msg.content.map((block) => {
+        switch (block.type) {
+          case "text":
+            return { type: "text", text: block.text };
+          case "tool_use":
+            return {
+              type: "tool_use",
+              id: block.id,
+              name: block.name,
+              input: block.input
+            };
+          case "tool_result":
+            return {
+              type: "tool_result",
+              tool_use_id: block.tool_use_id,
+              content: block.content,
+              is_error: block.is_error
+            };
+          default:
+            return { type: "text", text: String(block) };
+        }
+      });
+      return { role: msg.role, content };
+    });
+  }
+  convertTools(tools) {
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputSchema
+    }));
+  }
+  mapStopReason(reason) {
+    switch (reason) {
+      case "end_turn":
+        return "end_turn";
+      case "tool_use":
+        return "tool_use";
+      case "max_tokens":
+        return "max_tokens";
+      case "stop_sequence":
+        return "stop_sequence";
+      default:
+        return "end_turn";
+    }
+  }
+}
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+var CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+var CODEX_DEFAULT_MODEL = "gpt-5.3-codex";
+var CODEX_MODELS = new Set([
+  "gpt-5.3-codex",
+  "gpt-5.2-codex",
+  "gpt-5.1-codex-mini",
+  "gpt-5.1-codex-max",
+  "gpt-5.1-codex",
+  "gpt-5-codex",
+  "gpt-5-codex-mini"
+]);
+
+class OpenAIAdapter {
+  name = "openai";
+  client;
+  codexMode;
+  accountId;
+  currentAccessToken;
+  constructor(options) {
+    const key = options?.apiKey ?? process.env.OPENAI_API_KEY;
+    if (key) {
+      this.codexMode = false;
+      this.client = new OpenAI({
+        apiKey: key,
+        baseURL: options?.baseUrl
+      });
+    } else {
+      const tokens = loadTokensSync();
+      if (tokens) {
+        this.codexMode = true;
+        this.accountId = tokens.account_id;
+        this.currentAccessToken = tokens.access_token;
+        this.client = new OpenAI({
+          apiKey: tokens.access_token,
+          baseURL: options?.baseUrl ?? CODEX_BASE_URL,
+          defaultHeaders: {
+            "chatgpt-account-id": tokens.account_id,
+            originator: "codex_cli_rs"
+          }
+        });
+      } else {
+        this.codexMode = false;
+        this.client = new OpenAI({
+          apiKey: undefined,
+          baseURL: options?.baseUrl
+        });
+      }
+    }
+  }
+  async* chat(request) {
+    if (this.codexMode) {
+      yield* this.chatResponses(request);
+    } else {
+      yield* this.chatCompletions(request);
+    }
+  }
+  calculateCost(model, usage) {
+    return calculateOpenAICost(model, usage);
+  }
+  getContextWindow(model) {
+    return OPENAI_CONTEXT_WINDOWS[model] ?? 128000;
+  }
+  supportsFeature(feature) {
+    switch (feature) {
+      case "streaming":
+      case "tool_calling":
+      case "image_input":
+      case "structured_output":
+        return true;
+      case "thinking":
+      case "pdf_input":
+        return false;
+      default:
+        return false;
+    }
+  }
+  async* chatCompletions(request) {
+    const messages = this.convertMessages(request.messages, request.systemPrompt);
+    const tools = request.tools ? this.convertTools(request.tools) : undefined;
+    const maxTokens = request.maxTokens ?? OPENAI_MAX_OUTPUT[request.model] ?? 16384;
+    const params = {
+      model: request.model,
+      messages,
+      max_completion_tokens: maxTokens,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (tools && tools.length > 0) {
+      params.tools = tools;
+    }
+    if (request.temperature !== undefined) {
+      params.temperature = request.temperature;
+    }
+    const stream = await this.client.chat.completions.create(params, {
+      signal: request.signal ?? undefined
+    });
+    const toolCallBuffers = new Map;
+    let finishReason = null;
+    for await (const chunk of stream) {
+      if (chunk.usage) {
+        const cached = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+        yield {
+          type: "usage",
+          usage: {
+            inputTokens: chunk.usage.prompt_tokens - cached,
+            outputTokens: chunk.usage.completion_tokens,
+            cacheReadInputTokens: cached,
+            cacheCreationInputTokens: 0
+          }
+        };
+      }
+      const choice = chunk.choices?.[0];
+      if (!choice)
+        continue;
+      if (choice.finish_reason) {
+        finishReason = choice.finish_reason;
+      }
+      const delta = choice.delta;
+      if (delta.content) {
+        yield { type: "text_delta", text: delta.content };
+      }
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index;
+          if (!toolCallBuffers.has(idx)) {
+            toolCallBuffers.set(idx, {
+              id: tc.id ?? "",
+              name: tc.function?.name ?? "",
+              args: ""
+            });
+          }
+          const buf = toolCallBuffers.get(idx);
+          if (tc.id)
+            buf.id = tc.id;
+          if (tc.function?.name)
+            buf.name = tc.function.name;
+          if (tc.function?.arguments)
+            buf.args += tc.function.arguments;
+        }
+      }
+    }
+    for (const [, buf] of toolCallBuffers) {
+      let input;
+      try {
+        input = buf.args ? JSON.parse(buf.args) : {};
+      } catch {
+        input = {};
+      }
+      yield {
+        type: "tool_call",
+        id: buf.id,
+        name: buf.name,
+        input
+      };
+    }
+    yield { type: "done", stopReason: this.mapStopReason(finishReason) };
+  }
+  async* chatResponses(request) {
+    await this.refreshTokenIfNeeded();
+    const input = this.convertMessagesForResponses(request.messages);
+    const tools = request.tools ? this.convertToolsForResponses(request.tools) : undefined;
+    const model = CODEX_MODELS.has(request.model) ? request.model : CODEX_DEFAULT_MODEL;
+    const params = {
+      model,
+      input,
+      instructions: request.systemPrompt || "You are a helpful coding assistant.",
+      store: false,
+      stream: true
+    };
+    if (tools && tools.length > 0) {
+      params.tools = tools;
+    }
+    if (request.temperature !== undefined) {
+      params.temperature = request.temperature;
+    }
+    const stream = await this.client.responses.create(params, {
+      signal: request.signal ?? undefined
+    });
+    for await (const event of stream) {
+      switch (event.type) {
+        case "response.output_text.delta":
+          yield { type: "text_delta", text: event.delta };
+          break;
+        case "response.output_item.done": {
+          const item = event.item;
+          if (item?.type === "function_call") {
+            let parsedInput;
+            try {
+              parsedInput = item.arguments ? JSON.parse(item.arguments) : {};
+            } catch {
+              parsedInput = {};
+            }
+            yield {
+              type: "tool_call",
+              id: item.call_id,
+              name: item.name,
+              input: parsedInput
+            };
+          }
+          break;
+        }
+        case "response.completed": {
+          const resp = event.response;
+          if (resp?.usage) {
+            const u = resp.usage;
+            const cached = u.input_tokens_details?.cached_tokens ?? 0;
+            yield {
+              type: "usage",
+              usage: {
+                inputTokens: u.input_tokens - cached,
+                outputTokens: u.output_tokens,
+                cacheReadInputTokens: cached,
+                cacheCreationInputTokens: 0
+              }
+            };
+          }
+          yield { type: "done", stopReason: this.mapResponseStatus(resp) };
+          break;
+        }
+      }
+    }
+  }
+  async refreshTokenIfNeeded() {
+    if (!this.codexMode)
+      return;
+    try {
+      const { getValidToken: getValidToken2 } = await Promise.resolve().then(() => (init_openai_oauth(), exports_openai_oauth));
+      const tokens = await getValidToken2();
+      if (tokens && tokens.accessToken !== this.currentAccessToken) {
+        this.currentAccessToken = tokens.accessToken;
+        this.client = new OpenAI({
+          apiKey: tokens.accessToken,
+          baseURL: CODEX_BASE_URL,
+          defaultHeaders: {
+            "chatgpt-account-id": tokens.accountId,
+            originator: "codex_cli_rs"
+          }
+        });
+      }
+    } catch {}
+  }
+  convertMessages(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt) {
+      result.push({ role: "developer", content: systemPrompt });
+    }
+    for (const msg of messages) {
+      if (typeof msg.content === "string") {
+        result.push({ role: msg.role, content: msg.content });
+        continue;
+      }
+      if (msg.role === "assistant") {
+        const textParts = [];
+        const toolCalls = [];
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            textParts.push(block.text);
+          } else if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: JSON.stringify(block.input)
+              }
+            });
+          }
+        }
+        const assistantMsg = {
+          role: "assistant",
+          content: textParts.length > 0 ? textParts.join("") : null
+        };
+        if (toolCalls.length > 0) {
+          assistantMsg.tool_calls = toolCalls;
+        }
+        result.push(assistantMsg);
+      } else {
+        const toolResults = [];
+        const textParts = [];
+        for (const block of msg.content) {
+          if (block.type === "tool_result") {
+            toolResults.push(block);
+          } else if (block.type === "text") {
+            textParts.push(block.text);
+          }
+        }
+        for (const tr of toolResults) {
+          result.push({
+            role: "tool",
+            tool_call_id: tr.tool_use_id,
+            content: tr.content
+          });
+        }
+        if (textParts.length > 0) {
+          result.push({ role: "user", content: textParts.join("") });
+        }
+      }
+    }
+    return result;
+  }
+  convertMessagesForResponses(messages) {
+    const result = [];
+    for (const msg of messages) {
+      if (typeof msg.content === "string") {
+        result.push({ role: msg.role, content: msg.content });
+        continue;
+      }
+      if (msg.role === "assistant") {
+        const textParts = [];
+        const toolUses = [];
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            textParts.push(block.text);
+          } else if (block.type === "tool_use") {
+            toolUses.push(block);
+          }
+        }
+        if (textParts.length > 0) {
+          result.push({
+            role: "assistant",
+            content: [{ type: "output_text", text: textParts.join("") }]
+          });
+        }
+        for (const tu of toolUses) {
+          result.push({
+            type: "function_call",
+            call_id: tu.id,
+            name: tu.name,
+            arguments: JSON.stringify(tu.input)
+          });
+        }
+      } else if (msg.role === "user") {
+        const textParts = [];
+        const toolResults = [];
+        for (const block of msg.content) {
+          if (block.type === "tool_result") {
+            toolResults.push(block);
+          } else if (block.type === "text") {
+            textParts.push(block.text);
+          }
+        }
+        for (const tr of toolResults) {
+          result.push({
+            type: "function_call_output",
+            call_id: tr.tool_use_id,
+            output: tr.content
+          });
+        }
+        if (textParts.length > 0) {
+          result.push({ role: "user", content: textParts.join("") });
+        }
+      }
+    }
+    return result;
+  }
+  convertTools(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+  }
+  convertToolsForResponses(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema,
+      strict: false
+    }));
+  }
+  mapStopReason(reason) {
+    switch (reason) {
+      case "stop":
+        return "end_turn";
+      case "tool_calls":
+        return "tool_use";
+      case "length":
+        return "max_tokens";
+      default:
+        return "end_turn";
+    }
+  }
+  mapResponseStatus(response) {
+    if (!response)
+      return "end_turn";
+    const hasToolCalls = response.output?.some?.((item) => item.type === "function_call");
+    if (hasToolCalls)
+      return "tool_use";
+    if (response.status === "incomplete") {
+      const reason = response.incomplete_details?.reason;
+      if (reason === "max_output_tokens")
+        return "max_tokens";
+    }
+    return "end_turn";
+  }
+}
+function loadTokensSync() {
+  const paths = [
+    `${process.env.HOME}/.fourmis/openai-auth.json`,
+    `${process.env.HOME}/.codex/auth.json`
+  ];
+  for (const p of paths) {
+    try {
+      const fs = __require("fs");
+      const raw = fs.readFileSync(p, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.access_token && data.account_id) {
+        return data;
+      }
+    } catch {}
+  }
+  return null;
+}
+
+// src/providers/registry.ts
+var providers = new Map;
+function registerProvider(name, adapter) {
+  providers.set(name, adapter);
+}
+function getProvider(name, options) {
+  if (!options?.apiKey && !options?.baseUrl) {
+    const existing = providers.get(name);
+    if (existing)
+      return existing;
+  }
+  if (name === "anthropic") {
+    const adapter = new AnthropicAdapter(options);
+    if (!options?.apiKey && !options?.baseUrl) {
+      providers.set(name, adapter);
+    }
+    return adapter;
+  }
+  if (name === "openai") {
+    const adapter = new OpenAIAdapter(options);
+    if (!options?.apiKey && !options?.baseUrl) {
+      providers.set(name, adapter);
+    }
+    return adapter;
+  }
+  throw new Error(`Unknown provider: "${name}". Register it with registerProvider() first.`);
+}
+function listProviders() {
+  return [...providers.keys()];
+}
+
+// src/tools/registry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  getDefinitions() {
+    return [...this.tools.values()].map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema
+    }));
+  }
+  async execute(name, input, ctx) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return { content: `Unknown tool: ${name}`, isError: true };
+    }
+    try {
+      return await tool.execute(input, ctx);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Tool error: ${message}`, isError: true };
+    }
+  }
+  list() {
+    return [...this.tools.keys()];
+  }
+}
+
+// src/tools/presets.ts
+var PRESETS = {
+  coding: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"],
+  readonly: ["Read", "Glob", "Grep"],
+  minimal: ["Read", "Write", "Edit", "Glob", "Grep"]
+};
+function resolveToolNames(tools) {
+  if (!tools)
+    return PRESETS.coding;
+  if (typeof tools === "string") {
+    return PRESETS[tools] ?? [tools];
+  }
+  return tools;
+}
+
+// src/tools/bash.ts
+var DEFAULT_TIMEOUT = 120000;
+var MAX_TIMEOUT = 600000;
+var MAX_OUTPUT_LENGTH = 30000;
+var BashTool = {
+  name: "Bash",
+  description: "Executes a bash command. Use for system operations, git commands, running scripts, and other terminal tasks. " + "Working directory persists between calls. Commands timeout after 120s by default (max 600s).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "The bash command to execute"
+      },
+      description: {
+        type: "string",
+        description: "Brief description of what this command does"
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (max 600000)"
+      }
+    },
+    required: ["command"]
+  },
+  async execute(input, ctx) {
+    const { command, timeout: timeoutMs, description } = input;
+    if (!command || typeof command !== "string") {
+      return { content: "Error: command is required", isError: true };
+    }
+    const timeout = Math.min(timeoutMs ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
+    try {
+      const proc = Bun.spawn(["bash", "-c", command], {
+        cwd: ctx.cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: { ...process.env, ...ctx.env }
+      });
+      const timeoutId = setTimeout(() => {
+        proc.kill();
+      }, timeout);
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      const exitCode = await proc.exited;
+      clearTimeout(timeoutId);
+      let output = "";
+      if (stdout)
+        output += stdout;
+      if (stderr)
+        output += (output ? `
+` : "") + stderr;
+      if (output.length > MAX_OUTPUT_LENGTH) {
+        output = output.slice(0, MAX_OUTPUT_LENGTH) + `
+... (output truncated)`;
+      }
+      if (!output) {
+        output = exitCode === 0 ? "(no output)" : `Command failed with exit code ${exitCode}`;
+      }
+      return {
+        content: output,
+        isError: exitCode !== 0 ? true : undefined,
+        metadata: { exitCode }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error executing command: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/read.ts
+var MAX_LINE_LENGTH = 2000;
+var DEFAULT_LINE_LIMIT = 2000;
+var ReadTool = {
+  name: "Read",
+  description: "Reads a file from the filesystem. Returns content with line numbers (cat -n format). " + "Supports offset/limit for large files. Lines longer than 2000 chars are truncated.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "Absolute path to the file to read"
+      },
+      offset: {
+        type: "number",
+        description: "Line number to start reading from (1-based)"
+      },
+      limit: {
+        type: "number",
+        description: "Number of lines to read"
+      }
+    },
+    required: ["file_path"]
+  },
+  async execute(input, ctx) {
+    const { file_path, offset, limit } = input;
+    if (!file_path) {
+      return { content: "Error: file_path is required", isError: true };
+    }
+    const resolvedPath = resolvePath(file_path, ctx.cwd);
+    try {
+      const file = Bun.file(resolvedPath);
+      const exists = await file.exists();
+      if (!exists) {
+        return { content: `Error: File not found: ${resolvedPath}`, isError: true };
+      }
+      const text = await file.text();
+      const lines = text.split(`
+`);
+      const startLine = Math.max(1, offset ?? 1);
+      const lineLimit = limit ?? DEFAULT_LINE_LIMIT;
+      const endLine = Math.min(lines.length, startLine + lineLimit - 1);
+      const numberedLines = [];
+      for (let i = startLine - 1;i < endLine; i++) {
+        let line = lines[i];
+        if (line.length > MAX_LINE_LENGTH) {
+          line = line.slice(0, MAX_LINE_LENGTH) + "... (truncated)";
+        }
+        const lineNum = String(i + 1).padStart(6, " ");
+        numberedLines.push(`${lineNum}	${line}`);
+      }
+      return { content: numberedLines.join(`
+`) };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error reading file: ${message}`, isError: true };
+    }
+  }
+};
+function resolvePath(filePath, cwd) {
+  if (filePath.startsWith("/"))
+    return filePath;
+  return `${cwd}/${filePath}`;
+}
+
+// src/tools/write.ts
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+var WriteTool = {
+  name: "Write",
+  description: "Writes content to a file. Creates parent directories if needed. " + "Overwrites existing files.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "Absolute path to the file to write"
+      },
+      content: {
+        type: "string",
+        description: "The content to write to the file"
+      }
+    },
+    required: ["file_path", "content"]
+  },
+  async execute(input, ctx) {
+    const { file_path, content } = input;
+    if (!file_path) {
+      return { content: "Error: file_path is required", isError: true };
+    }
+    if (content === undefined || content === null) {
+      return { content: "Error: content is required", isError: true };
+    }
+    const resolvedPath = file_path.startsWith("/") ? file_path : `${ctx.cwd}/${file_path}`;
+    try {
+      const dir = dirname(resolvedPath);
+      await mkdir(dir, { recursive: true });
+      await Bun.write(resolvedPath, content);
+      const lines = content.split(`
+`).length;
+      return {
+        content: `Successfully wrote ${lines} lines to ${resolvedPath}`,
+        metadata: { path: resolvedPath, lines }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error writing file: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/edit.ts
+var EditTool = {
+  name: "Edit",
+  description: "Performs exact string replacements in files. The old_string must be unique in the file " + "unless replace_all is true. Use this for precise edits to existing files.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "Absolute path to the file to edit"
+      },
+      old_string: {
+        type: "string",
+        description: "The exact text to find and replace"
+      },
+      new_string: {
+        type: "string",
+        description: "The replacement text"
+      },
+      replace_all: {
+        type: "boolean",
+        description: "Replace all occurrences (default: false)",
+        default: false
+      }
+    },
+    required: ["file_path", "old_string", "new_string"]
+  },
+  async execute(input, ctx) {
+    const { file_path, old_string, new_string, replace_all = false } = input;
+    if (!file_path) {
+      return { content: "Error: file_path is required", isError: true };
+    }
+    if (old_string === undefined) {
+      return { content: "Error: old_string is required", isError: true };
+    }
+    if (new_string === undefined) {
+      return { content: "Error: new_string is required", isError: true };
+    }
+    if (old_string === new_string) {
+      return { content: "Error: old_string and new_string are identical", isError: true };
+    }
+    const resolvedPath = file_path.startsWith("/") ? file_path : `${ctx.cwd}/${file_path}`;
+    try {
+      const file = Bun.file(resolvedPath);
+      const exists = await file.exists();
+      if (!exists) {
+        return { content: `Error: File not found: ${resolvedPath}`, isError: true };
+      }
+      const content = await file.text();
+      let count = 0;
+      let searchFrom = 0;
+      while (true) {
+        const idx = content.indexOf(old_string, searchFrom);
+        if (idx === -1)
+          break;
+        count++;
+        searchFrom = idx + old_string.length;
+      }
+      if (count === 0) {
+        const preview = old_string.length > 100 ? old_string.slice(0, 100) + "..." : old_string;
+        return {
+          content: `Error: old_string not found in ${resolvedPath}. Searched for:
+${preview}`,
+          isError: true
+        };
+      }
+      if (count > 1 && !replace_all) {
+        return {
+          content: `Error: old_string appears ${count} times in the file. Use replace_all: true to replace all occurrences, or provide a longer string with more context to make it unique.`,
+          isError: true
+        };
+      }
+      let newContent;
+      if (replace_all) {
+        newContent = content.replaceAll(old_string, new_string);
+      } else {
+        const idx = content.indexOf(old_string);
+        newContent = content.slice(0, idx) + new_string + content.slice(idx + old_string.length);
+      }
+      await Bun.write(resolvedPath, newContent);
+      const replacements = replace_all ? count : 1;
+      return {
+        content: `Successfully replaced ${replacements} occurrence${replacements > 1 ? "s" : ""} in ${resolvedPath}`,
+        metadata: { path: resolvedPath, replacements }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error editing file: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/glob.ts
+var {Glob } = globalThis.Bun;
+var GlobTool = {
+  name: "Glob",
+  description: "Fast file pattern matching. Supports glob patterns like '**/*.ts' or 'src/**/*.tsx'. " + "Returns matching file paths sorted by modification time.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Glob pattern to match files against"
+      },
+      path: {
+        type: "string",
+        description: "Directory to search in (defaults to cwd)"
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx) {
+    const { pattern, path } = input;
+    if (!pattern) {
+      return { content: "Error: pattern is required", isError: true };
+    }
+    const searchDir = path ? path.startsWith("/") ? path : `${ctx.cwd}/${path}` : ctx.cwd;
+    try {
+      const glob = new Glob(pattern);
+      const matches = [];
+      for await (const filePath of glob.scan({ cwd: searchDir, dot: false })) {
+        try {
+          const file = Bun.file(`${searchDir}/${filePath}`);
+          const stat = await file.stat();
+          matches.push({ path: filePath, mtime: stat?.mtime?.getTime() ?? 0 });
+        } catch {
+          matches.push({ path: filePath, mtime: 0 });
+        }
+      }
+      matches.sort((a, b) => b.mtime - a.mtime);
+      if (matches.length === 0) {
+        return { content: "No files matched the pattern." };
+      }
+      const result = matches.map((m) => m.path).join(`
+`);
+      return {
+        content: result,
+        metadata: { count: matches.length }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error: ${message}`, isError: true };
+    }
+  }
+};
+
+// src/tools/grep.ts
+var GrepTool = {
+  name: "Grep",
+  description: "Search file contents using regex patterns. Supports multiple output modes: " + "'content' (matching lines), 'files_with_matches' (file paths only, default), 'count' (match counts). " + "Supports context lines, case-insensitive search, glob filtering, and head_limit.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regex pattern to search for"
+      },
+      path: {
+        type: "string",
+        description: "File or directory to search in (defaults to cwd)"
+      },
+      glob: {
+        type: "string",
+        description: "Glob pattern to filter files (e.g., '*.ts')"
+      },
+      output_mode: {
+        type: "string",
+        enum: ["content", "files_with_matches", "count"],
+        description: "Output mode (default: files_with_matches)"
+      },
+      "-i": {
+        type: "boolean",
+        description: "Case insensitive search"
+      },
+      "-n": {
+        type: "boolean",
+        description: "Show line numbers (for content mode)"
+      },
+      "-A": {
+        type: "number",
+        description: "Lines to show after each match"
+      },
+      "-B": {
+        type: "number",
+        description: "Lines to show before each match"
+      },
+      "-C": {
+        type: "number",
+        description: "Context lines before and after each match"
+      },
+      head_limit: {
+        type: "number",
+        description: "Limit output to first N entries"
+      }
+    },
+    required: ["pattern"]
+  },
+  async execute(input, ctx) {
+    const opts = input;
+    if (!opts.pattern) {
+      return { content: "Error: pattern is required", isError: true };
+    }
+    const searchPath = opts.path ? opts.path.startsWith("/") ? opts.path : `${ctx.cwd}/${opts.path}` : ctx.cwd;
+    const mode = opts.output_mode ?? "files_with_matches";
+    try {
+      return await runRipgrep(opts, searchPath, mode, ctx);
+    } catch {
+      return await runJsGrep(opts, searchPath, mode, ctx);
+    }
+  }
+};
+async function runRipgrep(opts, searchPath, mode, ctx) {
+  const args = ["rg"];
+  if (mode === "files_with_matches") {
+    args.push("-l");
+  } else if (mode === "count") {
+    args.push("-c");
+  }
+  if (opts["-i"])
+    args.push("-i");
+  if (opts["-n"] !== false && mode === "content")
+    args.push("-n");
+  if (opts["-A"])
+    args.push("-A", String(opts["-A"]));
+  if (opts["-B"])
+    args.push("-B", String(opts["-B"]));
+  if (opts["-C"])
+    args.push("-C", String(opts["-C"]));
+  if (opts.glob)
+    args.push("--glob", opts.glob);
+  args.push("--", opts.pattern, searchPath);
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, ...ctx.env }
+  });
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+  if (exitCode === 2) {
+    throw new Error(stderr || "ripgrep error");
+  }
+  let output = stdout.trim();
+  if (opts.head_limit && output) {
+    const lines = output.split(`
+`);
+    output = lines.slice(0, opts.head_limit).join(`
+`);
+  }
+  return { content: output || "No matches found." };
+}
+async function runJsGrep(opts, searchPath, mode, ctx) {
+  const flags = opts["-i"] ? "gi" : "g";
+  let regex;
+  try {
+    regex = new RegExp(opts.pattern, flags);
+  } catch (err) {
+    return { content: `Invalid regex: ${opts.pattern}`, isError: true };
+  }
+  const files = await collectFiles(searchPath, opts.glob);
+  const results = [];
+  let totalCount = 0;
+  for (const filePath of files) {
+    try {
+      const content = await Bun.file(filePath).text();
+      const lines = content.split(`
+`);
+      const matchedLines = [];
+      for (let i = 0;i < lines.length; i++) {
+        if (regex.test(lines[i])) {
+          matchedLines.push({ num: i + 1, line: lines[i] });
+          regex.lastIndex = 0;
+        }
+      }
+      if (matchedLines.length === 0)
+        continue;
+      totalCount += matchedLines.length;
+      const relativePath = filePath.startsWith(ctx.cwd) ? filePath.slice(ctx.cwd.length + 1) : filePath;
+      if (mode === "files_with_matches") {
+        results.push(relativePath);
+      } else if (mode === "count") {
+        results.push(`${relativePath}:${matchedLines.length}`);
+      } else {
+        for (const { num, line } of matchedLines) {
+          results.push(`${relativePath}:${num}:${line}`);
+        }
+      }
+    } catch {}
+    if (opts.head_limit && results.length >= opts.head_limit) {
+      break;
+    }
+  }
+  let output = results.join(`
+`);
+  if (opts.head_limit) {
+    const entries = output.split(`
+`).slice(0, opts.head_limit);
+    output = entries.join(`
+`);
+  }
+  return { content: output || "No matches found." };
+}
+async function collectFiles(dir, globPattern) {
+  const { Glob: Glob2 } = await Promise.resolve(globalThis.Bun);
+  const pattern = globPattern ?? "**/*";
+  const glob = new Glob2(pattern);
+  const files = [];
+  for await (const path of glob.scan({ cwd: dir, dot: false, onlyFiles: true })) {
+    files.push(`${dir}/${path}`);
+  }
+  return files;
+}
+// src/tools/index.ts
+var ALL_TOOLS = {
+  Bash: BashTool,
+  Read: ReadTool,
+  Write: WriteTool,
+  Edit: EditTool,
+  Glob: GlobTool,
+  Grep: GrepTool
+};
+function buildToolRegistry(toolNames, allowedTools, disallowedTools) {
+  const registry = new ToolRegistry;
+  for (const name of toolNames) {
+    if (allowedTools && !allowedTools.includes(name))
+      continue;
+    if (disallowedTools?.includes(name))
+      continue;
+    const tool = ALL_TOOLS[name];
+    if (tool) {
+      registry.register(tool);
+    }
+  }
+  return registry;
+}
+
+// src/agents/tools.ts
+function createTaskTool(ctx) {
+  return {
+    name: "Task",
+    description: "Launch a subagent to handle a task. Specify the agent type and a prompt describing what to do.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        description: {
+          type: "string",
+          description: "A short description of the task (3-5 words)."
+        },
+        prompt: {
+          type: "string",
+          description: "The detailed task prompt for the subagent."
+        },
+        subagent_type: {
+          type: "string",
+          description: "The type of agent to use. Must match a registered agent definition."
+        },
+        run_in_background: {
+          type: "boolean",
+          description: "If true, run the task in the background and return a task ID."
+        },
+        max_turns: {
+          type: "number",
+          description: "Maximum number of turns for the subagent."
+        }
+      },
+      required: ["prompt", "subagent_type"]
+    },
+    async execute(input, toolCtx) {
+      const {
+        prompt,
+        subagent_type,
+        run_in_background,
+        max_turns
+      } = input;
+      const agentDef = ctx.agents[subagent_type];
+      if (!agentDef) {
+        const available = Object.keys(ctx.agents).join(", ");
+        return {
+          content: `Unknown agent type "${subagent_type}". Available: ${available || "none"}`,
+          isError: true
+        };
+      }
+      if (ctx.parentHooks) {
+        await ctx.parentHooks.fire("SubagentStart", { event: "SubagentStart", agent_type: subagent_type, session_id: toolCtx.sessionId }, undefined, { signal: toolCtx.signal });
+      }
+      const provider = agentDef.provider ? getProvider(agentDef.provider) : ctx.parentProvider;
+      const model = agentDef.model ?? ctx.parentModel;
+      let subTools;
+      if (agentDef.tools) {
+        subTools = buildToolRegistry(agentDef.tools);
+      } else {
+        subTools = buildToolRegistry(resolveToolNames("coding"));
+      }
+      const maxTurns = max_turns ?? agentDef.maxTurns ?? 10;
+      const sessionId = uuid();
+      const abortController = new AbortController;
+      if (toolCtx.signal) {
+        toolCtx.signal.addEventListener("abort", () => abortController.abort(), { once: true });
+      }
+      const systemPrompt = `${agentDef.prompt}
+
+You are a subagent of type "${subagent_type}". ${agentDef.description}`;
+      const runAgent = async () => {
+        const messages = [];
+        let resultText = "";
+        for await (const msg of agentLoop(prompt, {
+          provider,
+          model,
+          systemPrompt,
+          tools: subTools,
+          permissions: ctx.parentPermissions,
+          cwd: ctx.parentCwd,
+          sessionId,
+          maxTurns,
+          maxBudgetUsd: 5,
+          includeStreamEvents: false,
+          signal: abortController.signal,
+          env: ctx.parentEnv,
+          debug: ctx.parentDebug,
+          hooks: ctx.parentHooks
+        })) {
+          messages.push(msg);
+          if (msg.type === "text") {
+            resultText += msg.text;
+          }
+          if (msg.type === "result" && msg.subtype === "success") {
+            resultText = msg.text ?? resultText;
+          }
+        }
+        return resultText || "Subagent completed with no text output.";
+      };
+      if (run_in_background) {
+        const taskId = uuid();
+        const task = {
+          id: taskId,
+          agentType: subagent_type,
+          status: "running",
+          abortController,
+          promise: (async () => {
+            try {
+              const result = await runAgent();
+              const t = ctx.taskManager.get(taskId);
+              if (t && t.status === "running") {
+                t.status = "completed";
+                t.result = result;
+              }
+            } catch (err) {
+              const t = ctx.taskManager.get(taskId);
+              if (t && t.status === "running") {
+                t.status = "failed";
+                t.error = err instanceof Error ? err.message : String(err);
+              }
+            }
+          })()
+        };
+        ctx.taskManager.register(task);
+        return {
+          content: `Background task started with ID: ${taskId}. Use TaskOutput to check results.`
+        };
+      }
+      try {
+        const result = await runAgent();
+        if (ctx.parentHooks) {
+          await ctx.parentHooks.fire("SubagentStop", { event: "SubagentStop", agent_type: subagent_type, session_id: toolCtx.sessionId }, undefined, { signal: toolCtx.signal });
+        }
+        return { content: result };
+      } catch (err) {
+        if (ctx.parentHooks) {
+          await ctx.parentHooks.fire("SubagentStop", { event: "SubagentStop", agent_type: subagent_type, session_id: toolCtx.sessionId }, undefined, { signal: toolCtx.signal });
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: `Subagent error: ${message}`, isError: true };
+      }
+    }
+  };
+}
+function createTaskOutputTool(taskManager) {
+  return {
+    name: "TaskOutput",
+    description: "Get the output from a background task.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task_id: {
+          type: "string",
+          description: "The ID of the background task."
+        },
+        block: {
+          type: "boolean",
+          description: "Whether to wait for the task to complete. Default: true."
+        },
+        timeout: {
+          type: "number",
+          description: "Max wait time in milliseconds. Default: 30000."
+        }
+      },
+      required: ["task_id"]
+    },
+    async execute(input) {
+      const { task_id, block = true, timeout = 30000 } = input;
+      const output = await taskManager.getOutput(task_id, block, timeout);
+      return { content: output };
+    }
+  };
+}
+function createTaskStopTool(taskManager) {
+  return {
+    name: "TaskStop",
+    description: "Stop a running background task.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task_id: {
+          type: "string",
+          description: "The ID of the background task to stop."
+        }
+      },
+      required: ["task_id"]
+    },
+    async execute(input) {
+      const { task_id } = input;
+      const stopped = taskManager.stop(task_id);
+      if (stopped) {
+        return { content: `Task "${task_id}" has been stopped.` };
+      }
+      const task = taskManager.get(task_id);
+      if (!task) {
+        return { content: `Task "${task_id}" not found.`, isError: true };
+      }
+      return { content: `Task "${task_id}" is already ${task.status}.` };
+    }
+  };
+}
+
+// src/agents/task-manager.ts
+class TaskManager {
+  tasks = new Map;
+  register(task) {
+    this.tasks.set(task.id, task);
+  }
+  get(id) {
+    return this.tasks.get(id);
+  }
+  stop(id) {
+    const task = this.tasks.get(id);
+    if (!task)
+      return false;
+    if (task.status !== "running")
+      return false;
+    task.abortController.abort();
+    task.status = "stopped";
+    return true;
+  }
+  async getOutput(id, block, timeoutMs) {
+    const task = this.tasks.get(id);
+    if (!task) {
+      return `Task "${id}" not found.`;
+    }
+    if (task.status !== "running") {
+      return this.formatOutput(task);
+    }
+    if (!block) {
+      return `Task "${id}" is still running.`;
+    }
+    const timeoutPromise = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    await Promise.race([task.promise, timeoutPromise]);
+    if (task.status === "running") {
+      return `Task "${id}" is still running (timed out after ${timeoutMs}ms).`;
+    }
+    return this.formatOutput(task);
+  }
+  list() {
+    return [...this.tasks.values()];
+  }
+  formatOutput(task) {
+    if (task.status === "failed") {
+      return `Task "${task.id}" failed: ${task.error ?? "unknown error"}`;
+    }
+    if (task.status === "stopped") {
+      return `Task "${task.id}" was stopped.`;
+    }
+    return task.result ?? `Task "${task.id}" completed with no output.`;
+  }
+}
+export {
+  createTaskTool,
+  createTaskStopTool,
+  createTaskOutputTool,
+  TaskManager
+};