@nuvin/nuvin-core 1.0.0 → 1.1.0

package/dist/index.js

@@ -14,7 +14,6 @@ var AgentEventTypes = {
   AssistantChunk: "assistant_chunk",
   AssistantMessage: "assistant_message",
   StreamFinish: "stream_finish",
-  MemoryAppended: "memory_appended",
   Done: "done",
   Error: "error",
   MCPStderr: "mcp_stderr",
@@ -161,19 +160,22 @@ var AgentOrchestrator = class {
     const todoTools = ["todo_write", "todo_read"];
     return readOnlyTools.includes(toolName) || todoTools.includes(toolName);
   }
-  async handleToolDenial(denialMessage, conversationId, messageId, accumulatedMessages, turnHistory, originalToolCalls, assistantContent) {
-    accumulatedMessages.push({
-      role: "assistant",
-      content: assistantContent ?? null,
-      tool_calls: originalToolCalls
-    });
-    turnHistory.push({
+  async handleToolDenial(denialMessage, conversationId, messageId, accumulatedMessages, turnHistory, originalToolCalls, assistantContent, usage) {
+    const assistantMsg = {
       id: this.deps.ids.uuid(),
       role: "assistant",
       content: assistantContent ?? null,
       timestamp: this.deps.clock.iso(),
+      tool_calls: originalToolCalls,
+      usage
+    };
+    accumulatedMessages.push({
+      role: "assistant",
+      content: assistantContent ?? null,
       tool_calls: originalToolCalls
     });
+    turnHistory.push(assistantMsg);
+    const toolResultMsgs = [];
     for (const toolCall of originalToolCalls) {
       const toolDenialResult = "Tool execution denied by user";
       accumulatedMessages.push({
@@ -182,23 +184,27 @@ var AgentOrchestrator = class {
         tool_call_id: toolCall.id,
         name: toolCall.function.name
       });
-      turnHistory.push({
+      const toolMsg = {
         id: toolCall.id,
         role: "tool",
         content: toolDenialResult,
         timestamp: this.deps.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({
       type: AgentEventTypes.AssistantMessage,
       conversationId,
       messageId,
-      content: denialMessage
+      content: denialMessage,
+      usage: void 0
     });
   }
-  async processToolApproval(toolCalls, conversationId, messageId, accumulatedMessages, turnHistory, assistantContent) {
+  async processToolApproval(toolCalls, conversationId, messageId, accumulatedMessages, turnHistory, assistantContent, usage) {
     if (this.cfg.requireToolApproval === false) {
       return { approvedCalls: toolCalls, wasDenied: false };
     }
@@ -220,7 +226,8 @@ var AgentOrchestrator = class {
         accumulatedMessages,
         turnHistory,
         toolCalls,
-        assistantContent
+        assistantContent,
+        usage
       );
       return { approvedCalls: [], wasDenied: true, denialMessage };
     }
@@ -263,6 +270,7 @@ var AgentOrchestrator = class {
       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);
     }
     if (opts.signal?.aborted) throw new Error("Aborted");
     const toolDefs = this.deps.tools.getToolDefinitions(this.cfg.enabledTools ?? []);
@@ -293,8 +301,10 @@ var AgentOrchestrator = class {
     let result;
     let toolApprovalDenied = false;
     let denialMessage = "";
+    let finalResponseSaved = false;
     try {
       if (opts.stream && typeof this.deps.llm.streamCompletion === "function") {
+        let isFirstChunk = true;
         result = await this.deps.llm.streamCompletion(
           params,
           {
@@ -303,7 +313,8 @@ var AgentOrchestrator = class {
                 streamedAssistantContent += delta;
               } catch {
               }
-              const cleanDelta = delta.replace(/^\n+/, "");
+              const cleanDelta = isFirstChunk ? delta.replace(/^\n+/, "") : delta;
+              isFirstChunk = false;
               const chunkEvent = {
                 type: AgentEventTypes.AssistantChunk,
                 conversationId: convo,
@@ -329,6 +340,28 @@ var AgentOrchestrator = class {
       } else {
         result = await this.deps.llm.generateCompletion(params, opts.signal);
       }
+      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.deps.clock.iso(),
+          usage: result.usage
+        };
+        await this.deps.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.deps.events?.emit(messageEvent);
+        }
+      }
       while (result.tool_calls?.length) {
         if (result.content?.trim()) {
           const messageEvent = {
@@ -345,7 +378,8 @@ var AgentOrchestrator = class {
           type: AgentEventTypes.ToolCalls,
           conversationId: convo,
           messageId: msgId,
-          toolCalls: result.tool_calls
+          toolCalls: result.tool_calls,
+          usage: result.usage
         });
         const approvalResult = await this.processToolApproval(
           result.tool_calls,
@@ -353,7 +387,8 @@ var AgentOrchestrator = class {
           msgId,
           accumulatedMessages,
           turnHistory,
-          result.content
+          result.content,
+          result.usage
         );
         if (approvalResult.wasDenied) {
           denialMessage = approvalResult.denialMessage || "";
@@ -375,18 +410,18 @@ var AgentOrchestrator = class {
           opts.signal
         );
         allToolResults.push(...toolResults);
-        accumulatedMessages.push({ role: "assistant", content: result.content ?? null, tool_calls: approvedCalls });
-        turnHistory.push({
+        const assistantMsg = {
           id: this.deps.ids.uuid(),
           role: "assistant",
           content: result.content ?? null,
           timestamp: this.deps.clock.iso(),
-          tool_calls: approvedCalls
-        });
+          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);
-          accumulatedMessages.push({ role: "tool", content: contentStr, tool_call_id: tr.id, name: tr.name });
-          turnHistory.push({
+          toolResultMsgs.push({
             id: tr.id,
             role: "tool",
             content: contentStr,
@@ -401,8 +436,16 @@ var AgentOrchestrator = class {
             result: tr
           });
         }
+        await this.deps.memory.append(convo, [assistantMsg, ...toolResultMsgs]);
+        accumulatedMessages.push({ 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 },
             {
@@ -411,7 +454,8 @@ var AgentOrchestrator = class {
                   streamedAssistantContent += delta;
                 } catch {
                 }
-                const cleanDelta = delta.replace(/^\n+/, "");
+                const cleanDelta = isFirstChunk ? delta.replace(/^\n+/, "") : delta;
+                isFirstChunk = false;
                 const chunkEvent = {
                   type: AgentEventTypes.AssistantChunk,
                   conversationId: convo,
@@ -437,16 +481,32 @@ var AgentOrchestrator = class {
         } 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 newHistory = [];
-      for (const m of userMessages) newHistory.push(m);
-      for (const m of turnHistory) newHistory.push(m);
-      if (!toolApprovalDenied) {
-        newHistory.push({ id: msgId, role: "assistant", content: result.content, timestamp });
-      }
-      const shouldEmitFinalMessage = result.content?.trim() && !toolApprovalDenied;
+      const shouldEmitFinalMessage = result.content?.trim() && !toolApprovalDenied && !finalResponseSaved;
       if (shouldEmitFinalMessage) {
         const messageEvent = {
           type: AgentEventTypes.AssistantMessage,
@@ -475,8 +535,6 @@ var AgentOrchestrator = class {
           toolCalls: allToolResults.length
         }
       };
-      await this.deps.memory.append(convo, newHistory);
-      await this.deps.events?.emit({ type: AgentEventTypes.MemoryAppended, conversationId: convo, delta: newHistory });
       await this.deps.events?.emit({
         type: AgentEventTypes.Done,
         conversationId: convo,
@@ -486,26 +544,6 @@ var AgentOrchestrator = class {
       });
       return resp;
     } catch (err2) {
-      try {
-        const partial = [];
-        for (const m of userMessages) partial.push(m);
-        for (const m of turnHistory) partial.push(m);
-        const partialAssistant = (streamedAssistantContent || "").trim();
-        const assistantAlreadyRecorded = turnHistory.some((m) => m.role === "assistant");
-        if (partialAssistant && !assistantAlreadyRecorded) {
-          partial.push({
-            id: this.deps.ids.uuid(),
-            role: "assistant",
-            content: partialAssistant,
-            timestamp: this.deps.clock.iso()
-          });
-        }
-        if (partial.length) {
-          await this.deps.memory.append(convo, partial);
-          await this.deps.events?.emit({ type: AgentEventTypes.MemoryAppended, conversationId: convo, delta: partial });
-        }
-      } catch {
-      }
       throw err2;
     }
   }
@@ -1251,9 +1289,8 @@ var SystemClock = class {
 
 // cost.ts
 var SimpleCost = class {
-  // Demo cost: $0.00 (undefined) to avoid implying pricing; could be extended
-  estimate(_model, _usage) {
-    return void 0;
+  estimate(_model, usage) {
+    return usage?.cost;
   }
 };
 
@@ -1843,7 +1880,10 @@ var FileReadTool = class {
   parameters = {
     type: "object",
     properties: {
-      description: { type: "string", description: 'Explanation of what file is being read and why (e.g., "Read package.json to check dependencies")' },
+      description: {
+        type: "string",
+        description: 'Explanation of what file is being read and why (e.g., "Read package.json to check dependencies")'
+      },
       path: { type: "string", description: "Read contents of this file" },
       lineStart: { type: "integer", minimum: 1, description: "Start reading from this line number (1-based)" },
       lineEnd: { type: "integer", minimum: 1, description: "Stop reading at this line number (inclusive)" }
@@ -1884,7 +1924,7 @@ var FileReadTool = class {
         const [lo, hi] = a <= b ? [a, b] : [b, a];
         const numberedLines = lines.slice(lo - 1, hi).map((line, index) => {
           const lineNum = lo + index;
-          return `${lineNum}:${line}`;
+          return `${lineNum}\u2502${line}`;
         });
         const slice = numberedLines.join("\n");
         return ok(slice, {
@@ -3643,59 +3683,6 @@ var AgentFilePersistence = class {
   }
 };
 
-// llm-providers/llm-echo.ts
-var EchoLLM = class {
-  async generateCompletion(params) {
-    const last = [...params.messages].reverse().find((m) => m.role === "user");
-    const content = String(last?.content ?? "");
-    const toolCalls = [];
-    if (content.startsWith("!reverse ") && this.hasTool(params, "reverse_text")) {
-      const text = content.slice("!reverse ".length);
-      toolCalls.push({
-        id: this.id("rev"),
-        type: "function",
-        function: { name: "reverse_text", arguments: JSON.stringify({ text }) }
-      });
-    } else if (content.startsWith("!wc ") && this.hasTool(params, "word_count")) {
-      const text = content.slice("!wc ".length);
-      toolCalls.push({
-        id: this.id("wc"),
-        type: "function",
-        function: { name: "word_count", arguments: JSON.stringify({ text }) }
-      });
-    } else if (content.startsWith("!todo ") && this.hasTool(params, "todo_write")) {
-      const payload = content.slice("!todo ".length);
-      let todos;
-      try {
-        todos = JSON.parse(payload);
-      } catch {
-        todos = [];
-      }
-      toolCalls.push({
-        id: this.id("todo"),
-        type: "function",
-        function: { name: "todo_write", arguments: JSON.stringify({ todos }) }
-      });
-    }
-    const sawTool = params.messages.some((m) => m.role === "tool");
-    if (sawTool) {
-      const lastTool = [...params.messages].reverse().find((m) => m.role === "tool");
-      const toolText = typeof lastTool?.content === "string" ? lastTool.content : "";
-      return { content: `Tool result: ${toolText}` };
-    }
-    if (toolCalls.length > 0) {
-      return { content: "", tool_calls: toolCalls };
-    }
-    return { content: `Echo: ${content}` };
-  }
-  hasTool(params, name) {
-    return !!params.tools?.some((t) => t.function.name === name);
-  }
-  id(prefix) {
-    return `${prefix}_${Math.random().toString(36).slice(2, 10)}`;
-  }
-};
-
 // llm-providers/llm-utils.ts
 function mergeChoices(choices) {
   const contentParts = [];
@@ -3794,9 +3781,7 @@ var BaseLLM = class {
         }
       }
     }
-    const userAssistantMessages = messages.filter(
-      (msg) => msg.role === "user" || msg.role === "assistant"
-    );
+    const userAssistantMessages = messages.filter((msg) => msg.role === "user" || msg.role === "assistant");
     const lastTwoIndices = [];
     if (userAssistantMessages.length >= 2) {
       for (let i = userAssistantMessages.length - 2; i < userAssistantMessages.length; i++) {
@@ -3839,7 +3824,8 @@ var BaseLLM = class {
       ...enhancedParams.usage && { usage: enhancedParams.usage }
     };
     if (enhancedParams.tools && enhancedParams.tools.length > 0) body.tools = enhancedParams.tools;
-    if (enhancedParams.tool_choice && enhancedParams.tools && enhancedParams.tools.length > 0) body.tool_choice = enhancedParams.tool_choice;
+    if (enhancedParams.tool_choice && enhancedParams.tools && enhancedParams.tools.length > 0)
+      body.tool_choice = enhancedParams.tool_choice;
     const res = await this.getTransport().postJson("/chat/completions", body, void 0, signal);
     if (!res.ok) {
       const text = await res.text();
@@ -3864,7 +3850,8 @@ var BaseLLM = class {
       ...enhancedParams.usage && { usage: enhancedParams.usage }
     };
     if (enhancedParams.tools && enhancedParams.tools.length > 0) body.tools = enhancedParams.tools;
-    if (enhancedParams.tool_choice && enhancedParams.tools && enhancedParams.tools.length > 0) body.tool_choice = enhancedParams.tool_choice;
+    if (enhancedParams.tool_choice && enhancedParams.tools && enhancedParams.tools.length > 0)
+      body.tool_choice = enhancedParams.tool_choice;
     const res = await this.getTransport().postStream(
       "/chat/completions",
       body,
@@ -3883,6 +3870,7 @@ var BaseLLM = class {
     let content = "";
     const mergedToolCalls = [];
     let usage;
+    let lastFinishReason;
     const flushEvent = (rawEvent) => {
       const lines = rawEvent.split("\n");
       const dataLines = [];
@@ -3895,11 +3883,15 @@ var BaseLLM = class {
       try {
         const evt = JSON.parse(dataStr);
         const choices = Array.isArray(evt.choices) ? evt.choices : [];
-        const finishReason = choices.find((ch) => ch.finish_reason)?.finish_reason;
-        if (evt.usage) {
-          usage = normalizeUsage(evt.usage);
-          if (finishReason && handlers.onStreamFinish) {
-            handlers.onStreamFinish(finishReason, usage);
+        const finishReason = choices.find((ch) => ch.finish_reason && ch.finish_reason !== null)?.finish_reason;
+        if (finishReason) {
+          lastFinishReason = finishReason;
+        }
+        const usageData = evt.usage || choices[0]?.usage;
+        if (usageData) {
+          usage = normalizeUsage(usageData);
+          if (lastFinishReason && handlers.onStreamFinish) {
+            handlers.onStreamFinish(lastFinishReason, usage);
           } else {
             handlers.onChunk?.("", usage);
           }
@@ -4447,15 +4439,17 @@ var GithubAuthTransport = class {
   }
 };
 
-// transports/openrouter-transport.ts
-var OpenRouterAuthTransport = class {
+// transports/base-bearer-auth-transport.ts
+var BaseBearerAuthTransport = class {
   inner;
   apiKey;
   baseUrl;
-  constructor(inner, apiKey, baseUrl) {
+  version;
+  constructor(inner, apiKey, baseUrl, version) {
     this.inner = inner;
     this.apiKey = apiKey;
-    this.baseUrl = baseUrl ?? "https://openrouter.ai/api/v1";
+    this.baseUrl = baseUrl ?? this.getDefaultBaseUrl();
+    this.version = version;
   }
   buildFullUrl(path9) {
     if (path9.startsWith("/")) {
@@ -4468,45 +4462,10 @@ var OpenRouterAuthTransport = class {
       throw new Error("API key missing");
     }
     const base = headers ? { ...headers } : {};
-    base["Authorization"] = `Bearer ${this.apiKey}`;
-    return base;
-  }
-  async get(url, headers, signal) {
-    const fullUrl = this.buildFullUrl(url);
-    return this.inner.get(fullUrl, this.makeAuthHeaders(headers), signal);
-  }
-  async postJson(url, body, headers, signal) {
-    const fullUrl = this.buildFullUrl(url);
-    return this.inner.postJson(fullUrl, body, this.makeAuthHeaders(headers), signal);
-  }
-  async postStream(url, body, headers, signal) {
-    const fullUrl = this.buildFullUrl(url);
-    return this.inner.postStream(fullUrl, body, this.makeAuthHeaders(headers), signal);
-  }
-};
-
-// transports/deepinfra-transport.ts
-var DeepInfraAuthTransport = class {
-  inner;
-  apiKey;
-  baseUrl;
-  constructor(inner, apiKey, baseUrl) {
-    this.inner = inner;
-    this.apiKey = apiKey;
-    this.baseUrl = baseUrl ?? "https://api.deepinfra.com/v1/openai";
-  }
-  buildFullUrl(path9) {
-    if (path9.startsWith("/")) {
-      return `${this.baseUrl}${path9}`;
-    }
-    return path9;
-  }
-  makeAuthHeaders(headers) {
-    if (!this.apiKey || this.apiKey.trim() === "") {
-      throw new Error("API key missing");
+    base.Authorization = `Bearer ${this.apiKey}`;
+    if (!base["User-Agent"] && this.version) {
+      base["User-Agent"] = `nuvin-cli/${this.version}`;
     }
-    const base = headers ? { ...headers } : {};
-    base["Authorization"] = `Bearer ${this.apiKey}`;
     return base;
   }
   async get(url, headers, signal) {
@@ -4523,142 +4482,22 @@ var DeepInfraAuthTransport = class {
   }
 };
 
-// transports/zai-transport.ts
-var ZAIAuthTransport = class {
-  inner;
-  apiKey;
-  baseUrl;
-  constructor(inner, apiKey, baseUrl) {
-    this.inner = inner;
-    this.apiKey = apiKey;
-    this.baseUrl = baseUrl ?? "https://api.z.ai/api/coding/paas/v4";
-  }
-  buildFullUrl(path9) {
-    if (path9.startsWith("/")) {
-      return `${this.baseUrl}${path9}`;
-    }
-    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}`;
-    return base;
-  }
-  async get(url, headers, signal) {
-    const fullUrl = this.buildFullUrl(url);
-    return this.inner.get(fullUrl, this.makeAuthHeaders(headers), signal);
+// transports/simple-bearer-transport.ts
+var SimpleBearerAuthTransport = class extends BaseBearerAuthTransport {
+  defaultUrl;
+  constructor(inner, defaultBaseUrl, apiKey, baseUrl, version) {
+    super(inner, apiKey, baseUrl ?? defaultBaseUrl, version);
+    this.defaultUrl = defaultBaseUrl;
   }
-  async postJson(url, body, headers, signal) {
-    const fullUrl = this.buildFullUrl(url);
-    return this.inner.postJson(fullUrl, body, this.makeAuthHeaders(headers), signal);
-  }
-  async postStream(url, body, headers, signal) {
-    const fullUrl = this.buildFullUrl(url);
-    return this.inner.postStream(fullUrl, body, this.makeAuthHeaders(headers), signal);
+  getDefaultBaseUrl() {
+    return this.defaultUrl;
   }
 };
 
-// transports/anthropic-transport.ts
-var AnthropicAuthTransport = class {
-  apiKey;
-  oauth;
-  baseUrl;
-  inner;
-  constructor(inner, opts = {}) {
-    this.inner = inner;
-    this.apiKey = opts.apiKey;
-    this.oauth = opts.oauth;
-    this.baseUrl = opts.baseUrl || "https://api.anthropic.com";
-  }
-  async refreshOAuth(signal) {
-    if (!this.oauth?.refresh) return;
-    if (this.oauth.expires > Date.now()) return;
-    try {
-      const response = await fetch("https://console.anthropic.com/v1/oauth/token", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          grant_type: "refresh_token",
-          refresh_token: this.oauth.refresh,
-          client_id: "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
-        }),
-        signal
-      });
-      if (!response.ok) {
-        throw new Error(`OAuth token refresh failed: ${response.status} ${response.statusText}`);
-      }
-      const data = await response.json();
-      this.oauth = {
-        type: "oauth",
-        access: data.access_token,
-        refresh: data.refresh_token || this.oauth.refresh,
-        expires: Date.now() + data.expires_in * 1e3
-      };
-    } catch (error) {
-      throw new Error(`Failed to refresh OAuth token: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  buildFullUrl(path9) {
-    if (path9.startsWith("/")) {
-      return `${this.baseUrl}${path9}`;
-    }
-    return path9;
-  }
-  getAuthHeaders() {
-    const headers = {};
-    if (this.oauth) {
-      headers.authorization = `Bearer ${this.oauth.access}`;
-    } else if (this.apiKey) {
-      headers["x-api-key"] = this.apiKey;
-    } else {
-      throw new Error("No authentication credentials provided");
-    }
-    headers["anthropic-version"] = "2023-06-01";
-    headers["anthropic-beta"] = [
-      "claude-code-20250219",
-      "interleaved-thinking-2025-05-14",
-      "fine-grained-tool-streaming-2025-05-14"
-    ].join(",");
-    return headers;
-  }
-  async get(url, headers, signal) {
-    if (this.oauth) {
-      await this.refreshOAuth(signal);
-    }
-    const fullUrl = this.buildFullUrl(url);
-    const authHeaders = this.getAuthHeaders();
-    const mergedHeaders = { ...authHeaders, ...headers };
-    return this.inner.get(fullUrl, mergedHeaders, signal);
-  }
-  async postJson(url, body, headers, signal) {
-    if (this.oauth) {
-      await this.refreshOAuth(signal);
-    }
-    const fullUrl = this.buildFullUrl(url);
-    const authHeaders = this.getAuthHeaders();
-    const mergedHeaders = { ...authHeaders, ...headers };
-    return this.inner.postJson(fullUrl, body, mergedHeaders, signal);
-  }
-  async postStream(url, body, headers, signal) {
-    if (this.oauth) {
-      await this.refreshOAuth(signal);
-    }
-    const fullUrl = this.buildFullUrl(url);
-    const authHeaders = this.getAuthHeaders();
-    const mergedHeaders = { ...authHeaders, ...headers };
-    return this.inner.postStream(fullUrl, body, mergedHeaders, signal);
-  }
-  // Method to update OAuth credentials (useful for token refresh from config)
-  updateCredentials(opts) {
-    if (opts.apiKey) this.apiKey = opts.apiKey;
-    if (opts.oauth) this.oauth = opts.oauth;
-  }
-};
+// transports/transport-factory.ts
+function createTransport(inner, defaultBaseUrl, apiKey, baseUrl, version) {
+  return new SimpleBearerAuthTransport(inner, defaultBaseUrl, apiKey, baseUrl, version);
+}
 
 // llm-providers/llm-github.ts
 var GithubLLM = class extends BaseLLM {
@@ -4685,392 +4524,6 @@ var GithubLLM = class extends BaseLLM {
   }
 };
 
-// llm-providers/llm-openrouter.ts
-var OpenRouterLLM = class extends BaseLLM {
-  includeUsage;
-  constructor(opts = {}) {
-    const { enablePromptCaching = true, includeUsage = true, ...restOpts } = opts;
-    super("https://openrouter.ai/api/v1", { enablePromptCaching });
-    this.includeUsage = includeUsage;
-    this.opts = restOpts;
-  }
-  opts;
-  createTransport() {
-    const base = new FetchTransport({ persistFile: this.opts.httpLogFile });
-    return new OpenRouterAuthTransport(base, this.opts.apiKey, this.apiUrl);
-  }
-  async generateCompletion(params, signal) {
-    let enhancedParams = params;
-    if (this.includeUsage && !enhancedParams.usage) {
-      enhancedParams = { ...enhancedParams, usage: { include: true } };
-    }
-    return super.generateCompletion(enhancedParams, signal);
-  }
-  async streamCompletion(params, handlers, signal) {
-    let enhancedParams = params;
-    if (this.includeUsage && !enhancedParams.usage) {
-      enhancedParams = { ...enhancedParams, usage: { include: true } };
-    }
-    return super.streamCompletion(enhancedParams, handlers, signal);
-  }
-  async getModels(signal) {
-    const transport = this.createTransport();
-    const res = await transport.get("/models", void 0, signal);
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Failed to fetch models: ${res.status} ${text}`);
-    }
-    const data = await res.json();
-    return data.data;
-  }
-};
-
-// llm-providers/llm-deepinfra.ts
-var DeepInfraLLM = class extends BaseLLM {
-  opts;
-  constructor(opts = {}) {
-    super(opts.apiUrl || "https://api.deepinfra.com/v1/openai");
-    this.opts = opts;
-  }
-  createTransport() {
-    const base = new FetchTransport({ persistFile: this.opts.httpLogFile });
-    return new DeepInfraAuthTransport(base, this.opts.apiKey || process.env.DEEPINFRA_API_KEY, this.opts.apiUrl);
-  }
-  async getModels(signal) {
-    const transport = this.createTransport();
-    const res = await transport.get("/models", void 0, signal);
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Failed to fetch models: ${res.status} ${text}`);
-    }
-    const data = await res.json();
-    return data.data;
-  }
-};
-
-// llm-providers/llm-zai.ts
-var ZaiLLM = class extends BaseLLM {
-  opts;
-  constructor(opts = {}) {
-    super("https://api.z.ai/api/coding/paas/v4");
-    this.opts = opts;
-  }
-  createTransport() {
-    const base = new FetchTransport({
-      persistFile: this.opts.httpLogFile,
-      logLevel: "INFO",
-      enableConsoleLog: false,
-      maxFileSize: 5 * 1024 * 1024,
-      // 5MB before rotation
-      captureResponseBody: true
-      // Disable for better performance
-    });
-    return new ZAIAuthTransport(base, this.opts.apiKey, this.apiUrl);
-  }
-};
-
-// llm-providers/llm-anthropic.ts
-var AnthropicLLM = class {
-  transport = null;
-  opts;
-  apiUrl;
-  constructor(opts = {}) {
-    this.opts = opts;
-    this.apiUrl = opts.apiUrl || "https://api.anthropic.com";
-  }
-  getTransport() {
-    if (!this.transport) {
-      const base = new FetchTransport({
-        persistFile: this.opts.httpLogFile
-      });
-      this.transport = new AnthropicAuthTransport(base, {
-        apiKey: this.opts.apiKey,
-        oauth: this.opts.oauth,
-        baseUrl: this.apiUrl
-      });
-    }
-    return this.transport;
-  }
-  transformToAnthropicMessages(messages) {
-    const systemMessages = [];
-    const anthropicMessages = [];
-    for (const msg of messages) {
-      if (msg.role === "system") {
-        if (typeof msg.content === "string") {
-          systemMessages.push(msg.content);
-        } else if (Array.isArray(msg.content)) {
-          for (const part of msg.content) {
-            if (part.type === "text") {
-              systemMessages.push(part.text);
-            }
-          }
-        }
-        continue;
-      }
-      if (msg.role === "tool") {
-        const lastMsg = anthropicMessages[anthropicMessages.length - 1];
-        if (lastMsg && lastMsg.role === "user" && Array.isArray(lastMsg.content)) {
-          lastMsg.content.push({
-            type: "tool_result",
-            tool_use_id: msg.tool_call_id || "",
-            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-          });
-        } else {
-          anthropicMessages.push({
-            role: "user",
-            content: [
-              {
-                type: "tool_result",
-                tool_use_id: msg.tool_call_id || "",
-                content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-              }
-            ]
-          });
-        }
-        continue;
-      }
-      const content = [];
-      if (typeof msg.content === "string" && msg.content) {
-        content.push({ type: "text", text: msg.content });
-      } else if (Array.isArray(msg.content)) {
-        for (const part of msg.content) {
-          if (part.type === "text") {
-            content.push({ type: "text", text: part.text });
-          } else if (part.type === "image_url") {
-            const url = part.image_url.url;
-            if (url.startsWith("data:")) {
-              const match = url.match(/^data:([^;]+);base64,(.+)$/);
-              if (match) {
-                content.push({
-                  type: "image",
-                  source: {
-                    type: "base64",
-                    media_type: match[1],
-                    data: match[2]
-                  }
-                });
-              }
-            }
-          }
-        }
-      }
-      if (msg.tool_calls) {
-        for (const toolCall of msg.tool_calls) {
-          content.push({
-            type: "tool_use",
-            id: toolCall.id,
-            name: toolCall.function.name,
-            input: JSON.parse(toolCall.function.arguments || "{}")
-          });
-        }
-      }
-      if (content.length > 0) {
-        anthropicMessages.push({
-          role: msg.role === "assistant" ? "assistant" : "user",
-          content: content.length === 1 && content[0].type === "text" ? content[0].text : content
-        });
-      }
-    }
-    const result = {
-      messages: anthropicMessages
-    };
-    if (systemMessages.length > 0) {
-      result.system = [
-        {
-          type: "text",
-          text: "You are Claude Code, Anthropic's official CLI for Claude."
-        },
-        { type: "text", text: systemMessages.join("\n\n") }
-      ];
-    }
-    return result;
-  }
-  transformTools(tools) {
-    if (!tools || tools.length === 0) return void 0;
-    return tools.map((tool) => ({
-      name: tool.function.name,
-      description: tool.function.description,
-      input_schema: tool.function.parameters
-    }));
-  }
-  transformToolChoice(toolChoice) {
-    if (!toolChoice || toolChoice === "auto") {
-      return { type: "auto" };
-    }
-    if (toolChoice === "none") {
-      return void 0;
-    }
-    if (typeof toolChoice === "object" && toolChoice.type === "function") {
-      return { type: "tool", name: toolChoice.function.name };
-    }
-    return { type: "auto" };
-  }
-  transformResponse(response) {
-    let content = "";
-    const tool_calls = [];
-    for (const block of response.content) {
-      if (block.type === "text") {
-        content += block.text;
-      } else if (block.type === "tool_use") {
-        tool_calls.push({
-          id: block.id,
-          type: "function",
-          function: {
-            name: block.name,
-            arguments: JSON.stringify(block.input)
-          }
-        });
-      }
-    }
-    const usage = {
-      prompt_tokens: response.usage.input_tokens,
-      completion_tokens: response.usage.output_tokens,
-      total_tokens: response.usage.input_tokens + response.usage.output_tokens
-    };
-    return {
-      content,
-      ...tool_calls.length > 0 ? { tool_calls } : {},
-      usage
-    };
-  }
-  async generateCompletion(params, signal) {
-    const { system, messages } = this.transformToAnthropicMessages(params.messages);
-    const tools = this.transformTools(params.tools);
-    const tool_choice = tools ? this.transformToolChoice(params.tool_choice) : void 0;
-    const body = {
-      model: params.model,
-      messages,
-      max_tokens: params.maxTokens ?? 10240,
-      temperature: params.temperature,
-      stream: false,
-      // ...(params.topP !== undefined && { top_p: params.topP }),
-      ...system && { system },
-      ...tools && { tools },
-      ...tool_choice && { tool_choice }
-    };
-    const res = await this.getTransport().postJson("/v1/messages", body, void 0, signal);
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(text || `Anthropic API error ${res.status}`);
-    }
-    const data = await res.json();
-    return this.transformResponse(data);
-  }
-  async streamCompletion(params, handlers = {}, signal) {
-    const { system, messages } = this.transformToAnthropicMessages(params.messages);
-    const tools = this.transformTools(params.tools);
-    const tool_choice = tools ? this.transformToolChoice(params.tool_choice) : void 0;
-    const body = {
-      model: params.model,
-      messages,
-      max_tokens: params.maxTokens ?? 10240,
-      temperature: params.temperature,
-      stream: true,
-      // ...(params.topP !== undefined && { top_p: params.topP }),
-      ...system && { system },
-      ...tools && { tools },
-      ...tool_choice && { tool_choice }
-    };
-    const res = await this.getTransport().postStream("/v1/messages", body, { Accept: "text/event-stream" }, signal);
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(text || `Anthropic stream error ${res.status}`);
-    }
-    const reader = res.body?.getReader();
-    if (!reader) return { content: "" };
-    const decoder = new TextDecoder("utf-8");
-    let buffer = "";
-    let content = "";
-    const toolCalls = /* @__PURE__ */ new Map();
-    let usage;
-    let inputTokens = 0;
-    let stopReason = null;
-    const processEvent = (eventData) => {
-      try {
-        const event = JSON.parse(eventData);
-        if (event.type === "message_start") {
-          if (event.message?.usage) {
-            inputTokens = event.message.usage.input_tokens || 0;
-          }
-        } else if (event.type === "content_block_start") {
-          const block = event.content_block;
-          if (block?.type === "tool_use" && "id" in block && "name" in block) {
-            toolCalls.set(event.index, {
-              id: String(block.id),
-              type: "function",
-              function: {
-                name: String(block.name) || "",
-                arguments: ""
-              }
-            });
-          }
-        } else if (event.type === "content_block_delta") {
-          if (event.delta.type === "text_delta") {
-            const textDelta = event.delta.text;
-            if (textDelta) {
-              content += textDelta;
-              handlers.onChunk?.(textDelta);
-            }
-          } else if (event.delta.type === "input_json_delta") {
-            const toolCall = toolCalls.get(event.index);
-            if (toolCall) {
-              toolCall.function.arguments += event.delta.partial_json;
-              handlers.onToolCallDelta?.(toolCall);
-            }
-          }
-        } else if (event.type === "message_delta") {
-          if (event.delta.stop_reason) {
-            stopReason = event.delta.stop_reason;
-          }
-          if (event.usage) {
-            usage = {
-              prompt_tokens: inputTokens,
-              completion_tokens: event.usage.output_tokens,
-              total_tokens: inputTokens + event.usage.output_tokens
-            };
-          }
-        } else if (event.type === "message_stop") {
-          if (handlers.onStreamFinish) {
-            handlers.onStreamFinish(stopReason || void 0, usage);
-          }
-        }
-      } catch (err2) {
-      }
-    };
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      const chunk = decoder.decode(value, { stream: true });
-      buffer += chunk;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6).trim();
-          if (data && data !== "[DONE]") {
-            processEvent(data);
-          }
-        }
-      }
-    }
-    if (buffer.trim()) {
-      const line = buffer.trim();
-      if (line.startsWith("data: ")) {
-        const data = line.slice(6).trim();
-        if (data && data !== "[DONE]") {
-          processEvent(data);
-        }
-      }
-    }
-    const tool_calls = toolCalls.size > 0 ? Array.from(toolCalls.values()) : void 0;
-    return {
-      content,
-      ...tool_calls && { tool_calls },
-      ...usage && { usage }
-    };
-  }
-};
-
 // llm-providers/llm-anthropic-aisdk.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import {
@@ -5515,6 +4968,171 @@ var AnthropicAISDKLLM = class {
   }
 };
 
+// llm-providers/llm-provider-config.json
+var llm_provider_config_default = {
+  providers: [
+    {
+      name: "deepinfra",
+      type: "openai-compat",
+      baseUrl: "https://api.deepinfra.com/v1/openai",
+      features: {
+        promptCaching: false,
+        getModels: true
+      }
+    },
+    {
+      name: "openrouter",
+      type: "openai-compat",
+      baseUrl: "https://openrouter.ai/api/v1",
+      features: {
+        promptCaching: true,
+        getModels: true,
+        includeUsage: true
+      }
+    },
+    {
+      name: "zai",
+      type: "openai-compat",
+      baseUrl: "https://api.z.ai/api/coding/paas/v4",
+      features: {
+        promptCaching: false,
+        getModels: false
+      }
+    },
+    {
+      name: "moonshot",
+      type: "openai-compat",
+      baseUrl: "https://api.moonshot.ai/v1",
+      features: {
+        promptCaching: false,
+        getModels: true
+      }
+    }
+  ]
+};
+
+// llm-providers/llm-factory.ts
+var providers = llm_provider_config_default.providers;
+var GenericLLM = class extends BaseLLM {
+  opts;
+  includeUsage;
+  modelConfig;
+  constructor(baseUrl, modelConfig, opts = {}) {
+    const { enablePromptCaching = false, includeUsage = false, ...restOpts } = opts;
+    super(opts.apiUrl || baseUrl, { enablePromptCaching });
+    this.includeUsage = includeUsage;
+    this.modelConfig = modelConfig;
+    this.opts = restOpts;
+  }
+  createTransport() {
+    const base = new FetchTransport({
+      persistFile: this.opts.httpLogFile,
+      logLevel: "INFO",
+      enableConsoleLog: false,
+      maxFileSize: 5 * 1024 * 1024,
+      captureResponseBody: true
+    });
+    return createTransport(base, this.apiUrl, this.opts.apiKey, this.opts.apiUrl, this.opts.version);
+  }
+  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);
+    }
+    if (typeof this.modelConfig === "string") {
+      const transport2 = this.createTransport();
+      const res2 = await transport2.get(this.modelConfig, void 0, signal);
+      if (!res2.ok) {
+        const text = await res2.text();
+        throw new Error(`Failed to fetch models: ${res2.status} ${text}`);
+      }
+      const data2 = await res2.json();
+      return data2.data;
+    }
+    const transport = this.createTransport();
+    const res = await transport.get("/models", void 0, signal);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Failed to fetch models: ${res.status} ${text}`);
+    }
+    const data = await res.json();
+    return data.data;
+  }
+  async generateCompletion(params, signal) {
+    let enhancedParams = params;
+    if (this.includeUsage && !enhancedParams.usage) {
+      enhancedParams = { ...enhancedParams, usage: { include: true } };
+    }
+    return super.generateCompletion(enhancedParams, signal);
+  }
+  async streamCompletion(params, handlers, signal) {
+    let enhancedParams = params;
+    if (this.includeUsage && !enhancedParams.usage) {
+      enhancedParams = { ...enhancedParams, usage: { include: true } };
+    }
+    return super.streamCompletion(enhancedParams, handlers, signal);
+  }
+};
+function normalizeModelConfig(config) {
+  if (config.models !== void 0) {
+    return config.models;
+  }
+  return config.features.getModels ?? false;
+}
+function mergeProviders(customProviders) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const provider of providers) {
+    merged.set(provider.name.toLowerCase(), provider);
+  }
+  if (customProviders) {
+    for (const [name, custom] of Object.entries(customProviders)) {
+      if (!custom.baseUrl) {
+        continue;
+      }
+      const existing = merged.get(name.toLowerCase());
+      const providerConfig = {
+        name,
+        type: custom.type ?? "openai-compat",
+        baseUrl: custom.baseUrl,
+        models: custom.models ?? false,
+        features: existing?.features ?? {
+          promptCaching: false,
+          getModels: custom.models !== false,
+          includeUsage: false
+        }
+      };
+      merged.set(name.toLowerCase(), providerConfig);
+    }
+  }
+  return Array.from(merged.values());
+}
+function createLLM(providerName, options = {}, customProviders) {
+  const allProviders = mergeProviders(customProviders);
+  const config = allProviders.find((p) => p.name.toLowerCase() === providerName.toLowerCase());
+  if (!config) {
+    throw new Error(`Unknown LLM provider: ${providerName}. Available: ${allProviders.map((p) => p.name).join(", ")}`);
+  }
+  const modelConfig = normalizeModelConfig(config);
+  return new GenericLLM(config.baseUrl, modelConfig, {
+    ...options,
+    enablePromptCaching: options.enablePromptCaching ?? config.features.promptCaching,
+    includeUsage: options.includeUsage ?? config.features.includeUsage
+  });
+}
+function getAvailableProviders(customProviders) {
+  const allProviders = mergeProviders(customProviders);
+  return allProviders.map((p) => p.name);
+}
+function supportsGetModels(providerName, customProviders) {
+  const allProviders = mergeProviders(customProviders);
+  const config = allProviders.find((p) => p.name.toLowerCase() === providerName.toLowerCase());
+  if (!config) return false;
+  const modelConfig = normalizeModelConfig(config);
+  return modelConfig !== false;
+}
+
 // mcp/mcp-client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -5815,19 +5433,16 @@ export {
   AgentOrchestrator,
   AgentRegistry,
   AnthropicAISDKLLM,
-  AnthropicLLM,
   BashTool,
   CompositeToolPort,
   ConversationContext,
   ConversationStore,
   CoreMCPClient,
-  DeepInfraLLM,
   DefaultDelegationPolicy,
   DefaultDelegationResultFormatter,
   DefaultDelegationService,
   DefaultSpecialistAgentFactory,
   DelegationServiceFactory,
-  EchoLLM,
   GithubLLM,
   InMemoryMemory,
   InMemoryMetadata,
@@ -5837,7 +5452,6 @@ export {
   MCPToolPort,
   MemoryPortMetadataAdapter,
   NoopReminders,
-  OpenRouterLLM,
   PersistedMemory,
   PersistingConsoleEventPort,
   RuntimeEnv,
@@ -5846,15 +5460,17 @@ export {
   SimpleId,
   SystemClock,
   ToolRegistry,
-  ZaiLLM,
   buildAgentCreationPrompt,
   buildInjectedSystem,
   canonicalizeTerminalPaste,
+  createLLM,
   generateFolderTree,
+  getAvailableProviders,
   loadMCPConfig,
   normalizeNewlines,
   renderTemplate,
   resolveBackspaces,
   resolveCarriageReturns,
-  stripAnsiAndControls
+  stripAnsiAndControls,
+  supportsGetModels
 };