@claude-code-kit/agent 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1670 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/compaction/interface.ts
+var NoopCompaction = class {
+  compact(messages, _maxTokens) {
+    return messages;
+  }
+};
+
+// src/context-manager.ts
+function estimateTokens(message) {
+  let text;
+  if (typeof message.content === "string") {
+    text = message.content;
+  } else {
+    text = message.content.map((part) => part.type === "text" ? part.text : "[image]").join("");
+  }
+  if (message.role === "assistant" && message.toolCalls) {
+    for (const tc of message.toolCalls) {
+      text += tc.name + JSON.stringify(tc.input);
+    }
+  }
+  return Math.ceil(text.length / 4);
+}
+function estimateTotalTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += estimateTokens(msg);
+  }
+  return total;
+}
+var ContextManager = class {
+  contextLimit;
+  compactionStrategy;
+  provider;
+  /** Compact when usage exceeds this fraction of the context limit */
+  compactionThreshold = 0.85;
+  constructor(options) {
+    this.contextLimit = options.contextLimit ?? 1e5;
+    this.compactionStrategy = options.compactionStrategy ?? new NoopCompaction();
+    this.provider = options.provider ?? null;
+  }
+  /**
+   * Count tokens for the messages. Uses provider.countTokens if available,
+   * otherwise falls back to heuristic estimation.
+   */
+  async countTokens(messages) {
+    if (this.provider?.countTokens) {
+      return this.provider.countTokens(messages);
+    }
+    return estimateTotalTokens(messages);
+  }
+  /**
+   * Check if compaction is needed and apply it if so.
+   * Returns the (possibly compacted) messages array.
+   */
+  async maybeCompact(messages) {
+    const tokenCount = await this.countTokens(messages);
+    const threshold = this.contextLimit * this.compactionThreshold;
+    if (tokenCount > threshold) {
+      const targetTokens = Math.floor(this.contextLimit * 0.6);
+      return await this.compactionStrategy.compact(messages, targetTokens);
+    }
+    return messages;
+  }
+  /**
+   * Force compaction (e.g. after receiving a "context too long" error from the API).
+   */
+  async forceCompact(messages) {
+    const targetTokens = Math.floor(this.contextLimit * 0.5);
+    return await this.compactionStrategy.compact(messages, targetTokens);
+  }
+  setContextLimit(limit) {
+    this.contextLimit = limit;
+  }
+  setCompactionStrategy(strategy) {
+    this.compactionStrategy = strategy;
+  }
+};
+
+// src/permission.ts
+function createPermissionHandler(config) {
+  return async (request) => {
+    if (config.alwaysAllow?.includes(request.tool)) {
+      return { decision: "allow" };
+    }
+    if (config.alwaysDeny?.includes(request.tool)) {
+      return { decision: "deny", reason: `Tool "${request.tool}" is in the deny list` };
+    }
+    if (config.sessionApproved?.has(request.tool)) {
+      return { decision: "allow" };
+    }
+    if (config.autoApproveReadOnly && request.isReadOnly) {
+      return { decision: "allow" };
+    }
+    if (config.onPermission) {
+      return config.onPermission(request);
+    }
+    return { decision: "allow" };
+  };
+}
+var allowAll = async () => ({ decision: "allow" });
+var allowReadOnly = async (request) => {
+  if (request.isReadOnly) {
+    return { decision: "allow" };
+  }
+  return {
+    decision: "deny",
+    reason: "No permission handler configured. Set permissionHandler in AgentConfig."
+  };
+};
+var denyAll = async () => ({
+  decision: "deny",
+  reason: "All tool executions are denied"
+});
+
+// src/session/memory.ts
+var InMemorySession = class {
+  messages = [];
+  getMessages() {
+    return [...this.messages];
+  }
+  setMessages(messages) {
+    this.messages = [...messages];
+  }
+  clear() {
+    this.messages = [];
+  }
+};
+
+// src/tool-formatter.ts
+import { z } from "zod";
+function zodToInputSchema(schema) {
+  if (typeof z.toJSONSchema === "function") {
+    const jsonSchema = z.toJSONSchema(schema);
+    const { $schema: _, ...rest } = jsonSchema;
+    return rest;
+  }
+  try {
+    const mod = __require("zod-to-json-schema");
+    const jsonSchema = mod.zodToJsonSchema(schema, { target: "openApi3" });
+    const { $schema: _, ...rest } = jsonSchema;
+    return rest;
+  } catch {
+    return { type: "object" };
+  }
+}
+function toolToProviderFormat(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: zodToInputSchema(tool.inputSchema)
+  };
+}
+
+// src/tool-registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    if (this.tools.has(tool.name)) {
+      throw new Error(`Tool "${tool.name}" is already registered`);
+    }
+    this.tools.set(tool.name, tool);
+  }
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  list() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Returns all tools in the provider-ready format (name, description, JSON Schema).
+   */
+  toProviderFormat() {
+    return this.list().map(toolToProviderFormat);
+  }
+  /**
+   * Execute a tool by name with the given input.
+   */
+  async execute(name, input, context) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return { content: `Unknown tool: ${name}`, isError: true };
+    }
+    const parsed = tool.inputSchema.safeParse(input);
+    if (!parsed.success) {
+      return {
+        content: `Invalid input for tool "${name}": ${parsed.error.message}`,
+        isError: true
+      };
+    }
+    const timeout = tool.timeout ?? 12e4;
+    const timeoutSignal = AbortSignal.timeout(timeout);
+    const combinedSignal = AbortSignal.any([context.abortSignal, timeoutSignal]);
+    const toolContext = { ...context, abortSignal: combinedSignal };
+    try {
+      return await tool.execute(parsed.data, toolContext);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { content: `Tool "${name}" failed: ${message}`, isError: true };
+    }
+  }
+  clear() {
+    this.tools.clear();
+  }
+};
+
+// src/agent.ts
+var DEFAULT_MAX_TURNS = 50;
+var Agent = class {
+  provider;
+  model;
+  systemPrompt;
+  maxTokens;
+  temperature;
+  maxTurns;
+  session;
+  toolRegistry;
+  contextManager;
+  permissionHandler;
+  workingDirectory;
+  abortController = null;
+  constructor(config) {
+    this.provider = config.provider;
+    this.model = config.model;
+    this.systemPrompt = config.systemPrompt;
+    this.maxTokens = config.maxTokens;
+    this.temperature = config.temperature;
+    this.maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
+    this.session = config.session ?? new InMemorySession();
+    this.permissionHandler = config.permissionHandler ?? allowReadOnly;
+    this.workingDirectory = config.workingDirectory ?? process.cwd();
+    this.toolRegistry = new ToolRegistry();
+    if (config.tools) {
+      for (const tool of config.tools) {
+        this.toolRegistry.register(tool);
+      }
+    }
+    this.contextManager = new ContextManager({
+      contextLimit: config.contextLimit,
+      compactionStrategy: config.compactionStrategy,
+      provider: config.provider
+    });
+  }
+  /**
+   * Run the agent loop. Yields events as the agent processes the input.
+   *
+   * The loop:
+   * 1. Add user message(s) to conversation
+   * 2. Check compaction
+   * 3. Call provider.chat() with messages + tools
+   * 4. Stream chunks, accumulate text + tool calls
+   * 5. If tool_use: check permission -> execute -> add results -> loop to step 2
+   * 6. If end_turn: yield done event with full message history
+   */
+  async *run(input) {
+    this.abortController = new AbortController();
+    const messages = this.session.getMessages();
+    if (typeof input === "string") {
+      messages.push({ role: "user", content: input });
+    } else {
+      messages.push(...input);
+    }
+    this.session.setMessages(messages);
+    let turns = 0;
+    while (turns < this.maxTurns) {
+      turns++;
+      const currentMessages = await this.contextManager.maybeCompact(this.session.getMessages());
+      this.session.setMessages(currentMessages);
+      const providerTools = this.toolRegistry.toProviderFormat();
+      let accumulatedText = "";
+      const accumulatedToolCalls = [];
+      const toolParseErrors = /* @__PURE__ */ new Map();
+      let currentToolId;
+      let currentToolName;
+      let currentToolArgs = "";
+      try {
+        const stream = this.provider.chat({
+          model: this.model,
+          messages: this.session.getMessages(),
+          tools: providerTools.length > 0 ? providerTools : void 0,
+          systemPrompt: this.systemPrompt,
+          maxTokens: this.maxTokens,
+          temperature: this.temperature,
+          signal: this.abortController.signal
+        });
+        for await (const chunk of stream) {
+          switch (chunk.type) {
+            case "text":
+              if (chunk.text) {
+                accumulatedText += chunk.text;
+                yield { type: "text", text: chunk.text };
+              }
+              break;
+            case "tool_use_start":
+              if (chunk.toolCall) {
+                currentToolId = chunk.toolCall.id;
+                currentToolName = chunk.toolCall.name;
+                currentToolArgs = "";
+              }
+              break;
+            case "tool_use_delta":
+              if (chunk.text) {
+                currentToolArgs += chunk.text;
+              }
+              break;
+            case "tool_use_end": {
+              if (currentToolId && currentToolName) {
+                let input2;
+                try {
+                  input2 = currentToolArgs ? JSON.parse(currentToolArgs) : {};
+                } catch (err) {
+                  input2 = {};
+                  toolParseErrors.set(
+                    currentToolId,
+                    `Failed to parse tool input JSON: ${err instanceof Error ? err.message : String(err)}. Raw input: ${currentToolArgs}`
+                  );
+                }
+                const toolCall = {
+                  id: currentToolId,
+                  name: currentToolName,
+                  input: input2
+                };
+                accumulatedToolCalls.push(toolCall);
+                yield { type: "tool_call", toolCall };
+              }
+              currentToolId = void 0;
+              currentToolName = void 0;
+              currentToolArgs = "";
+              break;
+            }
+            case "thinking":
+              if (chunk.text) {
+                yield { type: "thinking", text: chunk.text };
+              }
+              break;
+            case "usage":
+              if (chunk.usage) {
+                yield {
+                  type: "usage",
+                  inputTokens: chunk.usage.inputTokens,
+                  outputTokens: chunk.usage.outputTokens
+                };
+              }
+              break;
+            case "done":
+              break;
+          }
+        }
+      } catch (error) {
+        if (isContextTooLongError(error)) {
+          const compacted = await this.contextManager.forceCompact(this.session.getMessages());
+          this.session.setMessages(compacted);
+          continue;
+        }
+        const err = error instanceof Error ? error : new Error(String(error));
+        yield { type: "error", error: err };
+        yield { type: "done", messages: this.session.getMessages() };
+        return;
+      }
+      const assistantMessage = {
+        role: "assistant",
+        content: accumulatedText,
+        ...accumulatedToolCalls.length > 0 ? { toolCalls: accumulatedToolCalls } : {}
+      };
+      const msgs = this.session.getMessages();
+      msgs.push(assistantMessage);
+      this.session.setMessages(msgs);
+      if (accumulatedToolCalls.length > 0) {
+        const toolResults = await this.executeToolCalls(accumulatedToolCalls, toolParseErrors);
+        const currentMsgs = this.session.getMessages();
+        for (const result of toolResults) {
+          yield {
+            type: "tool_result",
+            toolCallId: result.toolCallId,
+            result: {
+              content: typeof result.content === "string" ? result.content : "",
+              isError: result.isError
+            }
+          };
+          currentMsgs.push(result);
+        }
+        this.session.setMessages(currentMsgs);
+        continue;
+      }
+      yield { type: "done", messages: this.session.getMessages() };
+      return;
+    }
+    yield {
+      type: "error",
+      error: new Error(`Agent exceeded maximum turns (${this.maxTurns})`)
+    };
+    yield { type: "done", messages: this.session.getMessages() };
+  }
+  /**
+   * Simple API that wraps run() — sends a message and returns the final text response.
+   */
+  async chat(input) {
+    let result = "";
+    for await (const event of this.run(input)) {
+      if (event.type === "text") {
+        result += event.text;
+      }
+      if (event.type === "error") {
+        throw event.error;
+      }
+    }
+    return result;
+  }
+  /** Abort the current run. */
+  abort() {
+    this.abortController?.abort();
+  }
+  /** Replace the provider (e.g. to switch models mid-conversation). */
+  setProvider(provider) {
+    this.provider = provider;
+  }
+  /** Get the full message history. */
+  getMessages() {
+    return this.session.getMessages();
+  }
+  /** Clear the message history. */
+  clearMessages() {
+    this.session.clear();
+  }
+  /** Add a tool to the registry. */
+  addTool(tool) {
+    this.toolRegistry.register(tool);
+  }
+  /** Remove a tool from the registry. */
+  removeTool(name) {
+    return this.toolRegistry.unregister(name);
+  }
+  /** Replace the permission handler at runtime. */
+  setPermissionHandler(handler) {
+    this.permissionHandler = handler;
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  async executeToolCalls(toolCalls, parseErrors) {
+    const results = [];
+    for (const tc of toolCalls) {
+      const parseError = parseErrors?.get(tc.id);
+      if (parseError) {
+        results.push({
+          role: "tool",
+          toolCallId: tc.id,
+          content: parseError,
+          isError: true
+        });
+        continue;
+      }
+      const toolDef = this.toolRegistry.get(tc.name);
+      const permissionResult = await this.permissionHandler({
+        tool: tc.name,
+        input: tc.input,
+        isReadOnly: toolDef?.isReadOnly
+      });
+      if (permissionResult.decision === "deny") {
+        results.push({
+          role: "tool",
+          toolCallId: tc.id,
+          content: `Permission denied for tool "${tc.name}"${permissionResult.reason ? `: ${permissionResult.reason}` : ""}`,
+          isError: true
+        });
+        continue;
+      }
+      const context = {
+        workingDirectory: this.workingDirectory,
+        abortSignal: this.abortController?.signal ?? AbortSignal.timeout(12e4)
+      };
+      const result = await this.toolRegistry.execute(tc.name, tc.input, context);
+      results.push({
+        role: "tool",
+        toolCallId: tc.id,
+        content: result.content,
+        isError: result.isError
+      });
+    }
+    return results;
+  }
+};
+function isContextTooLongError(error) {
+  if (!(error instanceof Error)) return false;
+  const msg = error.message.toLowerCase();
+  return msg.includes("context_length_exceeded") || msg.includes("maximum context length") || msg.includes("too many tokens") || msg.includes("request too large");
+}
+
+// src/compaction/sliding-window.ts
+var SlidingWindowCompaction = class {
+  compact(messages, maxTokens) {
+    if (messages.length === 0) return messages;
+    const systemMessages = [];
+    const conversationMessages = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        systemMessages.push(msg);
+      } else {
+        conversationMessages.push(msg);
+      }
+    }
+    let totalTokens = 0;
+    for (const msg of systemMessages) {
+      totalTokens += estimateTokens(msg);
+    }
+    if (totalTokens >= maxTokens) {
+      return systemMessages;
+    }
+    const remainingBudget = maxTokens - totalTokens;
+    const kept = [];
+    let usedTokens = 0;
+    for (let i = conversationMessages.length - 1; i >= 0; i--) {
+      const msg = conversationMessages[i];
+      const msgTokens = estimateTokens(msg);
+      if (usedTokens + msgTokens > remainingBudget) {
+        break;
+      }
+      kept.unshift(msg);
+      usedTokens += msgTokens;
+    }
+    while (kept.length > 0 && kept[0].role === "tool") {
+      kept.shift();
+    }
+    return [...systemMessages, ...kept];
+  }
+};
+
+// src/compaction/summarization.ts
+var SUMMARY_PROMPT = "Please summarize the following conversation history concisely. Capture the key information, decisions, and context needed to continue the conversation. Be comprehensive but brief.";
+var SummarizationCompaction = class {
+  keepRecentN;
+  thresholdFraction;
+  summaryMaxTokens;
+  summaryModel;
+  provider;
+  constructor(provider, options = {}) {
+    this.provider = provider;
+    this.keepRecentN = options.keepRecentN ?? 10;
+    this.thresholdFraction = options.thresholdFraction ?? 0.75;
+    this.summaryMaxTokens = options.summaryMaxTokens ?? 2e3;
+    this.summaryModel = options.summaryModel ?? "claude-3-5-haiku-20241022";
+  }
+  /** Return true when the current usage exceeds the configured threshold. */
+  shouldCompact(messages, tokenCount, contextLimit) {
+    return tokenCount >= contextLimit * this.thresholdFraction;
+  }
+  /**
+   * Async compaction conforming to the CompactionStrategy interface.
+   * Uses the LLM provider to summarize older messages before dropping them.
+   */
+  async compact(messages, _maxTokens) {
+    const result = await this.compactAsync(messages);
+    return result.messages;
+  }
+  /**
+   * Async compaction that uses the LLM provider to summarize older messages.
+   * Returns a `CompactionResult` with full token stats.
+   */
+  async compactAsync(messages) {
+    const tokensBefore = estimateTotalTokens(messages);
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const conversationMessages = messages.filter((m) => m.role !== "system");
+    if (conversationMessages.length <= this.keepRecentN) {
+      return {
+        messages,
+        tokensBefore,
+        tokensAfter: tokensBefore,
+        strategy: "summarization"
+      };
+    }
+    const toSummarize = conversationMessages.slice(0, -this.keepRecentN);
+    const toKeep = conversationMessages.slice(-this.keepRecentN);
+    const transcript = toSummarize.map((m) => {
+      const role = m.role.toUpperCase();
+      const text = typeof m.content === "string" ? m.content : m.content.map((part) => part.type === "text" ? part.text : "[image]").join("");
+      return `${role}: ${text}`;
+    }).join("\n\n");
+    const summaryMessages = [
+      {
+        role: "user",
+        content: `${SUMMARY_PROMPT}
+
+---
+
+${transcript}`
+      }
+    ];
+    let summaryText = "";
+    const stream = this.provider.chat({
+      model: this.summaryModel,
+      messages: summaryMessages,
+      maxTokens: this.summaryMaxTokens
+    });
+    for await (const chunk of stream) {
+      if (chunk.type === "text" && chunk.text) {
+        summaryText += chunk.text;
+      }
+    }
+    const summaryUserMessage = {
+      role: "user",
+      content: `[Summary of earlier conversation]
+
+${summaryText}`
+    };
+    const understoodMessage = {
+      role: "assistant",
+      content: "Understood."
+    };
+    const compactedMessages = [
+      ...systemMessages,
+      summaryUserMessage,
+      understoodMessage,
+      ...toKeep
+    ];
+    return {
+      messages: compactedMessages,
+      tokensBefore,
+      tokensAfter: estimateTotalTokens(compactedMessages),
+      strategy: "summarization"
+    };
+  }
+};
+
+// src/session/file.ts
+import { promises as fs } from "fs";
+import path from "path";
+function isErrnoException(err) {
+  return err instanceof Error && "code" in err;
+}
+var FileSession = class {
+  directory;
+  id;
+  messages = [];
+  constructor(directory, id) {
+    this.directory = directory;
+    this.id = id;
+  }
+  /** Return a snapshot of the in-memory messages. */
+  getMessages() {
+    return [...this.messages];
+  }
+  /** Replace the in-memory messages and persist to disk. */
+  setMessages(messages) {
+    this.messages = [...messages];
+  }
+  /** Clear in-memory messages (does not delete the file). */
+  clear() {
+    this.messages = [];
+  }
+  // ---------------------------------------------------------------------------
+  // Persistence helpers (used by FileSessionStore)
+  // ---------------------------------------------------------------------------
+  /** Resolve the .jsonl file path for this session. */
+  filePath() {
+    return path.join(this.directory, `${this.id}.jsonl`);
+  }
+  /** Load messages from disk into memory. Returns self for chaining. */
+  async load() {
+    try {
+      const content = await fs.readFile(this.filePath(), "utf8");
+      this.messages = content.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+    } catch (err) {
+      if (isErrnoException(err) && err.code === "ENOENT") {
+        this.messages = [];
+      } else {
+        throw err;
+      }
+    }
+    return this;
+  }
+  /** Write current in-memory messages to disk (overwrites the file). */
+  async save() {
+    await fs.mkdir(this.directory, { recursive: true });
+    const content = this.messages.map((m) => JSON.stringify(m)).join("\n");
+    await fs.writeFile(this.filePath(), content, "utf8");
+  }
+  /** Append a single message to the file without rewriting it. */
+  async append(message) {
+    await fs.mkdir(this.directory, { recursive: true });
+    await fs.appendFile(this.filePath(), JSON.stringify(message) + "\n", "utf8");
+    this.messages.push(message);
+  }
+};
+var FileSessionStore = class {
+  constructor(directory) {
+    this.directory = directory;
+  }
+  /** Create a new (empty) session without persisting it. */
+  create(id) {
+    return new FileSession(this.directory, id);
+  }
+  /** Load an existing session from disk. Returns null if not found. */
+  async load(id) {
+    const session = new FileSession(this.directory, id);
+    try {
+      await session.load();
+      return session;
+    } catch {
+      return null;
+    }
+  }
+  /** Persist the current messages of a session to disk. */
+  async save(id, session) {
+    const target = new FileSession(this.directory, id);
+    target.setMessages(session.getMessages());
+    await target.save();
+  }
+  /** List all session IDs in the directory. */
+  async list() {
+    try {
+      const entries = await fs.readdir(this.directory);
+      return entries.filter((f) => f.endsWith(".jsonl")).map((f) => f.slice(0, -".jsonl".length));
+    } catch (err) {
+      if (isErrnoException(err) && err.code === "ENOENT") {
+        return [];
+      }
+      throw err;
+    }
+  }
+  /** Delete a session file from disk. */
+  async delete(id) {
+    const filePath = path.join(this.directory, `${id}.jsonl`);
+    try {
+      await fs.unlink(filePath);
+    } catch (err) {
+      if (!isErrnoException(err) || err.code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+};
+
+// src/providers/anthropic.ts
+var AnthropicProvider = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.clientPromise = loadSDK().then(
+      (SDK) => new SDK({
+        apiKey: options.apiKey,
+        ...options.baseURL ? { baseURL: options.baseURL } : {}
+      })
+    );
+  }
+  clientPromise;
+  async *chat(options) {
+    const client = await this.clientPromise;
+    const { systemPrompt, messages: rawMessages, tools, model, maxTokens, temperature, signal } = options;
+    const anthropicMessages = rawMessages.filter((m) => m.role !== "system").map((m) => toAnthropicMessage(m));
+    const anthropicTools = tools?.map(toAnthropicTool);
+    const params = {
+      model,
+      max_tokens: maxTokens ?? 4096,
+      ...temperature !== void 0 ? { temperature } : {},
+      ...systemPrompt ? { system: systemPrompt } : {},
+      messages: anthropicMessages,
+      ...anthropicTools?.length ? { tools: anthropicTools } : {}
+    };
+    const stream = client.messages.stream(params, { signal });
+    let currentToolId;
+    for await (const event of stream) {
+      switch (event.type) {
+        case "content_block_start": {
+          const block = event.content_block;
+          if (block.type === "text") {
+          } else if (block.type === "tool_use") {
+            currentToolId = block.id;
+            yield {
+              type: "tool_use_start",
+              toolCall: { id: block.id, name: block.name }
+            };
+          } else if (block.type === "thinking") {
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const delta = event.delta;
+          if (delta.type === "text_delta") {
+            yield { type: "text", text: delta.text };
+          } else if (delta.type === "input_json_delta") {
+            yield { type: "tool_use_delta", text: delta.partial_json };
+          } else if (delta.type === "thinking_delta") {
+            yield { type: "thinking", text: delta.thinking };
+          }
+          break;
+        }
+        case "content_block_stop": {
+          if (currentToolId) {
+            yield { type: "tool_use_end" };
+            currentToolId = void 0;
+          }
+          break;
+        }
+        case "message_delta": {
+          if (event.usage) {
+            yield {
+              type: "usage",
+              usage: {
+                inputTokens: 0,
+                outputTokens: event.usage.output_tokens
+              }
+            };
+          }
+          break;
+        }
+        case "message_start": {
+          if (event.message.usage) {
+            yield {
+              type: "usage",
+              usage: {
+                inputTokens: event.message.usage.input_tokens,
+                outputTokens: event.message.usage.output_tokens
+              }
+            };
+          }
+          break;
+        }
+      }
+    }
+    yield { type: "done" };
+  }
+  async countTokens(messages) {
+    let total = 0;
+    for (const msg of messages) {
+      if (typeof msg.content === "string") {
+        total += Math.ceil(msg.content.length / 4);
+      } else {
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            total += Math.ceil(part.text.length / 4);
+          } else {
+            total += 1e3;
+          }
+        }
+      }
+    }
+    return total;
+  }
+};
+function toAnthropicMessage(msg) {
+  if (msg.role === "user") {
+    if (typeof msg.content === "string") {
+      return { role: "user", content: msg.content };
+    }
+    return {
+      role: "user",
+      content: msg.content.map((part) => {
+        if (part.type === "text") return { type: "text", text: part.text };
+        return {
+          type: "image",
+          source: { type: "base64", media_type: part.mediaType, data: part.data }
+        };
+      })
+    };
+  }
+  if (msg.role === "assistant") {
+    const content = [];
+    if (typeof msg.content === "string") {
+      if (msg.content) {
+        content.push({ type: "text", text: msg.content });
+      }
+    } else {
+      for (const part of msg.content) {
+        if (part.type === "text") content.push({ type: "text", text: part.text });
+      }
+    }
+    if (msg.toolCalls) {
+      for (const tc of msg.toolCalls) {
+        content.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
+      }
+    }
+    return { role: "assistant", content };
+  }
+  return {
+    role: "user",
+    content: [
+      {
+        type: "tool_result",
+        tool_use_id: msg.toolCallId,
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        ...msg.isError ? { is_error: true } : {}
+      }
+    ]
+  };
+}
+function toAnthropicTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  };
+}
+var sdkModule = null;
+async function loadSDK() {
+  if (sdkModule) return sdkModule.default;
+  try {
+    sdkModule = await import("@anthropic-ai/sdk");
+    return sdkModule.default;
+  } catch {
+    throw new Error(
+      'AnthropicProvider requires "@anthropic-ai/sdk" package. Install it with: pnpm add @anthropic-ai/sdk'
+    );
+  }
+}
+
+// src/providers/openai.ts
+var OpenAIProvider = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.clientPromise = loadSDK2().then(
+      (SDK) => new SDK({
+        apiKey: options.apiKey,
+        ...options.baseURL ? { baseURL: options.baseURL } : {}
+      })
+    );
+  }
+  clientPromise;
+  async *chat(options) {
+    const client = await this.clientPromise;
+    const { model, messages, tools, systemPrompt, maxTokens, temperature, signal } = options;
+    const openaiMessages = [];
+    if (systemPrompt) {
+      openaiMessages.push({ role: "system", content: systemPrompt });
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        openaiMessages.push({ role: "system", content: msg.content });
+      } else {
+        openaiMessages.push(
+          toOpenAIMessage(msg)
+        );
+      }
+    }
+    const openaiTools = tools?.map(toOpenAITool);
+    const params = {
+      model,
+      messages: openaiMessages,
+      ...maxTokens ? { max_tokens: maxTokens } : {},
+      ...temperature !== void 0 ? { temperature } : {},
+      ...openaiTools?.length ? { tools: openaiTools } : {},
+      stream: true
+    };
+    const stream = await client.chat.completions.create(params, { signal });
+    const toolCalls = /* @__PURE__ */ new Map();
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for await (const chunk of stream) {
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      const delta = choice.delta;
+      if (delta?.content) {
+        yield { type: "text", text: delta.content };
+      }
+      if (delta?.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index;
+          if (!toolCalls.has(idx)) {
+            toolCalls.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", args: "" });
+          }
+          const entry = toolCalls.get(idx);
+          if (tc.id) entry.id = tc.id;
+          if (tc.function?.name) {
+            entry.name = tc.function.name;
+            yield { type: "tool_use_start", toolCall: { id: entry.id, name: entry.name } };
+          }
+          if (tc.function?.arguments) {
+            entry.args += tc.function.arguments;
+            yield { type: "tool_use_delta", text: tc.function.arguments };
+          }
+        }
+      }
+      if (chunk.usage) {
+        inputTokens = chunk.usage.prompt_tokens ?? 0;
+        outputTokens = chunk.usage.completion_tokens ?? 0;
+      }
+      if (choice.finish_reason) {
+        for (const [, _entry] of toolCalls) {
+          yield { type: "tool_use_end" };
+        }
+        toolCalls.clear();
+      }
+    }
+    if (inputTokens > 0 || outputTokens > 0) {
+      yield { type: "usage", usage: { inputTokens, outputTokens } };
+    }
+    yield { type: "done" };
+  }
+  async countTokens(messages) {
+    let total = 0;
+    for (const msg of messages) {
+      if (typeof msg.content === "string") {
+        total += Math.ceil(msg.content.length / 4);
+      } else {
+        for (const part of msg.content) {
+          if (part.type === "text") total += Math.ceil(part.text.length / 4);
+          else total += 1e3;
+        }
+      }
+    }
+    return total;
+  }
+};
+function toOpenAIMessage(msg) {
+  if (msg.role === "user") {
+    if (typeof msg.content === "string") {
+      return { role: "user", content: msg.content };
+    }
+    return {
+      role: "user",
+      content: msg.content.map((part) => {
+        if (part.type === "text") return { type: "text", text: part.text };
+        return {
+          type: "image_url",
+          image_url: { url: `data:${part.mediaType};base64,${part.data}` }
+        };
+      })
+    };
+  }
+  if (msg.role === "assistant") {
+    const result = { role: "assistant" };
+    if (typeof msg.content === "string") {
+      result.content = msg.content || null;
+    } else {
+      const text = msg.content.filter((p) => p.type === "text").map((p) => p.text).join("");
+      result.content = text || null;
+    }
+    if (msg.toolCalls?.length) {
+      result.tool_calls = msg.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.name,
+          arguments: JSON.stringify(tc.input)
+        }
+      }));
+    }
+    return result;
+  }
+  return {
+    role: "tool",
+    tool_call_id: msg.toolCallId,
+    content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+  };
+}
+function toOpenAITool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  };
+}
+var sdkModule2 = null;
+async function loadSDK2() {
+  if (sdkModule2) return sdkModule2.default;
+  try {
+    sdkModule2 = await import("openai");
+    return sdkModule2.default;
+  } catch {
+    throw new Error(
+      'OpenAIProvider requires "openai" package. Install it with: pnpm add openai'
+    );
+  }
+}
+
+// src/providers/mock.ts
+var MockProvider = class {
+  queue;
+  callLog = [];
+  constructor(responses) {
+    this.queue = [...responses];
+  }
+  async *chat(options) {
+    this.callLog.push(options);
+    const response = this.queue.shift();
+    if (!response) {
+      throw new Error("MockProvider: no more scripted responses in queue");
+    }
+    for (const chunk of response) {
+      yield chunk;
+    }
+  }
+  async countTokens(messages) {
+    let total = 0;
+    for (const msg of messages) {
+      if (typeof msg.content === "string") {
+        total += Math.ceil(msg.content.length / 4);
+      }
+    }
+    return total;
+  }
+  /** Get the log of all chat() calls made to this provider. */
+  getCalls() {
+    return this.callLog;
+  }
+  /** Check if all scripted responses have been consumed. */
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+};
+
+// src/auth/storage.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os from "os";
+var DEFAULT_STORAGE_PATH = path2.join(os.homedir(), ".claude-code-kit", "credentials.json");
+var FileAuthStorage = class {
+  constructor(filePath = DEFAULT_STORAGE_PATH) {
+    this.filePath = filePath;
+  }
+  async get(provider) {
+    const data = await this.read();
+    return data[provider] ?? null;
+  }
+  async set(provider, credential) {
+    const data = await this.read();
+    data[provider] = credential;
+    await this.write(data);
+  }
+  async delete(provider) {
+    const data = await this.read();
+    delete data[provider];
+    await this.write(data);
+  }
+  async list() {
+    const data = await this.read();
+    return Object.keys(data);
+  }
+  async read() {
+    try {
+      const content = fs2.readFileSync(this.filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  async write(data) {
+    const dir = path2.dirname(this.filePath);
+    fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs2.writeFileSync(this.filePath, JSON.stringify(data, null, 2), { mode: 384 });
+  }
+};
+var MemoryAuthStorage = class {
+  store = /* @__PURE__ */ new Map();
+  async get(provider) {
+    return this.store.get(provider) ?? null;
+  }
+  async set(provider, credential) {
+    this.store.set(provider, credential);
+  }
+  async delete(provider) {
+    this.store.delete(provider);
+  }
+  async list() {
+    return [...this.store.keys()];
+  }
+};
+
+// src/auth/registry.ts
+var AuthRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  storage;
+  constructor(options) {
+    this.storage = options?.storage ?? new FileAuthStorage(options?.storagePath);
+  }
+  /**
+   * Register a provider. Open — any provider, any auth type.
+   * Overwrites existing registration with the same name.
+   */
+  register(name, registration) {
+    this.providers.set(name, registration);
+  }
+  unregister(name) {
+    return this.providers.delete(name);
+  }
+  getRegistration(name) {
+    return this.providers.get(name);
+  }
+  /**
+   * Get the list of available models for a registered provider.
+   */
+  getModels(providerName) {
+    const reg = this.providers.get(providerName);
+    if (!reg) {
+      throw new Error(
+        `Provider "${providerName}" is not registered. Available: ${[...this.providers.keys()].join(", ")}`
+      );
+    }
+    return reg.models ?? [];
+  }
+  // -------------------------------------------------------------------------
+  // Resolve credential from an auth method (env → storage → null)
+  // -------------------------------------------------------------------------
+  resolveEnvCredential(method) {
+    if (method.type === "none") return {};
+    const envVar = method.type === "api-key" ? method.envVar : method.envVar;
+    if (envVar) {
+      const value = process.env[envVar];
+      if (value) {
+        if (method.type === "base-url-key") {
+          return { apiKey: value, baseURL: method.defaultBaseURL || void 0 };
+        }
+        return { apiKey: value };
+      }
+    }
+    return null;
+  }
+  /**
+   * Authenticate and get a configured LLMProvider.
+   *
+   * Resolution order for each auth method (tried in order):
+   * 1. Environment variable (if method has `envVar`)
+   * 2. Stored credential (from AuthStorage)
+   * 3. Next auth method
+   *
+   * If no method resolves, throws.
+   *
+   * For providers with a `type: 'none'` auth method, no credential is required.
+   */
+  async authenticate(name) {
+    const reg = this.providers.get(name);
+    if (!reg) {
+      throw new Error(
+        `Provider "${name}" is not registered. Available: ${[...this.providers.keys()].join(", ")}`
+      );
+    }
+    for (const method of reg.authMethods) {
+      if (method.type === "none") {
+        return reg.createProvider({});
+      }
+      const envCred = this.resolveEnvCredential(method);
+      if (envCred) {
+        return reg.createProvider(envCred);
+      }
+      const stored = await this.storage.get(name);
+      if (stored) {
+        if (method.type === "base-url-key") {
+          return reg.createProvider({
+            apiKey: stored,
+            baseURL: method.defaultBaseURL || void 0
+          });
+        }
+        return reg.createProvider({ apiKey: stored });
+      }
+    }
+    const envVars = reg.authMethods.map((m) => {
+      if (m.type === "api-key" || m.type === "base-url-key") return m.envVar;
+      return void 0;
+    }).filter(Boolean);
+    const envHint = envVars.length > 0 ? ` Set ${envVars.join(" or ")} or call registry.storeCredential("${name}", key).` : "";
+    throw new Error(`No credential found for provider "${name}".${envHint}`);
+  }
+  /**
+   * Get a provider using only environment variables — no storage, no prompts.
+   * Throws if no env var resolves (or provider has a 'none' method).
+   */
+  fromEnv(name) {
+    const reg = this.providers.get(name);
+    if (!reg) {
+      throw new Error(
+        `Provider "${name}" is not registered. Available: ${[...this.providers.keys()].join(", ")}`
+      );
+    }
+    for (const method of reg.authMethods) {
+      if (method.type === "none") {
+        return reg.createProvider({});
+      }
+      const envCred = this.resolveEnvCredential(method);
+      if (envCred) {
+        return reg.createProvider(envCred);
+      }
+    }
+    const envVars = reg.authMethods.map((m) => {
+      if (m.type === "api-key" || m.type === "base-url-key") return m.envVar;
+      return void 0;
+    }).filter(Boolean);
+    if (envVars.length === 0) {
+      throw new Error(
+        `Provider "${name}" has no envVar configured for env-only auth.`
+      );
+    }
+    throw new Error(
+      `Environment variable ${envVars.join(" / ")} is not set for provider "${name}".`
+    );
+  }
+  async storeCredential(name, credential) {
+    await this.storage.set(name, credential);
+  }
+  async listProviders() {
+    const stored = await this.storage.list();
+    const storedSet = new Set(stored);
+    const result = [];
+    for (const [name, registration] of this.providers) {
+      let hasCredential = registration.authMethods.some(
+        (m) => m.type === "none"
+      );
+      if (!hasCredential) {
+        for (const method of registration.authMethods) {
+          const envCred = this.resolveEnvCredential(method);
+          if (envCred) {
+            hasCredential = true;
+            break;
+          }
+        }
+      }
+      if (!hasCredential && storedSet.has(name)) {
+        hasCredential = true;
+      }
+      result.push({ name, registration, hasCredential });
+    }
+    return result;
+  }
+  async logout(name) {
+    await this.storage.delete(name);
+  }
+  // -------------------------------------------------------------------------
+  // Interactive auth flow — step-by-step state machine
+  // -------------------------------------------------------------------------
+  /**
+   * Start the interactive auth flow.
+   * Returns the initial state with all available providers listed.
+   */
+  interactive() {
+    const providers = [...this.providers.entries()].map(([name, reg]) => ({
+      name,
+      displayName: reg.displayName,
+      description: reg.description
+    }));
+    return {
+      step: "select-provider",
+      providers
+    };
+  }
+  /**
+   * Advance the interactive flow by selecting a provider.
+   */
+  selectProvider(providerName) {
+    const reg = this.providers.get(providerName);
+    if (!reg) {
+      throw new Error(
+        `Provider "${providerName}" is not registered. Available: ${[...this.providers.keys()].join(", ")}`
+      );
+    }
+    if (reg.authMethods.length === 1) {
+      const method = reg.authMethods[0];
+      if (method.type === "none") {
+        if (reg.models && reg.models.length > 0) {
+          return {
+            step: "select-model",
+            currentProvider: providerName,
+            currentAuthMethod: method,
+            models: reg.models,
+            currentModel: reg.defaultModel
+          };
+        }
+        return {
+          step: "done",
+          currentProvider: providerName,
+          currentAuthMethod: method,
+          currentModel: reg.defaultModel,
+          result: {
+            provider: reg.createProvider({}),
+            model: reg.defaultModel ?? "",
+            providerName
+          }
+        };
+      }
+      return {
+        step: "input-credentials",
+        currentProvider: providerName,
+        currentAuthMethod: method
+      };
+    }
+    return {
+      step: "select-auth-method",
+      currentProvider: providerName,
+      authMethods: reg.authMethods
+    };
+  }
+  /**
+   * Advance the interactive flow by selecting an auth method.
+   * Only needed when a provider has multiple auth methods.
+   */
+  selectAuthMethod(providerName, methodIndex) {
+    const reg = this.providers.get(providerName);
+    if (!reg) {
+      throw new Error(`Provider "${providerName}" is not registered.`);
+    }
+    const method = reg.authMethods[methodIndex];
+    if (!method) {
+      throw new Error(
+        `Auth method index ${methodIndex} is out of range for "${providerName}" (has ${reg.authMethods.length} methods).`
+      );
+    }
+    if (method.type === "none") {
+      if (reg.models && reg.models.length > 0) {
+        return {
+          step: "select-model",
+          currentProvider: providerName,
+          currentAuthMethod: method,
+          models: reg.models,
+          currentModel: reg.defaultModel
+        };
+      }
+      return {
+        step: "done",
+        currentProvider: providerName,
+        currentAuthMethod: method,
+        currentModel: reg.defaultModel,
+        result: {
+          provider: reg.createProvider({}),
+          model: reg.defaultModel ?? "",
+          providerName
+        }
+      };
+    }
+    return {
+      step: "input-credentials",
+      currentProvider: providerName,
+      currentAuthMethod: method
+    };
+  }
+  /**
+   * Advance the interactive flow by providing credentials.
+   * Stores the credential and moves to model selection (or done).
+   */
+  async inputCredentials(providerName, method, credentials) {
+    const reg = this.providers.get(providerName);
+    if (!reg) {
+      throw new Error(`Provider "${providerName}" is not registered.`);
+    }
+    if (credentials.apiKey) {
+      await this.storage.set(providerName, credentials.apiKey);
+    }
+    const resolvedCredentials = { ...credentials };
+    if (method.type === "base-url-key" && !resolvedCredentials.baseURL && method.defaultBaseURL) {
+      resolvedCredentials.baseURL = method.defaultBaseURL;
+    }
+    if (reg.models && reg.models.length > 0) {
+      return {
+        step: "select-model",
+        currentProvider: providerName,
+        currentAuthMethod: method,
+        models: reg.models,
+        currentModel: reg.defaultModel
+      };
+    }
+    return {
+      step: "done",
+      currentProvider: providerName,
+      currentAuthMethod: method,
+      currentModel: reg.defaultModel,
+      result: {
+        provider: reg.createProvider(resolvedCredentials),
+        model: reg.defaultModel ?? "",
+        providerName
+      }
+    };
+  }
+  /**
+   * Advance the interactive flow by selecting a model.
+   * Returns the final 'done' state with a configured provider.
+   */
+  async selectModel(providerName, method, model, credentials) {
+    const reg = this.providers.get(providerName);
+    if (!reg) {
+      throw new Error(`Provider "${providerName}" is not registered.`);
+    }
+    let resolvedCreds = credentials;
+    if (!resolvedCreds || !resolvedCreds.apiKey && !resolvedCreds.token) {
+      if (method.type === "none") {
+        resolvedCreds = {};
+      } else {
+        const envCred = this.resolveEnvCredential(method);
+        if (envCred) {
+          resolvedCreds = envCred;
+        } else {
+          const stored = await this.storage.get(providerName);
+          if (stored) {
+            resolvedCreds = { apiKey: stored };
+            if (method.type === "base-url-key" && method.defaultBaseURL) {
+              resolvedCreds.baseURL = method.defaultBaseURL;
+            }
+          }
+        }
+      }
+    }
+    if (!resolvedCreds) {
+      throw new Error(
+        `No credentials available for provider "${providerName}". Provide credentials or set env var.`
+      );
+    }
+    return {
+      step: "done",
+      currentProvider: providerName,
+      currentAuthMethod: method,
+      currentModel: model,
+      result: {
+        provider: reg.createProvider(resolvedCreds),
+        model,
+        providerName
+      }
+    };
+  }
+};
+
+// src/auth/presets.ts
+var PRESET_PROVIDERS = {
+  anthropic: {
+    displayName: "Anthropic",
+    description: "Claude Opus, Sonnet, Haiku",
+    authMethods: [
+      {
+        type: "api-key",
+        envVar: "ANTHROPIC_API_KEY",
+        inputLabel: "Anthropic API Key"
+      }
+    ],
+    models: ["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"],
+    defaultModel: "claude-sonnet-4-6",
+    createProvider: ({ apiKey }) => new AnthropicProvider({ apiKey })
+  },
+  openai: {
+    displayName: "OpenAI",
+    description: "GPT-4o, GPT-4, o1",
+    authMethods: [
+      {
+        type: "api-key",
+        envVar: "OPENAI_API_KEY",
+        inputLabel: "OpenAI API Key"
+      }
+    ],
+    models: ["gpt-4o", "gpt-4-turbo", "o1", "o1-mini"],
+    defaultModel: "gpt-4o",
+    createProvider: ({ apiKey }) => new OpenAIProvider({ apiKey })
+  },
+  deepseek: {
+    displayName: "DeepSeek",
+    description: "DeepSeek-V3, DeepSeek-R1",
+    authMethods: [
+      {
+        type: "api-key",
+        envVar: "DEEPSEEK_API_KEY",
+        inputLabel: "DeepSeek API Key"
+      }
+    ],
+    models: ["deepseek-chat", "deepseek-reasoner"],
+    defaultModel: "deepseek-chat",
+    createProvider: ({ apiKey }) => new OpenAIProvider({ apiKey, baseURL: "https://api.deepseek.com/v1" })
+  },
+  siliconflow: {
+    displayName: "SiliconFlow",
+    description: "Qwen, DeepSeek, GLM via SiliconFlow",
+    authMethods: [
+      {
+        type: "base-url-key",
+        defaultBaseURL: "https://api.siliconflow.cn/v1",
+        envVar: "SILICONFLOW_API_KEY",
+        inputLabel: "SiliconFlow API Key"
+      }
+    ],
+    models: ["Qwen/Qwen2.5-72B-Instruct", "deepseek-ai/DeepSeek-V3"],
+    defaultModel: "Qwen/Qwen2.5-72B-Instruct",
+    createProvider: ({ apiKey, baseURL }) => new OpenAIProvider({
+      apiKey,
+      baseURL: baseURL || "https://api.siliconflow.cn/v1"
+    })
+  },
+  moonshot: {
+    displayName: "Moonshot (Kimi)",
+    description: "Kimi K2.5, Moonshot v1",
+    authMethods: [
+      {
+        type: "api-key",
+        envVar: "MOONSHOT_API_KEY",
+        inputLabel: "Moonshot API Key"
+      }
+    ],
+    models: ["moonshot-v1-auto", "kimi-k2.5"],
+    defaultModel: "moonshot-v1-auto",
+    createProvider: ({ apiKey }) => new OpenAIProvider({ apiKey, baseURL: "https://api.moonshot.cn/v1" })
+  },
+  groq: {
+    displayName: "Groq",
+    description: "Fast inference for Llama, Mixtral",
+    authMethods: [
+      {
+        type: "api-key",
+        envVar: "GROQ_API_KEY",
+        inputLabel: "Groq API Key"
+      }
+    ],
+    models: ["llama-3.3-70b-versatile", "mixtral-8x7b-32768"],
+    defaultModel: "llama-3.3-70b-versatile",
+    createProvider: ({ apiKey }) => new OpenAIProvider({
+      apiKey,
+      baseURL: "https://api.groq.com/openai/v1"
+    })
+  },
+  ollama: {
+    displayName: "Ollama (local)",
+    description: "Local models via Ollama",
+    authMethods: [{ type: "none" }],
+    models: ["llama3.1", "qwen2.5", "mistral"],
+    defaultModel: "llama3.1",
+    createProvider: () => new OpenAIProvider({
+      apiKey: "ollama",
+      baseURL: "http://localhost:11434/v1"
+    })
+  },
+  custom: {
+    displayName: "Custom (OpenAI-compatible)",
+    description: "Any OpenAI-compatible API endpoint",
+    authMethods: [
+      {
+        type: "base-url-key",
+        defaultBaseURL: "",
+        inputLabel: "Base URL + API Key"
+      }
+    ],
+    createProvider: ({ apiKey, baseURL }) => new OpenAIProvider({ apiKey: apiKey || "x", baseURL })
+  }
+};
+
+// src/auth/index.ts
+function createAuth(options) {
+  const registry = new AuthRegistry(options);
+  for (const [name, reg] of Object.entries(PRESET_PROVIDERS)) {
+    registry.register(name, reg);
+  }
+  return registry;
+}
+export {
+  Agent,
+  AnthropicProvider,
+  AuthRegistry,
+  ContextManager,
+  FileAuthStorage,
+  FileSession,
+  FileSessionStore,
+  InMemorySession,
+  MemoryAuthStorage,
+  MockProvider,
+  NoopCompaction,
+  OpenAIProvider,
+  PRESET_PROVIDERS,
+  SlidingWindowCompaction,
+  SummarizationCompaction,
+  ToolRegistry,
+  allowAll,
+  allowReadOnly,
+  createAuth,
+  createPermissionHandler,
+  denyAll,
+  estimateTokens,
+  estimateTotalTokens
+};