neoagent 1.5.0 → 1.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/app.html

@@ -593,6 +593,13 @@
             <span>Create disabled draft skills from successful multi-step runs</span>
           </label>
         </div>
+        <div class="form-group">
+          <label class="form-label">Smart Selection</label>
+          <label class="flex items-center gap-2" style="cursor:pointer;">
+            <input type="checkbox" id="settingSmarterModelSelector" autocomplete="off" data-bwignore="true">
+            <span>Automatically select best model based on task type (coding, planning, etc.)</span>
+          </label>
+        </div>
         <div class="form-group">
           <label class="form-label">Default Chat Model</label>
           <select id="settingDefaultChatModel" class="input" autocomplete="off" data-bwignore="true">
@@ -605,6 +612,13 @@
             <option value="auto">Smart Selector (Auto)</option>
           </select>
         </div>
+        <div class="form-group">
+          <label class="form-label">Fallback Model</label>
+          <select id="settingFallbackModelId" class="input" autocomplete="off" data-bwignore="true">
+            <option value="gpt-5-nano">GPT-5 Nano (Default Cloud Fallback)</option>
+          </select>
+          <small class="text-muted" style="font-size: 11px; display: block; margin-top: 4px;">Used if the primary model fails or is offline.</small>
+        </div>
         <div class="form-group">
           <label class="form-label">Smart Selector Allowed Models</label>
           <div id="modelCheckboxesContainer" style="display:flex; flex-direction:column; gap:8px;">

package/server/public/js/app.js

