@nuvin/nuvin-core 1.2.0 → 1.3.1

package/dist/index.js

@@ -36,6 +36,345 @@ var AgentEventTypes = {
   SubAgentCompleted: "sub_agent_completed"
 };
 
+// metrics.ts
+var createEmptySnapshot = () => ({
+  totalTokens: 0,
+  totalPromptTokens: 0,
+  totalCompletionTokens: 0,
+  totalCachedTokens: 0,
+  totalReasoningTokens: 0,
+  requestCount: 0,
+  llmCallCount: 0,
+  toolCallCount: 0,
+  totalTimeMs: 0,
+  totalCost: 0,
+  currentTokens: 0,
+  currentPromptTokens: 0,
+  currentCompletionTokens: 0,
+  currentCachedTokens: 0,
+  currentCost: 0
+});
+var NoopMetricsPort = class {
+  recordLLMCall(_usage, _cost) {
+  }
+  recordToolCall() {
+  }
+  recordRequestComplete(_responseTimeMs) {
+  }
+  setContextWindow(_limit, _usage) {
+  }
+  reset() {
+  }
+  getSnapshot() {
+    return createEmptySnapshot();
+  }
+};
+var InMemoryMetricsPort = class {
+  snapshot = createEmptySnapshot();
+  onChange;
+  constructor(onChange) {
+    this.onChange = onChange;
+  }
+  emit() {
+    this.onChange?.({ ...this.snapshot });
+  }
+  recordLLMCall(usage, cost) {
+    const prompt = usage.prompt_tokens ?? 0;
+    const completion = usage.completion_tokens ?? 0;
+    const total = usage.total_tokens ?? prompt + completion;
+    const cached = usage.prompt_tokens_details?.cached_tokens ?? 0;
+    const reasoning = usage.reasoning_tokens ?? usage.completion_tokens_details?.reasoning_tokens ?? 0;
+    const actualCost = cost ?? usage.cost ?? 0;
+    this.snapshot.totalTokens += total;
+    this.snapshot.totalPromptTokens += prompt;
+    this.snapshot.totalCompletionTokens += completion;
+    this.snapshot.totalCachedTokens += cached;
+    this.snapshot.totalReasoningTokens += reasoning;
+    this.snapshot.totalCost += actualCost;
+    this.snapshot.llmCallCount += 1;
+    this.snapshot.currentTokens = total;
+    this.snapshot.currentPromptTokens = prompt;
+    this.snapshot.currentCompletionTokens = completion;
+    this.snapshot.currentCachedTokens = cached;
+    this.snapshot.currentCost = actualCost;
+    this.emit();
+  }
+  recordToolCall() {
+    this.snapshot.toolCallCount += 1;
+    this.emit();
+  }
+  recordRequestComplete(responseTimeMs) {
+    this.snapshot.requestCount += 1;
+    this.snapshot.totalTimeMs += responseTimeMs;
+    this.emit();
+  }
+  setContextWindow(limit, usage) {
+    this.snapshot.contextWindowLimit = limit;
+    this.snapshot.contextWindowUsage = usage;
+    this.emit();
+  }
+  reset() {
+    this.snapshot = createEmptySnapshot();
+    this.emit();
+  }
+  getSnapshot() {
+    return { ...this.snapshot };
+  }
+  setOnChange(fn) {
+    this.onChange = fn;
+  }
+};
+
+// clock.ts
+var SystemClock = class {
+  now() {
+    return Date.now();
+  }
+  iso(dateMs) {
+    return new Date(dateMs ?? Date.now()).toISOString();
+  }
+};
+
+// id.ts
+var SimpleId = class {
+  uuid() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+};
+
+// cost.ts
+var SimpleCost = class {
+  estimate(_model, usage) {
+    return usage?.cost;
+  }
+};
+
+// reminders.ts
+var NoopReminders = class {
+  enhance(content, _opts) {
+    return [content];
+  }
+};
+
+// context.ts
+var toProviderContent = (content) => {
+  if (content === null || content === void 0) {
+    return "";
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content.type === "parts") {
+    const providerParts = [];
+    for (const part of content.parts) {
+      if (part.type === "text") {
+        if (part.text.length > 0) {
+          providerParts.push({ type: "text", text: part.text });
+        }
+        continue;
+      }
+      const label = part.altText ?? (part.name ? `Image attachment: ${part.name}` : void 0);
+      if (label) {
+        providerParts.push({ type: "text", text: label });
+      }
+      const url = `data:${part.mimeType};base64,${part.data}`;
+      providerParts.push({ type: "image_url", image_url: { url } });
+    }
+    return providerParts.length > 0 ? providerParts : [];
+  }
+  return [];
+};
+var SimpleContextBuilder = class {
+  toProviderMessages(history, systemPrompt, newUserContent) {
+    const transformed = [];
+    for (const m of history) {
+      const providerContent = toProviderContent(m.content);
+      if (m.role === "user") {
+        transformed.push({ role: "user", content: providerContent ?? "" });
+      } else if (m.role === "assistant") {
+        if (m.tool_calls && m.tool_calls.length > 0) {
+          transformed.push({
+            ...m,
+            role: "assistant",
+            content: providerContent ?? null,
+            tool_calls: m.tool_calls
+          });
+        } else {
+          transformed.push({
+            ...m,
+            role: "assistant",
+            content: providerContent ?? ""
+          });
+        }
+      } else if (m.role === "tool") {
+        if (m.tool_call_id) {
+          transformed.push({
+            role: "tool",
+            content: typeof providerContent === "string" ? providerContent : providerContent ?? "",
+            tool_call_id: m.tool_call_id,
+            name: m.name
+          });
+        }
+      }
+    }
+    const userMsgs = newUserContent.map((c) => ({
+      role: "user",
+      content: toProviderContent(c) ?? ""
+    }));
+    return [{ role: "system", content: systemPrompt }, ...transformed, ...userMsgs];
+  }
+};
+
+// persistent/memory.ts
+var InMemoryMemory = class {
+  store = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.store.get(key) ?? [];
+  }
+  async set(key, items) {
+    this.store.set(key, [...items]);
+  }
+  async append(key, items) {
+    const existing = this.store.get(key) ?? [];
+    this.store.set(key, [...existing, ...items]);
+  }
+  async delete(key) {
+    this.store.delete(key);
+  }
+  async keys() {
+    return Array.from(this.store.keys());
+  }
+  async clear() {
+    this.store.clear();
+  }
+  async exportSnapshot() {
+    const snap = {};
+    for (const [k, v] of this.store.entries()) snap[k] = [...v];
+    return snap;
+  }
+  async importSnapshot(snapshot) {
+    this.store.clear();
+    for (const [k, v] of Object.entries(snapshot)) this.store.set(k, [...v]);
+  }
+};
+var JsonFileMemoryPersistence = class {
+  constructor(filename = "history.json") {
+    this.filename = filename;
+  }
+  async load() {
+    try {
+      const fs10 = await import("fs");
+      if (!fs10.existsSync(this.filename)) return {};
+      const text = fs10.readFileSync(this.filename, "utf-8");
+      const data = JSON.parse(text);
+      return typeof data === "object" && data ? data : {};
+    } catch {
+      console.warn(`Failed to load memory from ${this.filename}`);
+      return {};
+    }
+  }
+  async save(snapshot) {
+    try {
+      const fs10 = await import("fs");
+      const path9 = await import("path");
+      const dir = path9.dirname(this.filename);
+      if (dir && dir !== "." && !fs10.existsSync(dir)) {
+        fs10.mkdirSync(dir, { recursive: true });
+      }
+      fs10.writeFileSync(this.filename, JSON.stringify(snapshot, null, 2), "utf-8");
+    } catch (err2) {
+      console.warn(`Failed to save memory to ${this.filename}`, err2);
+    }
+  }
+};
+var PersistedMemory = class {
+  constructor(persistence) {
+    this.persistence = persistence;
+  }
+  inner = new InMemoryMemory();
+  initialized = false;
+  async ensureInitialized() {
+    if (this.initialized) return;
+    const snap = await this.persistence.load();
+    if (snap && typeof snap === "object") await this.inner.importSnapshot(snap);
+    this.initialized = true;
+  }
+  async save() {
+    const snap = await this.inner.exportSnapshot();
+    await this.persistence.save(snap);
+  }
+  async get(key) {
+    await this.ensureInitialized();
+    return this.inner.get(key);
+  }
+  async set(key, items) {
+    await this.ensureInitialized();
+    await this.inner.set(key, items);
+    await this.save();
+  }
+  async append(key, items) {
+    await this.ensureInitialized();
+    await this.inner.append(key, items);
+    await this.save();
+  }
+  async delete(key) {
+    await this.ensureInitialized();
+    await this.inner.delete(key);
+    await this.save();
+  }
+  async keys() {
+    await this.ensureInitialized();
+    return this.inner.keys();
+  }
+  async clear() {
+    await this.ensureInitialized();
+    await this.inner.clear();
+    await this.save();
+  }
+  async exportSnapshot() {
+    await this.ensureInitialized();
+    return this.inner.exportSnapshot();
+  }
+  async importSnapshot(snapshot) {
+    await this.ensureInitialized();
+    await this.inner.importSnapshot(snapshot);
+    await this.save();
+  }
+};
+
+// events.ts
+var NoopEventPort = class {
+  emit(_event) {
+  }
+};
+var PersistingConsoleEventPort = class {
+  memory;
+  maxPerConversation;
+  writeQueue = Promise.resolve();
+  constructor(opts) {
+    this.memory = opts?.memory ?? new PersistedMemory(new JsonFileMemoryPersistence(opts?.filename || "events.json"));
+    this.maxPerConversation = opts?.maxPerConversation ?? 500;
+  }
+  async emit(event) {
+    this.writeQueue = this.writeQueue.then(async () => {
+      try {
+        const key = event?.conversationId ?? "default";
+        const existing = await this.memory.get(key);
+        const next = [...existing, { ...event }];
+        const max = this.maxPerConversation;
+        const trimmed = max > 0 && next.length > max ? next.slice(next.length - max) : next;
+        await this.memory.set(key, trimmed);
+      } catch {
+      }
+    });
+    return this.writeQueue;
+  }
+};
+
 // orchestrator.ts
 var removeAttachmentTokens = (value, attachments) => {
   return attachments.reduce((acc, attachment) => {
@@ -107,9 +446,29 @@ var resolveDisplayText = (text, attachments, provided) => {
 var AgentOrchestrator = class {
   constructor(cfg, deps) {
     this.cfg = cfg;
-    this.deps = deps;
+    this.memory = deps.memory;
+    this.tools = deps.tools;
+    this.llm = deps.llm;
+    this.context = deps.context ?? this.context;
+    this.ids = deps.ids ?? this.ids;
+    this.clock = deps.clock ?? this.clock;
+    this.cost = deps.cost ?? this.cost;
+    this.reminders = deps.reminders ?? this.reminders;
+    this.metrics = deps.metrics ?? this.metrics;
+    this.events = deps.events ?? this.events;
   }
   pendingApprovals = /* @__PURE__ */ new Map();
+  context = new SimpleContextBuilder();
+  ids = new SimpleId();
+  clock = new SystemClock();
+  cost = new SimpleCost();
+  reminders = new NoopReminders();
+  // private llm: LLMPort;
+  metrics = new NoopMetricsPort();
+  events = new NoopEventPort();
+  llm;
+  tools;
+  memory;
   /**
    * Updates the agent configuration dynamically after initialization.
    * This allows for runtime changes to model, provider, and other settings.
@@ -122,26 +481,26 @@ var AgentOrchestrator = class {
    * This preserves conversation history, MCP connections, and other state.
    */
   setLLM(newLLM) {
-    this.deps.llm = newLLM;
+    this.llm = newLLM;
   }
   /**
    * Updates the tool port without reinitializing the entire orchestrator.
    * This preserves conversation history and other state while adding/removing tools.
    */
   setTools(newTools) {
-    this.deps.tools = newTools;
+    this.tools = newTools;
   }
   /**
    * Gets the current tool port.
    */
   getTools() {
-    return this.deps.tools;
+    return this.tools;
   }
   /**
    * Gets the current LLM port.
    */
   getLLM() {
-    return this.deps.llm;
+    return this.llm;
   }
   /**
    * Gets the current agent configuration.
@@ -155,14 +514,26 @@ var AgentOrchestrator = class {
    * MCP servers, and other state.
    */
   setMemory(newMemory) {
-    this.deps.memory = newMemory;
+    this.memory = newMemory;
   }
   /**
    * Updates the event port without reinitializing the entire orchestrator.
    * This is useful when switching to a new session with a different event log file.
    */
   setEvents(newEvents) {
-    this.deps.events = newEvents;
+    this.events = newEvents;
+  }
+  /**
+   * Updates the metrics port without reinitializing the entire orchestrator.
+   */
+  setMetrics(newMetrics) {
+    this.metrics = newMetrics;
+  }
+  /**
+   * Gets the current metrics port.
+   */
+  getMetrics() {
+    return this.metrics;
   }
   /**
    * Determines if a tool should bypass approval requirements.
@@ -175,10 +546,10 @@ var AgentOrchestrator = class {
   }
   async handleToolDenial(denialMessage, conversationId, messageId, accumulatedMessages, turnHistory, originalToolCalls, assistantContent, usage) {
     const assistantMsg = {
-      id: this.deps.ids.uuid(),
+      id: this.ids.uuid(),
       role: "assistant",
       content: assistantContent ?? null,
-      timestamp: this.deps.clock.iso(),
+      timestamp: this.clock.iso(),
       tool_calls: originalToolCalls,
       usage
     };
@@ -201,15 +572,15 @@ var AgentOrchestrator = class {
         id: toolCall.id,
         role: "tool",
         content: toolDenialResult,
-        timestamp: this.deps.clock.iso(),
+        timestamp: this.clock.iso(),
         tool_call_id: toolCall.id,
         name: toolCall.function.name
       };
       turnHistory.push(toolMsg);
       toolResultMsgs.push(toolMsg);
     }
-    await this.deps.memory.append(conversationId, [assistantMsg, ...toolResultMsgs]);
-    await this.deps.events?.emit({
+    await this.memory.append(conversationId, [assistantMsg, ...toolResultMsgs]);
+    await this.events?.emit({
       type: AgentEventTypes.AssistantMessage,
       conversationId,
       messageId,
@@ -247,15 +618,19 @@ var AgentOrchestrator = class {
   }
   async send(content, opts = {}) {
     const convo = opts.conversationId ?? "default";
-    const t0 = this.deps.clock.now();
-    const msgId = this.deps.ids.uuid();
-    const history = await this.deps.memory.get(convo);
+    const t0 = this.clock.now();
+    const msgId = this.ids.uuid();
+    const history = await this.memory.get(convo);
     let providerMsgs;
     let userMessages;
     let userDisplay;
     let enhanced;
+    const _llm = this.getLLM();
+    if (!_llm) {
+      throw new Error("LLM provider not set");
+    }
     if (opts.retry) {
-      providerMsgs = this.deps.context.toProviderMessages(history, this.cfg.systemPrompt, []);
+      providerMsgs = this.context.toProviderMessages(history, this.cfg.systemPrompt, []);
       userMessages = [];
       userDisplay = "[Retry]";
       enhanced = [];
@@ -266,7 +641,7 @@ var AgentOrchestrator = class {
         attachments: Array.isArray(content.attachments) ? content.attachments : []
       };
       const attachments = normalized.attachments;
-      enhanced = this.deps.reminders.enhance(normalized.text, { conversationId: convo });
+      enhanced = this.reminders.enhance(normalized.text, { conversationId: convo });
       const enhancedCombined = enhanced.join("\n");
       const messageParts = buildMessageParts(enhancedCombined, attachments);
       let userContent;
@@ -279,16 +654,16 @@ var AgentOrchestrator = class {
       } else {
         userContent = enhancedCombined;
       }
-      providerMsgs = this.deps.context.toProviderMessages(history, this.cfg.systemPrompt, [userContent]);
+      providerMsgs = this.context.toProviderMessages(history, this.cfg.systemPrompt, [userContent]);
       userDisplay = resolveDisplayText(normalized.text, attachments, normalized.displayText);
-      const userTimestamp = this.deps.clock.iso();
-      userMessages = [{ id: this.deps.ids.uuid(), role: "user", content: userContent, timestamp: userTimestamp }];
-      await this.deps.memory.append(convo, userMessages);
+      const userTimestamp = this.clock.iso();
+      userMessages = [{ id: this.ids.uuid(), role: "user", content: userContent, timestamp: userTimestamp }];
+      await this.memory.append(convo, userMessages);
     }
     if (opts.signal?.aborted) throw new Error("Aborted");
-    const toolDefs = this.deps.tools.getToolDefinitions(this.cfg.enabledTools ?? []);
+    const toolDefs = this.tools.getToolDefinitions(this.cfg.enabledTools ?? []);
     const toolNames = toolDefs.map((t) => t.function.name);
-    await this.deps.events?.emit({
+    await this.events?.emit({
       type: AgentEventTypes.MessageStarted,
       conversationId: convo,
       messageId: msgId,
@@ -315,17 +690,166 @@ var AgentOrchestrator = class {
     let toolApprovalDenied = false;
     let denialMessage = "";
     let finalResponseSaved = false;
-    try {
-      if (opts.stream && typeof this.deps.llm.streamCompletion === "function") {
+    if (opts.stream && typeof _llm.streamCompletion === "function") {
+      let isFirstChunk = true;
+      result = await _llm.streamCompletion(
+        params,
+        {
+          onChunk: async (delta, usage) => {
+            streamedAssistantContent += delta;
+            const cleanDelta = isFirstChunk ? delta.replace(/^\n+/, "") : delta;
+            isFirstChunk = false;
+            const chunkEvent = {
+              type: AgentEventTypes.AssistantChunk,
+              conversationId: convo,
+              messageId: msgId,
+              delta: cleanDelta,
+              ...usage && { usage }
+            };
+            await this.events?.emit(chunkEvent);
+          },
+          onStreamFinish: async (finishReason, usage) => {
+            if (usage) {
+              const cost = this.cost.estimate(this.cfg.model, usage);
+              this.metrics?.recordLLMCall?.(usage, cost);
+            }
+            const finishEvent = {
+              type: AgentEventTypes.StreamFinish,
+              conversationId: convo,
+              messageId: msgId,
+              ...finishReason && { finishReason },
+              ...usage && { usage }
+            };
+            await this.events?.emit(finishEvent);
+          }
+        },
+        opts.signal
+      );
+    } else {
+      result = await _llm.generateCompletion(params, opts.signal);
+      if (result.usage) {
+        const cost = this.cost.estimate(this.cfg.model, result.usage);
+        this.metrics?.recordLLMCall?.(result.usage, cost);
+      }
+    }
+    if (!result.tool_calls?.length && result.content && !finalResponseSaved) {
+      const content2 = opts.stream ? streamedAssistantContent : result.content;
+      const assistantMsg = {
+        id: msgId,
+        role: "assistant",
+        content: content2,
+        timestamp: this.clock.iso(),
+        usage: result.usage
+      };
+      await this.memory.append(convo, [assistantMsg]);
+      finalResponseSaved = true;
+      if (content2.trim()) {
+        const messageEvent = {
+          type: AgentEventTypes.AssistantMessage,
+          conversationId: convo,
+          messageId: msgId,
+          content: content2,
+          ...result.usage && { usage: result.usage }
+        };
+        await this.events?.emit(messageEvent);
+      }
+    }
+    while (result.tool_calls?.length) {
+      if (result.content?.trim()) {
+        const messageEvent = {
+          type: AgentEventTypes.AssistantMessage,
+          conversationId: convo,
+          messageId: msgId,
+          content: result.content,
+          ...result.usage && { usage: result.usage }
+        };
+        await this.events?.emit(messageEvent);
+      }
+      if (opts.signal?.aborted) throw new Error("Aborted");
+      await this.events?.emit({
+        type: AgentEventTypes.ToolCalls,
+        conversationId: convo,
+        messageId: msgId,
+        toolCalls: result.tool_calls,
+        usage: result.usage
+      });
+      const approvalResult = await this.processToolApproval(
+        result.tool_calls,
+        convo,
+        msgId,
+        accumulatedMessages,
+        turnHistory,
+        result.content,
+        result.usage
+      );
+      if (approvalResult.wasDenied) {
+        denialMessage = approvalResult.denialMessage || "";
+        toolApprovalDenied = true;
+        break;
+      }
+      const approvedCalls = approvalResult.approvedCalls;
+      const invocations = this.toInvocations(approvedCalls);
+      if (opts.signal?.aborted) throw new Error("Aborted");
+      const toolResults = await this.tools.executeToolCalls(
+        invocations,
+        {
+          conversationId: convo,
+          agentId: this.cfg.id,
+          messageId: msgId,
+          eventPort: this.events
+        },
+        this.cfg.maxToolConcurrency ?? 3,
+        opts.signal
+      );
+      allToolResults.push(...toolResults);
+      const assistantMsg = {
+        id: this.ids.uuid(),
+        role: "assistant",
+        content: result.content ?? null,
+        timestamp: this.clock.iso(),
+        tool_calls: approvedCalls,
+        usage: result.usage
+      };
+      const toolResultMsgs = [];
+      for (const tr of toolResults) {
+        const contentStr = tr.status === "error" ? String(tr.result) : typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
+        toolResultMsgs.push({
+          id: tr.id,
+          role: "tool",
+          content: contentStr,
+          timestamp: this.clock.iso(),
+          tool_call_id: tr.id,
+          name: tr.name
+        });
+        this.metrics?.recordToolCall?.();
+        await this.events?.emit({
+          type: AgentEventTypes.ToolResult,
+          conversationId: convo,
+          messageId: msgId,
+          result: tr
+        });
+      }
+      await this.memory.append(convo, [assistantMsg, ...toolResultMsgs]);
+      const { usage: _usage, ...extraField } = result;
+      accumulatedMessages.push({
+        ...extraField,
+        role: "assistant",
+        content: result.content ?? null,
+        tool_calls: approvedCalls
+      });
+      for (const tr of toolResults) {
+        const contentStr = tr.status === "error" ? String(tr.result) : typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
+        accumulatedMessages.push({ role: "tool", content: contentStr, tool_call_id: tr.id, name: tr.name });
+      }
+      if (opts.signal?.aborted) throw new Error("Aborted");
+      streamedAssistantContent = "";
+      if (opts.stream && typeof _llm.streamCompletion === "function") {
         let isFirstChunk = true;
-        result = await this.deps.llm.streamCompletion(
-          params,
+        result = await _llm.streamCompletion(
+          { ...params, messages: accumulatedMessages },
           {
             onChunk: async (delta, usage) => {
-              try {
-                streamedAssistantContent += delta;
-              } catch {
-              }
+              streamedAssistantContent += delta;
               const cleanDelta = isFirstChunk ? delta.replace(/^\n+/, "") : delta;
               isFirstChunk = false;
               const chunkEvent = {
@@ -335,9 +859,13 @@ var AgentOrchestrator = class {
                 delta: cleanDelta,
                 ...usage && { usage }
               };
-              await this.deps.events?.emit(chunkEvent);
+              await this.events?.emit(chunkEvent);
             },
             onStreamFinish: async (finishReason, usage) => {
+              if (usage) {
+                const cost = this.cost.estimate(this.cfg.model, usage);
+                this.metrics?.recordLLMCall?.(usage, cost);
+              }
               const finishEvent = {
                 type: AgentEventTypes.StreamFinish,
                 conversationId: convo,
@@ -345,24 +873,28 @@ var AgentOrchestrator = class {
                 ...finishReason && { finishReason },
                 ...usage && { usage }
               };
-              await this.deps.events?.emit(finishEvent);
+              await this.events?.emit(finishEvent);
             }
           },
           opts.signal
         );
       } else {
-        result = await this.deps.llm.generateCompletion(params, opts.signal);
+        result = await _llm.generateCompletion({ ...params, messages: accumulatedMessages }, opts.signal);
+        if (result.usage) {
+          const cost = this.cost.estimate(this.cfg.model, result.usage);
+          this.metrics?.recordLLMCall?.(result.usage, cost);
+        }
       }
       if (!result.tool_calls?.length && result.content && !finalResponseSaved) {
         const content2 = opts.stream ? streamedAssistantContent : result.content;
-        const assistantMsg = {
+        const assistantMsg2 = {
           id: msgId,
           role: "assistant",
           content: content2,
-          timestamp: this.deps.clock.iso(),
+          timestamp: this.clock.iso(),
           usage: result.usage
         };
-        await this.deps.memory.append(convo, [assistantMsg]);
+        await this.memory.append(convo, [assistantMsg2]);
         finalResponseSaved = true;
         if (content2.trim()) {
           const messageEvent = {
@@ -372,205 +904,56 @@ var AgentOrchestrator = class {
             content: content2,
             ...result.usage && { usage: result.usage }
           };
-          await this.deps.events?.emit(messageEvent);
+          await this.events?.emit(messageEvent);
         }
       }
-      while (result.tool_calls?.length) {
-        if (result.content?.trim()) {
-          const messageEvent = {
-            type: AgentEventTypes.AssistantMessage,
-            conversationId: convo,
-            messageId: msgId,
-            content: result.content,
-            ...result.usage && { usage: result.usage }
-          };
-          await this.deps.events?.emit(messageEvent);
-        }
-        if (opts.signal?.aborted) throw new Error("Aborted");
-        await this.deps.events?.emit({
-          type: AgentEventTypes.ToolCalls,
-          conversationId: convo,
-          messageId: msgId,
-          toolCalls: result.tool_calls,
-          usage: result.usage
-        });
-        const approvalResult = await this.processToolApproval(
-          result.tool_calls,
-          convo,
-          msgId,
-          accumulatedMessages,
-          turnHistory,
-          result.content,
-          result.usage
-        );
-        if (approvalResult.wasDenied) {
-          denialMessage = approvalResult.denialMessage || "";
-          toolApprovalDenied = true;
-          break;
-        }
-        const approvedCalls = approvalResult.approvedCalls;
-        const invocations = this.toInvocations(approvedCalls);
-        if (opts.signal?.aborted) throw new Error("Aborted");
-        const toolResults = await this.deps.tools.executeToolCalls(
-          invocations,
-          {
-            conversationId: convo,
-            agentId: this.cfg.id,
-            messageId: msgId,
-            eventPort: this.deps.events
-          },
-          this.cfg.maxToolConcurrency ?? 3,
-          opts.signal
-        );
-        allToolResults.push(...toolResults);
-        const assistantMsg = {
-          id: this.deps.ids.uuid(),
-          role: "assistant",
-          content: result.content ?? null,
-          timestamp: this.deps.clock.iso(),
-          tool_calls: approvedCalls,
-          usage: result.usage
-        };
-        const toolResultMsgs = [];
-        for (const tr of toolResults) {
-          const contentStr = tr.status === "error" ? String(tr.result) : typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
-          toolResultMsgs.push({
-            id: tr.id,
-            role: "tool",
-            content: contentStr,
-            timestamp: this.deps.clock.iso(),
-            tool_call_id: tr.id,
-            name: tr.name
-          });
-          await this.deps.events?.emit({
-            type: AgentEventTypes.ToolResult,
-            conversationId: convo,
-            messageId: msgId,
-            result: tr
-          });
-        }
-        await this.deps.memory.append(convo, [assistantMsg, ...toolResultMsgs]);
-        const { usage: _usage, ...extraField } = result;
-        accumulatedMessages.push({
-          ...extraField,
-          role: "assistant",
-          content: result.content ?? null,
-          tool_calls: approvedCalls
-        });
-        for (const tr of toolResults) {
-          const contentStr = tr.status === "error" ? String(tr.result) : typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result);
-          accumulatedMessages.push({ role: "tool", content: contentStr, tool_call_id: tr.id, name: tr.name });
-        }
-        if (opts.signal?.aborted) throw new Error("Aborted");
-        streamedAssistantContent = "";
-        if (opts.stream && typeof this.deps.llm.streamCompletion === "function") {
-          let isFirstChunk = true;
-          result = await this.deps.llm.streamCompletion(
-            { ...params, messages: accumulatedMessages },
-            {
-              onChunk: async (delta, usage) => {
-                try {
-                  streamedAssistantContent += delta;
-                } catch {
-                }
-                const cleanDelta = isFirstChunk ? delta.replace(/^\n+/, "") : delta;
-                isFirstChunk = false;
-                const chunkEvent = {
-                  type: AgentEventTypes.AssistantChunk,
-                  conversationId: convo,
-                  messageId: msgId,
-                  delta: cleanDelta,
-                  ...usage && { usage }
-                };
-                await this.deps.events?.emit(chunkEvent);
-              },
-              onStreamFinish: async (finishReason, usage) => {
-                const finishEvent = {
-                  type: AgentEventTypes.StreamFinish,
-                  conversationId: convo,
-                  messageId: msgId,
-                  ...finishReason && { finishReason },
-                  ...usage && { usage }
-                };
-                await this.deps.events?.emit(finishEvent);
-              }
-            },
-            opts.signal
-          );
-        } else {
-          result = await this.deps.llm.generateCompletion({ ...params, messages: accumulatedMessages }, opts.signal);
-        }
-        if (!result.tool_calls?.length && result.content && !finalResponseSaved) {
-          const content2 = opts.stream ? streamedAssistantContent : result.content;
-          const assistantMsg2 = {
-            id: msgId,
-            role: "assistant",
-            content: content2,
-            timestamp: this.deps.clock.iso(),
-            usage: result.usage
-          };
-          await this.deps.memory.append(convo, [assistantMsg2]);
-          finalResponseSaved = true;
-          if (content2.trim()) {
-            const messageEvent = {
-              type: AgentEventTypes.AssistantMessage,
-              conversationId: convo,
-              messageId: msgId,
-              content: content2,
-              ...result.usage && { usage: result.usage }
-            };
-            await this.deps.events?.emit(messageEvent);
-          }
-        }
-      }
-      const t1 = this.deps.clock.now();
-      const timestamp = this.deps.clock.iso();
-      const shouldEmitFinalMessage = result.content?.trim() && !toolApprovalDenied && !finalResponseSaved;
-      if (shouldEmitFinalMessage) {
-        const messageEvent = {
-          type: AgentEventTypes.AssistantMessage,
-          conversationId: convo,
-          messageId: msgId,
-          content: result.content,
-          ...result.usage && { usage: result.usage }
-        };
-        await this.deps.events?.emit(messageEvent);
-      }
-      const responseContent = toolApprovalDenied ? denialMessage : result.content;
-      const resp = {
-        id: msgId,
-        content: responseContent,
-        role: MessageRoles.Assistant,
-        timestamp,
-        metadata: {
-          model: this.cfg.model,
-          provider: "echo",
-          agentId: this.cfg.id,
-          responseTime: t1 - t0,
-          promptTokens: result.usage?.prompt_tokens,
-          completionTokens: result.usage?.completion_tokens,
-          totalTokens: result.usage?.total_tokens,
-          estimatedCost: this.deps.cost.estimate(this.cfg.model, result.usage),
-          toolCalls: allToolResults.length
-        }
-      };
-      await this.deps.events?.emit({
-        type: AgentEventTypes.Done,
+    }
+    const t1 = this.clock.now();
+    const timestamp = this.clock.iso();
+    this.metrics?.recordRequestComplete?.(t1 - t0);
+    const shouldEmitFinalMessage = result.content?.trim() && !toolApprovalDenied && !finalResponseSaved;
+    if (shouldEmitFinalMessage) {
+      const messageEvent = {
+        type: AgentEventTypes.AssistantMessage,
         conversationId: convo,
         messageId: msgId,
-        responseTimeMs: t1 - t0,
-        usage: result.usage
-      });
-      return resp;
-    } catch (err2) {
-      throw err2;
-    }
+        content: result.content,
+        ...result.usage && { usage: result.usage }
+      };
+      await this.events?.emit(messageEvent);
+    }
+    const responseContent = toolApprovalDenied ? denialMessage : result.content;
+    const resp = {
+      id: msgId,
+      content: responseContent,
+      role: MessageRoles.Assistant,
+      timestamp,
+      metadata: {
+        model: this.cfg.model,
+        provider: "echo",
+        agentId: this.cfg.id,
+        responseTime: t1 - t0,
+        promptTokens: result.usage?.prompt_tokens,
+        completionTokens: result.usage?.completion_tokens,
+        totalTokens: result.usage?.total_tokens,
+        estimatedCost: this.cost.estimate(this.cfg.model, result.usage),
+        toolCalls: allToolResults.length
+      }
+    };
+    await this.events?.emit({
+      type: AgentEventTypes.Done,
+      conversationId: convo,
+      messageId: msgId,
+      responseTimeMs: t1 - t0,
+      usage: result.usage
+    });
+    return resp;
   }
   async waitForToolApproval(toolCalls, conversationId, messageId) {
-    const approvalId = this.deps.ids.uuid();
+    const approvalId = this.ids.uuid();
     return new Promise((resolve6, reject) => {
       this.pendingApprovals.set(approvalId, { resolve: resolve6, reject });
-      this.deps.events?.emit({
+      this.events?.emit({
         type: AgentEventTypes.ToolApprovalRequired,
         conversationId,
         messageId,
@@ -579,100 +962,31 @@ var AgentOrchestrator = class {
       });
     });
   }
-  handleToolApproval(approvalId, decision, approvedCalls) {
-    const approval = this.pendingApprovals.get(approvalId);
-    if (!approval) {
-      console.warn(`[Orchestrator] Received approval for unknown or already processed ID: ${approvalId}`);
-      return;
-    }
-    this.pendingApprovals.delete(approvalId);
-    if (decision === "deny") {
-      approval.reject(new Error("Tool execution denied by user"));
-    } else if (decision === "approve_all" || decision === "approve") {
-      approval.resolve(approvedCalls || []);
-    } else {
-      approval.reject(new Error(`Invalid approval decision: ${decision}`));
-    }
-  }
-  toInvocations(toolCalls) {
-    return toolCalls.map((tc) => {
-      let parameters = {};
-      try {
-        parameters = JSON.parse(tc.function.arguments || "{}");
-      } catch {
-        parameters = {};
-      }
-      return { id: tc.id, name: tc.function.name, parameters };
-    });
-  }
-};
-
-// context.ts
-var toProviderContent = (content) => {
-  if (content === null || content === void 0) {
-    return "";
-  }
-  if (typeof content === "string") {
-    return content;
-  }
-  if (content.type === "parts") {
-    const providerParts = [];
-    for (const part of content.parts) {
-      if (part.type === "text") {
-        if (part.text.length > 0) {
-          providerParts.push({ type: "text", text: part.text });
-        }
-        continue;
-      }
-      const label = part.altText ?? (part.name ? `Image attachment: ${part.name}` : void 0);
-      if (label) {
-        providerParts.push({ type: "text", text: label });
-      }
-      const url = `data:${part.mimeType};base64,${part.data}`;
-      providerParts.push({ type: "image_url", image_url: { url } });
-    }
-    return providerParts.length > 0 ? providerParts : [];
-  }
-  return [];
-};
-var SimpleContextBuilder = class {
-  toProviderMessages(history, systemPrompt, newUserContent) {
-    const transformed = [];
-    for (const m of history) {
-      const providerContent = toProviderContent(m.content);
-      if (m.role === "user") {
-        transformed.push({ role: "user", content: providerContent ?? "" });
-      } else if (m.role === "assistant") {
-        if (m.tool_calls && m.tool_calls.length > 0) {
-          transformed.push({
-            ...m,
-            role: "assistant",
-            content: providerContent ?? null,
-            tool_calls: m.tool_calls
-          });
-        } else {
-          transformed.push({
-            ...m,
-            role: "assistant",
-            content: providerContent ?? ""
-          });
-        }
-      } else if (m.role === "tool") {
-        if (m.tool_call_id) {
-          transformed.push({
-            role: "tool",
-            content: typeof providerContent === "string" ? providerContent : providerContent ?? "",
-            tool_call_id: m.tool_call_id,
-            name: m.name
-          });
-        }
-      }
+  handleToolApproval(approvalId, decision, approvedCalls) {
+    const approval = this.pendingApprovals.get(approvalId);
+    if (!approval) {
+      console.warn(`[Orchestrator] Received approval for unknown or already processed ID: ${approvalId}`);
+      return;
     }
-    const userMsgs = newUserContent.map((c) => ({
-      role: "user",
-      content: toProviderContent(c) ?? ""
-    }));
-    return [{ role: "system", content: systemPrompt }, ...transformed, ...userMsgs];
+    this.pendingApprovals.delete(approvalId);
+    if (decision === "deny") {
+      approval.reject(new Error("Tool execution denied by user"));
+    } else if (decision === "approve_all" || decision === "approve") {
+      approval.resolve(approvedCalls || []);
+    } else {
+      approval.reject(new Error(`Invalid approval decision: ${decision}`));
+    }
+  }
+  toInvocations(toolCalls) {
+    return toolCalls.map((tc) => {
+      let parameters = {};
+      try {
+        parameters = JSON.parse(tc.function.arguments || "{}");
+      } catch {
+        parameters = {};
+      }
+      return { id: tc.id, name: tc.function.name, parameters };
+    });
   }
 };
 
@@ -937,7 +1251,12 @@ async function buildTree(dir, rootDir, gitignore, options, depth, fileCount) {
   if (depth >= options.maxDepth || fileCount.count >= options.maxFiles) {
     return [];
   }
-  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  let entries;
+  try {
+    entries = await fs2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
   const lines = [];
   const sortedEntries = entries.sort((a, b) => {
     if (a.isDirectory() && !b.isDirectory()) return -1;
@@ -981,123 +1300,6 @@ async function generateFolderTree(rootDir, options = {}) {
   return [header, ...lines].join("\n");
 }
 
-// persistent/memory.ts
-var InMemoryMemory = class {
-  store = /* @__PURE__ */ new Map();
-  async get(key) {
-    return this.store.get(key) ?? [];
-  }
-  async set(key, items) {
-    this.store.set(key, [...items]);
-  }
-  async append(key, items) {
-    const existing = this.store.get(key) ?? [];
-    this.store.set(key, [...existing, ...items]);
-  }
-  async delete(key) {
-    this.store.delete(key);
-  }
-  async keys() {
-    return Array.from(this.store.keys());
-  }
-  async clear() {
-    this.store.clear();
-  }
-  async exportSnapshot() {
-    const snap = {};
-    for (const [k, v] of this.store.entries()) snap[k] = [...v];
-    return snap;
-  }
-  async importSnapshot(snapshot) {
-    this.store.clear();
-    for (const [k, v] of Object.entries(snapshot)) this.store.set(k, [...v]);
-  }
-};
-var JsonFileMemoryPersistence = class {
-  constructor(filename = "history.json") {
-    this.filename = filename;
-  }
-  async load() {
-    try {
-      const fs10 = await import("fs");
-      if (!fs10.existsSync(this.filename)) return {};
-      const text = fs10.readFileSync(this.filename, "utf-8");
-      const data = JSON.parse(text);
-      return typeof data === "object" && data ? data : {};
-    } catch {
-      console.warn(`Failed to load memory from ${this.filename}`);
-      return {};
-    }
-  }
-  async save(snapshot) {
-    try {
-      const fs10 = await import("fs");
-      const path9 = await import("path");
-      const dir = path9.dirname(this.filename);
-      if (dir && dir !== "." && !fs10.existsSync(dir)) {
-        fs10.mkdirSync(dir, { recursive: true });
-      }
-      fs10.writeFileSync(this.filename, JSON.stringify(snapshot, null, 2), "utf-8");
-    } catch (err2) {
-      console.warn(`Failed to save memory to ${this.filename}`, err2);
-    }
-  }
-};
-var PersistedMemory = class {
-  constructor(persistence) {
-    this.persistence = persistence;
-  }
-  inner = new InMemoryMemory();
-  initialized = false;
-  async ensureInitialized() {
-    if (this.initialized) return;
-    const snap = await this.persistence.load();
-    if (snap && typeof snap === "object") await this.inner.importSnapshot(snap);
-    this.initialized = true;
-  }
-  async save() {
-    const snap = await this.inner.exportSnapshot();
-    await this.persistence.save(snap);
-  }
-  async get(key) {
-    await this.ensureInitialized();
-    return this.inner.get(key);
-  }
-  async set(key, items) {
-    await this.ensureInitialized();
-    await this.inner.set(key, items);
-    await this.save();
-  }
-  async append(key, items) {
-    await this.ensureInitialized();
-    await this.inner.append(key, items);
-    await this.save();
-  }
-  async delete(key) {
-    await this.ensureInitialized();
-    await this.inner.delete(key);
-    await this.save();
-  }
-  async keys() {
-    await this.ensureInitialized();
-    return this.inner.keys();
-  }
-  async clear() {
-    await this.ensureInitialized();
-    await this.inner.clear();
-    await this.save();
-  }
-  async exportSnapshot() {
-    await this.ensureInitialized();
-    return this.inner.exportSnapshot();
-  }
-  async importSnapshot(snapshot) {
-    await this.ensureInitialized();
-    await this.inner.importSnapshot(snapshot);
-    await this.save();
-  }
-};
-
 // persistent/metadata-memory.ts
 var MemoryPortMetadataAdapter = class {
   constructor(memory, prefix = "__metadata__") {
@@ -1232,6 +1434,27 @@ var ConversationStore = class {
     };
     await this.metadataMemory.set(conversationId, updatedMetadata);
   }
+  async recordRequestMetrics(conversationId, metrics) {
+    const metadata = await this.metadataMemory.get(conversationId);
+    const updatedMetadata = {
+      ...metadata,
+      promptTokens: (metadata?.promptTokens ?? 0) + (metrics.promptTokens ?? 0),
+      completionTokens: (metadata?.completionTokens ?? 0) + (metrics.completionTokens ?? 0),
+      totalTokens: (metadata?.totalTokens ?? 0) + (metrics.totalTokens ?? 0),
+      requestCount: (metadata?.requestCount ?? 0) + 1,
+      toolCallCount: (metadata?.toolCallCount ?? 0) + (metrics.toolCalls ?? 0),
+      totalTimeMs: (metadata?.totalTimeMs ?? 0) + (metrics.responseTimeMs ?? 0),
+      totalPrice: (metadata?.totalPrice ?? 0) + (metrics.cost ?? 0),
+      contextWindow: {
+        promptTokens: metrics.promptTokens,
+        completionTokens: metrics.completionTokens,
+        totalTokens: metrics.totalTokens
+      },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.metadataMemory.set(conversationId, updatedMetadata);
+    return updatedMetadata;
+  }
   async updateTopic(conversationId, topic) {
     const metadata = await this.metadataMemory.get(conversationId);
     const updatedMetadata = {
@@ -1294,41 +1517,6 @@ var ConversationContext = class {
   }
 };
 
-// id.ts
-var SimpleId = class {
-  uuid() {
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-      const r = Math.random() * 16 | 0;
-      const v = c === "x" ? r : r & 3 | 8;
-      return v.toString(16);
-    });
-  }
-};
-
-// clock.ts
-var SystemClock = class {
-  now() {
-    return Date.now();
-  }
-  iso(dateMs) {
-    return new Date(dateMs ?? Date.now()).toISOString();
-  }
-};
-
-// cost.ts
-var SimpleCost = class {
-  estimate(_model, usage) {
-    return usage?.cost;
-  }
-};
-
-// reminders.ts
-var NoopReminders = class {
-  enhance(content, _opts) {
-    return [content];
-  }
-};
-
 // todo-store.ts
 var TodoStore = class {
   constructor(memory) {
@@ -3627,9 +3815,12 @@ var AgentFilePersistence = class {
    * Load all agents from the agents directory
    */
   async loadAll() {
-    this.ensureAgentsDir();
     const agents = [];
     try {
+      this.ensureAgentsDir();
+      if (!fs8.existsSync(this.agentsDir)) {
+        return agents;
+      }
       const files = fs8.readdirSync(this.agentsDir);
       const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
       for (const file of yamlFiles) {
@@ -3642,8 +3833,7 @@ var AgentFilePersistence = class {
           console.warn(`Failed to load agent from ${file}:`, error);
         }
       }
-    } catch (error) {
-      console.warn("Failed to read agents directory:", error);
+    } catch (_error) {
     }
     return agents;
   }
@@ -3774,6 +3964,7 @@ function normalizeUsage(usage) {
   const prompt_tokens = usage.prompt_tokens ?? (typeof usageObj.input_tokens === "number" ? usageObj.input_tokens : void 0);
   const completion_tokens = usage.completion_tokens ?? (typeof usageObj.output_tokens === "number" ? usageObj.output_tokens : void 0);
   const total_tokens = usage.total_tokens ?? (prompt_tokens != null && completion_tokens != null ? prompt_tokens + completion_tokens : void 0);
+  const cost = usage.cost ?? (typeof usageObj.estimated_cost === "number" ? usageObj.estimated_cost : void 0);
   return {
     prompt_tokens,
     completion_tokens,
@@ -3781,7 +3972,7 @@ function normalizeUsage(usage) {
     ...usage.reasoning_tokens !== void 0 && { reasoning_tokens: usage.reasoning_tokens },
     ...usage.prompt_tokens_details && { prompt_tokens_details: usage.prompt_tokens_details },
     ...usage.completion_tokens_details && { completion_tokens_details: usage.completion_tokens_details },
-    ...usage.cost !== void 0 && { cost: usage.cost },
+    ...cost !== void 0 && { cost },
     ...usage.cost_details && { cost_details: usage.cost_details }
   };
 }
@@ -4520,11 +4711,13 @@ var BaseBearerAuthTransport = class {
   apiKey;
   baseUrl;
   version;
-  constructor(inner, apiKey, baseUrl, version) {
+  customHeaders;
+  constructor(inner, apiKey, baseUrl, version, customHeaders) {
     this.inner = inner;
     this.apiKey = apiKey;
     this.baseUrl = baseUrl ?? this.getDefaultBaseUrl();
     this.version = version;
+    this.customHeaders = customHeaders;
   }
   buildFullUrl(path9) {
     if (path9.startsWith("/")) {
@@ -4533,14 +4726,16 @@ var BaseBearerAuthTransport = class {
     return path9;
   }
   makeAuthHeaders(headers) {
-    if (!this.apiKey || this.apiKey.trim() === "") {
-      throw new Error("API key missing");
-    }
     const base = headers ? { ...headers } : {};
-    base.Authorization = `Bearer ${this.apiKey}`;
     if (!base["User-Agent"] && this.version) {
       base["User-Agent"] = `nuvin-cli/${this.version}`;
     }
+    if (this.apiKey && this.apiKey.trim() !== "" && !this.customHeaders?.Authorization) {
+      base.Authorization = `Bearer ${this.apiKey}`;
+    }
+    if (this.customHeaders) {
+      Object.assign(base, this.customHeaders);
+    }
     return base;
   }
   async get(url, headers, signal) {
@@ -4560,8 +4755,8 @@ var BaseBearerAuthTransport = class {
 // transports/simple-bearer-transport.ts
 var SimpleBearerAuthTransport = class extends BaseBearerAuthTransport {
   defaultUrl;
-  constructor(inner, defaultBaseUrl, apiKey, baseUrl, version) {
-    super(inner, apiKey, baseUrl ?? defaultBaseUrl, version);
+  constructor(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders) {
+    super(inner, apiKey, baseUrl ?? defaultBaseUrl, version, customHeaders);
     this.defaultUrl = defaultBaseUrl;
   }
   getDefaultBaseUrl() {
@@ -4570,8 +4765,107 @@ var SimpleBearerAuthTransport = class extends BaseBearerAuthTransport {
 };
 
 // transports/transport-factory.ts
-function createTransport(inner, defaultBaseUrl, apiKey, baseUrl, version) {
-  return new SimpleBearerAuthTransport(inner, defaultBaseUrl, apiKey, baseUrl, version);
+function createTransport(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders) {
+  return new SimpleBearerAuthTransport(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders);
+}
+
+// llm-providers/model-limits.ts
+function normalizeModelLimits(provider, model) {
+  switch (provider.toLowerCase()) {
+    case "github": {
+      const capabilities = model.capabilities;
+      const limits = capabilities?.limits;
+      const contextWindow = limits?.max_context_window_tokens;
+      if (!contextWindow) return null;
+      return {
+        contextWindow,
+        maxOutput: limits?.max_output_tokens
+      };
+    }
+    case "deepinfra": {
+      const metadata = model.metadata;
+      const contextLength = metadata?.context_length;
+      if (!contextLength) return null;
+      return {
+        contextWindow: contextLength,
+        maxOutput: metadata?.max_tokens
+      };
+    }
+    case "moonshot": {
+      const contextLength = model.context_length;
+      if (!contextLength) return null;
+      return { contextWindow: contextLength };
+    }
+    case "openrouter": {
+      const topProvider = model.top_provider;
+      const contextLength = model.context_length ?? topProvider?.context_length;
+      if (!contextLength) return null;
+      return {
+        contextWindow: contextLength,
+        maxOutput: topProvider?.max_completion_tokens
+      };
+    }
+    default: {
+      const contextLength = model.context_length;
+      if (!contextLength) return null;
+      return { contextWindow: contextLength };
+    }
+  }
+}
+var FALLBACK_LIMITS = {
+  zai: {
+    "glm-4.6": { contextWindow: 2e5, maxOutput: 128e3 }
+  },
+  openrouter: {
+    "anthropic/claude-sonnet-4": { contextWindow: 2e5, maxOutput: 16e3 },
+    "anthropic/claude-3.5-sonnet": { contextWindow: 2e5, maxOutput: 8192 },
+    "openai/gpt-4o": { contextWindow: 128e3, maxOutput: 16384 },
+    "openai/gpt-4.1": { contextWindow: 128e3, maxOutput: 32768 },
+    "openai/gpt-4o-mini": { contextWindow: 128e3, maxOutput: 16384 },
+    "google/gemini-pro-1.5": { contextWindow: 2097152, maxOutput: 8192 },
+    "meta-llama/llama-3.1-70b-instruct": { contextWindow: 131072, maxOutput: 131072 }
+  },
+  github: {
+    "gpt-4.1": { contextWindow: 128e3, maxOutput: 16384 },
+    "gpt-4o": { contextWindow: 128e3, maxOutput: 16384 },
+    "gpt-4o-mini": { contextWindow: 128e3, maxOutput: 16384 },
+    "claude-sonnet-4": { contextWindow: 2e5, maxOutput: 16e3 },
+    "claude-3.5-sonnet": { contextWindow: 2e5, maxOutput: 8192 },
+    o1: { contextWindow: 2e5, maxOutput: 1e5 },
+    "o1-mini": { contextWindow: 128e3, maxOutput: 65536 }
+  },
+  deepinfra: {
+    "meta-llama/Meta-Llama-3.1-70B-Instruct": { contextWindow: 131072, maxOutput: 131072 },
+    "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo": { contextWindow: 131072, maxOutput: 131072 },
+    "Qwen/Qwen2.5-72B-Instruct": { contextWindow: 131072, maxOutput: 131072 }
+  },
+  moonshot: {
+    "moonshot-v1-8k": { contextWindow: 8192 },
+    "moonshot-v1-32k": { contextWindow: 32768 },
+    "moonshot-v1-128k": { contextWindow: 131072 },
+    "kimi-k2-turbo-preview": { contextWindow: 262144 }
+  },
+  anthropic: {
+    "claude-sonnet-4-5": { contextWindow: 2e5, maxOutput: 16e3 },
+    "claude-3-5-sonnet-20241022": { contextWindow: 2e5, maxOutput: 8192 },
+    "claude-3-opus-20240229": { contextWindow: 2e5, maxOutput: 4096 },
+    "claude-3-haiku-20240307": { contextWindow: 2e5, maxOutput: 4096 }
+  }
+};
+function getFallbackLimits(provider, model) {
+  const providerLimits = FALLBACK_LIMITS[provider.toLowerCase()];
+  if (!providerLimits) return null;
+  return providerLimits[model] ?? null;
+}
+function normalizeModelInfo(provider, model) {
+  const id = model.id;
+  const name = model.name ?? id;
+  const limits = normalizeModelLimits(provider, model);
+  return {
+    id,
+    name,
+    ...limits ? { limits } : {}
+  };
 }
 
 // llm-providers/llm-github.ts
@@ -4604,7 +4898,7 @@ var GithubLLM = class extends BaseLLM {
       throw new LLMError(text || `Failed to fetch models: ${res.status}`, res.status);
     }
     const body = await res.json();
-    return body.data;
+    return body.data.map((m) => normalizeModelInfo("github", m));
   }
   handleError(error, model) {
     if (error instanceof LLMError) {
@@ -5127,6 +5421,19 @@ var llm_provider_config_default = {
         promptCaching: false,
         getModels: true
       }
+    },
+    {
+      name: "kimi-for-coding",
+      type: "openai-compat",
+      baseUrl: "https://api.kimi.com/coding/v1",
+      features: {
+        promptCaching: true,
+        getModels: true,
+        includeUsage: true
+      },
+      customHeaders: {
+        "User-Agent": "KimiCLI/0.59"
+      }
     }
   ]
 };
@@ -5137,12 +5444,16 @@ var GenericLLM = class extends BaseLLM {
   opts;
   includeUsage;
   modelConfig;
-  constructor(baseUrl, modelConfig, opts = {}) {
-    const { enablePromptCaching = false, includeUsage = false, ...restOpts } = opts;
+  providerName;
+  customHeaders;
+  constructor(baseUrl, modelConfig, opts = {}, customHeaders) {
+    const { enablePromptCaching = false, includeUsage = false, providerName = "unknown", ...restOpts } = opts;
     super(opts.apiUrl || baseUrl, { enablePromptCaching });
     this.includeUsage = includeUsage;
     this.modelConfig = modelConfig;
+    this.providerName = providerName;
     this.opts = restOpts;
+    this.customHeaders = customHeaders;
   }
   createTransport() {
     const base = new FetchTransport({
@@ -5152,14 +5463,17 @@ var GenericLLM = class extends BaseLLM {
       maxFileSize: 5 * 1024 * 1024,
       captureResponseBody: true
     });
-    return createTransport(base, this.apiUrl, this.opts.apiKey, this.opts.apiUrl, this.opts.version);
+    return createTransport(base, this.apiUrl, this.opts.apiKey, this.opts.apiUrl, this.opts.version, this.customHeaders);
   }
   async getModels(signal) {
     if (this.modelConfig === false) {
       throw new Error("Provider does not support getModels");
     }
     if (Array.isArray(this.modelConfig)) {
-      return this.modelConfig.map((m) => typeof m === "string" ? { id: m } : m);
+      return this.modelConfig.map((m) => {
+        const raw = typeof m === "string" ? { id: m } : m;
+        return normalizeModelInfo(this.providerName, raw);
+      });
     }
     if (typeof this.modelConfig === "string") {
       const transport2 = this.createTransport();
@@ -5169,7 +5483,7 @@ var GenericLLM = class extends BaseLLM {
         throw new Error(`Failed to fetch models: ${res2.status} ${text}`);
       }
       const data2 = await res2.json();
-      return data2.data;
+      return data2.data.map((m) => normalizeModelInfo(this.providerName, m));
     }
     const transport = this.createTransport();
     const res = await transport.get("/models", void 0, signal);
@@ -5178,7 +5492,7 @@ var GenericLLM = class extends BaseLLM {
       throw new Error(`Failed to fetch models: ${res.status} ${text}`);
     }
     const data = await res.json();
-    return data.data;
+    return data.data.map((m) => normalizeModelInfo(this.providerName, m));
   }
   async generateCompletion(params, signal) {
     let enhancedParams = params;
@@ -5217,6 +5531,7 @@ function mergeProviders(customProviders) {
         type: custom.type ?? "openai-compat",
         baseUrl: custom.baseUrl,
         models: custom.models ?? false,
+        customHeaders: custom.customHeaders,
         features: existing?.features ?? {
           promptCaching: false,
           getModels: custom.models !== false,
@@ -5237,9 +5552,10 @@ function createLLM(providerName, options = {}, customProviders) {
   const modelConfig = normalizeModelConfig(config);
   return new GenericLLM(config.baseUrl, modelConfig, {
     ...options,
+    providerName: config.name,
     enablePromptCaching: options.enablePromptCaching ?? config.features.promptCaching,
     includeUsage: options.includeUsage ?? config.features.includeUsage
-  });
+  }, config.customHeaders);
 }
 function getAvailableProviders(customProviders) {
   const allProviders = mergeProviders(customProviders);
@@ -5522,31 +5838,6 @@ function isValidConfig(value) {
   }
   return true;
 }
-
-// events.ts
-var PersistingConsoleEventPort = class {
-  memory;
-  maxPerConversation;
-  writeQueue = Promise.resolve();
-  constructor(opts) {
-    this.memory = opts?.memory ?? new PersistedMemory(new JsonFileMemoryPersistence(opts?.filename || "events.json"));
-    this.maxPerConversation = opts?.maxPerConversation ?? 500;
-  }
-  async emit(event) {
-    this.writeQueue = this.writeQueue.then(async () => {
-      try {
-        const key = event?.conversationId ?? "default";
-        const existing = await this.memory.get(key);
-        const next = [...existing, { ...event }];
-        const max = this.maxPerConversation;
-        const trimmed = max > 0 && next.length > max ? next.slice(next.length - max) : next;
-        await this.memory.set(key, trimmed);
-      } catch {
-      }
-    });
-    return this.writeQueue;
-  }
-};
 export {
   AGENT_CREATOR_SYSTEM_PROMPT,
   AgentEventTypes,
@@ -5570,11 +5861,13 @@ export {
   GithubLLM,
   InMemoryMemory,
   InMemoryMetadata,
+  InMemoryMetricsPort,
   JsonFileMemoryPersistence,
   LLMError,
   LLMResolver,
   MCPToolPort,
   MemoryPortMetadataAdapter,
+  NoopMetricsPort,
   NoopReminders,
   PersistedMemory,
   PersistingConsoleEventPort,
@@ -5587,10 +5880,14 @@ export {
   buildAgentCreationPrompt,
   buildInjectedSystem,
   canonicalizeTerminalPaste,
+  createEmptySnapshot,
   createLLM,
   generateFolderTree,
   getAvailableProviders,
+  getFallbackLimits,
   loadMCPConfig,
+  normalizeModelInfo,
+  normalizeModelLimits,
   normalizeNewlines,
   renderTemplate,
   resolveBackspaces,