@nuvin/nuvin-core 0.1.0 → 1.0.1

package/dist/index.js

@@ -1251,9 +1251,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;
   }
 };
 
@@ -2620,7 +2619,6 @@ var AgentRegistry = class {
       maxTokens: partial.maxTokens ?? 4e3,
       provider: partial.provider,
       model: partial.model,
-      apiKey: partial.apiKey,
       topP: partial.topP,
       timeoutMs: partial.timeoutMs,
       shareContext: partial.shareContext,
@@ -2911,16 +2909,34 @@ var DefaultSpecialistAgentFactory = class {
   }
 };
 
+// delegation/LLMResolver.ts
+var LLMResolver = class {
+  constructor(factory) {
+    this.factory = factory;
+  }
+  resolve(config) {
+    return this.factory.createLLM({
+      provider: config.provider,
+      model: config.model
+    });
+  }
+};
+
 // agent-manager.ts
 var DEFAULT_TIMEOUT_MS = 3e5;
 var MAX_DELEGATION_DEPTH = 3;
 var AgentManager = class {
-  constructor(delegatingConfig, delegatingLLM, delegatingTools, eventCallback) {
+  constructor(delegatingConfig, delegatingTools, llmFactory, eventCallback, configResolver) {
     this.delegatingConfig = delegatingConfig;
-    this.delegatingLLM = delegatingLLM;
     this.delegatingTools = delegatingTools;
+    this.llmFactory = llmFactory;
     this.eventCallback = eventCallback;
+    this.configResolver = configResolver;
+    if (llmFactory) {
+      this.llmResolver = new LLMResolver(llmFactory);
+    }
   }
+  llmResolver = null;
   activeAgents = /* @__PURE__ */ new Map();
   eventCollectors = /* @__PURE__ */ new Map();
   /**
@@ -2997,18 +3013,19 @@ var AgentManager = class {
         }
       }
     };
+    const freshConfig = this.configResolver?.() ?? {};
     const specialistConfig = {
       id: agentId,
       systemPrompt: config.systemPrompt,
       temperature: config.temperature ?? this.delegatingConfig.temperature,
       topP: config.topP ?? this.delegatingConfig.topP,
-      model: config.model ?? this.delegatingConfig.model,
+      model: config.model ?? freshConfig.model ?? this.delegatingConfig.model,
       maxTokens: config.maxTokens ?? this.delegatingConfig.maxTokens,
       enabledTools: config.tools,
       maxToolConcurrency: this.delegatingConfig.maxToolConcurrency,
       requireToolApproval: false,
       // Specialists run autonomously
-      reasoningEffort: this.delegatingConfig.reasoningEffort
+      reasoningEffort: freshConfig.reasoningEffort ?? this.delegatingConfig.reasoningEffort
     };
     const llm = this.resolveLLM(config);
     const specialistOrchestrator = new AgentOrchestrator(specialistConfig, {
@@ -3090,13 +3107,13 @@ var AgentManager = class {
     }
   }
   /**
-   * Resolve which LLM to use (reuse delegating LLM or create new one)
+   * Resolve which LLM to use - creates fresh LLM instance via factory
    */
   resolveLLM(config) {
-    if (!config.provider && !config.model) {
-      return this.delegatingLLM;
+    if (!this.llmResolver) {
+      throw new Error("AgentManager requires LLMFactory to create sub-agents. Please provide llmFactory in constructor.");
     }
-    return this.delegatingLLM;
+    return this.llmResolver.resolve(config);
   }
   /**
    * Execute agent task with timeout
@@ -3145,19 +3162,21 @@ var AgentManager = class {
 
 // delegation/AgentManagerCommandRunner.ts
 var AgentManagerCommandRunner = class {
-  constructor(delegatingConfig, delegatingLLM, delegatingTools) {
+  constructor(delegatingConfig, delegatingTools, llmFactory, configResolver) {
     this.delegatingConfig = delegatingConfig;
-    this.delegatingLLM = delegatingLLM;
     this.delegatingTools = delegatingTools;
+    this.llmFactory = llmFactory;
+    this.configResolver = configResolver;
   }
   async run(config, context) {
     const eventPort = context?.eventPort;
     const signal = context?.signal;
     const agentManager = new AgentManager(
       this.delegatingConfig,
-      this.delegatingLLM,
       this.delegatingTools,
-      eventPort ? (event) => eventPort.emit(event) : void 0
+      this.llmFactory,
+      eventPort ? (event) => eventPort.emit(event) : void 0,
+      this.configResolver
     );
     return agentManager.executeTask(config, signal);
   }
@@ -3253,16 +3272,34 @@ var DefaultDelegationResultFormatter = class {
   }
 };
 
+// delegation/DelegationServiceFactory.ts
+var DelegationServiceFactory = class {
+  create(config) {
+    const specialistFactory = new DefaultSpecialistAgentFactory({
+      agentListProvider: config.agentListProvider
+    });
+    return new DefaultDelegationService(
+      config.agentRegistry,
+      new DefaultDelegationPolicy(),
+      specialistFactory,
+      config.commandRunner,
+      new DefaultDelegationResultFormatter()
+    );
+  }
+};
+
 // tools.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   toolsMemory;
   agentRegistry;
+  delegationServiceFactory;
   assignTool;
   enabledAgentsConfig = {};
   constructor(opts) {
     this.toolsMemory = opts?.toolsMemory || new InMemoryMemory();
     this.agentRegistry = opts?.agentRegistry || new AgentRegistry();
+    this.delegationServiceFactory = opts?.delegationServiceFactory;
     const todoStore = new TodoStore(opts?.todoMemory || new InMemoryMemory());
     const toolInstances = [
       new TodoWriteTool(todoStore),
@@ -3301,22 +3338,20 @@ var ToolRegistry = class {
   /**
    * Initialize AssignTool with orchestrator dependencies (lazy initialization)
    */
-  setOrchestrator(config, llm, tools) {
-    const delegationService = new DefaultDelegationService(
-      this.agentRegistry,
-      new DefaultDelegationPolicy(),
-      new DefaultSpecialistAgentFactory({
-        agentListProvider: () => this.agentRegistry.list().filter(
-          (agent) => typeof agent.id === "string" && typeof agent.name === "string" && typeof agent.description === "string"
-        ).map((agent) => ({
-          id: agent.id,
-          name: agent.name,
-          description: agent.description
-        }))
-      }),
-      new AgentManagerCommandRunner(config, llm, tools),
-      new DefaultDelegationResultFormatter()
-    );
+  setOrchestrator(config, tools, llmFactory, configResolver) {
+    const commandRunner = new AgentManagerCommandRunner(config, tools, llmFactory, configResolver);
+    const factory = this.delegationServiceFactory ?? new DelegationServiceFactory();
+    const delegationService = factory.create({
+      agentRegistry: this.agentRegistry,
+      commandRunner,
+      agentListProvider: () => this.agentRegistry.list().filter(
+        (agent) => typeof agent.id === "string" && typeof agent.name === "string" && typeof agent.description === "string"
+      ).map((agent) => ({
+        id: agent.id,
+        name: agent.name,
+        description: agent.description
+      }))
+    });
     delegationService.setEnabledAgents(this.enabledAgentsConfig);
     this.assignTool = new AssignTool(delegationService);
     this.tools.set("assign_task", this.assignTool);
@@ -3758,9 +3793,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++) {
@@ -3803,7 +3836,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();
@@ -3828,7 +3862,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,
@@ -3847,6 +3882,7 @@ var BaseLLM = class {
     let content = "";
     const mergedToolCalls = [];
     let usage;
+    let lastFinishReason;
     const flushEvent = (rawEvent) => {
       const lines = rawEvent.split("\n");
       const dataLines = [];
@@ -3859,11 +3895,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);
           }
@@ -4411,91 +4451,15 @@ var GithubAuthTransport = class {
   }
 };
 
-// transports/openrouter-transport.ts
-var OpenRouterAuthTransport = class {
-  inner;
-  apiKey;
-  baseUrl;
-  constructor(inner, apiKey, baseUrl) {
-    this.inner = inner;
-    this.apiKey = apiKey;
-    this.baseUrl = baseUrl ?? "https://openrouter.ai/api/v1";
-  }
-  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);
-  }
-  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 {
+// transports/base-bearer-auth-transport.ts
+var BaseBearerAuthTransport = 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");
-    }
-    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/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";
+    this.baseUrl = baseUrl ?? this.getDefaultBaseUrl();
   }
   buildFullUrl(path9) {
     if (path9.startsWith("/")) {
@@ -4525,105 +4489,23 @@ var ZAIAuthTransport = class {
   }
 };
 
-// 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";
+// transports/simple-bearer-transport.ts
+var SimpleBearerAuthTransport = class extends BaseBearerAuthTransport {
+  defaultUrl;
+  constructor(inner, defaultBaseUrl, apiKey, baseUrl) {
+    super(inner, apiKey, baseUrl ?? defaultBaseUrl);
+    this.defaultUrl = defaultBaseUrl;
   }
-  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;
+  getDefaultBaseUrl() {
+    return this.defaultUrl;
   }
 };
 
+// transports/transport-factory.ts
+function createTransport(_name, inner, defaultBaseUrl, apiKey, baseUrl) {
+  return new SimpleBearerAuthTransport(inner, defaultBaseUrl, apiKey, baseUrl);
+}
+
 // llm-providers/llm-github.ts
 var GithubLLM = class extends BaseLLM {
   opts;
@@ -4649,392 +4531,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 {
@@ -5479,6 +4975,125 @@ var AnthropicAISDKLLM = class {
   }
 };
 
+// llm-providers/llm-provider-config.json
+var llm_provider_config_default = {
+  providers: [
+    {
+      name: "deepinfra",
+      className: "DeepInfraLLM",
+      baseUrl: "https://api.deepinfra.com/v1/openai",
+      transportName: "deepinfra",
+      features: {
+        promptCaching: false,
+        getModels: true
+      }
+    },
+    {
+      name: "openrouter",
+      className: "OpenRouterLLM",
+      baseUrl: "https://openrouter.ai/api/v1",
+      transportName: "openrouter",
+      features: {
+        promptCaching: true,
+        getModels: true,
+        includeUsage: true
+      }
+    },
+    {
+      name: "zai",
+      className: "ZaiLLM",
+      baseUrl: "https://api.z.ai/api/coding/paas/v4",
+      transportName: "zai",
+      features: {
+        promptCaching: false,
+        getModels: false
+      }
+    },
+    {
+      name: "moonshot",
+      className: "MoonshotLLM",
+      baseUrl: "https://api.moonshot.ai/v1",
+      transportName: "moonshot",
+      features: {
+        promptCaching: false,
+        getModels: true
+      }
+    }
+  ]
+};
+
+// llm-providers/llm-factory.ts
+var providers = llm_provider_config_default.providers;
+var GenericLLM = class extends BaseLLM {
+  opts;
+  transportName;
+  includeUsage;
+  supportsModels;
+  constructor(transportName, baseUrl, supportsModels, opts = {}) {
+    const { enablePromptCaching = false, includeUsage = false, ...restOpts } = opts;
+    super(opts.apiUrl || baseUrl, { enablePromptCaching });
+    this.transportName = transportName;
+    this.includeUsage = includeUsage;
+    this.supportsModels = supportsModels;
+    this.opts = restOpts;
+  }
+  createTransport() {
+    const base = new FetchTransport({
+      persistFile: this.opts.httpLogFile,
+      logLevel: "INFO",
+      enableConsoleLog: false,
+      maxFileSize: 5 * 1024 * 1024,
+      captureResponseBody: true
+    });
+    return createTransport(this.transportName, base, this.apiUrl, this.opts.apiKey, this.opts.apiUrl);
+  }
+  async getModels(signal) {
+    if (!this.supportsModels) {
+      throw new Error(`Provider ${this.transportName} does not support getModels`);
+    }
+    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 createLLM(providerName, options = {}) {
+  const config = providers.find((p) => p.name.toLowerCase() === providerName.toLowerCase());
+  if (!config) {
+    throw new Error(`Unknown LLM provider: ${providerName}. Available: ${providers.map((p) => p.name).join(", ")}`);
+  }
+  return new GenericLLM(config.transportName, config.baseUrl, config.features.getModels ?? false, {
+    ...options,
+    enablePromptCaching: options.enablePromptCaching ?? config.features.promptCaching,
+    includeUsage: options.includeUsage ?? config.features.includeUsage
+  });
+}
+function getAvailableProviders() {
+  return providers.map((p) => p.name);
+}
+function supportsGetModels(providerName) {
+  const config = providers.find((p) => p.name.toLowerCase() === providerName.toLowerCase());
+  return config?.features.getModels ?? false;
+}
+
 // mcp/mcp-client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -5779,27 +5394,26 @@ export {
   AgentOrchestrator,
   AgentRegistry,
   AnthropicAISDKLLM,
-  AnthropicLLM,
   BashTool,
   CompositeToolPort,
   ConversationContext,
   ConversationStore,
   CoreMCPClient,
-  DeepInfraLLM,
   DefaultDelegationPolicy,
   DefaultDelegationResultFormatter,
   DefaultDelegationService,
   DefaultSpecialistAgentFactory,
+  DelegationServiceFactory,
   EchoLLM,
   GithubLLM,
   InMemoryMemory,
   InMemoryMetadata,
   JsonFileMemoryPersistence,
   LLMError,
+  LLMResolver,
   MCPToolPort,
   MemoryPortMetadataAdapter,
   NoopReminders,
-  OpenRouterLLM,
   PersistedMemory,
   PersistingConsoleEventPort,
   RuntimeEnv,
@@ -5808,15 +5422,17 @@ export {
   SimpleId,
   SystemClock,
   ToolRegistry,
-  ZaiLLM,
   buildAgentCreationPrompt,
   buildInjectedSystem,
   canonicalizeTerminalPaste,
+  createLLM,
   generateFolderTree,
+  getAvailableProviders,
   loadMCPConfig,
   normalizeNewlines,
   renderTemplate,
   resolveBackspaces,
   resolveCarriageReturns,
-  stripAnsiAndControls
+  stripAnsiAndControls,
+  supportsGetModels
 };