neoagent 2.4.1-beta.39 → 2.4.1-beta.40

package/server/services/ai/models.js

@@ -8,6 +8,7 @@ const { OpenAICodexProvider } = require('./providers/openaiCodex');
 const { ClaudeCodeProvider } = require('./providers/claudeCode');
 const { GrokOAuthProvider } = require('./providers/grokOauth');
 const { NvidiaProvider } = require('./providers/nvidia');
+const { OpenRouterProvider } = require('./providers/openrouter');
 const {
     AI_PROVIDER_DEFINITIONS,
     getProviderConfigs,
@@ -15,24 +16,21 @@ const {
 } = require('./settings');
 
 const STATIC_MODELS = [
-    {
-        id: 'grok-4-1-fast-reasoning',
-        label: 'Grok 4.1 (Personality / Default)',
-        provider: 'grok',
-        purpose: 'general'
-    },
+    // — xAI OAuth — fallback entries shown when grok-oauth token is invalid/exhausted.
+    // When the token is valid, DYNAMIC_PROVIDERS will replace these with the live list.
     {
         id: 'grok-4',
-        label: 'Grok 4 (xAI OAuth / Default)',
+        label: 'Grok 4 (xAI OAuth)',
         provider: 'grok-oauth',
-        purpose: 'general'
+        purpose: 'general',
     },
     {
         id: 'grok-4-mini',
-        label: 'Grok 4 Mini (xAI OAuth / Fast)',
+        label: 'Grok 4 Mini (xAI OAuth)',
         provider: 'grok-oauth',
-        purpose: 'coding'
+        purpose: 'fast',
     },
+    // — GitHub Copilot (subscription; no public /models endpoint) ————————
     {
         id: 'gpt-5.3',
         label: 'GPT-5.3 (Copilot Default)',
@@ -45,6 +43,7 @@ const STATIC_MODELS = [
         provider: 'github-copilot',
         purpose: 'coding'
     },
+    // — OpenAI Codex ——————————————————————————————————————————————————————
     {
         id: 'gpt-5.5',
         label: 'GPT-5.5 (Codex Default)',
@@ -63,80 +62,13 @@ const STATIC_MODELS = [
         provider: 'openai-codex',
         purpose: 'general'
     },
-    // — NVIDIA NIM — free tier ————————————————————————————————————————————
-    {
-        id: 'nvidia/nemotron-3-super-120b-a12b',
-        label: 'Nemotron Super 120B (NVIDIA / Free)',
-        provider: 'nvidia',
-        purpose: 'general'
-    },
-    {
-        id: 'moonshotai/kimi-k2.5',
-        label: 'Kimi K2.5 (NVIDIA NIM / Free)',
-        provider: 'nvidia',
-        purpose: 'coding'
-    },
-    {
-        id: 'minimaxai/minimax-m2.5',
-        label: 'MiniMax M2.5 (NVIDIA NIM / Free)',
-        provider: 'nvidia',
-        purpose: 'planning'
-    },
-    {
-        id: 'z-ai/glm5',
-        label: 'GLM 5 (NVIDIA NIM / Free)',
-        provider: 'nvidia',
-        purpose: 'fast'
-    },
-    // — NVIDIA NIM — notable models ————————————————————————————————————————
-    {
-        id: 'meta/llama-4-maverick-17b-128e-instruct',
-        label: 'Llama 4 Maverick 17B (NVIDIA NIM)',
-        provider: 'nvidia',
-        purpose: 'general'
-    },
+    // — Claude Code ————————————————————————————————————————————————————————
     {
-        id: 'meta/llama-4-scout-17b-16e-instruct',
-        label: 'Llama 4 Scout 17B (NVIDIA NIM)',
-        provider: 'nvidia',
-        purpose: 'planning'
-    },
-    {
-        id: 'deepseek-ai/deepseek-r1-0528',
-        label: 'DeepSeek R1 0528 (NVIDIA NIM)',
-        provider: 'nvidia',
+        id: 'claude-opus-4-8',
+        label: 'Claude Opus 4.8 (Claude Code / Flagship)',
+        provider: 'claude-code',
         purpose: 'general'
     },
-    {
-        id: 'qwen/qwq-32b',
-        label: 'QwQ 32B (NVIDIA NIM)',
-        provider: 'nvidia',
-        purpose: 'planning'
-    },
-    {
-        id: 'gpt-5-nano',
-        label: 'GPT-5 Nano (Fast / Subagents)',
-        provider: 'openai',
-        purpose: 'fast'
-    },
-    {
-        id: 'gpt-5-mini',
-        label: 'GPT-5 Mini (Planning / Complex)',
-        provider: 'openai',
-        purpose: 'planning'
-    },
-    {
-        id: 'claude-sonnet-4-20250514',
-        label: 'Claude Sonnet 4 (Analysis / Writing)',
-        provider: 'anthropic',
-        purpose: 'planning'
-    },
-    {
-        id: 'claude-3-5-haiku-20241022',
-        label: 'Claude 3.5 Haiku (Fast)',
-        provider: 'anthropic',
-        purpose: 'fast'
-    },
     {
         id: 'claude-opus-4-7',
         label: 'Claude Opus 4.7 (Claude Code / Default)',
@@ -155,35 +87,25 @@ const STATIC_MODELS = [
         provider: 'claude-code',
         purpose: 'fast'
     },
-    {
-        id: 'gemini-3.1-flash-lite-preview',
-        label: 'Gemini 3.1 Flash Lite (Preview)',
-        provider: 'google',
-        purpose: 'general'
-    },
-    {
-        id: 'gemini-3.1-pro',
-        label: 'Gemini 3.1 Pro (High)',
-        provider: 'google',
-        purpose: 'general'
-    },
+    // — MiniMax ————————————————————————————————————————————————————————————
     {
         id: 'MiniMax-M2.7',
         label: 'MiniMax M2.7 (Coding Plan)',
         provider: 'minimax',
         purpose: 'coding'
     },
+    // — Ollama — default suggestions (full list loaded dynamically) ————————
     {
         id: 'qwen3.5:4b',
         label: 'Qwen 3.5 4B (Local / Ollama)',
         provider: 'ollama',
-        purpose: 'general'
+        purpose: 'general',
     },
     {
         id: 'gemma4:12b',
         label: 'Gemma 4 12B (Local / Ollama)',
         provider: 'ollama',
-        purpose: 'general'
+        purpose: 'general',
     }
 ];
 
@@ -205,11 +127,107 @@ const PROVIDER_FACTORIES = Object.freeze({
     'claude-code': { Provider: ClaudeCodeProvider, apiKey: true, baseUrl: false },
     'grok-oauth': { Provider: GrokOAuthProvider, apiKey: true, baseUrl: false },
     nvidia: { Provider: NvidiaProvider, apiKey: true, baseUrl: true },
+    openrouter: { Provider: OpenRouterProvider, apiKey: true, baseUrl: true },
 });
 
 const dynamicModelsByBaseUrl = new Map();
 const REFRESH_INTERVAL = 30000; // 30 seconds
 
+// Unified dynamic model cache for all API-backed providers.
+// Keyed by `${providerId}:${apiKey.slice(0,8)}` to handle per-user keys.
+const providerModelCache = new Map();
+const DYNAMIC_REFRESH_INTERVAL = 5 * 60 * 1000; // 5 minutes
+
+// Populated from OpenRouter's /models response; used to price-classify models
+// from all providers.  Keyed by both the full OpenRouter ID ("openai/gpt-5-mini")
+// and the bare model ID ("gpt-5-mini") for cross-provider lookup.
+const openrouterPricingCache = new Map();
+
+// Providers whose full model list is fetched from their API at runtime.
+// grok-oauth inherits listModels() from GrokProvider and uses the same xAI endpoint.
+const DYNAMIC_PROVIDERS = ['openai', 'anthropic', 'google', 'nvidia', 'grok', 'grok-oauth', 'openrouter'];
+
+function inferModelPurpose(id) {
+    const s = id.toLowerCase();
+    if (/flash|nano|lite|tiny|haiku|scout|mini(?!max)|small/.test(s)) return 'fast';
+    if (/r1|qwq|o[0-9]|reasoning|thinking/.test(s)) return 'planning';
+    if (/code|coder|starcoder|devstral|codex|codegemma/.test(s)) return 'coding';
+    return 'general';
+}
+
+// Pricing tiers: free=$0  cheap<$0.50/1M  medium=$0.50–$5/1M  expensive>$5/1M
+// Uses live prices from openrouterPricingCache; returns null when unknown.
+function classifyPriceTier(modelId) {
+    const costPerM = openrouterPricingCache.get(modelId);
+    if (costPerM === undefined) return null;
+    if (costPerM === 0) return 'free';
+    if (costPerM < 0.5) return 'cheap';
+    if (costPerM < 5) return 'medium';
+    return 'expensive';
+}
+
+// Per-provider functions that turn a raw model object from listModels() into a display label.
+const PROVIDER_LABEL_FN = {
+    openai:    (m) => `${m.id} (OpenAI)`,
+    anthropic: (m) => `${m.name || m.id} (Anthropic)`,
+    google:    (m) => `${m.name || m.id} (Google)`,
+    nvidia:    (m) => `${m.id} (NVIDIA NIM)`,
+    grok:      (m) => `${m.id} (xAI)`,
+    openrouter:(m) => `${m.name || m.id} (OpenRouter)`,
+};
+
+async function refreshProviderModelList(providerId, apiKey, baseUrl) {
+    const cacheKey = `${providerId}:${(apiKey || '').slice(0, 8)}`;
+    const existing = providerModelCache.get(cacheKey);
+    const now = Date.now();
+
+    if (existing && now - existing.lastRefresh <= DYNAMIC_REFRESH_INTERVAL) {
+        return existing.models;
+    }
+
+    try {
+        const factory = PROVIDER_FACTORIES[providerId];
+        const config = {};
+        if (factory.apiKey) config.apiKey = apiKey;
+        if (factory.baseUrl) config.baseUrl = baseUrl;
+        const provider = new factory.Provider(config);
+
+        const raw = await provider.listModels();
+
+        // OpenRouter returns live pricing — populate the shared cache so all
+        // other providers can resolve their price tier without a lookup table.
+        if (providerId === 'openrouter') {
+            for (const m of raw) {
+                if (m.pricing?.prompt == null) continue;
+                const inputPerM = parseFloat(m.pricing.prompt) * 1_000_000;
+                openrouterPricingCache.set(m.id, inputPerM);
+                // Also index by the bare model ID (everything after the first "/")
+                // so that e.g. "gpt-5-mini" resolves from "openai/gpt-5-mini".
+                if (m.id.includes('/')) {
+                    const bareId = m.id.slice(m.id.indexOf('/') + 1);
+                    if (!openrouterPricingCache.has(bareId)) {
+                        openrouterPricingCache.set(bareId, inputPerM);
+                    }
+                }
+            }
+        }
+
+        const labelFn = PROVIDER_LABEL_FN[providerId] || ((m) => m.id);
+        const models = raw.map((m) => ({
+            id: m.id,
+            label: labelFn(m),
+            provider: providerId,
+            purpose: inferModelPurpose(m.id),
+        }));
+
+        providerModelCache.set(cacheKey, { models, lastRefresh: now });
+        return models;
+    } catch (err) {
+        console.warn(`[Models] Failed to refresh ${providerId} models:`, err.message);
+        return existing?.models || [];
+    }
+}
+
 async function probeOllama(baseUrl, timeoutMs = 1500) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -373,8 +391,9 @@ async function getSupportedModels(userId, agentId = null) {
 
     const all = [...STATIC_MODELS];
     const staticIds = new Set(STATIC_MODELS.map((model) => model.id));
-    const ollama = providerById.get('ollama');
 
+    // Ollama: dynamic list from local server
+    const ollama = providerById.get('ollama');
     if (ollama?.enabled) {
         const dynamicModels = await refreshDynamicModels(ollama.baseUrl);
         for (const model of dynamicModels) {
@@ -384,10 +403,35 @@ async function getSupportedModels(userId, agentId = null) {
         }
     }
 
+    // API-backed providers: fetch model lists in parallel
+    const dynamicFetches = DYNAMIC_PROVIDERS
+        .filter((id) => providerById.get(id)?.available)
+        .map(async (id) => {
+            const runtime = getProviderRuntimeConfig(userId, id, agentId);
+            return refreshProviderModelList(id, runtime.apiKey, runtime.baseUrl);
+        });
+
+    const dynamicResults = await Promise.allSettled(dynamicFetches);
+    for (const result of dynamicResults) {
+        if (result.status === 'fulfilled') {
+            for (const model of result.value) {
+                if (!staticIds.has(model.id)) {
+                    all.push(model);
+                }
+            }
+        }
+    }
+
     return all.map((model) => {
         const provider = providerById.get(model.provider);
+        // Ollama models are always local/free; all others look up the OpenRouter
+        // pricing cache (populated above by Promise.allSettled).
+        const priceTier = model.provider === 'ollama'
+            ? 'free'
+            : (model.priceTier ?? classifyPriceTier(model.id));
         return {
             ...model,
+            priceTier,
             available: provider?.available !== false,
             providerStatus: provider?.status || 'unknown',
             providerStatusLabel: provider?.statusLabel || 'Unknown'
@@ -411,7 +455,7 @@ async function refreshDynamicModels(baseUrl) {
             id: name,
             label: `${name} (Ollama / Local)`,
             provider: 'ollama',
-            purpose: 'general'
+            purpose: 'general',
         }));
 
         dynamicModelsByBaseUrl.set(cacheKey, {

package/server/services/ai/providers/anthropic.js

@@ -6,18 +6,24 @@ class AnthropicProvider extends BaseProvider {
     super(config);
     this.name = 'anthropic';
     this.models = [
+      'claude-opus-4-8',
+      'claude-opus-4-7',
+      'claude-sonnet-4-6',
       'claude-sonnet-4-20250514',
-      'claude-3-5-sonnet-20241022',
+      'claude-haiku-4-5-20251001',
       'claude-3-5-haiku-20241022',
+      'claude-3-5-sonnet-20241022',
       'claude-3-opus-20240229',
-      'MiniMax-M2.7'
     ];
     this.contextWindows = {
+      'claude-opus-4-8': 1000000,
+      'claude-opus-4-7': 200000,
+      'claude-sonnet-4-6': 200000,
       'claude-sonnet-4-20250514': 200000,
-      'claude-3-5-sonnet-20241022': 200000,
+      'claude-haiku-4-5-20251001': 200000,
       'claude-3-5-haiku-20241022': 200000,
+      'claude-3-5-sonnet-20241022': 200000,
       'claude-3-opus-20240229': 200000,
-      'MiniMax-M2.7': 204800
     };
     this.client = new Anthropic({
       apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY,
@@ -25,6 +31,11 @@ class AnthropicProvider extends BaseProvider {
     });
   }
 
+  async listModels() {
+    const res = await this.client.models.list({ limit: 100 });
+    return (res.data || []).map((m) => ({ id: m.id, name: m.display_name || m.id }));
+  }
+
   getContextWindow(model) {
     return this.contextWindows[model] || 200000;
   }

package/server/services/ai/providers/google.js

@@ -6,22 +6,49 @@ class GoogleProvider extends BaseProvider {
     super(config);
     this.name = 'google';
     this.models = [
+      'gemini-3.5-pro',
+      'gemini-3.5-flash',
+      'gemini-3.1-pro',
+      'gemini-3.1-flash-lite-preview',
+      'gemini-2.5-pro',
+      'gemini-2.5-flash',
       'gemini-2.0-flash',
-      'gemini-2.0-pro',
       'gemini-1.5-pro',
       'gemini-1.5-flash',
-      'gemini-3.1-flash-lite-preview',
-      'gemini-3.1-pro'
     ];
     this.contextWindows = {
+      'gemini-3.5-pro': 2097152,
+      'gemini-3.5-flash': 1048576,
+      'gemini-3.1-pro': 2097152,
+      'gemini-3.1-flash-lite-preview': 1048576,
+      'gemini-2.5-pro': 1048576,
+      'gemini-2.5-flash': 1048576,
       'gemini-2.0-flash': 1048576,
-      'gemini-2.0-pro': 2097152,
       'gemini-1.5-pro': 2097152,
       'gemini-1.5-flash': 1048576,
-      'gemini-3.1-flash-lite-preview': 1048576,
-      'gemini-3.1-pro': 2097152
     };
-    this.genAI = new GoogleGenerativeAI(config.apiKey || process.env.GOOGLE_AI_KEY);
+    this.apiKey = config.apiKey || process.env.GOOGLE_AI_KEY;
+    this.genAI = new GoogleGenerativeAI(this.apiKey);
+  }
+
+  async listModels() {
+    const DROP = /tts|lyria|robotics|deep-research|antigravity|computer-use|-image(?!.*it)/i;
+    const res = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models?key=${this.apiKey}&pageSize=200`
+    );
+    if (!res.ok) throw new Error(`Google models API returned ${res.status}`);
+    const { models = [] } = await res.json();
+    return models
+      .filter((m) => {
+        const id = m.name.replace('models/', '');
+        return (m.supportedGenerationMethods || []).includes('generateContent')
+          && !DROP.test(id);
+      })
+      .map((m) => {
+        const id = m.name.replace('models/', '');
+        this.contextWindows[id] = m.inputTokenLimit || 1048576;
+        return { id, name: m.displayName || id };
+      });
   }
 
   getContextWindow(model) {

package/server/services/ai/providers/grok.js

@@ -11,8 +11,21 @@ class GrokProvider extends OpenAICompatibleProvider {
     });
   }
 
+  async listModels() {
+    try {
+      const res = await this.client.models.list();
+      const DROP = /imagine|diffus|embed|-tts/i;
+      return res.data
+        .filter((m) => !DROP.test(m.id))
+        .map((m) => ({ id: m.id, name: m.id }));
+    } catch (err) {
+      throw new Error(`Failed to list Grok models: ${err.message || String(err)}`);
+    }
+  }
+
   getContextWindow(model) {
-    return 131072; // grok-4 context window
+    if (model === 'grok-4.3') return 1000000;
+    return 131072;
   }
 
   supportsVision() {

package/server/services/ai/providers/nvidia.js

@@ -32,6 +32,18 @@ class NvidiaProvider extends OpenAICompatibleProvider {
     });
   }
 
+  async listModels() {
+    try {
+      const res = await this.client.models.list();
+      const DROP = /embed|bge|e5-|rerank|guard|safety|moderat|diffus|flux|stable|imagen|vision-enc|whisper|tts|speech|paraphrase|classif/i;
+      return res.data
+        .filter((m) => !DROP.test(m.id))
+        .map((m) => ({ id: m.id, name: m.id }));
+    } catch (err) {
+      throw new Error(`NVIDIA NIM request failed: ${err?.message || String(err)}`);
+    }
+  }
+
   getContextWindow(model) {
     return CONTEXT_WINDOWS[model] ?? 131072;
   }

package/server/services/ai/providers/openai.js

@@ -6,24 +6,26 @@ class OpenAIProvider extends OpenAICompatibleProvider {
     super(config);
     this.name = 'openai';
     this.models = [
+      'gpt-5.5',
       'gpt-5',
       'gpt-5-mini',
       'gpt-5-nano',
       'gpt-5.2',
-      'gpt-4.1',
       'o3',
+      'o3-pro',
       'o4-mini'
     ];
     // Reasoning models: no temperature, use max_completion_tokens, support reasoning_effort
-    this.reasoningModels = new Set(['gpt-5', 'gpt-5-mini', 'gpt-5-nano', 'gpt-5.2', 'gpt-5.1', 'o1', 'o3', 'o4-mini', 'o3-mini']);
+    this.reasoningModels = new Set(['gpt-5.5', 'gpt-5', 'gpt-5-mini', 'gpt-5-nano', 'gpt-5.2', 'gpt-5.1', 'o1', 'o3', 'o3-pro', 'o4-mini', 'o3-mini']);
     this.contextWindows = {
+      'gpt-5.5': 1000000,
       'gpt-5': 400000,
-      'gpt-5-mini': 200000,
+      'gpt-5-mini': 400000,
       'gpt-5-nano': 128000,
       'gpt-5.2': 400000,
       'gpt-5.1': 400000,
-      'gpt-4.1': 1047576,
       'o3': 200000,
+      'o3-pro': 200000,
       'o4-mini': 200000,
       'o3-mini': 200000
     };
@@ -34,6 +36,18 @@ class OpenAIProvider extends OpenAICompatibleProvider {
     });
   }
 
+  async listModels() {
+    try {
+      const res = await this.client.models.list();
+      const DROP = /dall-e|whisper|tts|embed|moderat|realtime|audio|transcribe|search-api|-image-|babbage|davinci-002|^sora|-instruct/i;
+      return res.data
+        .filter((m) => !DROP.test(m.id))
+        .map((m) => ({ id: m.id, name: m.id }));
+    } catch (err) {
+      throw new Error(`Failed to list OpenAI models: ${err.message || String(err)}`);
+    }
+  }
+
   isReasoningModel(model) {
     // Match exact IDs and prefix variants (gpt-5-2025-08-07 etc)
     for (const id of this.reasoningModels) {

package/server/services/ai/providers/openrouter.js

@@ -0,0 +1,139 @@
+const OpenAI = require('openai');
+const { OpenAICompatibleProvider } = require('./openaiCompatible');
+
+const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
+
+// Context windows fetched from the API are cached here so getContextWindow
+// can serve them without a network call at inference time.
+const contextWindowCache = new Map();
+
+class OpenRouterProvider extends OpenAICompatibleProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'openrouter';
+    this.models = [];
+    this.baseURL = config.baseUrl || OPENROUTER_BASE_URL;
+    this.client = new OpenAI({
+      apiKey: config.apiKey || process.env.OPENROUTER_API_KEY,
+      baseURL: this.baseURL,
+      defaultHeaders: {
+        'HTTP-Referer': 'https://github.com/NeoLabs-Systems/NeoAgent',
+        'X-Title': 'NeoAgent',
+      },
+    });
+  }
+
+  async listModels() {
+    const res = await fetch(`${this.baseURL}/models`, {
+      headers: { 'Authorization': `Bearer ${this.client.apiKey}` },
+    });
+    if (!res.ok) throw new Error(`OpenRouter /models returned HTTP ${res.status}`);
+    const { data } = await res.json();
+    const models = data || [];
+    for (const m of models) {
+      if (m.context_length) contextWindowCache.set(m.id, m.context_length);
+    }
+    this.models = models.map((m) => m.id);
+    return models;
+  }
+
+  getContextWindow(model) {
+    return contextWindowCache.get(model) ?? 128000;
+  }
+
+  _buildParams(model, messages, tools, options) {
+    const params = {
+      model,
+      messages,
+      temperature: options.temperature ?? 0.7,
+      max_tokens: options.maxTokens || 16384,
+    };
+
+    if (tools && tools.length > 0) {
+      params.tools = this.formatTools(tools);
+      params.tool_choice = 'auto';
+    }
+
+    return params;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || this.getDefaultModel();
+    const params = this._buildParams(model, messages, tools, options);
+    let response;
+    try {
+      response = await this.client.chat.completions.create(params);
+    } catch (err) {
+      throw new Error(`OpenRouter request failed: ${err?.message || String(err)}`);
+    }
+    return this.normalizeResponse(response);
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    const model = options.model || this.getDefaultModel();
+    const params = {
+      ...this._buildParams(model, messages, tools, options),
+      stream: true,
+      stream_options: { include_usage: true },
+    };
+
+    let stream;
+    try {
+      stream = await this.client.chat.completions.create(params);
+    } catch (err) {
+      throw new Error(`OpenRouter request failed: ${err?.message || String(err)}`);
+    }
+
+    let toolCalls = [];
+    let content = '';
+    let finalUsage = null;
+
+    for await (const chunk of stream) {
+      if (chunk.usage && (!chunk.choices || chunk.choices.length === 0)) {
+        finalUsage = this.normalizeUsage(chunk.usage);
+        continue;
+      }
+
+      const delta = chunk.choices?.[0]?.delta;
+      if (!delta) continue;
+
+      if (delta.content) {
+        content += delta.content;
+        yield { type: 'content', content: delta.content };
+      }
+
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          if (!toolCalls[tc.index]) {
+            toolCalls[tc.index] = {
+              id: tc.id || '',
+              type: 'function',
+              function: { name: tc.function?.name || '', arguments: '' },
+            };
+          }
+          if (tc.id) toolCalls[tc.index].id = tc.id;
+          if (tc.function?.name) toolCalls[tc.index].function.name = tc.function.name;
+          if (tc.function?.arguments) toolCalls[tc.index].function.arguments += tc.function.arguments;
+        }
+      }
+
+      const finishReason = chunk.choices[0]?.finish_reason;
+      if (finishReason === 'tool_calls' || (finishReason === 'stop' && toolCalls.length > 0)) {
+        yield { type: 'tool_calls', toolCalls, content, usage: this.normalizeUsage(chunk.usage) || finalUsage };
+        return;
+      }
+      if (finishReason === 'stop') {
+        yield { type: 'done', content, usage: this.normalizeUsage(chunk.usage) || finalUsage };
+        return;
+      }
+    }
+
+    if (toolCalls.length > 0) {
+      yield { type: 'tool_calls', toolCalls, content, usage: finalUsage };
+    } else {
+      yield { type: 'done', content, usage: finalUsage };
+    }
+  }
+}
+
+module.exports = { OpenRouterProvider };

package/server/services/ai/settings.js

@@ -109,6 +109,16 @@ const AI_PROVIDER_DEFINITIONS = Object.freeze({
     defaultEnabled: false,
     defaultBaseUrl: ''
   },
+  openrouter: {
+    id: 'openrouter',
+    label: 'OpenRouter',
+    description: 'Access 300+ models through one API, including free-tier models. Get a key at openrouter.ai.',
+    envKey: 'OPENROUTER_API_KEY',
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    defaultEnabled: false,
+    defaultBaseUrl: 'https://openrouter.ai/api/v1'
+  },
   ollama: {
     id: 'ollama',
     label: 'Ollama',