@geminilight/mindos 0.6.38 → 0.6.40

package/app/app/api/settings/list-models/route.ts

@@ -1,6 +1,7 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
 import { effectiveAiConfig } from '@/lib/settings';
+import { type ProviderId, isProviderId, PROVIDER_PRESETS, getDefaultBaseUrl } from '@/lib/agent/providers';
 
 const TIMEOUT = 10_000;
 
@@ -13,14 +14,19 @@ export async function POST(req: NextRequest) {
       baseUrl?: string;
     };
 
-    if (provider !== 'anthropic' && provider !== 'openai') {
+    if (!provider || !isProviderId(provider)) {
       return NextResponse.json({ ok: false, error: 'Invalid provider' }, { status: 400 });
     }
 
-    const cfg = effectiveAiConfig();
+    const preset = PROVIDER_PRESETS[provider as ProviderId];
+    if (!preset.supportsListModels) {
+      return NextResponse.json({ ok: false, error: 'This provider does not support listing models' });
+    }
+
+    const cfg = effectiveAiConfig(provider as ProviderId);
     let resolvedKey = apiKey || '';
     if (!resolvedKey || resolvedKey === '***set***') {
-      resolvedKey = provider === 'anthropic' ? cfg.anthropicApiKey : cfg.openaiApiKey;
+      resolvedKey = cfg.apiKey;
     }
 
     if (!resolvedKey) {
@@ -31,56 +37,7 @@ export async function POST(req: NextRequest) {
     const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
 
     try {
-      let models: string[] = [];
-
-      if (provider === 'openai') {
-        const resolvedBaseUrl = (baseUrl || cfg.openaiBaseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
-        const res = await fetch(`${resolvedBaseUrl}/models`, {
-          headers: { Authorization: `Bearer ${resolvedKey}` },
-          signal: ctrl.signal,
-        });
-
-        if (!res.ok) {
-          const errBody = await res.text().catch(() => '');
-          return NextResponse.json({
-            ok: false,
-            error: `Failed to list models: HTTP ${res.status} ${errBody.slice(0, 200)}`,
-          });
-        }
-
-        const json = await res.json();
-        if (Array.isArray(json?.data)) {
-          models = json.data
-            .map((m: any) => m.id as string)
-            .filter(Boolean)
-            .sort((a: string, b: string) => a.localeCompare(b));
-        }
-      } else {
-        const res = await fetch('https://api.anthropic.com/v1/models', {
-          headers: {
-            'x-api-key': resolvedKey,
-            'anthropic-version': '2023-06-01',
-          },
-          signal: ctrl.signal,
-        });
-
-        if (!res.ok) {
-          const errBody = await res.text().catch(() => '');
-          return NextResponse.json({
-            ok: false,
-            error: `Failed to list models: HTTP ${res.status} ${errBody.slice(0, 200)}`,
-          });
-        }
-
-        const json = await res.json();
-        if (Array.isArray(json?.data)) {
-          models = json.data
-            .map((m: any) => m.id as string)
-            .filter(Boolean)
-            .sort((a: string, b: string) => a.localeCompare(b));
-        }
-      }
-
+      const models = await fetchModels(provider as ProviderId, resolvedKey, baseUrl || cfg.baseUrl || '', ctrl.signal);
       return NextResponse.json({ ok: true, models });
     } catch (e: unknown) {
       if (e instanceof Error && e.name === 'AbortError') {
@@ -94,3 +51,66 @@ export async function POST(req: NextRequest) {
     return NextResponse.json({ ok: false, error: String(err) }, { status: 500 });
   }
 }
+
+async function fetchModels(provider: ProviderId, apiKey: string, baseUrl: string, signal: AbortSignal): Promise<string[]> {
+  if (provider === 'anthropic') {
+    return fetchAnthropicModels(apiKey, signal);
+  }
+
+  const endpoint = resolveListModelsUrl(provider, baseUrl);
+  return fetchOpenAICompatModels(endpoint, apiKey, signal);
+}
+
+function resolveListModelsUrl(provider: ProviderId, baseUrl: string): string {
+  if (baseUrl) {
+    return baseUrl.replace(/\/+$/, '') + '/models';
+  }
+
+  const base = getDefaultBaseUrl(provider);
+  if (base) {
+    return base.replace(/\/+$/, '') + '/models';
+  }
+
+  return 'https://api.openai.com/v1/models';
+}
+
+async function fetchAnthropicModels(apiKey: string, signal: AbortSignal): Promise<string[]> {
+  const res = await fetch('https://api.anthropic.com/v1/models', {
+    headers: {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    signal,
+  });
+
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => '');
+    throw new Error(`Failed to list models: HTTP ${res.status} ${errBody.slice(0, 200)}`);
+  }
+
+  const json = await res.json();
+  if (Array.isArray(json?.data)) {
+    return json.data.map((m: any) => m.id as string).filter(Boolean).sort();
+  }
+  return [];
+}
+
+async function fetchOpenAICompatModels(
+  endpoint: string, apiKey: string, signal: AbortSignal,
+): Promise<string[]> {
+  const res = await fetch(endpoint, {
+    headers: { 'Authorization': `Bearer ${apiKey}` },
+    signal,
+  });
+
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => '');
+    throw new Error(`Failed to list models: HTTP ${res.status} ${errBody.slice(0, 200)}`);
+  }
+
+  const json = await res.json();
+  if (Array.isArray(json?.data)) {
+    return json.data.map((m: any) => m.id as string).filter(Boolean).sort();
+  }
+  return [];
+}

package/app/app/api/settings/route.ts

@@ -2,10 +2,10 @@ export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
 import { readSettings, writeSettings, ServerSettings } from '@/lib/settings';
 import { invalidateCache } from '@/lib/fs';
+import { PROVIDER_PRESETS, ALL_PROVIDER_IDS, getApiKeyEnvVar, getApiKeyFromEnv } from '@/lib/agent/providers';
 
 function maskToken(token: string | undefined): string {
   if (!token) return '';
-  // Show first 4 and last 4 chars: xxxx-••••-••••-••••-••••-xxxx
   const parts = token.split('-');
   if (parts.length >= 2) {
     return parts[0] + '-' + parts.slice(1, -1).map(() => '••••').join('-') + '-' + parts[parts.length - 1];
@@ -16,49 +16,46 @@ function maskToken(token: string | undefined): string {
 export async function GET() {
   const settings = readSettings();
 
-  const envValues = {
-    AI_PROVIDER:       process.env.AI_PROVIDER || '',
-    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY ? '***set***' : '',
-    ANTHROPIC_MODEL:   process.env.ANTHROPIC_MODEL || '',
-    OPENAI_API_KEY:    process.env.OPENAI_API_KEY ? '***set***' : '',
-    OPENAI_MODEL:      process.env.OPENAI_MODEL || '',
-    OPENAI_BASE_URL:   process.env.OPENAI_BASE_URL || '',
-    MIND_ROOT:         process.env.MIND_ROOT || '',
+  // Build env values/overrides dynamically from all provider presets
+  const envOverrides: Record<string, boolean> = {
+    AI_PROVIDER: !!process.env.AI_PROVIDER,
+    MIND_ROOT:   !!process.env.MIND_ROOT,
+  };
+  const envValues: Record<string, string> = {
+    AI_PROVIDER: process.env.AI_PROVIDER || '',
+    MIND_ROOT:   process.env.MIND_ROOT || '',
   };
 
-  // Mask API keys
-  const anthropic = settings.ai.providers.anthropic;
-  const openai    = settings.ai.providers.openai;
+  for (const id of ALL_PROVIDER_IDS) {
+    const envKey = getApiKeyEnvVar(id);
+    if (envKey) {
+      envOverrides[envKey] = !!getApiKeyFromEnv(id);
+      envValues[envKey] = getApiKeyFromEnv(id) ? '***set***' : '';
+    }
+  }
+
+  // Mask API keys for all configured providers
+  const maskedProviders: Record<string, { apiKey: string; model: string; baseUrl?: string }> = {};
+  for (const [id, cfg] of Object.entries(settings.ai.providers)) {
+    if (!cfg) continue;
+    maskedProviders[id] = {
+      apiKey: cfg.apiKey ? '***set***' : '',
+      model: cfg.model ?? '',
+      ...(cfg.baseUrl !== undefined ? { baseUrl: cfg.baseUrl } : {}),
+    };
+  }
 
   const masked = {
     ai: {
       provider: settings.ai.provider,
-      providers: {
-        anthropic: {
-          apiKey: anthropic?.apiKey ? '***set***' : '',
-          model:  anthropic?.model  ?? '',
-        },
-        openai: {
-          apiKey:  openai?.apiKey  ? '***set***' : '',
-          model:   openai?.model   ?? '',
-          baseUrl: openai?.baseUrl ?? '',
-        },
-      },
+      providers: maskedProviders,
     },
     mindRoot: settings.mindRoot,
     webPassword: settings.webPassword ? '***set***' : '',
     authToken: maskToken(settings.authToken),
     mcpPort: settings.mcpPort ?? 8781,
     agent: settings.agent ?? {},
-    envOverrides: {
-      AI_PROVIDER:       !!process.env.AI_PROVIDER,
-      ANTHROPIC_API_KEY: !!process.env.ANTHROPIC_API_KEY,
-      ANTHROPIC_MODEL:   !!process.env.ANTHROPIC_MODEL,
-      OPENAI_API_KEY:    !!process.env.OPENAI_API_KEY,
-      OPENAI_MODEL:      !!process.env.OPENAI_MODEL,
-      OPENAI_BASE_URL:   !!process.env.OPENAI_BASE_URL,
-      MIND_ROOT:         !!process.env.MIND_ROOT,
-    },
+    envOverrides,
     envValues,
   };
   return NextResponse.json(masked);
@@ -69,11 +66,22 @@ export async function POST(req: NextRequest) {
     const body = await req.json() as Partial<ServerSettings>;
     const current = readSettings();
 
-    // Merge providers, preserving masked keys
-    const incomingAnthropic = body.ai?.providers?.anthropic;
-    const incomingOpenai    = body.ai?.providers?.openai;
-    const curAnthropic      = current.ai.providers.anthropic;
-    const curOpenai         = current.ai.providers.openai;
+    // Merge providers dynamically, preserving masked keys ('***set***' = keep existing)
+    const mergedProviders = { ...current.ai.providers };
+    if (body.ai?.providers) {
+      for (const [id, incoming] of Object.entries(body.ai.providers)) {
+        if (!incoming) continue;
+        const cur = mergedProviders[id as keyof typeof mergedProviders] ?? { apiKey: '', model: '' };
+        mergedProviders[id as keyof typeof mergedProviders] = {
+          ...cur,
+          ...incoming,
+          apiKey: incoming.apiKey === '***set***'
+            ? (cur.apiKey ?? '')
+            : (incoming.apiKey ?? cur.apiKey ?? ''),
+          model: incoming.model ?? cur.model ?? '',
+        };
+      }
+    }
 
     // Resolve webPassword: '***set***' means keep existing, '' means clear, anything else = new value
     const incomingWebPassword = body.webPassword;
@@ -91,24 +99,7 @@ export async function POST(req: NextRequest) {
     const next: ServerSettings = {
       ai: {
         provider: body.ai?.provider ?? current.ai.provider,
-        providers: {
-          anthropic: {
-            ...curAnthropic,
-            ...(incomingAnthropic ?? {}),
-            apiKey: incomingAnthropic?.apiKey === '***set***'
-              ? (curAnthropic.apiKey ?? '')
-              : (incomingAnthropic?.apiKey ?? curAnthropic.apiKey ?? ''),
-            model: incomingAnthropic?.model ?? curAnthropic.model ?? 'claude-sonnet-4-6',
-          },
-          openai: {
-            ...curOpenai,
-            ...(incomingOpenai ?? {}),
-            apiKey: incomingOpenai?.apiKey === '***set***'
-              ? (curOpenai.apiKey ?? '')
-              : (incomingOpenai?.apiKey ?? curOpenai.apiKey ?? ''),
-            model: incomingOpenai?.model ?? curOpenai.model ?? 'gpt-5.4',
-          },
-        },
+        providers: mergedProviders,
       },
       mindRoot: body.mindRoot ?? current.mindRoot,
       agent: body.agent ?? current.agent,

package/app/app/api/settings/test-key/route.ts

@@ -1,118 +1,39 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
+import { complete } from '@mariozechner/pi-ai';
 import { effectiveAiConfig } from '@/lib/settings';
+import { getModelConfig } from '@/lib/agent/model';
+import { type ProviderId, isProviderId } from '@/lib/agent/providers';
 
-const TIMEOUT = 10_000;
+const TIMEOUT = 15_000;
 
 type ErrorCode = 'auth_error' | 'model_not_found' | 'rate_limited' | 'network_error' | 'unknown';
 
-function classifyError(status: number, body: string): { code: ErrorCode; error: string } {
-  if (status === 401 || status === 403) return { code: 'auth_error', error: 'Invalid API key' };
-  if (status === 404) return { code: 'model_not_found', error: 'Model not found' };
-  if (status === 429) return { code: 'rate_limited', error: 'Rate limited' };
-  // Try to extract error message from response body
-  try {
-    const parsed = JSON.parse(body);
-    const msg = parsed?.error?.message || parsed?.error || '';
-    if (typeof msg === 'string' && msg.length > 0) return { code: 'unknown', error: msg.slice(0, 200) };
-  } catch { /* not JSON */ }
-  return { code: 'unknown', error: `HTTP ${status}` };
-}
+function classifyPiAiError(err: unknown): { code: ErrorCode; error: string } {
+  const msg = err instanceof Error ? err.message : String(err);
+  const lower = msg.toLowerCase();
 
-async function testAnthropic(apiKey: string, model: string): Promise<{ ok: boolean; latency?: number; code?: ErrorCode; error?: string }> {
-  const start = Date.now();
-  const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
-  try {
-    const res = await fetch('https://api.anthropic.com/v1/messages', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01',
-      },
-      body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
-      signal: ctrl.signal,
-    });
-    const latency = Date.now() - start;
-    if (res.ok) return { ok: true, latency };
-    const body = await res.text();
-    return { ok: false, ...classifyError(res.status, body) };
-  } catch (e: unknown) {
-    if (e instanceof Error && e.name === 'AbortError') return { ok: false, code: 'network_error', error: 'Request timed out' };
-    return { ok: false, code: 'network_error', error: e instanceof Error ? e.message : 'Network error' };
-  } finally {
-    clearTimeout(timer);
-  }
-}
+  if (err instanceof Error && err.name === 'AbortError')
+    return { code: 'network_error', error: 'Request timed out' };
 
-async function testOpenAI(apiKey: string, model: string, baseUrl: string): Promise<{ ok: boolean; latency?: number; code?: ErrorCode; error?: string }> {
-  const start = Date.now();
-  const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
-  const url = (baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '') + '/chat/completions';
-  try {
-    const res = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify({ model, messages: [{ role: 'user', content: 'hi' }] }),
-      signal: ctrl.signal,
-    });
-    const latency = Date.now() - start;
-    if (!res.ok) {
-      const body = await res.text();
-      return { ok: false, ...classifyError(res.status, body) };
-    }
+  if (lower.includes('401') || lower.includes('403')
+    || (lower.includes('invalid') && lower.includes('key'))
+    || lower.includes('authentication') || lower.includes('unauthorized')
+    || lower.includes('api key') && (lower.includes('not valid') || lower.includes('incorrect')))
+    return { code: 'auth_error', error: 'Invalid API key' };
 
-    // Tool compatibility test — `/api/ask` always sends tool definitions.
-    const toolRes = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify({
-        model,
-        messages: [
-          { role: 'system', content: 'You are a helpful assistant.' },
-          { role: 'user', content: 'hi' },
-        ],
-        tools: [{
-          type: 'function',
-          function: {
-            name: 'noop',
-            description: 'No-op function used for compatibility checks.',
-            parameters: {
-              type: 'object',
-              properties: {},
-              additionalProperties: false,
-            },
-          },
-        }],
-        tool_choice: 'none',
-      }),
-      signal: ctrl.signal,
-    });
-    if (!toolRes.ok) {
-      const toolBody = await toolRes.text();
-      const toolErr = classifyError(toolRes.status, toolBody);
-      return {
-        ok: false,
-        code: toolErr.code,
-        error: `Model endpoint passes basic test but is incompatible with agent tool calls: ${toolErr.error}`,
-      };
-    }
+  if (lower.includes('404') || lower.includes('not found') || lower.includes('does not exist'))
+    return { code: 'model_not_found', error: `Model not found: ${msg.slice(0, 200)}` };
 
-    return { ok: true, latency };
-  } catch (e: unknown) {
-    if (e instanceof Error && e.name === 'AbortError') return { ok: false, code: 'network_error', error: 'Request timed out' };
-    return { ok: false, code: 'network_error', error: e instanceof Error ? e.message : 'Network error' };
-  } finally {
-    clearTimeout(timer);
-  }
+  if (lower.includes('429') || lower.includes('rate') || lower.includes('quota'))
+    return { code: 'rate_limited', error: 'Rate limited — try again later' };
+
+  if (lower.includes('econnrefused') || lower.includes('enotfound')
+    || lower.includes('etimedout') || lower.includes('fetch failed')
+    || lower.includes('network'))
+    return { code: 'network_error', error: msg.slice(0, 200) };
+
+  return { code: 'unknown', error: msg.slice(0, 200) };
 }
 
 export async function POST(req: NextRequest) {
@@ -125,28 +46,50 @@ export async function POST(req: NextRequest) {
       baseUrl?: string;
     };
 
-    if (provider !== 'anthropic' && provider !== 'openai') {
-      return NextResponse.json({ ok: false, code: 'unknown', error: 'Invalid provider' }, { status: 400 });
+    if (!provider || !isProviderId(provider)) {
+      return NextResponse.json(
+        { ok: false, code: 'unknown', error: 'Invalid provider' },
+        { status: 400 },
+      );
     }
 
-    // Resolve actual API key: use provided key, fallback to config/env for masked or missing
-    const cfg = effectiveAiConfig();
+    const cfg = effectiveAiConfig(provider as ProviderId);
     let resolvedKey = apiKey || '';
     if (!resolvedKey || resolvedKey === '***set***') {
-      resolvedKey = provider === 'anthropic' ? cfg.anthropicApiKey : cfg.openaiApiKey;
+      resolvedKey = cfg.apiKey;
     }
 
     if (!resolvedKey) {
       return NextResponse.json({ ok: false, code: 'auth_error', error: 'No API key configured' });
     }
 
-    const resolvedModel = model || (provider === 'anthropic' ? cfg.anthropicModel : cfg.openaiModel);
+    const resolvedModel = model || cfg.model;
 
-    const result = provider === 'anthropic'
-      ? await testAnthropic(resolvedKey, resolvedModel)
-      : await testOpenAI(resolvedKey, resolvedModel, baseUrl || cfg.openaiBaseUrl);
+    const start = Date.now();
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
 
-    return NextResponse.json(result);
+    try {
+      const { model: piModel } = getModelConfig({
+        provider: provider as ProviderId,
+        apiKey: resolvedKey,
+        model: resolvedModel || undefined,
+        baseUrl: baseUrl || undefined,
+      });
+
+      await complete(piModel, {
+        messages: [{ role: 'user', content: 'hi', timestamp: Date.now() }],
+      }, {
+        apiKey: resolvedKey,
+        signal: ctrl.signal,
+      });
+
+      return NextResponse.json({ ok: true, latency: Date.now() - start });
+    } catch (e) {
+      return NextResponse.json({ ok: false, ...classifyPiAiError(e) });
+    } finally {
+      clearTimeout(timer);
+    }
   } catch (err) {
     return NextResponse.json({ ok: false, code: 'unknown', error: String(err) }, { status: 500 });
   }

package/app/app/api/setup/route.ts

@@ -5,6 +5,7 @@ import os from 'os';
 import { readSettings, writeSettings, ServerSettings } from '@/lib/settings';
 import { applyTemplate } from '@/lib/template';
 import { expandSetupPathHome } from './path-utils';
+import { type ProviderId, isProviderId, PROVIDER_PRESETS } from '@/lib/agent/providers';
 
 function maskApiKey(key: string): string {
   if (!key || key.length < 6) return key ? '***' : '';
@@ -17,6 +18,18 @@ export async function GET() {
     const home = os.homedir();
     const sep = process.platform === 'win32' ? '\\' : '/';
     const defaultMindRoot = s.mindRoot || [home, 'MindOS', 'mind'].join(sep);
+
+    // Build providerConfigs for frontend (masked keys)
+    const providerConfigs: Record<string, { model: string; baseUrl?: string; apiKeyMask: string }> = {};
+    for (const [id, cfg] of Object.entries(s.ai.providers)) {
+      if (!cfg) continue;
+      providerConfigs[id] = {
+        model: cfg.model,
+        baseUrl: cfg.baseUrl,
+        apiKeyMask: maskApiKey(cfg.apiKey),
+      };
+    }
+
     return NextResponse.json({
       mindRoot: defaultMindRoot,
       homeDir: home,
@@ -26,11 +39,7 @@ export async function GET() {
       authToken: s.authToken ?? '',
       webPassword: s.webPassword ?? '',
       provider: s.ai.provider,
-      anthropicApiKey: maskApiKey(s.ai.providers.anthropic.apiKey),
-      anthropicModel: s.ai.providers.anthropic.model,
-      openaiApiKey: maskApiKey(s.ai.providers.openai.apiKey),
-      openaiModel: s.ai.providers.openai.model,
-      openaiBaseUrl: s.ai.providers.openai.baseUrl ?? '',
+      providerConfigs,
       guideState: s.guideState ?? null,
     });
   } catch (e) {
@@ -95,22 +104,23 @@ export async function POST(req: NextRequest) {
     // configured key with blank just because the user didn't re-enter it.
     let mergedAi = current.ai;
     if (ai) {
-      const inAnthropicKey = ai.providers?.anthropic?.apiKey;
-      const inOpenaiKey    = ai.providers?.openai?.apiKey;
-      mergedAi = {
-        provider: ai.provider ?? current.ai.provider,
-        providers: {
-          anthropic: {
-            apiKey: inAnthropicKey || current.ai.providers.anthropic.apiKey,
-            model:  ai.providers?.anthropic?.model || current.ai.providers.anthropic.model,
-          },
-          openai: {
-            apiKey:  inOpenaiKey || current.ai.providers.openai.apiKey,
-            model:   ai.providers?.openai?.model  || current.ai.providers.openai.model,
-            baseUrl: ai.providers?.openai?.baseUrl ?? current.ai.providers.openai.baseUrl ?? '',
-          },
-        },
-      };
+      const newProvider = ai.provider && isProviderId(ai.provider) ? ai.provider : current.ai.provider;
+      const mergedProviders = { ...current.ai.providers };
+
+      // Merge each provider's config from the incoming payload
+      if (ai.providers && typeof ai.providers === 'object') {
+        for (const [id, inCfg] of Object.entries(ai.providers as Record<string, any>)) {
+          if (!isProviderId(id) || !inCfg) continue;
+          const existing = mergedProviders[id] ?? { apiKey: '', model: PROVIDER_PRESETS[id].defaultModel };
+          mergedProviders[id] = {
+            apiKey: inCfg.apiKey || existing.apiKey,
+            model: inCfg.model || existing.model,
+            ...(inCfg.baseUrl !== undefined ? { baseUrl: inCfg.baseUrl } : existing.baseUrl ? { baseUrl: existing.baseUrl } : {}),
+          };
+        }
+      }
+
+      mergedAi = { provider: newProvider, providers: mergedProviders };
     }
 
     const disabledSkills = body.template === 'zh' ? ['mindos'] : ['mindos-zh'];