@@ -1849,6 +1849,9 @@ $("#settingsBtn").addEventListener("click", async () => {
     $("#settingAutoSkillLearning").checked =
       settings.auto_skill_learning !== false &&
       settings.auto_skill_learning !== "false";
+    $("#settingSmarterModelSelector").checked =
+      settings.smarter_model_selector !== false &&
+      settings.smarter_model_selector !== "false";
 
     const enabledModels = Array.isArray(settings.enabled_models) ? settings.enabled_models : (meta.models || []).map(m => m.id);
 
@@ -1858,6 +1861,8 @@ $("#settingsBtn").addEventListener("click", async () => {
     if (chatModelSelect && subagentModelSelect && meta.models) {
       chatModelSelect.innerHTML = '<option value="auto">Smart Selector (Auto)</option>';
       subagentModelSelect.innerHTML = '<option value="auto">Smart Selector (Auto)</option>';
+      const fallbackModelSelect = $("#settingFallbackModelId");
+      if (fallbackModelSelect) fallbackModelSelect.innerHTML = "";
 
       for (const modelDef of meta.models) {
         const chatOption = document.createElement("option");
@@ -1869,10 +1874,20 @@ $("#settingsBtn").addEventListener("click", async () => {
         subagentOption.value = modelDef.id;
         subagentOption.textContent = modelDef.label;
         subagentModelSelect.appendChild(subagentOption);
+
+        if (fallbackModelSelect) {
+          const fallbackOption = document.createElement("option");
+          fallbackOption.value = modelDef.id;
+          fallbackOption.textContent = modelDef.label;
+          fallbackModelSelect.appendChild(fallbackOption);
+        }
       }
 
       chatModelSelect.value = settings.default_chat_model || "auto";
       subagentModelSelect.value = settings.default_subagent_model || "auto";
+      if ($("#settingFallbackModelId")) {
+        $("#settingFallbackModelId").value = settings.fallback_model_id || "gpt-5-nano";
+      }
 
       const indicator = $("#modelIndicator");
       if (indicator) {
@@ -1947,9 +1962,11 @@ $("#saveSettings").addEventListener("click", async () => {
         heartbeat_enabled: $("#settingHeartbeat").checked,
         headless_browser: $("#settingHeadlessBrowser").checked,
         auto_skill_learning: $("#settingAutoSkillLearning").checked,
+        smarter_model_selector: $("#settingSmarterModelSelector").checked,
         enabled_models: enabledModels,
         default_chat_model: defaultChatModel,
-        default_subagent_model: defaultSubagentModel
+        default_subagent_model: defaultSubagentModel,
+        fallback_model_id: $("#settingFallbackModelId") ? $("#settingFallbackModelId").value : 'gpt-5-nano'
       },
     });
 

package/server/routes/settings.js

@@ -29,9 +29,10 @@ function readUpdateStatus() {
 }
 
 // Get supported models metadata
-router.get('/meta/models', (req, res) => {
-  const { SUPPORTED_MODELS } = require('../services/ai/models');
-  res.json({ models: SUPPORTED_MODELS });
+router.get('/meta/models', async (req, res) => {
+  const { getSupportedModels } = require('../services/ai/models');
+  const models = await getSupportedModels();
+  res.json({ models });
 });
 
 // Get all settings

package/server/services/ai/engine.js

@@ -18,16 +18,19 @@ function generateTitle(task) {
   return cleaned.slice(0, 90);
 }
 
-function getProviderForUser(userId, task = '', isSubagent = false, modelOverride = null) {
-  const { SUPPORTED_MODELS, createProviderInstance } = require('./models');
+async function getProviderForUser(userId, task = '', isSubagent = false, modelOverride = null) {
+  const { getSupportedModels, createProviderInstance } = require('./models');
+  const models = await getSupportedModels();
 
   let enabledIds = [];
   let defaultChatModel = 'auto';
   let defaultSubagentModel = 'auto';
 
+  let smarterSelection = true;
+
   try {
-    const rows = db.prepare('SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?, ?)')
-      .all(userId, 'enabled_models', 'default_chat_model', 'default_subagent_model');
+    const rows = db.prepare('SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?, ?, ?)')
+      .all(userId, 'enabled_models', 'default_chat_model', 'default_subagent_model', 'smarter_model_selector');
 
     for (const row of rows) {
       if (!row.value) continue;
@@ -40,22 +43,23 @@ function getProviderForUser(userId, task = '', isSubagent = false, modelOverride
       if (row.key === 'enabled_models') enabledIds = parsedVal;
       if (row.key === 'default_chat_model') defaultChatModel = parsedVal;
       if (row.key === 'default_subagent_model') defaultSubagentModel = parsedVal;
+      if (row.key === 'smarter_model_selector') smarterSelection = parsedVal !== false && parsedVal !== 'false';
     }
   } catch (e) {
     console.error('Failed to fetch model settings:', e.message);
   }
 
   if (!Array.isArray(enabledIds) || enabledIds.length === 0) {
-    enabledIds = SUPPORTED_MODELS.map((m) => m.id);
+    enabledIds = models.map((m) => m.id);
   }
 
-  const availableModels = SUPPORTED_MODELS.filter((m) => enabledIds.includes(m.id));
-  const fallbackModel = availableModels.length > 0 ? availableModels[0] : SUPPORTED_MODELS[0];
+  const availableModels = models.filter((m) => enabledIds.includes(m.id));
+  const fallbackModel = availableModels.length > 0 ? availableModels[0] : models[0];
   let selectedModelDef = fallbackModel;
   const userSelectedDefault = isSubagent ? defaultSubagentModel : defaultChatModel;
 
   if (modelOverride && typeof modelOverride === 'string') {
-    const requested = SUPPORTED_MODELS.find((m) => m.id === modelOverride.trim());
+    const requested = models.find((m) => m.id === modelOverride.trim());
     if (requested && enabledIds.includes(requested.id)) {
       selectedModelDef = requested;
       return {
@@ -67,12 +71,24 @@ function getProviderForUser(userId, task = '', isSubagent = false, modelOverride
   }
 
   if (userSelectedDefault && userSelectedDefault !== 'auto') {
-    selectedModelDef = SUPPORTED_MODELS.find((m) => m.id === userSelectedDefault) || fallbackModel;
+    selectedModelDef = models.find((m) => m.id === userSelectedDefault) || fallbackModel;
   } else {
     const taskStr = String(task || '').toLowerCase();
-    const isPlanning = /\b(plan|think|analy[sz]e|complex|step by step)\b/.test(taskStr);
+
+    // Basic detection
+    let isPlanning = /\b(plan|think|analy[sz]e|complex|step by step)\b/.test(taskStr);
+    let isCoding = false;
+
+    // Enhanced detection if enabled
+    if (smarterSelection) {
+      isPlanning = isPlanning || /\b(reason|strategy|logical|math|complex)\b/.test(taskStr);
+      isCoding = /\b(code|program|script|debug|refactor|function|implementation|logic)\b/.test(taskStr);
+    }
+
     if (isPlanning) {
       selectedModelDef = availableModels.find((m) => m.purpose === 'planning') || fallbackModel;
+    } else if (isCoding) {
+      selectedModelDef = availableModels.find((m) => m.purpose === 'coding') || availableModels.find((m) => m.purpose === 'planning') || fallbackModel;
     } else if (isSubagent) {
       selectedModelDef = availableModels.find((m) => m.purpose === 'fast') || fallbackModel;
     } else {
@@ -225,7 +241,7 @@ class AgentEngine {
     const triggerType = options.triggerType || 'user';
     ensureDefaultAiSettings(userId);
     const aiSettings = getAiSettings(userId);
-    const { provider, model, providerName } = getProviderForUser(userId, userMessage, triggerType === 'subagent', _modelOverride);
+    const { provider, model, providerName } = await getProviderForUser(userId, userMessage, triggerType === 'subagent', _modelOverride);
 
     const runId = options.runId || uuidv4();
     const conversationId = options.conversationId;
@@ -302,28 +318,70 @@ class AgentEngine {
         let streamContent = '';
         const callOptions = { model, reasoningEffort: this.getReasoningEffort(providerName, options) };
 
-        if (options.stream !== false) {
-          const gen = provider.stream(messages, tools, callOptions);
-          for await (const chunk of gen) {
-            if (chunk.type === 'content') {
-              streamContent += chunk.content;
-              this.emit(userId, 'run:stream', { runId, content: streamContent, iteration });
-            }
-            if (chunk.type === 'done') {
-              response = chunk;
+        const tryModelCall = async (retryForFallback = true) => {
+          try {
+            if (options.stream !== false) {
+              const gen = provider.stream(messages, tools, callOptions);
+              for await (const chunk of gen) {
+                if (chunk.type === 'content') {
+                  streamContent += chunk.content;
+                  this.emit(userId, 'run:stream', { runId, content: streamContent, iteration });
+                }
+                if (chunk.type === 'done') {
+                  response = chunk;
+                }
+                if (chunk.type === 'tool_calls') {
+                  response = {
+                    content: chunk.content || streamContent,
+                    toolCalls: chunk.toolCalls,
+                    finishReason: 'tool_calls',
+                    usage: chunk.usage || null
+                  };
+                }
+              }
+            } else {
+              response = await provider.chat(messages, tools, callOptions);
             }
-            if (chunk.type === 'tool_calls') {
-              response = {
-                content: chunk.content || streamContent,
-                toolCalls: chunk.toolCalls,
-                finishReason: 'tool_calls',
-                usage: chunk.usage || null
-              };
+          } catch (err) {
+            console.error(`[Engine] Model call failed (${model}):`, err.message);
+            if (retryForFallback && aiSettings.fallback_model_id && aiSettings.fallback_model_id !== model) {
+              console.log(`[Engine] Attempting fallback to: ${aiSettings.fallback_model_id}`);
+              const fallback = await getProviderForUser(userId, userMessage, triggerType === 'subagent', aiSettings.fallback_model_id);
+              // Update local state for the retry
+              const nextProvider = fallback.provider;
+              const nextModel = fallback.model;
+              const nextProviderName = fallback.providerName;
+
+              // Recursive call once
+              const retryOptions = { ...callOptions, model: nextModel, reasoningEffort: this.getReasoningEffort(nextProviderName, options) };
+
+              if (options.stream !== false) {
+                const gen = nextProvider.stream(messages, tools, retryOptions);
+                for await (const chunk of gen) {
+                  if (chunk.type === 'content') {
+                    streamContent += chunk.content;
+                    this.emit(userId, 'run:stream', { runId, content: streamContent, iteration });
+                  }
+                  if (chunk.type === 'done') response = chunk;
+                  if (chunk.type === 'tool_calls') {
+                    response = {
+                      content: chunk.content || streamContent,
+                      toolCalls: chunk.toolCalls,
+                      finishReason: 'tool_calls',
+                      usage: chunk.usage || null
+                    };
+                  }
+                }
+              } else {
+                response = await nextProvider.chat(messages, tools, retryOptions);
+              }
+            } else {
+              throw err;
             }
           }
-        } else {
-          response = await provider.chat(messages, tools, callOptions);
-        }
+        };
+
+        await tryModelCall();
 
         if (!response) {
           response = { content: streamContent, toolCalls: [], finishReason: 'stop', usage: null };

package/server/services/ai/models.js

@@ -1,8 +1,9 @@
 const { GrokProvider } = require('./providers/grok');
 const { OpenAIProvider } = require('./providers/openai');
 const { GoogleProvider } = require('./providers/google');
+const { OllamaProvider } = require('./providers/ollama');
 
-const SUPPORTED_MODELS = [
+const STATIC_MODELS = [
     {
         id: 'grok-4-1-fast-reasoning',
         label: 'Grok 4.1 (Personality / Default)',
@@ -26,9 +27,73 @@ const SUPPORTED_MODELS = [
         label: 'Gemini 3.1 Flash Lite (Preview)',
         provider: 'google',
         purpose: 'general'
+    },
+    {
+        id: 'llama3.1:8b',
+        label: 'Llama 3.1 8B (Local / General)',
+        provider: 'ollama',
+        purpose: 'general'
+    },
+    {
+        id: 'phi4-mini',
+        label: 'Phi-4 Mini (Local / Fast)',
+        provider: 'ollama',
+        purpose: 'fast'
+    },
+    {
+        id: 'phi4',
+        label: 'Phi-4 (Local / Planning)',
+        provider: 'ollama',
+        purpose: 'planning'
+    },
+    {
+        id: 'qwen2.5-coder:7b',
+        label: 'Qwen 2.5 Coder 7B (Local / Coding)',
+        provider: 'ollama',
+        purpose: 'coding'
     }
 ];
 
+let dynamicModels = [];
+let lastRefresh = 0;
+const REFRESH_INTERVAL = 30000; // 30 seconds
+
+async function getSupportedModels() {
+    const now = Date.now();
+    if (now - lastRefresh > REFRESH_INTERVAL) {
+        await refreshDynamicModels();
+    }
+
+    const all = [...STATIC_MODELS];
+    const staticIds = new Set(STATIC_MODELS.map(m => m.id));
+
+    for (const dm of dynamicModels) {
+        if (!staticIds.has(dm.id)) {
+            all.push(dm);
+        }
+    }
+
+    return all;
+}
+
+async function refreshDynamicModels() {
+    try {
+        const ollama = new OllamaProvider({ baseUrl: process.env.OLLAMA_URL });
+        const models = await ollama.listModels();
+
+        dynamicModels = models.map(name => ({
+            id: name,
+            label: `${name} (Ollama / Local)`,
+            provider: 'ollama',
+            purpose: 'general'
+        }));
+
+        lastRefresh = Date.now();
+    } catch (err) {
+        console.warn('[Models] Failed to refresh Ollama models:', err.message);
+    }
+}
+
 function createProviderInstance(providerStr) {
     if (providerStr === 'grok') {
         return new GrokProvider({ apiKey: process.env.XAI_API_KEY });
@@ -36,11 +101,14 @@ function createProviderInstance(providerStr) {
         return new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY });
     } else if (providerStr === 'google') {
         return new GoogleProvider({ apiKey: process.env.GOOGLE_AI_KEY });
+    } else if (providerStr === 'ollama') {
+        return new OllamaProvider({ baseUrl: process.env.OLLAMA_URL });
     }
     throw new Error(`Unknown provider: ${providerStr}`);
 }
 
 module.exports = {
-    SUPPORTED_MODELS,
+    SUPPORTED_MODELS: STATIC_MODELS, // Backward compatibility
+    getSupportedModels,
     createProviderInstance
 };

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

@@ -19,6 +19,32 @@ class OllamaProvider extends BaseProvider {
     }
   }
 
+  async ensureModel(model) {
+    const models = await this.listModels();
+    // Normalization: Ollama often adds :latest if no tag is specified
+    const normalizedModel = model.includes(':') ? model : `${model}:latest`;
+    const found = models.some(m => m === model || m === normalizedModel);
+    
+    if (found) return true;
+
+    console.log(`[Ollama] Model '${model}' not found, pulling from registry...`);
+    try {
+      const res = await fetch(`${this.baseUrl}/api/pull`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: model, stream: false })
+      });
+      if (!res.ok) throw new Error(`Pull failed: ${res.statusText}`);
+      console.log(`[Ollama] Model '${model}' pulled successfully.`);
+      // Refresh local model list
+      await this.listModels();
+      return true;
+    } catch (e) {
+      console.error(`[Ollama] Failed to pull model '${model}':`, e.message);
+      throw e;
+    }
+  }
+
   getContextWindow(model) {
     return 128000;
   }
@@ -36,6 +62,7 @@ class OllamaProvider extends BaseProvider {
 
   async chat(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || 'llama3.1';
+    await this.ensureModel(model);
     const body = {
       model,
       messages: messages.map(m => ({
@@ -86,6 +113,7 @@ class OllamaProvider extends BaseProvider {
 
   async *stream(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || 'llama3.1';
+    await this.ensureModel(model);
     const body = {
       model,
       messages: messages.map(m => ({

package/server/services/ai/settings.js

@@ -5,7 +5,9 @@ const DEFAULT_AI_SETTINGS = Object.freeze({
   chat_history_window: 8,
   tool_replay_budget_chars: 1200,
   subagent_max_iterations: 6,
-  auto_skill_learning: true
+  auto_skill_learning: true,
+  fallback_model_id: 'gpt-5-nano',
+  smarter_model_selector: true
 });
 
 function parseSettingValue(value) {
@@ -21,14 +23,16 @@ function ensureDefaultAiSettings(userId) {
   if (!userId) return { ...DEFAULT_AI_SETTINGS };
 
   const existing = db.prepare(
-    'SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?, ?, ?, ?)'
+    'SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?, ?, ?, ?, ?, ?)'
   ).all(
     userId,
     'cost_mode',
     'chat_history_window',
     'tool_replay_budget_chars',
     'subagent_max_iterations',
-    'auto_skill_learning'
+    'auto_skill_learning',
+    'fallback_model_id',
+    'smarter_model_selector'
   );
 
   const seen = new Set(existing.map((row) => row.key));
@@ -49,14 +53,16 @@ function getAiSettings(userId) {
   if (!userId) return { ...DEFAULT_AI_SETTINGS };
 
   const rows = db.prepare(
-    'SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?, ?, ?, ?)'
+    'SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?, ?, ?, ?, ?, ?)'
   ).all(
     userId,
     'cost_mode',
     'chat_history_window',
     'tool_replay_budget_chars',
     'subagent_max_iterations',
-    'auto_skill_learning'
+    'auto_skill_learning',
+    'fallback_model_id',
+    'smarter_model_selector'
   );
 
   const settings = { ...DEFAULT_AI_SETTINGS };
@@ -69,6 +75,8 @@ function getAiSettings(userId) {
   settings.subagent_max_iterations = Math.max(2, Math.min(Number(settings.subagent_max_iterations) || DEFAULT_AI_SETTINGS.subagent_max_iterations, 12));
   settings.cost_mode = typeof settings.cost_mode === 'string' ? settings.cost_mode : DEFAULT_AI_SETTINGS.cost_mode;
   settings.auto_skill_learning = settings.auto_skill_learning !== false && settings.auto_skill_learning !== 'false';
+  settings.smarter_model_selector = settings.smarter_model_selector !== false && settings.smarter_model_selector !== 'false';
+  settings.fallback_model_id = typeof settings.fallback_model_id === 'string' ? settings.fallback_model_id : DEFAULT_AI_SETTINGS.fallback_model_id;
 
   return settings;
 }

package/server/services/ai/tools.js

@@ -4,44 +4,44 @@ const db = require('../../db/database');
 const { DATA_DIR } = require('../../../runtime/paths');
 
 function compactText(text, maxChars = 120) {
-  const str = String(text || '').replace(/\s+/g, ' ').trim();
-  if (str.length <= maxChars) return str;
-  const trimmed = str.slice(0, maxChars);
-  const sentenceBreak = Math.max(trimmed.lastIndexOf('. '), trimmed.lastIndexOf('; '), trimmed.lastIndexOf(', '));
-  if (sentenceBreak > 40) return trimmed.slice(0, sentenceBreak + 1).trim();
-  return `${trimmed.trim()}...`;
+    const str = String(text || '').replace(/\s+/g, ' ').trim();
+    if (str.length <= maxChars) return str;
+    const trimmed = str.slice(0, maxChars);
+    const sentenceBreak = Math.max(trimmed.lastIndexOf('. '), trimmed.lastIndexOf('; '), trimmed.lastIndexOf(', '));
+    if (sentenceBreak > 40) return trimmed.slice(0, sentenceBreak + 1).trim();
+    return `${trimmed.trim()}...`;
 }
 
 function compactToolDefinition(tool, options = {}) {
-  const compact = {
-    name: tool.name,
-    parameters: {
-      ...(tool.parameters || { type: 'object', properties: {} }),
-      properties: {}
+    const compact = {
+        name: tool.name,
+        parameters: {
+            ...(tool.parameters || { type: 'object', properties: {} }),
+            properties: {}
+        }
+    };
+
+    if (options.includeDescriptions) {
+        compact.description = compactText(tool.description, 120);
     }
-  };
-
-  if (options.includeDescriptions) {
-    compact.description = compactText(tool.description, 120);
-  }
-
-  if (tool.parameters?.properties) {
-    const properties = {};
-    for (const [key, value] of Object.entries(tool.parameters.properties)) {
-      properties[key] = { ...value };
-      if (options.includeDescriptions && value.description) {
-        properties[key].description = compactText(value.description, 70);
-      } else {
-        delete properties[key].description;
-      }
+
+    if (tool.parameters?.properties) {
+        const properties = {};
+        for (const [key, value] of Object.entries(tool.parameters.properties)) {
+            properties[key] = { ...value };
+            if (options.includeDescriptions && value.description) {
+                properties[key].description = compactText(value.description, 70);
+            } else {
+                delete properties[key].description;
+            }
+        }
+        compact.parameters = {
+            ...compact.parameters,
+            properties
+        };
     }
-    compact.parameters = {
-      ...compact.parameters,
-      properties
-    };
-  }
 
-  return compact;
+    return compact;
 }
 
 /**
@@ -1199,7 +1199,7 @@ async function executeTool(toolName, args, context, engine) {
                 const mimeMap = { '.png': 'image/png', '.gif': 'image/gif', '.webp': 'image/webp', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg' };
                 const mime = mimeMap[ext] || 'image/jpeg';
                 const { getProviderForUser } = require('./engine');
-                const { provider: visionProvider, model: visionModel } = getProviderForUser(userId);
+                const { provider: visionProvider, model: visionModel } = await getProviderForUser(userId);
                 const visionResponse = await visionProvider.chat(
                     [{
                         role: 'user', content: [

package/server/services/memory/manager.js

@@ -11,13 +11,10 @@ const {
 } = require('./embeddings');
 const { AGENT_DATA_DIR } = require('../../../runtime/paths');
 
-/**
- * Derive the active AI provider name from user settings so the right
- * embedding model is selected automatically (e.g. Gemini when using Google).
- */
-function getActiveProvider(userId) {
+async function getActiveProvider(userId) {
   try {
-    const { SUPPORTED_MODELS } = require('../ai/models');
+    const { getSupportedModels } = require('../ai/models');
+    const models = await getSupportedModels();
     const rows = db.prepare('SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?)')
       .all(userId || 1, 'default_chat_model', 'enabled_models');
 
@@ -36,7 +33,7 @@ function getActiveProvider(userId) {
       : (Array.isArray(enabledIds) && enabledIds.length > 0 ? enabledIds[0] : null);
 
     if (modelId) {
-      const def = SUPPORTED_MODELS.find(m => m.id === modelId);
+      const def = models.find(m => m.id === modelId);
       if (def) return def.provider;
     }
   } catch { }
@@ -118,7 +115,7 @@ class MemoryManager {
     category = CATEGORIES.includes(category) ? category : 'episodic';
     importance = Math.max(1, Math.min(10, Number(importance) || 5));
 
-    const embedding = await getEmbedding(content, getActiveProvider(userId));
+    const embedding = await getEmbedding(content, await getActiveProvider(userId));
 
     // Dedup check: compare against existing non-archived memories for this user
     const existing = db.prepare(
@@ -171,7 +168,7 @@ class MemoryManager {
 
     if (!all.length) return [];
 
-    const queryVec = await getEmbedding(query, getActiveProvider(userId));
+    const queryVec = await getEmbedding(query, await getActiveProvider(userId));
 
     const scored = all.map(mem => {
       let score = 0;
@@ -235,7 +232,7 @@ class MemoryManager {
 
     let newEmbed = mem.embedding;
     if (content && content !== mem.content) {
-      const vec = await getEmbedding(newContent, getActiveProvider(null));
+      const vec = await getEmbedding(newContent, await getActiveProvider(null));
       newEmbed = vec ? serializeEmbedding(vec) : mem.embedding;
     }
 

package/server/services/websocket.js

@@ -81,7 +81,7 @@ function setupWebSocket(io, services) {
             .run(userId, result.runId, 'assistant', result.content, JSON.stringify({ tokens: result.totalTokens }));
         }
 
-        const { provider, model } = getProviderForUser(userId, task, false, options?.model || null);
+        const { provider, model } = await getProviderForUser(userId, task, false, options?.model || null);
         refreshWebChatSummary(userId, provider, model, aiSettings.chat_history_window).catch((summaryErr) => {
           console.error('[WS] Web summary refresh failed:', summaryErr.message);
         });