@avasis-ai/synthcode 1.0.0

package/dist/index.js

@@ -0,0 +1,1048 @@
+import {
+  AnthropicProvider,
+  BaseProvider,
+  OllamaProvider,
+  OpenAIProvider,
+  RetryableError,
+  anthropic,
+  createProvider,
+  ollama,
+  openai
+} from "./chunk-F34HO4RA.js";
+import {
+  BashTool,
+  FileEditTool,
+  FileReadTool,
+  FileWriteTool,
+  GlobTool,
+  GrepTool,
+  ToolRegistry,
+  WebFetchTool,
+  orchestrateTools
+} from "./chunk-53ZOIXM4.js";
+import "./chunk-W6OLZ2OI.js";
+import {
+  InMemoryStore,
+  SQLiteStore
+} from "./chunk-CARUMOML.js";
+import {
+  MCPClient,
+  loadMCPTools
+} from "./chunk-TLPOO6C3.js";
+import {
+  defineTool,
+  defineToolFromClass
+} from "./chunk-FK7S2S7V.js";
+import {
+  init
+} from "./chunk-BWXHO6UJ.js";
+import "./chunk-MQ7XP6VT.js";
+import "./chunk-DGUM43GV.js";
+
+// 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/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/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 } = 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: z.object({
+        response: z.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 } = 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: z.object({
+        prompt: z.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/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 };
+}
+export {
+  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.js.map