@avasis-ai/synthcode 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2909 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  globToRegExp: () => globToRegExp,
+  walkDir: () => walkDir
+});
+function globToRegExp(pattern) {
+  const parts = pattern.split("/");
+  let regex = "";
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "**") {
+      regex += "(?:[^/]*(?:\\/|$))*";
+    } else {
+      const escaped = part.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+      regex += escaped + "\\/";
+    }
+  }
+  regex = regex.replace(/\\\//g, "/").replace(/\/$/, "");
+  return new RegExp(`(^|/)${regex}(/|$)`);
+}
+async function walkDir(dir, options) {
+  const maxDepth = options?.maxDepth ?? Infinity;
+  const followSymlinks = options?.followSymlinks ?? false;
+  const results = [];
+  async function walk(current, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await fs4.promises.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path4.join(current, entry.name);
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      try {
+        let stat;
+        if (entry.isSymbolicLink() && !followSymlinks) continue;
+        stat = await fs4.promises.stat(fullPath);
+        if (stat.isFile()) {
+          results.push({ path: fullPath, stat });
+        } else if (stat.isDirectory()) {
+          await walk(fullPath, depth + 1);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  await walk(dir, 0);
+  return results;
+}
+var fs4, path4;
+var init_utils = __esm({
+  "src/utils.ts"() {
+    "use strict";
+    fs4 = __toESM(require("fs"), 1);
+    path4 = __toESM(require("path"), 1);
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Agent: () => Agent,
+  AnthropicProvider: () => AnthropicProvider,
+  BaseProvider: () => BaseProvider,
+  BashTool: () => BashTool,
+  ContextManager: () => ContextManager,
+  CostTracker: () => CostTracker,
+  DEFAULT_COMPACT_THRESHOLD: () => DEFAULT_COMPACT_THRESHOLD,
+  DEFAULT_CONTEXT_WINDOW: () => DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_OUTPUT_TOKENS: () => DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_MAX_TURNS: () => DEFAULT_MAX_TURNS,
+  DEFAULT_PRICING: () => DEFAULT_PRICING,
+  FileEditTool: () => FileEditTool,
+  FileReadTool: () => FileReadTool,
+  FileWriteTool: () => FileWriteTool,
+  GlobTool: () => GlobTool,
+  GrepTool: () => GrepTool,
+  HookRunner: () => HookRunner,
+  InMemoryStore: () => InMemoryStore,
+  MAX_CONCURRENT_TOOLS: () => MAX_CONCURRENT_TOOLS,
+  MCPClient: () => MCPClient,
+  OllamaProvider: () => OllamaProvider,
+  OpenAIProvider: () => OpenAIProvider,
+  PermissionEngine: () => PermissionEngine,
+  RetryableError: () => RetryableError,
+  SQLiteStore: () => SQLiteStore,
+  ToolRegistry: () => ToolRegistry,
+  WebFetchTool: () => WebFetchTool,
+  agentLoop: () => agentLoop,
+  anthropic: () => anthropic,
+  createProvider: () => createProvider,
+  createStreamAggregator: () => createStreamAggregator,
+  defineTool: () => defineTool,
+  defineToolFromClass: () => defineToolFromClass,
+  estimateConversationTokens: () => estimateConversationTokens,
+  estimateMessageTokens: () => estimateMessageTokens,
+  estimateTokens: () => estimateTokens,
+  init: () => init,
+  loadMCPTools: () => loadMCPTools,
+  ollama: () => ollama,
+  openai: () => openai,
+  orchestrateTools: () => orchestrateTools
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types.ts
+var DEFAULT_CONTEXT_WINDOW = 2e5;
+var DEFAULT_MAX_OUTPUT_TOKENS = 16384;
+var DEFAULT_COMPACT_THRESHOLD = 0.85;
+var DEFAULT_MAX_TURNS = 100;
+var MAX_CONCURRENT_TOOLS = 10;
+
+// src/tools/orchestrator.ts
+var Semaphore = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  current = 0;
+  queue = [];
+  acquire() {
+    if (this.current < this.max) {
+      this.current++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    this.current--;
+    const next = this.queue.shift();
+    if (next) {
+      this.current++;
+      next();
+    }
+  }
+};
+function partitionToolCalls(toolCalls, registry) {
+  const batches = [];
+  let currentBatch = [];
+  let currentBatchIsConcurrent = false;
+  for (const call of toolCalls) {
+    const tool = registry.get(call.name);
+    const isConcurrent = tool ? tool.isReadOnly && tool.isConcurrencySafe : false;
+    if (isConcurrent && currentBatchIsConcurrent) {
+      currentBatch.push(call);
+    } else {
+      if (currentBatch.length > 0) {
+        batches.push(currentBatch);
+      }
+      currentBatch = [call];
+      currentBatchIsConcurrent = isConcurrent;
+    }
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
+}
+async function executeToolCall(call, registry, context, permissionCheck, abortSignal) {
+  if (abortSignal?.aborted) {
+    return {
+      id: call.id,
+      name: call.name,
+      output: "Execution aborted",
+      isError: true,
+      durationMs: 0
+    };
+  }
+  const tool = registry.get(call.name);
+  if (!tool) {
+    return {
+      id: call.id,
+      name: call.name,
+      output: `Unknown tool: ${call.name}`,
+      isError: true,
+      durationMs: 0
+    };
+  }
+  const start = performance.now();
+  try {
+    const parseResult = tool.inputSchema.safeParse(call.input);
+    if (!parseResult.success) {
+      return {
+        id: call.id,
+        name: call.name,
+        output: `Invalid input for ${call.name}: ${parseResult.error.issues.map((i) => i.message).join(", ")}`,
+        isError: true,
+        durationMs: Math.round(performance.now() - start)
+      };
+    }
+    if (permissionCheck) {
+      const allowed = await permissionCheck(call.name, call.input);
+      if (!allowed) {
+        return {
+          id: call.id,
+          name: call.name,
+          output: `Permission denied for tool: ${call.name}`,
+          isError: true,
+          durationMs: Math.round(performance.now() - start)
+        };
+      }
+    }
+    const output = await tool.execute(parseResult.data, context);
+    return {
+      id: call.id,
+      name: call.name,
+      output,
+      isError: false,
+      durationMs: Math.round(performance.now() - start)
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      id: call.id,
+      name: call.name,
+      output: `Error executing ${call.name}: ${message}`,
+      isError: true,
+      durationMs: Math.round(performance.now() - start)
+    };
+  }
+}
+async function orchestrateTools(tools, toolCalls, context, permissionCheck, abortSignal) {
+  const batches = partitionToolCalls(toolCalls, tools);
+  const results = [];
+  for (const batch of batches) {
+    if (abortSignal?.aborted) {
+      for (const call of batch) {
+        results.push({
+          id: call.id,
+          name: call.name,
+          output: "Execution aborted",
+          isError: true,
+          durationMs: 0
+        });
+      }
+      continue;
+    }
+    if (batch.length > 1) {
+      const semaphore = new Semaphore(10);
+      const promises2 = batch.map(
+        (call) => semaphore.acquire().then(async () => {
+          try {
+            return await executeToolCall(call, tools, context, permissionCheck, abortSignal);
+          } finally {
+            semaphore.release();
+          }
+        })
+      );
+      const settled = await Promise.allSettled(promises2);
+      for (let i = 0; i < settled.length; i++) {
+        const s = settled[i];
+        if (s.status === "fulfilled") {
+          results.push(s.value);
+        } else {
+          results.push({
+            id: batch[i].id,
+            name: batch[i].name,
+            output: `Unexpected error: ${s.reason instanceof Error ? s.reason.message : String(s.reason)}`,
+            isError: true,
+            durationMs: 0
+          });
+        }
+      }
+    } else {
+      const result = await executeToolCall(batch[0], tools, context, permissionCheck, abortSignal);
+      results.push(result);
+    }
+  }
+  return results;
+}
+
+// src/hooks.ts
+var HookRunner = class {
+  hooks;
+  constructor(hooks) {
+    this.hooks = hooks ?? {};
+  }
+  async runOnTurnStart(turn, messages) {
+    if (!this.hooks.onTurnStart) return messages;
+    const result = await this.hooks.onTurnStart(turn, messages);
+    return Array.isArray(result) ? result : messages;
+  }
+  async runOnTurnEnd(turn, messages) {
+    await this.hooks.onTurnEnd?.(turn, messages);
+  }
+  async runOnToolUse(name, input) {
+    if (!this.hooks.onToolUse) return { allow: true, input };
+    const result = await this.hooks.onToolUse(name, input);
+    return {
+      allow: result?.allow ?? true,
+      input: result?.input ?? input
+    };
+  }
+  async runOnToolResult(result) {
+    if (!this.hooks.onToolResult) return result.output;
+    const modified = await this.hooks.onToolResult(result);
+    return modified ?? result.output;
+  }
+  async runOnError(error, turn) {
+    if (!this.hooks.onError) return { retry: false };
+    const result = await this.hooks.onError(error, turn);
+    return { retry: result?.retry ?? false, message: result?.message };
+  }
+  async runOnCompact(result) {
+    await this.hooks.onCompact?.(result);
+  }
+};
+
+// src/loop.ts
+var DEFAULT_MAX_RETRIES = 5;
+var INITIAL_RETRY_DELAY_MS = 1e3;
+var MAX_RETRY_DELAY_MS = 3e4;
+var DOOM_LOOP_THRESHOLD = 3;
+var PRE_OVERFLOW_BUFFER = 2e4;
+var OUTPUT_MAX_LINES = 2e3;
+var OUTPUT_MAX_BYTES = 5e4;
+function parseRetryAfterMs(error) {
+  const msg = error.message ?? "";
+  const retryAfterMsMatch = msg.match(/retry-after-ms:\s*(\d+)/i);
+  if (retryAfterMsMatch) return parseInt(retryAfterMsMatch[1], 10);
+  const retryAfterMatch = msg.match(/retry-after:\s*(\d+)/i);
+  if (retryAfterMatch) return parseInt(retryAfterMatch[1], 10) * 1e3;
+  return null;
+}
+function truncateOutput(output, toolName, hasSubAgent) {
+  const lines = output.split("\n");
+  if (lines.length <= OUTPUT_MAX_LINES && output.length <= OUTPUT_MAX_BYTES) return output;
+  let truncated = "";
+  let byteCount = 0;
+  for (const line of lines) {
+    if (byteCount + line.length > OUTPUT_MAX_BYTES) break;
+    truncated += line + "\n";
+    byteCount += line.length;
+    if (byteCount > OUTPUT_MAX_BYTES) break;
+  }
+  const lineCount = truncated.split("\n").filter((l) => l.length > 0).length;
+  const suffix = hasSubAgent ? `
+
+[Output truncated: ${lineCount}/${lines.length} lines shown. Use the Task tool to have a sub-agent process the full output.]` : `
+
+[Output truncated: ${lineCount}/${lines.length} lines shown. Use Grep to search or Read with offset/limit for the full content.]`;
+  return truncated.trimEnd() + suffix;
+}
+function detectDoomLoop(messages) {
+  const recentToolCalls = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "assistant") continue;
+    if (typeof msg.content === "string") continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use") recentToolCalls.push(block);
+    }
+    if (recentToolCalls.length >= DOOM_LOOP_THRESHOLD) break;
+  }
+  if (recentToolCalls.length < DOOM_LOOP_THRESHOLD) return null;
+  const last = recentToolCalls[0];
+  return recentToolCalls.every(
+    (tc) => tc.name === last.name && JSON.stringify(tc.input) === JSON.stringify(last.input)
+  ) ? last : null;
+}
+async function* agentLoop(config) {
+  const {
+    model,
+    tools,
+    messages,
+    systemPrompt,
+    maxTurns = DEFAULT_MAX_TURNS,
+    contextManager,
+    permissionEngine,
+    cwd = process.cwd(),
+    abortSignal,
+    hooks,
+    costTracker
+  } = config;
+  const hookRunner = new HookRunner(hooks);
+  const context = { cwd, env: { ...process.env } };
+  let turns = 0;
+  let consecutiveRetries = 0;
+  const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+  let totalUsage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 };
+  let inFlightText = "";
+  let inFlightReasoning = "";
+  let inFlightToolCalls = [];
+  while (turns < maxTurns) {
+    if (abortSignal?.aborted) {
+      yield finalizeLoop("Aborted");
+      return;
+    }
+    const messagesAfterHook = await hookRunner.runOnTurnStart(turns + 1, messages);
+    if (messagesAfterHook !== messages) {
+      messages.length = 0;
+      messages.push(...messagesAfterHook);
+    }
+    const contextCheck = contextManager.check(messages);
+    if (contextCheck.needsCompact) {
+      const result = await contextManager.compact(messages);
+      messages.length = 0;
+      messages.push(...result.messages);
+      if (result.tokensSaved > 0) {
+        const thinking = `Context ${result.method}: saved ~${result.tokensSaved} tokens (${contextCheck.totalTokens} \u2192 ${contextCheck.totalTokens - result.tokensSaved})`;
+        yield { type: "thinking", thinking };
+        await hookRunner.runOnCompact(result);
+      }
+      const pruned = contextManager.pruneToolOutputs(messages);
+      if (pruned.length !== messages.length) {
+        messages.length = 0;
+        messages.push(...pruned);
+        yield { type: "thinking", thinking: "Pruned large tool outputs to free additional context" };
+      }
+    }
+    const estimatedTotal = totalUsage.inputTokens + totalUsage.outputTokens + (totalUsage.cacheReadTokens ?? 0) + (totalUsage.cacheWriteTokens ?? 0);
+    const maxContext = contextManager.maxTokens;
+    const maxOutput = contextManager.maxOutputTokens;
+    if (maxContext > 0 && estimatedTotal + maxOutput + PRE_OVERFLOW_BUFFER >= maxContext) {
+      yield { type: "thinking", thinking: "Approaching context limit, compacting preemptively..." };
+      const result = await contextManager.compact(messages);
+      messages.length = 0;
+      messages.push(...result.messages);
+      if (result.tokensSaved > 0) {
+        yield { type: "thinking", thinking: `Pre-overflow compact: freed ~${result.tokensSaved} tokens` };
+      }
+    }
+    const available = contextManager.getAvailableTokens(messages);
+    const maxTokens = Math.min(available, contextManager.maxOutputTokens);
+    if (maxTokens < 1024) {
+      yield finalizeLoop("Insufficient context window for next turn");
+      return;
+    }
+    inFlightText = "";
+    inFlightReasoning = "";
+    inFlightToolCalls = [];
+    let response;
+    try {
+      const mappedMessages = messages.map((m) => {
+        if (m.role === "tool") {
+          const toolCall = inFlightToolCalls.find((tc) => tc.id === m.tool_use_id);
+          if (toolCall) {
+            return {
+              role: "tool",
+              tool_use_id: m.role === "tool" ? m.tool_use_id : void 0,
+              is_error: m.role === "tool" ? m.is_error : void 0,
+              content: truncateOutput(
+                m.content,
+                toolCall.name,
+                tools.has("delegate_agent")
+              )
+            };
+          }
+        }
+        return {
+          role: m.role,
+          content: m.role === "tool" ? m.content : m.role === "user" ? m.content : m.content,
+          tool_use_id: m.role === "tool" ? m.tool_use_id : void 0,
+          is_error: m.role === "tool" ? m.is_error : void 0
+        };
+      });
+      response = await model.chat({
+        messages: mappedMessages,
+        tools: tools.getAPI(),
+        systemPrompt,
+        maxOutputTokens: maxTokens,
+        abortSignal
+      });
+    } catch (err) {
+      yield* flushInFlight();
+      const error = err instanceof Error ? err : new Error(String(err));
+      const hookResult = await hookRunner.runOnError(error, turns + 1);
+      if (hookResult.retry && hookResult.message) {
+        messages.push({ role: "user", content: hookResult.message });
+        turns++;
+        continue;
+      }
+      if (error.message.includes("429") || error.message.includes("529") || error.message.includes("overloaded")) {
+        consecutiveRetries++;
+        if (consecutiveRetries > maxRetries) {
+          yield { type: "error", error: new Error(`Max retries (${maxRetries}) exceeded`) };
+          return;
+        }
+        const headerDelay = parseRetryAfterMs(error);
+        const backoffDelay = headerDelay ?? Math.min(INITIAL_RETRY_DELAY_MS * 2 ** (consecutiveRetries - 1) + Math.random() * 500, MAX_RETRY_DELAY_MS);
+        yield { type: "thinking", thinking: `Rate limited, retry ${consecutiveRetries}/${maxRetries} in ${Math.round(backoffDelay)}ms...` };
+        await new Promise((r) => setTimeout(r, backoffDelay));
+        continue;
+      }
+      yield { type: "error", error };
+      return;
+    }
+    totalUsage.inputTokens += response.usage.inputTokens;
+    totalUsage.outputTokens += response.usage.outputTokens;
+    totalUsage.cacheReadTokens = (totalUsage.cacheReadTokens ?? 0) + (response.usage.cacheReadTokens ?? 0);
+    totalUsage.cacheWriteTokens = (totalUsage.cacheWriteTokens ?? 0) + (response.usage.cacheWriteTokens ?? 0);
+    if (costTracker) {
+      costTracker.record(model.model, response.usage, turns + 1);
+    }
+    const toolCalls = [];
+    for (const block of response.content) {
+      if (block.type === "text") {
+        inFlightText += block.text;
+        yield { type: "text", text: block.text };
+      } else if (block.type === "thinking") {
+        inFlightReasoning += block.thinking;
+        yield { type: "thinking", thinking: block.thinking };
+      } else if (block.type === "tool_use") {
+        const resolvedName = tools.has(block.name) ? block.name : tools.findCaseInsensitive(block.name);
+        if (!resolvedName) {
+          yield { type: "tool_result", id: block.id, name: block.name, output: `Unknown tool: ${block.name}. Available: ${tools.listNames().join(", ")}`, isError: true };
+          messages.push({ role: "assistant", content: response.content });
+          messages.push({ role: "tool", tool_use_id: block.id, content: `Unknown tool: ${block.name}`, is_error: true });
+          continue;
+        }
+        const modifiedBlock = resolvedName !== block.name ? { ...block, name: resolvedName } : block;
+        const hookToolResult = await hookRunner.runOnToolUse(modifiedBlock.name, modifiedBlock.input);
+        if (!hookToolResult.allow) {
+          yield { type: "tool_result", id: modifiedBlock.id, name: modifiedBlock.name, output: "Tool denied by hook", isError: true };
+          messages.push({ role: "assistant", content: response.content });
+          messages.push({ role: "tool", tool_use_id: modifiedBlock.id, content: "Tool denied by hook", is_error: true });
+          continue;
+        }
+        const finalBlock = { ...modifiedBlock, input: hookToolResult.input };
+        toolCalls.push(finalBlock);
+        inFlightToolCalls.push(finalBlock);
+        yield { type: "tool_use", id: finalBlock.id, name: finalBlock.name, input: finalBlock.input };
+      }
+    }
+    const hasNonToolContent = inFlightText.length > 0 || inFlightReasoning.length > 0;
+    if (!hasNonToolContent && toolCalls.length === 0) {
+      yield finalizeLoop("Assistant produced no content");
+      return;
+    }
+    const assistantContent = response.content.filter((b) => {
+      if (b.type !== "tool_use") return true;
+      return toolCalls.some((tc) => tc.id === b.id);
+    });
+    messages.push({ role: "assistant", content: assistantContent });
+    turns++;
+    consecutiveRetries = 0;
+    inFlightText = "";
+    inFlightReasoning = "";
+    inFlightToolCalls = [];
+    await hookRunner.runOnTurnEnd(turns, messages);
+    if (response.stopReason !== "tool_use" || toolCalls.length === 0) {
+      yield {
+        type: "done",
+        usage: {
+          inputTokens: totalUsage.inputTokens,
+          outputTokens: totalUsage.outputTokens,
+          cacheReadTokens: totalUsage.cacheReadTokens,
+          cacheWriteTokens: totalUsage.cacheWriteTokens
+        },
+        messages: [...messages]
+      };
+      return;
+    }
+    const doomLoopCall = detectDoomLoop(messages);
+    if (doomLoopCall) {
+      yield { type: "thinking", thinking: `Detected repetitive tool calls: ${doomLoopCall.name} called ${DOOM_LOOP_THRESHOLD} times with identical input. Breaking the loop.` };
+      messages.push({ role: "user", content: `STOP. You have called ${doomLoopCall.name} ${DOOM_LOOP_THRESHOLD} times in a row with the same input. This indicates a loop. Try a different approach or tool.` });
+      turns++;
+      continue;
+    }
+    const results = await orchestrateTools(
+      tools,
+      toolCalls,
+      context,
+      async (name, _input) => {
+        const perm = permissionEngine.check(name);
+        return perm.allowed;
+      },
+      abortSignal
+    );
+    for (const result of results) {
+      let output = truncateOutput(result.output, result.name, tools.has("delegate_agent"));
+      const toolResult = await hookRunner.runOnToolResult({
+        id: result.id,
+        name: result.name,
+        output: result.output,
+        isError: result.isError,
+        durationMs: result.durationMs
+      });
+      output = toolResult;
+      messages.push({
+        role: "tool",
+        tool_use_id: result.id,
+        content: output,
+        is_error: result.isError
+      });
+      yield {
+        type: "tool_result",
+        id: result.id,
+        name: result.name,
+        output,
+        isError: result.isError
+      };
+    }
+  }
+  yield { type: "error", error: new Error(`Max turns (${maxTurns}) reached`) };
+  function* flushInFlight() {
+    if (inFlightText.length > 0) {
+      yield { type: "text", text: inFlightText };
+    }
+    if (inFlightReasoning.length > 0) {
+      yield { type: "thinking", thinking: inFlightReasoning };
+    }
+    for (const tc of inFlightToolCalls) {
+      yield { type: "tool_result", id: tc.id, name: tc.name, output: "[Tool execution was interrupted]", isError: true };
+      messages.push({ role: "assistant", content: [{ type: "tool_use", id: tc.id, name: tc.name, input: tc.input }] });
+      messages.push({ role: "tool", tool_use_id: tc.id, content: "[Tool execution was interrupted]", is_error: true });
+    }
+  }
+  function finalizeLoop(reason) {
+    if (totalUsage.inputTokens > 0 || totalUsage.outputTokens > 0) {
+      return {
+        type: "done",
+        usage: {
+          inputTokens: totalUsage.inputTokens,
+          outputTokens: totalUsage.outputTokens,
+          cacheReadTokens: totalUsage.cacheReadTokens,
+          cacheWriteTokens: totalUsage.cacheWriteTokens
+        },
+        messages: [...messages]
+      };
+    }
+    return { type: "error", error: new Error(reason) };
+  }
+}
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor(tools) {
+    if (tools) {
+      for (const tool of tools) {
+        this.add(tool);
+      }
+    }
+  }
+  /** Add a tool to the registry. Duplicate names are ignored (first one wins). */
+  add(tool) {
+    if (this.tools.has(tool.name)) {
+      console.warn(`[ToolRegistry] Duplicate tool "${tool.name}" ignored (first one wins)`);
+      return;
+    }
+    this.tools.set(tool.name, tool);
+  }
+  /** Get a tool by name. */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /** Check if a tool exists by name. */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /** Find tool by case-insensitive name. Returns undefined if not found. */
+  findCaseInsensitive(name) {
+    const lower = name.toLowerCase();
+    if (this.tools.has(name)) return name;
+    for (const key of this.tools.keys()) {
+      if (key.toLowerCase() === lower) return key;
+    }
+    return void 0;
+  }
+  /** List all registered tool names. */
+  listNames() {
+    return Array.from(this.tools.keys());
+  }
+  /** Get all registered tools. */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /** Get all tools in API format, sorted by name for cache stability. */
+  getAPI() {
+    return this.getAll().sort((a, b) => a.name.localeCompare(b.name)).map((t) => t.toAPI());
+  }
+  /** Number of registered tools. */
+  get size() {
+    return this.tools.size;
+  }
+};
+
+// src/tools/tool.ts
+function zodToJsonSchema(schema) {
+  const s = schema;
+  const def = s._def;
+  const typeName = def.typeName;
+  const description = def.description;
+  const base = {};
+  if (description) base.description = description;
+  switch (typeName) {
+    case "ZodString":
+      return { ...base, type: "string" };
+    case "ZodNumber":
+      return { ...base, type: "number" };
+    case "ZodBoolean":
+      return { ...base, type: "boolean" };
+    case "ZodNull":
+      return { ...base, type: "null" };
+    case "ZodArray": {
+      const items = zodToJsonSchema(def.element);
+      return { ...base, type: "array", items };
+    }
+    case "ZodObject": {
+      const shapeFn = def.shape;
+      const shape = shapeFn();
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        const propDef = value._def;
+        if (propDef.typeName !== "ZodOptional" && propDef.typeName !== "ZodNullish" && propDef.typeName !== "ZodDefault") {
+          required.push(key);
+        }
+      }
+      const result = { ...base, type: "object", properties };
+      if (required.length > 0) result.required = required;
+      return result;
+    }
+    case "ZodEnum":
+      return { ...base, enum: def.values };
+    case "ZodLiteral":
+      return { ...base, const: def.value };
+    case "ZodUnion": {
+      const options = def.options.map((o) => zodToJsonSchema(o));
+      return { ...base, anyOf: options };
+    }
+    case "ZodDiscriminatedUnion": {
+      const options = def.options.map((o) => zodToJsonSchema(o));
+      return { ...base, anyOf: options };
+    }
+    case "ZodOptional":
+      return zodToJsonSchema(def.innerType);
+    case "ZodNullable": {
+      const inner = zodToJsonSchema(def.innerType);
+      inner.nullable = true;
+      return inner;
+    }
+    case "ZodNullish": {
+      const inner = zodToJsonSchema(def.innerType);
+      inner.nullable = true;
+      return inner;
+    }
+    case "ZodDefault":
+      return zodToJsonSchema(def.innerType);
+    case "ZodRecord": {
+      const valueSchema = zodToJsonSchema(def.valueType);
+      return { ...base, type: "object", additionalProperties: valueSchema };
+    }
+    case "ZodTuple": {
+      const items = def.items.map((o) => zodToJsonSchema(o));
+      return { ...base, type: "array", items, minItems: items.length, maxItems: items.length };
+    }
+    case "ZodEffects": {
+      return zodToJsonSchema(def.innerType);
+    }
+    case "ZodAny":
+      return {};
+    case "ZodUnknown":
+      return {};
+    case "ZodVoid":
+      return { ...base, type: "null" };
+    case "ZodNever":
+      return { ...base, not: {} };
+    default:
+      return { ...base, type: "string" };
+  }
+}
+function defineTool(config) {
+  const tool = {
+    name: config.name,
+    description: config.description,
+    inputSchema: config.inputSchema,
+    isReadOnly: config.isReadOnly ?? false,
+    isConcurrencySafe: config.isConcurrencySafe ?? false,
+    execute: config.execute,
+    toAPI() {
+      return {
+        name: config.name,
+        description: config.description,
+        input_schema: zodToJsonSchema(config.inputSchema)
+      };
+    },
+    toString(input) {
+      const entries = Object.entries(input).map(([k, v]) => {
+        if (typeof v === "string") return `${k}: "${v}"`;
+        if (v === void 0) return `${k}: undefined`;
+        if (v === null) return `${k}: null`;
+        return `${k}: ${String(v)}`;
+      }).join(", ");
+      return `${config.name}({ ${entries} })`;
+    }
+  };
+  return tool;
+}
+function defineToolFromClass(ctor) {
+  const instance = new ctor();
+  return {
+    name: instance.name,
+    description: instance.description,
+    inputSchema: instance.inputSchema,
+    isReadOnly: instance.isReadOnly,
+    isConcurrencySafe: instance.isConcurrencySafe,
+    execute: (input, context) => instance.execute(input, context),
+    toAPI: () => instance.toAPI(),
+    toString: (input) => instance.toString(input)
+  };
+}
+
+// src/context/tokenizer.ts
+function estimateTokens(text) {
+  const chars = text.length;
+  const words = text.split(/\s+/).filter(Boolean).length;
+  return Math.max(Math.ceil(chars / 4), Math.ceil(words * 1.3));
+}
+function estimateMessageTokens(message) {
+  if (message.role === "user") {
+    return estimateTokens(message.content) + 4;
+  }
+  if (message.role === "tool") {
+    return estimateTokens(message.content) + 4;
+  }
+  let tokens = 0;
+  for (const block of message.content) {
+    if (block.type === "text") {
+      tokens += estimateTokens(block.text) + 4;
+    } else if (block.type === "tool_use") {
+      tokens += estimateTokens(block.name) + estimateTokens(JSON.stringify(block.input)) + 4;
+    } else if (block.type === "thinking") {
+      tokens += estimateTokens(block.thinking) + 4;
+    }
+  }
+  return tokens;
+}
+function estimateConversationTokens(messages) {
+  const byRole = {};
+  let total = 0;
+  for (const message of messages) {
+    const msgTokens = estimateMessageTokens(message) + 10;
+    total += msgTokens;
+    byRole[message.role] = (byRole[message.role] ?? 0) + msgTokens;
+  }
+  return { total, byRole };
+}
+
+// src/context/manager.ts
+var PRUNE_MINIMUM = 2e4;
+var PRUNE_PROTECT_TOKENS = 4e4;
+var PROTECTED_TOOL_TYPES = /* @__PURE__ */ new Set(["skill", "delegate_agent"]);
+var RECENT_TURNS_TO_PROTECT = 2;
+var ContextManager = class {
+  maxTokens;
+  maxOutputTokens;
+  compactThreshold;
+  constructor(config) {
+    this.maxTokens = config?.maxTokens ?? DEFAULT_CONTEXT_WINDOW;
+    this.maxOutputTokens = config?.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
+    this.compactThreshold = config?.compactThreshold ?? DEFAULT_COMPACT_THRESHOLD;
+  }
+  check(messages) {
+    const { total: totalTokens } = estimateConversationTokens(messages);
+    const availableTokens = this.maxTokens - totalTokens - this.maxOutputTokens;
+    const usagePercent = totalTokens / this.maxTokens;
+    const needsCompact = usagePercent >= this.compactThreshold;
+    let recommendedMethod;
+    if (usagePercent > 0.95) {
+      recommendedMethod = "compact";
+    } else {
+      recommendedMethod = "snip";
+    }
+    return { totalTokens, availableTokens, usagePercent, needsCompact, recommendedMethod };
+  }
+  async compact(messages, summaryFn) {
+    const contextCheck = this.check(messages);
+    if (!contextCheck.needsCompact) {
+      return { messages: [...messages], tokensSaved: 0, method: "none" };
+    }
+    const originalTokens = contextCheck.totalTokens;
+    if (summaryFn && contextCheck.recommendedMethod === "compact") {
+      const recentCount = Math.max(Math.ceil(messages.length * 0.2), 1);
+      const cutoffIndex = messages.length - recentCount;
+      const oldMessages = messages.slice(0, cutoffIndex);
+      const recentMessages = messages.slice(cutoffIndex);
+      const summary = await summaryFn(oldMessages);
+      const summaryMessage = {
+        role: "user",
+        content: `Here is a summary of our previous conversation:
+${summary}`
+      };
+      const compacted = [summaryMessage, ...recentMessages];
+      const newTokens2 = estimateConversationTokens(compacted).total;
+      return {
+        messages: compacted,
+        tokensSaved: originalTokens - newTokens2,
+        method: "compact"
+      };
+    }
+    const keepFirst = 1;
+    const keepLast = 20;
+    const keepMin = keepFirst + keepLast;
+    if (messages.length <= keepMin) {
+      return { messages: [...messages], tokensSaved: 0, method: "none" };
+    }
+    let result = [...messages];
+    const targetUsage = 0.6;
+    while (result.length > keepMin) {
+      const { total } = estimateConversationTokens(result);
+      if (total / this.maxTokens < targetUsage) break;
+      const removeCount = Math.max(1, Math.floor((result.length - keepMin) * 0.3));
+      const removeEnd = Math.min(keepFirst + removeCount, result.length - keepLast);
+      result = [result[0], ...result.slice(removeEnd)];
+    }
+    const newTokens = estimateConversationTokens(result).total;
+    return {
+      messages: result,
+      tokensSaved: originalTokens - newTokens,
+      method: "snip"
+    };
+  }
+  pruneToolOutputs(messages) {
+    let totalPruned = 0;
+    let turnCount = 0;
+    const result = [...messages];
+    for (let i = result.length - 1; i >= 0; i--) {
+      const msg = result[i];
+      if (msg.role === "user") {
+        turnCount++;
+        if (turnCount <= RECENT_TURNS_TO_PROTECT) continue;
+      }
+      if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        if (block.type !== "tool_use") continue;
+        if (PROTECTED_TOOL_TYPES.has(block.name)) continue;
+        const toolResultIdx = result.findIndex(
+          (m, j) => j > i && m.role === "tool" && m.tool_use_id === block.id
+        );
+        if (toolResultIdx === -1) continue;
+        const toolResult = result[toolResultIdx];
+        const output = toolResult.content;
+        const estTokens = Math.ceil(output.length / 4);
+        if (totalPruned + estTokens >= PRUNE_MINIMUM && totalPruned >= PRUNE_PROTECT_TOKENS) {
+          return result;
+        }
+        totalPruned += estTokens;
+        result[toolResultIdx] = {
+          ...toolResult,
+          content: `[Output pruned: ${estTokens} tokens saved]`,
+          is_error: false
+        };
+      }
+    }
+    return result;
+  }
+  getAvailableTokens(messages) {
+    return this.maxTokens - estimateConversationTokens(messages).total - this.maxOutputTokens;
+  }
+  getUsagePercent(messages) {
+    return estimateConversationTokens(messages).total / this.maxTokens;
+  }
+};
+
+// src/permissions/engine.ts
+function matchPattern(pattern, toolName) {
+  if (!pattern.includes("*")) {
+    return pattern === toolName;
+  }
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  const regex = new RegExp(`^${escaped}$`);
+  return regex.test(toolName);
+}
+var PermissionEngine = class {
+  allowedPatterns;
+  deniedPatterns;
+  askPatterns;
+  defaultAction;
+  constructor(config) {
+    this.allowedPatterns = config?.allowedTools ?? [];
+    this.deniedPatterns = config?.deniedTools ?? [];
+    this.askPatterns = config?.askTools ?? [];
+    this.defaultAction = config?.defaultAction ?? "allow";
+  }
+  check(toolName, _input) {
+    for (const pattern of this.deniedPatterns) {
+      if (matchPattern(pattern, toolName)) {
+        return { allowed: false, reason: `Tool '${toolName}' matches denied pattern '${pattern}'` };
+      }
+    }
+    for (const pattern of this.allowedPatterns) {
+      if (matchPattern(pattern, toolName)) {
+        return { allowed: true };
+      }
+    }
+    for (const pattern of this.askPatterns) {
+      if (matchPattern(pattern, toolName)) {
+        return { allowed: false, reason: "ask" };
+      }
+    }
+    if (this.defaultAction === "deny") {
+      return { allowed: false, reason: `Tool '${toolName}' not explicitly allowed` };
+    }
+    if (this.defaultAction === "ask") {
+      return { allowed: false, reason: "ask" };
+    }
+    return { allowed: true };
+  }
+  addAllowed(pattern) {
+    this.allowedPatterns.push(pattern);
+  }
+  addDenied(pattern) {
+    this.deniedPatterns.push(pattern);
+  }
+  addAsk(pattern) {
+    this.askPatterns.push(pattern);
+  }
+};
+
+// src/cost/tracker.ts
+var DEFAULT_PRICING = {
+  "claude-sonnet-4-20250514": { inputCostPer1k: 3e-3, outputCostPer1k: 0.015 },
+  "claude-3-5-sonnet-20241022": { inputCostPer1k: 3e-3, outputCostPer1k: 0.015 },
+  "claude-3-5-haiku-20241022": { inputCostPer1k: 8e-4, outputCostPer1k: 4e-3 },
+  "claude-opus-4-20250514": { inputCostPer1k: 0.015, outputCostPer1k: 0.075 },
+  "gpt-4o": { inputCostPer1k: 25e-4, outputCostPer1k: 0.01 },
+  "gpt-4o-mini": { inputCostPer1k: 15e-5, outputCostPer1k: 6e-4 },
+  "gpt-4-turbo": { inputCostPer1k: 0.01, outputCostPer1k: 0.03 }
+};
+var CostTracker = class {
+  records = [];
+  pricing;
+  constructor(customPricing) {
+    this.pricing = { ...DEFAULT_PRICING, ...customPricing };
+  }
+  record(model, usage, turn, toolName) {
+    const pricing = this.pricing[model] ?? { inputCostPer1k: 1e-3, outputCostPer1k: 3e-3 };
+    this.records.push({
+      model,
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      cacheReadTokens: usage.cacheReadTokens ?? 0,
+      cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+      inputCost: usage.inputTokens / 1e3 * pricing.inputCostPer1k,
+      outputCost: usage.outputTokens / 1e3 * pricing.outputCostPer1k,
+      timestamp: Date.now(),
+      turn,
+      toolName
+    });
+  }
+  getTotal() {
+    let cost = 0;
+    let input = 0;
+    let output = 0;
+    let cacheRead = 0;
+    let cacheWrite = 0;
+    for (const r of this.records) {
+      cost += r.inputCost + r.outputCost;
+      input += r.inputTokens;
+      output += r.outputTokens;
+      cacheRead += r.cacheReadTokens;
+      cacheWrite += r.cacheWriteTokens;
+    }
+    return { cost, inputTokens: input, outputTokens: output, cacheReadTokens: cacheRead, cacheWriteTokens: cacheWrite };
+  }
+  getByModel() {
+    const byModel = {};
+    for (const r of this.records) {
+      if (!byModel[r.model]) byModel[r.model] = { cost: 0, calls: 0 };
+      byModel[r.model].cost += r.inputCost + r.outputCost;
+      byModel[r.model].calls++;
+    }
+    return byModel;
+  }
+  getByTool() {
+    const byTool = {};
+    for (const r of this.records) {
+      const key = r.toolName ?? "llm";
+      if (!byTool[key]) byTool[key] = { cost: 0, calls: 0 };
+      byTool[key].cost += r.inputCost + r.outputCost;
+      byTool[key].calls++;
+    }
+    return byTool;
+  }
+  getRecords() {
+    return [...this.records];
+  }
+  reset() {
+    this.records = [];
+  }
+  setPricing(model, pricing) {
+    this.pricing[model] = pricing;
+  }
+};
+
+// src/agent.ts
+var Agent = class _Agent {
+  model;
+  tools;
+  systemPrompt;
+  maxTurns;
+  contextManager;
+  permissionEngine;
+  permissionConfig;
+  cwd;
+  maxRetries;
+  messages = [];
+  hooks;
+  memory;
+  threadId;
+  costTracker;
+  _loaded = false;
+  _title;
+  _titleFetched = false;
+  _disableTitle = false;
+  constructor(config) {
+    this.model = config.model;
+    this.tools = new ToolRegistry(config.tools ?? []);
+    this.systemPrompt = config.systemPrompt ?? "";
+    this.maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
+    this.contextManager = new ContextManager({
+      maxTokens: config.context?.maxTokens ?? DEFAULT_CONTEXT_WINDOW,
+      maxOutputTokens: config.context?.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS,
+      compactThreshold: config.context?.compactThreshold ?? DEFAULT_COMPACT_THRESHOLD
+    });
+    this.permissionEngine = new PermissionEngine(config.permissions);
+    this.permissionConfig = config.permissions;
+    this.cwd = config.cwd ?? process.cwd();
+    this.maxRetries = config.maxRetries ?? 5;
+    const v2 = config;
+    this.hooks = v2.hooks;
+    this.memory = v2.memory;
+    this.threadId = v2.threadId;
+    this.costTracker = v2.costTracker ?? new CostTracker();
+    this._title = v2.title;
+    this._disableTitle = v2.disableTitle ?? false;
+  }
+  addTool(tool) {
+    this.tools.add(tool);
+  }
+  addMessage(message) {
+    this.messages.push(message);
+  }
+  reset() {
+    this.messages = [];
+    this._titleFetched = false;
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+  getCostTracker() {
+    return this.costTracker;
+  }
+  get title() {
+    return this._title;
+  }
+  async loadMemory() {
+    if (this._loaded || !this.memory || !this.threadId) return;
+    const stored = await this.memory.getThread(this.threadId);
+    if (stored.length > 0) {
+      this.messages = stored;
+    }
+    this._loaded = true;
+  }
+  async saveMemory() {
+    if (!this.memory || !this.threadId) return;
+    await this.memory.saveThread(this.threadId, this.messages);
+  }
+  fork(newThreadId) {
+    const forked = new _Agent({
+      model: this.model,
+      tools: this.tools.getAll(),
+      systemPrompt: this.systemPrompt,
+      maxTurns: this.maxTurns,
+      cwd: this.cwd,
+      maxRetries: this.maxRetries,
+      permissions: this.permissionConfig,
+      hooks: this.hooks,
+      memory: this.memory,
+      threadId: newThreadId,
+      costTracker: this.costTracker,
+      title: this._title,
+      context: {
+        maxTokens: this.contextManager.maxTokens,
+        maxOutputTokens: this.contextManager.maxOutputTokens,
+        compactThreshold: this.contextManager.compactThreshold
+      }
+    });
+    forked.messages = [...this.messages];
+    return forked;
+  }
+  async *run(prompt, options) {
+    await this.loadMemory();
+    const loopMessages = [...this.messages, { role: "user", content: prompt }];
+    if (!this._titleFetched && this.messages.length === 0 && !this._disableTitle) {
+      this._titleFetched = true;
+      this.generateTitle(prompt).catch(() => {
+      });
+    }
+    const loop = agentLoop({
+      model: this.model,
+      tools: this.tools,
+      messages: loopMessages,
+      systemPrompt: this.systemPrompt || void 0,
+      maxTurns: this.maxTurns,
+      contextManager: this.contextManager,
+      permissionEngine: this.permissionEngine,
+      cwd: this.cwd,
+      abortSignal: options?.abortSignal,
+      maxRetries: this.maxRetries,
+      hooks: this.hooks,
+      costTracker: this.costTracker
+    });
+    const finalMessages = [];
+    for await (const event of loop) {
+      yield event;
+      if (event.type === "done") {
+        finalMessages.length = 0;
+        finalMessages.push(...event.messages);
+      }
+    }
+    if (finalMessages.length > 0) {
+      this.messages = finalMessages;
+      await this.saveMemory();
+    }
+  }
+  async chat(prompt, options) {
+    let text = "";
+    let usage = { inputTokens: 0, outputTokens: 0 };
+    for await (const event of this.run(prompt, options)) {
+      if (event.type === "text") {
+        text += event.text;
+      }
+      if (event.type === "done") {
+        usage = {
+          inputTokens: event.usage.inputTokens,
+          outputTokens: event.usage.outputTokens
+        };
+      }
+    }
+    const total = this.costTracker.getTotal();
+    return { text, usage, messages: this.getMessages(), cost: total.cost };
+  }
+  async structured(prompt, schema, options) {
+    const maxRetries = options?.maxRetries ?? 3;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      const currentPrompt = attempt === 0 ? prompt : `${prompt}
+
+Previous attempt returned invalid JSON. Please fix and respond with valid JSON only.`;
+      const agent = new _Agent({
+        model: this.model,
+        tools: [],
+        systemPrompt: "You must respond with valid JSON matching the requested schema.",
+        maxTurns: 1,
+        cwd: this.cwd,
+        permissions: this.permissionConfig,
+        context: {
+          maxTokens: this.contextManager.maxTokens,
+          maxOutputTokens: this.contextManager.maxOutputTokens,
+          compactThreshold: this.contextManager.compactThreshold
+        },
+        costTracker: this.costTracker,
+        disableTitle: true
+      });
+      const result = await agent.chat(currentPrompt, options);
+      const jsonMatch = result.text.match(/```(?:json)?\s*([\s\S]*?)```/) ?? [null, result.text];
+      const jsonStr = jsonMatch[1] ?? result.text;
+      try {
+        const parsed = JSON.parse(jsonStr);
+        const validated = schema.safeParse(parsed);
+        if (validated.success && validated.data !== void 0) {
+          return validated.data;
+        }
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`Failed to get valid structured output after ${maxRetries} attempts`);
+  }
+  async structuredViaTool(prompt, schema, options) {
+    const { z: z8 } = await import("zod");
+    const maxRetries = options?.maxRetries ?? 3;
+    let captured;
+    const structTool = defineTool({
+      name: "structured_output",
+      description: "Return your final response in the required structured format.",
+      inputSchema: z8.object({
+        response: z8.unknown().describe("The structured JSON response")
+      }),
+      isReadOnly: true,
+      isConcurrencySafe: true,
+      execute: async (input) => {
+        captured = input.response;
+        return "Structured output captured.";
+      }
+    });
+    const agent = new _Agent({
+      model: this.model,
+      tools: [structTool],
+      systemPrompt: [
+        this.systemPrompt,
+        "You MUST call the structured_output tool with your response. Do not return plain text."
+      ].filter(Boolean).join("\n\n"),
+      maxTurns: 1,
+      cwd: this.cwd,
+      permissions: this.permissionConfig,
+      context: {
+        maxTokens: this.contextManager.maxTokens,
+        maxOutputTokens: this.contextManager.maxOutputTokens,
+        compactThreshold: this.contextManager.compactThreshold
+      },
+      costTracker: this.costTracker,
+      disableTitle: true
+    });
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      captured = void 0;
+      const currentPrompt = attempt === 0 ? prompt : `${prompt}
+
+Previous attempt failed validation. Fix your structured output and call the structured_output tool again.`;
+      await agent.chat(currentPrompt, options);
+      if (captured !== void 0) {
+        const validated = schema.safeParse(captured);
+        if (validated.success && validated.data !== void 0) {
+          return validated.data;
+        }
+      }
+    }
+    throw new Error(`Failed to get valid structured output via tool after ${maxRetries} attempts`);
+  }
+  async asTool(options) {
+    const { z: z8 } = await import("zod");
+    const allowSubAgents = options?.allowSubAgents ?? false;
+    return defineTool({
+      name: options?.name ?? "delegate_agent",
+      description: options?.description ?? `Delegate a task to a sub-agent with system prompt: ${this.systemPrompt?.slice(0, 100) ?? "none"}`,
+      inputSchema: z8.object({
+        prompt: z8.string().describe("The task to delegate")
+      }),
+      isReadOnly: true,
+      isConcurrencySafe: true,
+      execute: async (input) => {
+        const subAgent = this.fork();
+        if (!allowSubAgents) {
+          const forbiddenTools = ["delegate_agent", "task", "todowrite"];
+          const allowed = this.tools.getAll().filter((t) => !forbiddenTools.includes(t.name));
+          for (const tool of allowed) {
+            subAgent.addTool(tool);
+          }
+        }
+        const result = await subAgent.chat(input.prompt);
+        return result.text;
+      }
+    });
+  }
+  async generateTitle(prompt) {
+    try {
+      const firstLine = prompt.split("\n")[0].slice(0, 200);
+      const titleAgent = new _Agent({
+        model: this.model,
+        tools: [],
+        systemPrompt: "Generate a short, descriptive title (max 10 words) for a conversation that starts with this message. Return ONLY the title, nothing else.",
+        maxTurns: 1,
+        cwd: this.cwd,
+        costTracker: this.costTracker,
+        disableTitle: true
+      });
+      const result = await titleAgent.chat(firstLine);
+      const title = result.text.trim().replace(/^["']|["']$/g, "").slice(0, 80);
+      if (title.length > 0) {
+        this._title = title;
+      }
+    } catch {
+      this._title = prompt.slice(0, 50);
+    }
+  }
+};
+
+// src/tools/bash.ts
+var import_node_child_process = require("child_process");
+var import_zod = require("zod");
+var MAX_OUTPUT = 50 * 1024;
+var TRUNCATE_HALF = 25 * 1024;
+function truncateOutput2(output) {
+  if (output.length <= MAX_OUTPUT) return output;
+  const notice = `
+
+... [output truncated: showing first ${TRUNCATE_HALF} and last ${TRUNCATE_HALF} of ${output.length} characters] ...
+
+`;
+  return output.slice(0, TRUNCATE_HALF) + notice + output.slice(-TRUNCATE_HALF);
+}
+var BashTool = defineTool({
+  name: "bash",
+  description: "Execute a shell command. Returns stdout and stderr. Use for running build commands, git operations, package managers, and other CLI tools.",
+  inputSchema: import_zod.z.object({
+    command: import_zod.z.string().describe("The shell command to execute"),
+    timeout: import_zod.z.number().optional().describe("Timeout in milliseconds (default 120000)"),
+    workdir: import_zod.z.string().optional().describe("Working directory for the command")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ command, timeout = 12e4, workdir }, context) => {
+    return new Promise((resolve) => {
+      let settled = false;
+      const done = (result) => {
+        if (settled) return;
+        settled = true;
+        resolve(result);
+      };
+      if (context.abortSignal?.aborted) {
+        done("Command aborted before execution");
+        return;
+      }
+      const child = (0, import_node_child_process.exec)(
+        command,
+        {
+          cwd: workdir ?? context.cwd,
+          timeout,
+          maxBuffer: 10 * 1024 * 1024,
+          killSignal: "SIGKILL"
+        },
+        (error, stdout, stderr) => {
+          let output = "";
+          if (stdout) output += `STDOUT:
+${stdout}
+
+`;
+          if (stderr) output += `STDERR:
+${stderr}
+
+`;
+          output += `Exit code: ${error?.code ?? 0}`;
+          if (error && error.killed) {
+            output = `Command timed out after ${timeout}ms
+
+${output}`;
+          }
+          done(truncateOutput2(output));
+        }
+      );
+      child.on("error", (err) => {
+        done(`Failed to execute command: ${err.message}`);
+      });
+      if (context.abortSignal) {
+        context.abortSignal.addEventListener(
+          "abort",
+          () => {
+            child.kill("SIGKILL");
+            done("Command aborted");
+          },
+          { once: true }
+        );
+      }
+    });
+  }
+});
+
+// src/tools/file-read.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_zod2 = require("zod");
+var MAX_LINE_LENGTH = 2e3;
+var FileReadTool = defineTool({
+  name: "file_read",
+  description: "Read the contents of a file. Returns the file content with line numbers. Use GlobTool to find files first.",
+  inputSchema: import_zod2.z.object({
+    path: import_zod2.z.string().describe("Absolute or relative path to the file"),
+    offset: import_zod2.z.number().optional().describe("Line number to start reading from (1-indexed)"),
+    limit: import_zod2.z.number().optional().describe("Maximum number of lines to read")
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ path: filePath, offset, limit }, context) => {
+    try {
+      const resolved = import_node_path.default.isAbsolute(filePath) ? filePath : import_node_path.default.resolve(context.cwd, filePath);
+      const content = await import_promises.default.readFile(resolved, "utf-8");
+      const lines = content.split("\n");
+      const startLine = offset ? Math.max(1, offset) : 1;
+      const startIndex = startLine - 1;
+      const endIndex = limit != null ? startIndex + limit : lines.length;
+      const selected = lines.slice(startIndex, endIndex);
+      const formatted = selected.map((line, i) => {
+        const lineNum = startLine + i;
+        const truncated = line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + "..." : line;
+        return `${lineNum}: ${truncated}`;
+      }).join("\n");
+      return formatted;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return `Error: File not found: ${filePath}`;
+      }
+      if (err.code === "EISDIR") {
+        return `Error: Path is a directory: ${filePath}`;
+      }
+      return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/file-write.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_zod3 = require("zod");
+var FileWriteTool = defineTool({
+  name: "file_write",
+  description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Parent directories are created automatically.",
+  inputSchema: import_zod3.z.object({
+    path: import_zod3.z.string().describe("Path to the file"),
+    content: import_zod3.z.string().describe("Content to write")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ path: filePath, content }, context) => {
+    try {
+      const resolved = import_node_path2.default.isAbsolute(filePath) ? filePath : import_node_path2.default.resolve(context.cwd, filePath);
+      const dir = import_node_path2.default.dirname(resolved);
+      await import_promises2.default.mkdir(dir, { recursive: true });
+      await import_promises2.default.writeFile(resolved, content, "utf-8");
+      return `Wrote ${content.length} characters to ${filePath}`;
+    } catch (err) {
+      return `Error writing file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/file-edit.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_zod4 = require("zod");
+
+// src/tools/fuzzy-edit.ts
+var FuzzyEditError = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "FuzzyEditError";
+  }
+  kind;
+};
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+    }
+  }
+  return dp[m][n];
+}
+function similarity(a, b) {
+  if (a.length > 1e3 || b.length > 1e3) return a === b ? 1 : 0;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  return 1 - levenshtein(a, b) / maxLen;
+}
+function* simpleReplacer(content, find) {
+  if (content.includes(find)) yield find;
+}
+function* lineTrimmedReplacer(content, find) {
+  const lines = find.split("\n").map((l) => l.trim());
+  const contentLines = content.split("\n");
+  for (let i = 0; i <= contentLines.length - lines.length; i++) {
+    if (contentLines.slice(i, i + lines.length).every((cl, idx) => cl.trim() === lines[idx])) {
+      yield contentLines.slice(i, i + lines.length).join("\n");
+    }
+  }
+}
+function* blockAnchorReplacer(content, find) {
+  const findLines = find.split("\n");
+  const contentLines = content.split("\n");
+  if (findLines.length < 2) return;
+  const firstLine = findLines[0];
+  const lastLine = findLines[findLines.length - 1];
+  const middleLines = findLines.slice(1, -1);
+  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+    if (contentLines[i] !== firstLine) continue;
+    const endIdx = i + findLines.length - 1;
+    if (contentLines[endIdx] !== lastLine) continue;
+    const candidates = [];
+    for (let j = i + 1; j < endIdx; j++) {
+      candidates.push({ idx: j, score: 0 });
+    }
+    let totalScore = 0;
+    for (let k = 0; k < middleLines.length; k++) {
+      const contentLine = contentLines[i + 1 + k];
+      const sim = similarity(middleLines[k], contentLine);
+      totalScore += sim;
+      if (candidates[k]) candidates[k].score = sim;
+    }
+    const avgScore = totalScore / middleLines.length;
+    const threshold = candidates.length > 1 ? 0.3 : 0;
+    if (avgScore >= threshold) {
+      yield contentLines.slice(i, i + findLines.length).join("\n");
+    }
+  }
+}
+function* whitespaceNormalizedReplacer(content, find) {
+  const normFind = find.replace(/\s+/g, " ").trim();
+  if (!normFind) return;
+  const normContent = content.replace(/\s+/g, " ").trim();
+  const idx = normContent.indexOf(normFind);
+  if (idx === -1) return;
+  const firstWord = normFind.split(" ")[0];
+  const lastWord = normFind.split(" ").filter(Boolean).pop();
+  const firstIdx = content.indexOf(firstWord);
+  const lastIdx = content.lastIndexOf(lastWord);
+  if (firstIdx === -1 || lastIdx === -1 || lastIdx < firstIdx) return;
+  yield content.substring(firstIdx, lastIdx + lastWord.length);
+}
+function* indentationFlexibleReplacer(content, find) {
+  const lines = find.split("\n");
+  const minIndent = Math.min(...lines.filter((l) => l.trim().length > 0).map((l) => l.match(/^(\s*)/)?.[1].length ?? 0));
+  const dedented = lines.map((l) => l.substring(minIndent)).join("\n");
+  if (content.includes(dedented)) yield dedented;
+}
+function* escapeNormalizedReplacer(content, find) {
+  const normalized = find.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\'/g, "'");
+  if (content.includes(normalized)) yield normalized;
+}
+function* trimmedBoundaryReplacer(content, find) {
+  const trimmed = find.trim();
+  if (content.includes(trimmed)) yield trimmed;
+}
+function* contextAwareReplacer(content, find) {
+  const findLines = find.split("\n");
+  if (findLines.length < 3) return;
+  const firstLine = findLines[0].trim();
+  const lastLine = findLines[findLines.length - 1].trim();
+  const contentLines = content.split("\n");
+  for (let i = 0; i <= contentLines.length - 3; i++) {
+    if (contentLines[i].trim() !== firstLine) continue;
+    let bestEndIdx = -1;
+    let bestScore = 0;
+    for (let j = i + 2; j < contentLines.length; j++) {
+      if (contentLines[j].trim() === lastLine) {
+        const middleCount = j - i - 1;
+        let matchCount = 0;
+        for (let k = 1; k <= middleCount; k++) {
+          const fIdx = Math.floor(k / (middleCount + 1) * (findLines.length - 2));
+          if (fIdx >= 0 && fIdx < findLines.length - 2) {
+            if (similarity(contentLines[i + k].trim(), findLines[fIdx + 1].trim()) > 0.5) {
+              matchCount++;
+            }
+          }
+        }
+        const score = matchCount / middleCount;
+        if (score > bestScore) {
+          bestScore = score;
+          bestEndIdx = j;
+        }
+      }
+    }
+    if (bestEndIdx !== -1 && bestScore > 0.5) {
+      yield contentLines.slice(i, bestEndIdx + 1).join("\n");
+    }
+  }
+}
+var REPLACERS = [
+  simpleReplacer,
+  lineTrimmedReplacer,
+  blockAnchorReplacer,
+  whitespaceNormalizedReplacer,
+  indentationFlexibleReplacer,
+  escapeNormalizedReplacer,
+  trimmedBoundaryReplacer,
+  contextAwareReplacer
+];
+function fuzzyReplace(content, oldString, newString, replaceAll = false) {
+  for (const replacer of REPLACERS) {
+    for (const search of replacer(content, oldString)) {
+      const idx = content.indexOf(search);
+      if (idx === -1) continue;
+      if (replaceAll) {
+        return content.split(search).join(newString);
+      }
+      const firstIdx = content.indexOf(search);
+      const lastIdx = content.lastIndexOf(search);
+      if (firstIdx !== lastIdx) continue;
+      return content.substring(0, firstIdx) + newString + content.substring(firstIdx + search.length);
+    }
+  }
+  throw new FuzzyEditError("not_found", `Could not find match for replacement (after 8 fuzzy strategies)`);
+}
+
+// src/tools/file-edit.ts
+var FileEditTool = defineTool({
+  name: "file_edit",
+  description: "Edit an existing file by replacing a string match with new content. Uses 9-strategy fuzzy matching (exact, line-trimmed, block-anchor with Levenshtein, whitespace-normalized, indentation-flexible, escape-normalized, trimmed-boundary, context-aware, multi-occurrence) so the oldString does not need to be a perfect character-for-character match. For multi-line edits, include enough surrounding context to ensure uniqueness.",
+  inputSchema: import_zod4.z.object({
+    path: import_zod4.z.string().describe("Path to the file"),
+    oldString: import_zod4.z.string().describe("The string to find and replace (fuzzy-matched)"),
+    newString: import_zod4.z.string().describe("The replacement string"),
+    replaceAll: import_zod4.z.boolean().optional().describe("Replace all occurrences instead of just the first")
+  }),
+  isReadOnly: false,
+  isConcurrencySafe: false,
+  execute: async ({ path: filePath, oldString, newString, replaceAll = false }, context) => {
+    try {
+      const resolved = import_node_path3.default.isAbsolute(filePath) ? filePath : import_node_path3.default.resolve(context.cwd, filePath);
+      const content = await import_promises3.default.readFile(resolved, "utf-8");
+      let newContent;
+      let count = 0;
+      if (replaceAll) {
+        const occurrences = content.split(oldString).length - 1;
+        if (occurrences === 0) {
+          try {
+            newContent = fuzzyReplace(content, oldString, newString, true);
+            count = 1;
+          } catch {
+            return `Error: oldString not found in ${filePath} (tried 9 fuzzy strategies)`;
+          }
+        } else {
+          newContent = content.split(oldString).join(newString);
+          count = occurrences;
+        }
+      } else {
+        try {
+          newContent = fuzzyReplace(content, oldString, newString, false);
+          count = 1;
+        } catch (err) {
+          const kind = err.kind;
+          if (kind === "ambiguous") {
+            return `Error: Multiple matches for oldString in ${filePath}. Provide more surrounding context or set replaceAll to true.`;
+          }
+          return `Error: oldString not found in ${filePath} (tried 9 fuzzy strategies)`;
+        }
+      }
+      await import_promises3.default.writeFile(resolved, newContent, "utf-8");
+      return `Replaced ${count} occurrence(s) in ${filePath}`;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return `Error: File not found: ${filePath}`;
+      }
+      return `Error editing file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/glob.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_zod5 = require("zod");
+init_utils();
+var MAX_RESULTS = 200;
+async function walkDir2(dir) {
+  const { walkDir: walk } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+  const entries = await walk(dir);
+  return entries.map((e) => e.path);
+}
+function matchInclude(filePath, includePattern) {
+  if (!includePattern) return true;
+  const base = import_node_path4.default.basename(filePath);
+  const re = globToRegExp(includePattern);
+  return re.test(base);
+}
+var GlobTool = defineTool({
+  name: "glob",
+  description: "Find files matching a glob pattern. Returns matching file paths sorted by modification time.",
+  inputSchema: import_zod5.z.object({
+    pattern: import_zod5.z.string().describe('Glob pattern (e.g., "**/*.ts", "src/**/*.tsx")'),
+    path: import_zod5.z.string().optional().describe("Directory to search in (default: current directory)"),
+    include: import_zod5.z.string().optional().describe('File extension or pattern to include (e.g., "*.ts")')
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ pattern, path: searchPath, include }, context) => {
+    try {
+      const searchDir = searchPath ? import_node_path4.default.isAbsolute(searchPath) ? searchPath : import_node_path4.default.resolve(context.cwd, searchPath) : context.cwd;
+      const allFiles = await walkDir2(searchDir);
+      const re = globToRegExp(pattern);
+      const matched = [];
+      for (const filePath of allFiles) {
+        const relative = import_node_path4.default.relative(searchDir, filePath);
+        if (re.test(relative) && matchInclude(relative, include)) {
+          try {
+            const stat = await import_promises4.default.stat(filePath);
+            matched.push({ filePath: relative, mtimeMs: stat.mtimeMs });
+          } catch {
+            matched.push({ filePath: relative, mtimeMs: 0 });
+          }
+        }
+      }
+      matched.sort((a, b) => b.mtimeMs - a.mtimeMs);
+      const limited = matched.slice(0, MAX_RESULTS);
+      return limited.map((m) => m.filePath).join("\n");
+    } catch (err) {
+      return `Error searching files: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/grep.ts
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_zod6 = require("zod");
+init_utils();
+var MAX_MATCHES = 200;
+async function walkDir3(dir) {
+  const { walkDir: walk } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+  const entries = await walk(dir);
+  return entries.map((e) => e.path);
+}
+var GrepTool = defineTool({
+  name: "grep",
+  description: "Search file contents using a regular expression. Returns matching file paths with line numbers.",
+  inputSchema: import_zod6.z.object({
+    pattern: import_zod6.z.string().describe("Regular expression to search for"),
+    path: import_zod6.z.string().optional().describe("Directory to search in"),
+    include: import_zod6.z.string().optional().describe('File pattern to include (e.g., "*.ts")')
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ pattern, path: searchPath, include }, context) => {
+    try {
+      let regex;
+      try {
+        regex = new RegExp(pattern);
+      } catch {
+        return `Error: Invalid regular expression: ${pattern}`;
+      }
+      const searchDir = searchPath ? import_node_path5.default.isAbsolute(searchPath) ? searchPath : import_node_path5.default.resolve(context.cwd, searchPath) : context.cwd;
+      const includeRe = include ? globToRegExp(include) : null;
+      const allFiles = await walkDir3(searchDir);
+      const matches = [];
+      for (const filePath of allFiles) {
+        if (matches.length >= MAX_MATCHES) break;
+        if (includeRe) {
+          const base = import_node_path5.default.basename(filePath);
+          if (!includeRe.test(base)) continue;
+        }
+        let content;
+        try {
+          content = await import_promises5.default.readFile(filePath, "utf-8");
+        } catch {
+          continue;
+        }
+        const lines = content.split("\n");
+        const relative = import_node_path5.default.relative(searchDir, filePath);
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+          if (matches.length >= MAX_MATCHES) break;
+          const line = lines[lineIdx];
+          if (regex.test(line)) {
+            matches.push(`${relative}:${lineIdx + 1}: ${line}`);
+            regex.lastIndex = 0;
+          } else {
+            regex.lastIndex = 0;
+          }
+        }
+      }
+      if (matches.length === 0) {
+        return "No matches found.";
+      }
+      return matches.join("\n");
+    } catch (err) {
+      return `Error searching files: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/tools/web-fetch.ts
+var import_zod7 = require("zod");
+var MAX_RESPONSE_SIZE = 100 * 1024;
+var WebFetchTool = defineTool({
+  name: "web_fetch",
+  description: "Fetch content from a URL. Returns the response body as text. Supports HTTP and HTTPS.",
+  inputSchema: import_zod7.z.object({
+    url: import_zod7.z.string().url().describe("The URL to fetch"),
+    method: import_zod7.z.enum(["GET", "POST", "PUT", "DELETE"]).optional().describe("HTTP method (default: GET)"),
+    headers: import_zod7.z.record(import_zod7.z.string()).optional().describe("Request headers"),
+    body: import_zod7.z.string().optional().describe("Request body (for POST/PUT)")
+  }),
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  execute: async ({ url, method = "GET", headers, body }, context) => {
+    try {
+      if (context.abortSignal?.aborted) {
+        return "Request aborted before execution";
+      }
+      const timeoutSignal = AbortSignal.timeout(3e4);
+      let signal;
+      if (context.abortSignal) {
+        signal = AbortSignal.any([context.abortSignal, timeoutSignal]);
+      } else {
+        signal = timeoutSignal;
+      }
+      const fetchOptions = {
+        method,
+        headers,
+        signal,
+        redirect: "follow"
+      };
+      if (body && method !== "GET") {
+        fetchOptions.body = body;
+      }
+      const response = await fetch(url, fetchOptions);
+      const contentType = response.headers.get("content-type") ?? "unknown";
+      const status = response.status;
+      const text = await response.text();
+      let result = `Status: ${status}
+Content-Type: ${contentType}
+
+`;
+      if (text.length > MAX_RESPONSE_SIZE) {
+        const half = Math.floor(MAX_RESPONSE_SIZE / 2);
+        const notice = `
+
+... [response truncated: showing first ${half} and last ${half} of ${text.length} characters] ...
+
+`;
+        result += text.slice(0, half) + notice + text.slice(-half);
+      } else {
+        result += text;
+      }
+      return result;
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        return "Request aborted";
+      }
+      return `Error fetching URL: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+});
+
+// src/llm/provider.ts
+var RetryableError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "RetryableError";
+    this.cause = cause;
+  }
+};
+var BaseProvider = class {
+  model;
+  maxOutputTokens;
+  temperature;
+  constructor(config) {
+    this.model = config.model;
+    this.maxOutputTokens = config.maxOutputTokens;
+    this.temperature = config.temperature;
+  }
+  mapStopReason(reason) {
+    switch (reason) {
+      case "end_turn":
+      case "stop":
+        return "end_turn";
+      case "tool_use":
+      case "tool_calls":
+        return "tool_use";
+      case "max_tokens":
+      case "length":
+        return "max_tokens";
+      case "stop_sequence":
+        return "stop_sequence";
+      default:
+        return "end_turn";
+    }
+  }
+};
+
+// src/llm/anthropic.ts
+var AnthropicProvider = class extends BaseProvider {
+  apiKey;
+  baseURL;
+  dangerouslySkipAuth;
+  enableCaching;
+  client = null;
+  constructor(config) {
+    super(config);
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL;
+    this.dangerouslySkipAuth = config.dangerouslySkipAuth;
+    this.enableCaching = config.enableCaching ?? false;
+  }
+  async chat(request) {
+    const AnthropicSDK = (await import("@anthropic-ai/sdk")).default;
+    if (!this.client) {
+      const opts = { apiKey: this.apiKey };
+      if (this.baseURL) opts.baseURL = this.baseURL;
+      if (this.dangerouslySkipAuth) opts.dangerouslySkipAuth = true;
+      this.client = new AnthropicSDK(opts);
+    }
+    const messages = this.mapMessages(request.messages);
+    const tools = this.mapTools(request.tools);
+    const maxTokens = request.maxOutputTokens ?? this.maxOutputTokens ?? 4096;
+    const temperature = request.temperature ?? this.temperature;
+    const body = {
+      model: this.model,
+      max_tokens: maxTokens,
+      messages
+    };
+    if (request.systemPrompt) {
+      if (this.enableCaching) {
+        body.system = [
+          { type: "text", text: request.systemPrompt, cache_control: { type: "ephemeral" } }
+        ];
+      } else {
+        body.system = request.systemPrompt;
+      }
+    }
+    if (tools) body.tools = tools;
+    if (temperature !== void 0) body.temperature = temperature;
+    const reqOptions = {};
+    if (request.abortSignal) reqOptions.signal = request.abortSignal;
+    let response;
+    try {
+      response = await this.client.messages.create(body, reqOptions);
+    } catch (err) {
+      const status = err?.status;
+      const code = err?.code;
+      const isNetwork = err instanceof TypeError || typeof code === "string" && ["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT"].includes(code);
+      if (status === 429 || status === 529 || isNetwork) {
+        throw new RetryableError(
+          err instanceof Error ? err.message : String(err),
+          err instanceof Error ? err : void 0
+        );
+      }
+      throw new Error(
+        `Anthropic API error: ${err instanceof Error ? err.message : String(err)}`,
+        err instanceof Error ? { cause: err } : void 0
+      );
+    }
+    const content = [];
+    for (const block of response.content) {
+      if (block.type === "text") {
+        content.push({ type: "text", text: block.text });
+      } else if (block.type === "tool_use") {
+        content.push({ type: "tool_use", id: block.id, name: block.name, input: block.input });
+      } else if (block.type === "thinking") {
+        content.push({ type: "thinking", thinking: block.thinking });
+      }
+    }
+    return {
+      content,
+      usage: this.mapUsage(response.usage),
+      stopReason: this.mapStopReason(response.stop_reason)
+    };
+  }
+  mapMessages(messages) {
+    return messages.map((msg) => {
+      if (msg.role === "tool") {
+        const textContent = typeof msg.content === "string" ? msg.content : msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        return {
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: msg.tool_use_id ?? "",
+              content: textContent,
+              ...msg.is_error ? { is_error: true } : {}
+            }
+          ]
+        };
+      }
+      if (msg.role === "assistant") {
+        const content = typeof msg.content === "string" ? [{ type: "text", text: msg.content }] : msg.content.map((block) => this.mapOutgoingBlock(block));
+        return { role: "assistant", content };
+      }
+      if (typeof msg.content === "string") {
+        return { role: "user", content: msg.content };
+      }
+      return {
+        role: "user",
+        content: msg.content.map((block) => this.mapOutgoingBlock(block))
+      };
+    });
+  }
+  mapTools(tools) {
+    if (!tools || tools.length === 0) return void 0;
+    return tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.input_schema,
+      type: "tool"
+    }));
+  }
+  mapUsage(providerUsage) {
+    const u = providerUsage;
+    return {
+      inputTokens: u.input_tokens,
+      outputTokens: u.output_tokens,
+      cacheReadTokens: u.cache_read_input_tokens,
+      cacheWriteTokens: u.cache_creation_input_tokens
+    };
+  }
+  mapOutgoingBlock(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 "thinking":
+        return { type: "thinking", thinking: block.thinking };
+      default:
+        return { type: "text", text: "" };
+    }
+  }
+};
+
+// src/llm/openai.ts
+var OpenAIProvider = class extends BaseProvider {
+  apiKey;
+  baseURL;
+  organization;
+  client = null;
+  constructor(config) {
+    super(config);
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL;
+    this.organization = config.organization;
+  }
+  async chat(request) {
+    const OpenAI = (await import("openai")).default;
+    if (!this.client) {
+      const opts = { apiKey: this.apiKey };
+      if (this.baseURL) opts.baseURL = this.baseURL;
+      if (this.organization) opts.organization = this.organization;
+      this.client = new OpenAI(opts);
+    }
+    const mappedMessages = this.mapMessages(request.messages);
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    messages.push(...mappedMessages);
+    const tools = this.mapTools(request.tools);
+    const maxTokens = request.maxOutputTokens ?? this.maxOutputTokens;
+    const temperature = request.temperature ?? this.temperature;
+    const body = {
+      model: this.model,
+      messages,
+      stream: false
+    };
+    if (tools) body.tools = tools;
+    if (maxTokens !== void 0) body.max_tokens = maxTokens;
+    if (temperature !== void 0) body.temperature = temperature;
+    const reqOptions = {};
+    if (request.abortSignal) reqOptions.signal = request.abortSignal;
+    let response;
+    try {
+      response = await this.client.chat.completions.create(body, reqOptions);
+    } catch (err) {
+      const status = err?.status;
+      const code = err?.code;
+      const isNetwork = err instanceof TypeError || typeof code === "string" && ["ECONNRESET", "ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT"].includes(code);
+      if (status === 429 || isNetwork) {
+        throw new RetryableError(
+          err instanceof Error ? err.message : String(err),
+          err instanceof Error ? err : void 0
+        );
+      }
+      throw new Error(
+        `OpenAI API error: ${err instanceof Error ? err.message : String(err)}`,
+        err instanceof Error ? { cause: err } : void 0
+      );
+    }
+    const choice = response.choices[0];
+    const content = [];
+    if (choice.message.content) {
+      content.push({ type: "text", text: choice.message.content });
+    }
+    if (choice.message.tool_calls) {
+      for (const tc of choice.message.tool_calls) {
+        let input = {};
+        try {
+          input = JSON.parse(tc.function.arguments);
+        } catch {
+        }
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input
+        });
+      }
+    }
+    return {
+      content,
+      usage: this.mapUsage(response.usage),
+      stopReason: this.mapStopReason(choice.finish_reason)
+    };
+  }
+  mapMessages(messages) {
+    return messages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          role: "tool",
+          tool_call_id: msg.tool_use_id ?? "",
+          content: typeof msg.content === "string" ? msg.content : msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n")
+        };
+      }
+      if (msg.role === "assistant") {
+        if (typeof msg.content === "string") {
+          return { role: "assistant", content: msg.content };
+        }
+        const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
+          id: b.id,
+          type: "function",
+          function: { name: b.name, arguments: JSON.stringify(b.input) }
+        }));
+        return {
+          role: "assistant",
+          content: textParts || null,
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        };
+      }
+      return {
+        role: "user",
+        content: typeof msg.content === "string" ? msg.content : msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n")
+      };
+    });
+  }
+  mapTools(tools) {
+    if (!tools || tools.length === 0) return void 0;
+    return tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema
+      }
+    }));
+  }
+  mapUsage(providerUsage) {
+    const u = providerUsage;
+    return {
+      inputTokens: u.prompt_tokens,
+      outputTokens: u.completion_tokens,
+      cacheReadTokens: u.prompt_tokens_details?.cached_tokens
+    };
+  }
+};
+
+// src/llm/ollama.ts
+var OllamaProvider = class {
+  model;
+  baseURL;
+  constructor(config) {
+    this.model = config.model;
+    this.baseURL = config.baseURL ?? "http://localhost:11434/v1";
+  }
+  async chat(request) {
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    for (const m of request.messages) {
+      if (m.role === "tool") {
+        messages.push({
+          role: "tool",
+          tool_call_id: m.tool_use_id,
+          content: m.content
+        });
+        continue;
+      }
+      if (m.role === "assistant" && Array.isArray(m.content)) {
+        const textParts = m.content.filter((b) => b.type === "text");
+        const toolParts = m.content.filter((b) => b.type === "tool_use");
+        const msg = {};
+        if (textParts.length > 0) {
+          msg.content = textParts.map((p) => p.text).join("");
+        }
+        if (toolParts.length > 0) {
+          msg.tool_calls = toolParts.map((b) => {
+            const tb = b;
+            return {
+              id: tb.id,
+              type: "function",
+              function: { name: tb.name, arguments: JSON.stringify(tb.input) }
+            };
+          });
+        }
+        msg.role = "assistant";
+        messages.push(msg);
+        continue;
+      }
+      messages.push({ role: m.role, content: m.content });
+    }
+    const body = {
+      model: this.model,
+      messages,
+      stream: false
+    };
+    if (request.maxOutputTokens) {
+      body.max_tokens = request.maxOutputTokens;
+    }
+    if (request.tools?.length) {
+      body.tools = request.tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.input_schema
+        }
+      }));
+    }
+    let response;
+    try {
+      response = await fetch(`${this.baseURL}/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: request.abortSignal
+      });
+    } catch (err) {
+      if (err instanceof RetryableError) throw err;
+      throw new RetryableError(
+        `Ollama connection failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!response.ok) {
+      const text = await response.text();
+      if (response.status === 429 || response.status === 503 || response.status === 529) {
+        throw new RetryableError(`Ollama API error ${response.status}: ${text.slice(0, 200)}`);
+      }
+      throw new Error(`Ollama API error ${response.status}: ${text.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      throw new Error("Ollama returned no choices");
+    }
+    const content = [];
+    let stopReason = "end_turn";
+    if (choice.message?.content) {
+      let text = choice.message.content;
+      text = text.replace(/<think[^>]*>[\s\S]*?<\/think>/gi, "").trim();
+      text = text.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+      text = text.replace(/\[Thinking[^\]]*\]/gi, "").trim();
+      if (text.length > 0) {
+        content.push({ type: "text", text });
+      }
+    }
+    if (choice.message?.tool_calls?.length) {
+      stopReason = "tool_use";
+      for (const tc of choice.message.tool_calls) {
+        let input;
+        try {
+          input = JSON.parse(tc.function.arguments);
+        } catch {
+          input = {};
+        }
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input
+        });
+      }
+    }
+    return {
+      content,
+      stopReason,
+      usage: {
+        inputTokens: data.usage?.prompt_tokens ?? 0,
+        outputTokens: data.usage?.completion_tokens ?? 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0
+      }
+    };
+  }
+};
+
+// src/llm/index.ts
+function anthropic(config) {
+  return new AnthropicProvider(config);
+}
+function openai(config) {
+  return new OpenAIProvider(config);
+}
+function ollama(config) {
+  return new OllamaProvider(config);
+}
+var CustomProvider = class {
+  model;
+  chatFn;
+  constructor(config) {
+    this.model = config.model;
+    this.chatFn = config.chat;
+  }
+  chat(request) {
+    return this.chatFn(request);
+  }
+};
+function createProvider(config) {
+  switch (config.provider) {
+    case "anthropic":
+      return new AnthropicProvider(config);
+    case "openai":
+      return new OpenAIProvider(config);
+    case "ollama":
+      return new OllamaProvider(config);
+    case "custom":
+      return new CustomProvider(config);
+  }
+}
+
+// src/stream.ts
+function createStreamAggregator() {
+  let text = "";
+  const toolCalls = /* @__PURE__ */ new Map();
+  let usage;
+  let stopReason = "end_turn";
+  function push(event) {
+    switch (event.type) {
+      case "text_delta":
+        text += event.text ?? "";
+        break;
+      case "tool_use_start":
+        if (event.id) {
+          toolCalls.set(event.id, { id: event.id, name: event.name ?? "", input: event.input ?? "" });
+        }
+        stopReason = "tool_use";
+        break;
+      case "tool_use_delta":
+        if (event.id && toolCalls.has(event.id)) {
+          toolCalls.get(event.id).input += event.input ?? "";
+        }
+        break;
+      case "done":
+        usage = event.usage;
+        break;
+      case "tool_result":
+        break;
+      case "error":
+        break;
+    }
+  }
+  function getResponse() {
+    return { text, toolCalls: Array.from(toolCalls.values()), usage, stopReason };
+  }
+  return { push, getResponse };
+}
+
+// src/memory/store.ts
+var InMemoryStore = class {
+  threads = /* @__PURE__ */ new Map();
+  async getThread(threadId) {
+    return this.threads.get(threadId)?.messages ?? [];
+  }
+  async saveThread(threadId, messages) {
+    this.threads.set(threadId, { messages, updatedAt: Date.now() });
+  }
+  async appendMessage(threadId, message) {
+    const thread = this.threads.get(threadId);
+    if (thread) {
+      thread.messages.push(message);
+      thread.updatedAt = Date.now();
+    } else {
+      this.threads.set(threadId, { messages: [message], updatedAt: Date.now() });
+    }
+  }
+  async listThreads(opts) {
+    let entries = Array.from(this.threads.entries()).map(([id, data]) => ({ id, updatedAt: data.updatedAt, messageCount: data.messages.length })).sort((a, b) => b.updatedAt - a.updatedAt);
+    if (opts?.before) entries = entries.filter((e) => e.updatedAt < parseInt(opts.before, 10));
+    return entries.slice(0, opts?.limit ?? 100);
+  }
+  async deleteThread(threadId) {
+    this.threads.delete(threadId);
+  }
+};
+
+// src/memory/sqlite.ts
+function jsonSerialize(messages) {
+  return JSON.stringify(messages, (_, value) => {
+    if (value === void 0) return "__UNDEFINED__";
+    return value;
+  });
+}
+function jsonDeserialize(str) {
+  return JSON.parse(str, (_, value) => {
+    if (value === "__UNDEFINED__") return void 0;
+    return value;
+  });
+}
+var SQLiteStore = class {
+  store;
+  constructor(dbPath) {
+    try {
+      const Database = require("better-sqlite3");
+      const db = new Database(dbPath ?? "./synth-memory.db");
+      db.pragma("journal_mode = WAL");
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS threads (
+          id TEXT PRIMARY KEY,
+          messages TEXT NOT NULL,
+          updated_at INTEGER NOT NULL,
+          message_count INTEGER NOT NULL DEFAULT 0
+        )
+      `);
+      try {
+        db.exec("ALTER TABLE threads ADD COLUMN message_count INTEGER NOT NULL DEFAULT 0");
+      } catch {
+      }
+      this.store = {
+        async getThread(threadId) {
+          const row = db.prepare("SELECT messages FROM threads WHERE id = ?").get(threadId);
+          if (!row) return [];
+          return jsonDeserialize(row.messages);
+        },
+        async saveThread(threadId, messages) {
+          const now = Date.now();
+          const json = jsonSerialize(messages);
+          const msgCount = messages.length;
+          const exists = db.prepare("SELECT 1 FROM threads WHERE id = ?").get(threadId);
+          const stmt = exists ? db.prepare("UPDATE threads SET messages = ?, updated_at = ?, message_count = ? WHERE id = ?") : db.prepare("INSERT INTO threads (id, messages, updated_at, message_count) VALUES (?, ?, ?, ?)");
+          stmt.run(json, now, msgCount, threadId);
+        },
+        async appendMessage(threadId, message) {
+          const row = db.prepare("SELECT messages FROM threads WHERE id = ?").get(threadId);
+          const messages = row ? jsonDeserialize(row.messages) : [];
+          messages.push(message);
+          const json = jsonSerialize(messages);
+          const now = Date.now();
+          db.prepare("INSERT INTO threads (id, messages, updated_at, message_count) VALUES (?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET messages = excluded.messages, updated_at = excluded.updated_at, message_count = excluded.message_count").run(threadId, json, now, messages.length);
+        },
+        async listThreads(opts) {
+          const rows = db.prepare("SELECT id, updated_at, message_count FROM threads ORDER BY updated_at DESC").all();
+          let results = rows.map((r) => ({ id: r.id, updatedAt: r.updated_at, messageCount: r.message_count }));
+          if (opts?.before) results = results.filter((e) => e.updatedAt < parseInt(opts.before, 10));
+          return results.slice(0, opts?.limit ?? 100);
+        },
+        async deleteThread(threadId) {
+          db.prepare("DELETE FROM threads WHERE id = ?").run(threadId);
+        }
+      };
+    } catch {
+      console.warn("[synth] better-sqlite3 not available, falling back to in-memory store. Install it with: npm install better-sqlite3");
+      this.store = new InMemoryStore();
+    }
+  }
+  async getThread(threadId) {
+    return this.store.getThread(threadId);
+  }
+  async saveThread(threadId, messages) {
+    return this.store.saveThread(threadId, messages);
+  }
+  async appendMessage(threadId, message) {
+    return this.store.appendMessage(threadId, message);
+  }
+  async listThreads(opts) {
+    return this.store.listThreads(opts);
+  }
+  async deleteThread(threadId) {
+    return this.store.deleteThread(threadId);
+  }
+};
+
+// src/mcp/client.ts
+var MCPClient = class {
+  config;
+  tools = [];
+  proc = null;
+  initialized = false;
+  nextId = 1;
+  messageBuffer = "";
+  pendingHandlers = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  send(proc, method, params, id) {
+    const msgId = id ?? this.nextId++;
+    const msg = JSON.stringify({ jsonrpc: "2.0", id: msgId, method, params });
+    proc.stdin.write(msg + "\n");
+    return msgId;
+  }
+  setupMessageHandler(proc) {
+    proc.stdout.on("data", (data) => {
+      this.messageBuffer += data.toString();
+      const lines = this.messageBuffer.split("\n");
+      this.messageBuffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id !== void 0 && this.pendingHandlers.has(msg.id)) {
+            const handler = this.pendingHandlers.get(msg.id);
+            this.pendingHandlers.delete(msg.id);
+            handler(msg);
+          } else if (msg.method === "initialize" && msg.id) {
+            proc.stdin.write(JSON.stringify({
+              jsonrpc: "2.0",
+              id: msg.id,
+              result: { protocolVersion: "2024-11-05", capabilities: {}, serverInfo: { name: "synthcode-mcp-proxy", version: "0.6.0" } }
+            }) + "\n");
+          }
+        } catch {
+        }
+      }
+    });
+    proc.stderr.on("data", () => {
+    });
+  }
+  async connect() {
+    if (this.config.type === "stdio") {
+      const { spawn } = await import("child_process");
+      const proc = spawn(this.config.command, this.config.args ?? [], {
+        env: { ...process.env, ...this.config.env },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      proc.on("error", (err) => {
+        throw err;
+      });
+      proc.on("close", () => {
+        this.initialized = false;
+      });
+      this.proc = proc;
+      this.setupMessageHandler(proc);
+      await new Promise((resolve) => {
+        const handler = (_data) => {
+          proc.stdout.off("data", handler);
+          resolve();
+        };
+        proc.stdout.on("data", handler);
+        setTimeout(() => {
+          proc.stdout.off("data", handler);
+          resolve();
+        }, 2e3);
+      });
+      this.initialized = true;
+    }
+    if (this.config.type === "sse") {
+      if (!this.config.url) throw new Error("SSE MCP server requires a url");
+      this.initialized = true;
+    }
+  }
+  async listTools() {
+    if (this.config.type === "stdio" && this.proc) {
+      const id = this.nextId++;
+      const tools = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.pendingHandlers.delete(id);
+          reject(new Error("MCP listTools timeout"));
+        }, 1e4);
+        this.pendingHandlers.set(id, (msg) => {
+          clearTimeout(timeout);
+          const m = msg;
+          if (m.result?.tools) {
+            resolve(
+              m.result.tools.map((t) => ({
+                name: t.name,
+                description: t.description ?? "",
+                inputSchema: t.inputSchema ?? { type: "object", properties: {} }
+              }))
+            );
+          } else {
+            resolve([]);
+          }
+        });
+      });
+      this.send(this.proc, "tools/list", {}, id);
+      this.tools = tools;
+      return tools;
+    }
+    return [];
+  }
+  async callTool(name, input) {
+    if (this.config.type === "stdio" && this.proc) {
+      const id = this.nextId++;
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.pendingHandlers.delete(id);
+          reject(new Error("MCP callTool timeout"));
+        }, 3e4);
+        this.pendingHandlers.set(id, (msg) => {
+          clearTimeout(timeout);
+          const m = msg;
+          if (m.result) {
+            resolve(typeof m.result === "string" ? m.result : JSON.stringify(m.result));
+          } else if (m.error) {
+            reject(
+              new Error(
+                m.error.message ?? "MCP tool error"
+              )
+            );
+          }
+        });
+        this.send(this.proc, "tools/call", { name, arguments: input }, id);
+      });
+    }
+    throw new Error("MCP callTool not implemented for SSE type");
+  }
+  async disconnect() {
+    if (this.proc) {
+      this.proc.kill();
+      this.proc = null;
+    }
+  }
+  getTools() {
+    return this.tools;
+  }
+};
+
+// src/mcp/adapter.ts
+async function loadMCPTools(config) {
+  const { z: z8 } = await import("zod");
+  const client = new MCPClient(config);
+  await client.connect();
+  const definitions = await client.listTools();
+  const tools = definitions.map(
+    (def) => defineTool({
+      name: def.name,
+      description: def.description,
+      inputSchema: z8.object({}).passthrough(),
+      isReadOnly: true,
+      isConcurrencySafe: true,
+      execute: async (input, _context) => {
+        const result = await client.callTool(def.name, input);
+        return result;
+      }
+    })
+  );
+  return { tools, client };
+}
+
+// src/cli/init.ts
+var fs7 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+var import_node_child_process2 = require("child_process");
+var PACKAGE_JSON = JSON.stringify(
+  {
+    name: "my-agent",
+    version: "1.0.0",
+    type: "module",
+    scripts: {
+      start: "npx tsx src/index.ts",
+      test: "npx vitest run",
+      typecheck: "tsc --noEmit"
+    },
+    dependencies: {
+      "@avasis-ai/synthcode": "^0.6.0",
+      zod: "^3.24.0"
+    },
+    devDependencies: {
+      typescript: "^5.7.0",
+      tsx: "^4.19.0",
+      vitest: "^2.1.0"
+    }
+  },
+  null,
+  2
+);
+var TSCONFIG_JSON = JSON.stringify(
+  {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      outDir: "./dist",
+      rootDir: "./src",
+      declaration: true
+    },
+    include: ["src"]
+  },
+  null,
+  2
+);
+var ENV_EXAMPLE = `# Pick one provider and set its key:
+# ANTHROPIC_API_KEY=your-key-here
+# OPENAI_API_KEY=your-key-here
+# For Ollama (local, zero API costs): no key needed
+`;
+var INDEX_TS = `import { Agent, BashTool, FileReadTool, FileWriteTool, FileEditTool, GlobTool, GrepTool, WebFetchTool } from "@avasis-ai/synthcode";
+import { defineTool } from "@avasis-ai/synthcode/tools";
+import { z } from "zod";
+
+const agent = new Agent({
+  model: process.env.OLLAMA_MODEL
+    ? await import("@avasis-ai/synthcode/llm").then(m => new m.OllamaProvider({ model: process.env.OLLAMA_MODEL }))
+    : process.env.OPENAI_API_KEY
+      ? await import("@avasis-ai/synthcode/llm").then(m => new m.OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY }))
+      : await import("@avasis-ai/synthcode/llm").then(m => new m.AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY! })),
+  tools: [
+    BashTool,
+    FileReadTool,
+    FileWriteTool,
+    FileEditTool,
+    GlobTool,
+    GrepTool,
+    WebFetchTool,
+  ],
+  systemPrompt: "You are a helpful AI coding assistant with shell and file access.",
+});
+
+const prompt = process.argv[2] || "Hello! What can I help you with?";
+
+for await (const event of agent.run(prompt)) {
+  if (event.type === "text") process.stdout.write(event.text);
+  if (event.type === "tool_use") console.log(\`\\n  [\${event.name}]\`);
+  if (event.type === "tool_result") {
+    if (event.isError) console.log(\`\\n  [\${event.name}] FAILED\`);
+  }
+  if (event.type === "thinking") process.stderr.write(\`\\x1b[90m\${event.thinking}\\x1b[0m\`);
+  if (event.type === "done") console.log(\`\\n\\nTokens: \${event.usage.inputTokens} in, \${event.usage.outputTokens} out\`);
+  if (event.type === "error") {
+    console.error(\`\\nError: \${event.error.message}\`);
+    process.exit(1);
+  }
+}
+`;
+async function init(opts) {
+  const name = opts?.projectName ?? "my-agent";
+  const cwd = opts?.cwd ?? process.cwd();
+  const dir = path7.join(cwd, name);
+  fs7.mkdirSync(path7.join(dir, "src", "tools"), { recursive: true });
+  fs7.mkdirSync(path7.join(dir, "tests"), { recursive: true });
+  fs7.writeFileSync(path7.join(dir, "package.json"), PACKAGE_JSON, "utf-8");
+  fs7.writeFileSync(path7.join(dir, "tsconfig.json"), TSCONFIG_JSON, "utf-8");
+  fs7.writeFileSync(path7.join(dir, ".env.example"), ENV_EXAMPLE, "utf-8");
+  fs7.writeFileSync(path7.join(dir, "src", "index.ts"), INDEX_TS, "utf-8");
+  fs7.writeFileSync(path7.join(dir, "tests", "agent.test.ts"), `import { describe, it, expect } from "vitest";
+describe("Agent", () => { it("should have tools registered", () => { expect(true).toBe(true); }); });
+`, "utf-8");
+  if (!opts?.skipInstall) {
+    console.log("Installing dependencies...");
+    (0, import_node_child_process2.execSync)("npm install", { cwd: dir, stdio: "inherit" });
+  }
+  console.log(`
+  Created ${name}/`);
+  console.log(`  cd ${name} && npm start "your prompt here"
+`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent,
+  AnthropicProvider,
+  BaseProvider,
+  BashTool,
+  ContextManager,
+  CostTracker,
+  DEFAULT_COMPACT_THRESHOLD,
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_MAX_TURNS,
+  DEFAULT_PRICING,
+  FileEditTool,
+  FileReadTool,
+  FileWriteTool,
+  GlobTool,
+  GrepTool,
+  HookRunner,
+  InMemoryStore,
+  MAX_CONCURRENT_TOOLS,
+  MCPClient,
+  OllamaProvider,
+  OpenAIProvider,
+  PermissionEngine,
+  RetryableError,
+  SQLiteStore,
+  ToolRegistry,
+  WebFetchTool,
+  agentLoop,
+  anthropic,
+  createProvider,
+  createStreamAggregator,
+  defineTool,
+  defineToolFromClass,
+  estimateConversationTokens,
+  estimateMessageTokens,
+  estimateTokens,
+  init,
+  loadMCPTools,
+  ollama,
+  openai,
+  orchestrateTools
+});
+//# sourceMappingURL=index.cjs.map