neoagent 2.1.1 → 2.1.2

package/server/routes/settings.js

@@ -7,7 +7,11 @@ const { requireAuth } = require('../middleware/auth');
 const { normalizeWhatsAppWhitelist } = require('../utils/whatsapp');
 const { getVersionInfo } = require('../utils/version');
 const { UPDATE_STATUS_FILE, APP_DIR } = require('../../runtime/paths');
-const { ensureDefaultAiSettings, DEFAULT_AI_SETTINGS } = require('../services/ai/settings');
+const {
+  createDefaultAiSettings,
+  ensureDefaultAiSettings,
+  normalizeProviderConfigs,
+} = require('../services/ai/settings');
 
 router.use(requireAuth);
 
@@ -44,15 +48,39 @@ function writeUpdateStatus(patch) {
 // Get supported models metadata
 router.get('/meta/models', async (req, res) => {
   const { getSupportedModels } = require('../services/ai/models');
-  const models = await getSupportedModels();
+  const models = await getSupportedModels(req.session.userId);
   res.json({ models });
 });
 
+router.get('/meta/ai-providers', async (req, res) => {
+  const { getProviderCatalog, getSupportedModels } = require('../services/ai/models');
+  const [providers, models] = await Promise.all([
+    getProviderCatalog(req.session.userId),
+    getSupportedModels(req.session.userId),
+  ]);
+
+  const modelCounts = models.reduce((acc, model) => {
+    acc[model.provider] = (acc[model.provider] || 0) + 1;
+    if (model.available !== false) {
+      acc[`${model.provider}:available`] = (acc[`${model.provider}:available`] || 0) + 1;
+    }
+    return acc;
+  }, {});
+
+  res.json({
+    providers: providers.map((provider) => ({
+      ...provider,
+      modelCount: modelCounts[provider.id] || 0,
+      availableModelCount: modelCounts[`${provider.id}:available`] || 0,
+    })),
+  });
+});
+
 // Get all settings
 router.get('/', (req, res) => {
   ensureDefaultAiSettings(req.session.userId);
   const rows = db.prepare('SELECT key, value FROM user_settings WHERE user_id = ?').all(req.session.userId);
-  const settings = { ...DEFAULT_AI_SETTINGS };
+  const settings = createDefaultAiSettings();
   for (const row of rows) {
     try {
       settings[row.key] = JSON.parse(row.value);
@@ -63,6 +91,7 @@ router.get('/', (req, res) => {
       settings[row.key] = row.value;
     }
   }
+  settings.ai_provider_configs = normalizeProviderConfigs(settings.ai_provider_configs);
   res.json(settings);
 });
 
@@ -84,6 +113,10 @@ router.put('/', (req, res) => {
     normalizedBody.platform_whitelist_whatsapp = JSON.stringify(normalizeWhatsAppWhitelist(whitelist));
   }
 
+  if ('ai_provider_configs' in normalizedBody) {
+    normalizedBody.ai_provider_configs = normalizeProviderConfigs(normalizedBody.ai_provider_configs);
+  }
+
   const tx = db.transaction((entries) => {
     for (const [key, value] of entries) {
       const v = typeof value === 'string' ? value : JSON.stringify(value);
@@ -213,6 +246,8 @@ router.put('/:key', (req, res) => {
       }
     }
     value = normalizeWhatsAppWhitelist(value);
+  } else if (req.params.key === 'ai_provider_configs') {
+    value = normalizeProviderConfigs(value);
   }
   const v = typeof value === 'string' ? value : JSON.stringify(value);
   db.prepare('INSERT INTO user_settings (user_id, key, value) VALUES (?, ?, ?) ON CONFLICT(user_id, key) DO UPDATE SET value = excluded.value')

package/server/services/ai/engine.js

@@ -20,7 +20,7 @@ function generateTitle(task) {
 
 async function getProviderForUser(userId, task = '', isSubagent = false, modelOverride = null) {
   const { getSupportedModels, createProviderInstance } = require('./models');
-  const models = await getSupportedModels();
+  const models = await getSupportedModels(userId);
 
   let enabledIds = [];
   let defaultChatModel = 'auto';
@@ -53,17 +53,22 @@ async function getProviderForUser(userId, task = '', isSubagent = false, modelOv
     enabledIds = models.map((m) => m.id);
   }
 
-  const availableModels = models.filter((m) => enabledIds.includes(m.id));
-  const fallbackModel = availableModels.length > 0 ? availableModels[0] : models[0];
+  const availableModels = models.filter((m) => enabledIds.includes(m.id) && m.available !== false);
+  const fallbackModel = availableModels.length > 0 ? availableModels[0] : models.find((m) => m.available !== false);
+
+  if (!fallbackModel) {
+    throw new Error('No AI providers are currently available. Open Settings and configure at least one provider.');
+  }
+
   let selectedModelDef = fallbackModel;
   const userSelectedDefault = isSubagent ? defaultSubagentModel : defaultChatModel;
 
   if (modelOverride && typeof modelOverride === 'string') {
     const requested = models.find((m) => m.id === modelOverride.trim());
-    if (requested && enabledIds.includes(requested.id)) {
+    if (requested && requested.available !== false && enabledIds.includes(requested.id)) {
       selectedModelDef = requested;
       return {
-        provider: createProviderInstance(selectedModelDef.provider),
+        provider: createProviderInstance(selectedModelDef.provider, userId),
         model: selectedModelDef.id,
         providerName: selectedModelDef.provider
       };
@@ -97,7 +102,7 @@ async function getProviderForUser(userId, task = '', isSubagent = false, modelOv
   }
 
   return {
-    provider: createProviderInstance(selectedModelDef.provider),
+    provider: createProviderInstance(selectedModelDef.provider, userId),
     model: selectedModelDef.id,
     providerName: selectedModelDef.provider
   };

package/server/services/ai/models.js

@@ -1,7 +1,12 @@
-const { GrokProvider } = require('./providers/grok');
-const { OpenAIProvider } = require('./providers/openai');
+const { AnthropicProvider } = require('./providers/anthropic');
 const { GoogleProvider } = require('./providers/google');
+const { GrokProvider } = require('./providers/grok');
 const { OllamaProvider } = require('./providers/ollama');
+const { OpenAIProvider } = require('./providers/openai');
+const {
+    AI_PROVIDER_DEFINITIONS,
+    getProviderConfigs,
+} = require('./settings');
 
 const STATIC_MODELS = [
     {
@@ -22,6 +27,18 @@ const STATIC_MODELS = [
         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: 'gemini-3.1-flash-lite-preview',
         label: 'Gemini 3.1 Flash Lite (Preview)',
@@ -36,61 +53,174 @@ const STATIC_MODELS = [
     }
 ];
 
-let dynamicModels = [];
-let lastRefresh = 0;
+const dynamicModelsByBaseUrl = new Map();
 const REFRESH_INTERVAL = 30000; // 30 seconds
 
-async function getSupportedModels() {
-    const now = Date.now();
-    if (now - lastRefresh > REFRESH_INTERVAL) {
-        await refreshDynamicModels();
+function getProviderRuntimeConfig(userId, providerId) {
+    const definition = AI_PROVIDER_DEFINITIONS[providerId];
+    if (!definition) {
+        throw new Error(`Unknown provider: ${providerId}`);
     }
 
+    const configs = getProviderConfigs(userId);
+    const config = configs[providerId] || {};
+    const envApiKey = definition.envKey ? (process.env[definition.envKey] || '').trim() : '';
+    const storedApiKey = typeof config.apiKey === 'string' ? config.apiKey.trim() : '';
+    const resolvedApiKey = storedApiKey || envApiKey;
+    const baseUrl = definition.supportsBaseUrl
+        ? ((typeof config.baseUrl === 'string' ? config.baseUrl.trim() : '') || definition.defaultBaseUrl || '')
+        : '';
+
+    return {
+        ...definition,
+        enabled: config.enabled !== false,
+        apiKey: resolvedApiKey,
+        storedApiKey,
+        hasStoredApiKey: Boolean(storedApiKey),
+        hasEnvironmentApiKey: Boolean(envApiKey),
+        baseUrl
+    };
+}
+
+function getProviderCatalog(userId) {
+    return Object.values(AI_PROVIDER_DEFINITIONS).map((definition) => {
+        const runtime = getProviderRuntimeConfig(userId, definition.id);
+        const available = runtime.enabled && (!definition.supportsApiKey || Boolean(runtime.apiKey));
+
+        let status = 'ready';
+        let statusLabel = 'Ready';
+        let availabilityReason = 'Provider is available.';
+
+        if (!runtime.enabled) {
+            status = 'disabled';
+            statusLabel = 'Disabled';
+            availabilityReason = 'Enable this provider to make its models selectable.';
+        } else if (definition.supportsApiKey && !runtime.apiKey) {
+            status = 'needs_key';
+            statusLabel = 'Needs API key';
+            availabilityReason = `Add an API key here or expose ${definition.envKey} on the server.`;
+        } else if (definition.id === 'ollama') {
+            status = 'local';
+            statusLabel = 'Local';
+            availabilityReason = 'This provider connects to your local Ollama server.';
+        } else if (runtime.hasStoredApiKey) {
+            status = 'stored_key';
+            statusLabel = 'Saved here';
+            availabilityReason = 'This provider uses credentials stored in your profile settings.';
+        } else if (runtime.hasEnvironmentApiKey) {
+            status = 'env_key';
+            statusLabel = 'Using env';
+            availabilityReason = `This provider is currently using ${definition.envKey} from the server environment.`;
+        }
+
+        return {
+            id: definition.id,
+            label: definition.label,
+            description: definition.description,
+            supportsApiKey: definition.supportsApiKey,
+            supportsBaseUrl: definition.supportsBaseUrl,
+            defaultBaseUrl: definition.defaultBaseUrl,
+            enabled: runtime.enabled,
+            available,
+            hasStoredApiKey: runtime.hasStoredApiKey,
+            hasEnvironmentApiKey: runtime.hasEnvironmentApiKey,
+            usesEnvironmentApiKey: !runtime.hasStoredApiKey && runtime.hasEnvironmentApiKey,
+            baseUrl: runtime.baseUrl,
+            status,
+            statusLabel,
+            availabilityReason
+        };
+    });
+}
+
+async function getSupportedModels(userId) {
+    const providerCatalog = getProviderCatalog(userId);
+    const providerById = new Map(providerCatalog.map((provider) => [provider.id, provider]));
+
     const all = [...STATIC_MODELS];
-    const staticIds = new Set(STATIC_MODELS.map(m => m.id));
+    const staticIds = new Set(STATIC_MODELS.map((model) => model.id));
+    const ollama = providerById.get('ollama');
 
-    for (const dm of dynamicModels) {
-        if (!staticIds.has(dm.id)) {
-            all.push(dm);
+    if (ollama?.enabled) {
+        const dynamicModels = await refreshDynamicModels(ollama.baseUrl);
+        for (const model of dynamicModels) {
+            if (!staticIds.has(model.id)) {
+                all.push(model);
+            }
         }
     }
 
-    return all;
+    return all.map((model) => {
+        const provider = providerById.get(model.provider);
+        return {
+            ...model,
+            available: provider?.available !== false,
+            providerStatus: provider?.status || 'unknown',
+            providerStatusLabel: provider?.statusLabel || 'Unknown'
+        };
+    });
 }
 
-async function refreshDynamicModels() {
+async function refreshDynamicModels(baseUrl) {
+    const cacheKey = baseUrl || AI_PROVIDER_DEFINITIONS.ollama.defaultBaseUrl;
+    const existing = dynamicModelsByBaseUrl.get(cacheKey);
+    const now = Date.now();
+
+    if (existing && now - existing.lastRefresh <= REFRESH_INTERVAL) {
+        return existing.models;
+    }
+
     try {
-        const ollama = new OllamaProvider({ baseUrl: process.env.OLLAMA_URL });
+        const ollama = new OllamaProvider({ baseUrl: cacheKey });
         const models = await ollama.listModels();
-
-        dynamicModels = models.map(name => ({
+        const normalized = models.map((name) => ({
             id: name,
             label: `${name} (Ollama / Local)`,
             provider: 'ollama',
             purpose: 'general'
         }));
 
-        lastRefresh = Date.now();
+        dynamicModelsByBaseUrl.set(cacheKey, {
+            models: normalized,
+            lastRefresh: now
+        });
+        return normalized;
     } catch (err) {
         console.warn('[Models] Failed to refresh Ollama models:', err.message);
+        const cached = dynamicModelsByBaseUrl.get(cacheKey);
+        return cached?.models || [];
     }
 }
 
-function createProviderInstance(providerStr) {
+function createProviderInstance(providerStr, userId = null) {
+    const runtime = getProviderRuntimeConfig(userId, providerStr);
+
+    if (!runtime.enabled) {
+        throw new Error(`Provider '${providerStr}' is disabled in settings.`);
+    }
+    if (runtime.supportsApiKey && !runtime.apiKey) {
+        throw new Error(`Provider '${providerStr}' is missing an API key.`);
+    }
+
     if (providerStr === 'grok') {
-        return new GrokProvider({ apiKey: process.env.XAI_API_KEY });
+        return new GrokProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl });
     } else if (providerStr === 'openai') {
-        return new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY });
+        return new OpenAIProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl });
+    } else if (providerStr === 'anthropic') {
+        return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl });
     } else if (providerStr === 'google') {
-        return new GoogleProvider({ apiKey: process.env.GOOGLE_AI_KEY });
+        return new GoogleProvider({ apiKey: runtime.apiKey });
     } else if (providerStr === 'ollama') {
-        return new OllamaProvider({ baseUrl: process.env.OLLAMA_URL });
+        return new OllamaProvider({ baseUrl: runtime.baseUrl });
     }
     throw new Error(`Unknown provider: ${providerStr}`);
 }
 
 module.exports = {
+    AI_PROVIDER_DEFINITIONS,
     SUPPORTED_MODELS: STATIC_MODELS, // Backward compatibility
-    getSupportedModels,
-    createProviderInstance
+    createProviderInstance,
+    getProviderCatalog,
+    getProviderRuntimeConfig,
+    getSupportedModels
 };

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

@@ -18,7 +18,8 @@ class AnthropicProvider extends BaseProvider {
       'claude-3-opus-20240229': 200000
     };
     this.client = new Anthropic({
-      apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY
+      apiKey: config.apiKey || process.env.ANTHROPIC_API_KEY,
+      baseURL: config.baseUrl || process.env.ANTHROPIC_BASE_URL || undefined
     });
   }
 

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

@@ -7,7 +7,7 @@ class GrokProvider extends BaseProvider {
     this.name = 'grok';
     this.client = new OpenAI({
       apiKey: config.apiKey || process.env.XAI_API_KEY,
-      baseURL: 'https://api.x.ai/v1'
+      baseURL: config.baseUrl || process.env.XAI_BASE_URL || 'https://api.x.ai/v1'
     });
   }
 

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

@@ -28,7 +28,8 @@ class OpenAIProvider extends BaseProvider {
       'o3-mini': 200000
     };
     this.client = new OpenAI({
-      apiKey: config.apiKey || process.env.OPENAI_API_KEY
+      apiKey: config.apiKey || process.env.OPENAI_API_KEY,
+      baseURL: config.baseUrl || process.env.OPENAI_BASE_URL || undefined
     });
   }
 

package/server/services/ai/settings.js

@@ -1,15 +1,86 @@
 const db = require('../../db/database');
 
-const DEFAULT_AI_SETTINGS = Object.freeze({
-  cost_mode: 'balanced_auto',
-  chat_history_window: 8,
-  tool_replay_budget_chars: 1200,
-  subagent_max_iterations: 6,
-  auto_skill_learning: true,
-  fallback_model_id: 'gpt-5-nano',
-  smarter_model_selector: true
+const AI_PROVIDER_DEFINITIONS = Object.freeze({
+  openai: {
+    id: 'openai',
+    label: 'OpenAI',
+    description: 'GPT-5 and GPT-4.1 models for fast general work and reasoning.',
+    envKey: 'OPENAI_API_KEY',
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    defaultEnabled: true,
+    defaultBaseUrl: ''
+  },
+  anthropic: {
+    id: 'anthropic',
+    label: 'Anthropic',
+    description: 'Claude models for long-context drafting and analytical work.',
+    envKey: 'ANTHROPIC_API_KEY',
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    defaultEnabled: false,
+    defaultBaseUrl: ''
+  },
+  google: {
+    id: 'google',
+    label: 'Google',
+    description: 'Gemini models with large context windows and multimodal support.',
+    envKey: 'GOOGLE_AI_KEY',
+    supportsApiKey: true,
+    supportsBaseUrl: false,
+    defaultEnabled: true,
+    defaultBaseUrl: ''
+  },
+  grok: {
+    id: 'grok',
+    label: 'xAI',
+    description: 'Grok models tuned for personality-heavy chat and reasoning.',
+    envKey: 'XAI_API_KEY',
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    defaultEnabled: true,
+    defaultBaseUrl: 'https://api.x.ai/v1'
+  },
+  ollama: {
+    id: 'ollama',
+    label: 'Ollama',
+    description: 'Local models running on your machine through an Ollama server.',
+    envKey: '',
+    supportsApiKey: false,
+    supportsBaseUrl: true,
+    defaultEnabled: true,
+    defaultBaseUrl: 'http://localhost:11434'
+  }
 });
 
+function createDefaultProviderConfigs() {
+  return Object.fromEntries(
+    Object.values(AI_PROVIDER_DEFINITIONS).map((definition) => [
+      definition.id,
+      {
+        enabled: definition.defaultEnabled,
+        apiKey: '',
+        baseUrl: definition.supportsBaseUrl ? definition.defaultBaseUrl : ''
+      }
+    ])
+  );
+}
+
+function createDefaultAiSettings() {
+  return {
+    cost_mode: 'balanced_auto',
+    chat_history_window: 8,
+    tool_replay_budget_chars: 1200,
+    subagent_max_iterations: 6,
+    auto_skill_learning: true,
+    fallback_model_id: 'gpt-5-nano',
+    smarter_model_selector: true,
+    ai_provider_configs: createDefaultProviderConfigs()
+  };
+}
+
+const DEFAULT_AI_SETTINGS = Object.freeze(createDefaultAiSettings());
+
 function parseSettingValue(value) {
   if (value == null) return null;
   try {
@@ -19,11 +90,47 @@ function parseSettingValue(value) {
   }
 }
 
+function normalizeProviderConfigs(rawConfigs) {
+  const defaults = createDefaultProviderConfigs();
+  const parsed = rawConfigs && typeof rawConfigs === 'object' && !Array.isArray(rawConfigs)
+    ? rawConfigs
+    : {};
+
+  const normalized = {};
+  for (const definition of Object.values(AI_PROVIDER_DEFINITIONS)) {
+    const raw = parsed[definition.id];
+    const entry = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+    const baseUrl = typeof entry.baseUrl === 'string' ? entry.baseUrl.trim() : '';
+
+    normalized[definition.id] = {
+      enabled: entry.enabled !== false && entry.enabled !== 'false' && entry.enabled !== 0,
+      apiKey: definition.supportsApiKey && typeof entry.apiKey === 'string'
+        ? entry.apiKey.trim()
+        : '',
+      baseUrl: definition.supportsBaseUrl
+        ? (baseUrl || defaults[definition.id].baseUrl)
+        : ''
+    };
+  }
+
+  return normalized;
+}
+
+function getProviderConfigs(userId) {
+  if (!userId) return normalizeProviderConfigs(DEFAULT_AI_SETTINGS.ai_provider_configs);
+
+  const row = db.prepare(
+    'SELECT value FROM user_settings WHERE user_id = ? AND key = ?'
+  ).get(userId, 'ai_provider_configs');
+
+  return normalizeProviderConfigs(parseSettingValue(row?.value));
+}
+
 function ensureDefaultAiSettings(userId) {
-  if (!userId) return { ...DEFAULT_AI_SETTINGS };
+  if (!userId) return createDefaultAiSettings();
 
   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',
@@ -32,7 +139,8 @@ function ensureDefaultAiSettings(userId) {
     'subagent_max_iterations',
     'auto_skill_learning',
     'fallback_model_id',
-    'smarter_model_selector'
+    'smarter_model_selector',
+    'ai_provider_configs'
   );
 
   const seen = new Set(existing.map((row) => row.key));
@@ -40,7 +148,7 @@ function ensureDefaultAiSettings(userId) {
     'INSERT INTO user_settings (user_id, key, value) VALUES (?, ?, ?) ON CONFLICT(user_id, key) DO NOTHING'
   );
 
-  for (const [key, value] of Object.entries(DEFAULT_AI_SETTINGS)) {
+  for (const [key, value] of Object.entries(createDefaultAiSettings())) {
     if (!seen.has(key)) {
       insert.run(userId, key, JSON.stringify(value));
     }
@@ -50,10 +158,10 @@ function ensureDefaultAiSettings(userId) {
 }
 
 function getAiSettings(userId) {
-  if (!userId) return { ...DEFAULT_AI_SETTINGS };
+  if (!userId) return createDefaultAiSettings();
 
   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',
@@ -62,10 +170,11 @@ function getAiSettings(userId) {
     'subagent_max_iterations',
     'auto_skill_learning',
     'fallback_model_id',
-    'smarter_model_selector'
+    'smarter_model_selector',
+    'ai_provider_configs'
   );
 
-  const settings = { ...DEFAULT_AI_SETTINGS };
+  const settings = createDefaultAiSettings();
   for (const row of rows) {
     settings[row.key] = parseSettingValue(row.value);
   }
@@ -77,12 +186,17 @@ function getAiSettings(userId) {
   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;
+  settings.ai_provider_configs = normalizeProviderConfigs(settings.ai_provider_configs);
 
   return settings;
 }
 
 module.exports = {
+  AI_PROVIDER_DEFINITIONS,
   DEFAULT_AI_SETTINGS,
+  createDefaultAiSettings,
   ensureDefaultAiSettings,
-  getAiSettings
+  getAiSettings,
+  getProviderConfigs,
+  normalizeProviderConfigs
 };