@geminilight/mindos 0.6.56 → 0.6.58

package/app/app/api/agents/custom/detect/route.ts

@@ -0,0 +1,31 @@
+export const dynamic = 'force-dynamic';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { detectBaseDir } from '@/lib/custom-agents';
+
+/** POST — Auto-detect config files in a baseDir. */
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { baseDir } = body as { baseDir?: string };
+
+    if (!baseDir?.trim()) {
+      return NextResponse.json({ error: 'baseDir is required' }, { status: 400 });
+    }
+
+    const dir = baseDir.trim();
+
+    // Security: restrict to home directory only
+    if (!dir.startsWith('~/')) {
+      return NextResponse.json(
+        { error: 'baseDir must start with ~/ (e.g. ~/.qclaw/)' },
+        { status: 400 },
+      );
+    }
+
+    const result = detectBaseDir(dir);
+    return NextResponse.json(result);
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/agents/custom/route.ts

@@ -0,0 +1,158 @@
+export const dynamic = 'force-dynamic';
+
+import { NextRequest, NextResponse } from 'next/server';
+import { MCP_AGENTS } from '@/lib/mcp-agents';
+import {
+  loadCustomAgents,
+  saveCustomAgents,
+  inferDefaults,
+  slugify,
+  generateUniqueKey,
+  validateCustomAgentInput,
+  type CustomAgentDef,
+} from '@/lib/custom-agents';
+
+/** POST — Create a new custom agent. */
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { name, baseDir, ...overrides } = body as Partial<CustomAgentDef> & { name?: string; baseDir?: string };
+
+    if (!name?.trim() || !baseDir?.trim()) {
+      return NextResponse.json({ error: 'name and baseDir are required' }, { status: 400 });
+    }
+
+    const customs = loadCustomAgents();
+    const existingKeys = new Set([
+      ...Object.keys(MCP_AGENTS),
+      ...customs.map(c => c.key),
+    ]);
+
+    const key = overrides.key && !existingKeys.has(overrides.key)
+      ? overrides.key
+      : generateUniqueKey(name.trim(), existingKeys);
+
+    const error = validateCustomAgentInput({ name, baseDir, key }, existingKeys);
+    if (error) {
+      return NextResponse.json({ error }, { status: 400 });
+    }
+
+    const defaults = inferDefaults(name.trim(), baseDir.trim());
+    const agent: CustomAgentDef = {
+      ...defaults,
+      key,
+      ...(overrides.global && { global: overrides.global }),
+      ...(overrides.project !== undefined && { project: overrides.project }),
+      ...(overrides.configKey && { configKey: overrides.configKey }),
+      ...(overrides.format && { format: overrides.format }),
+      ...(overrides.preferredTransport && { preferredTransport: overrides.preferredTransport }),
+      ...(overrides.presenceDirs && { presenceDirs: overrides.presenceDirs }),
+      ...(overrides.presenceCli && { presenceCli: overrides.presenceCli }),
+      ...(overrides.globalNestedKey && { globalNestedKey: overrides.globalNestedKey }),
+      ...(overrides.skillDir && { skillDir: overrides.skillDir }),
+    };
+
+    customs.push(agent);
+    saveCustomAgents(customs);
+
+    return NextResponse.json({ agent }, { status: 201 });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}
+
+/** PUT — Update an existing custom agent. */
+export async function PUT(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { key, ...updates } = body as Partial<CustomAgentDef> & { key: string };
+
+    if (!key) {
+      return NextResponse.json({ error: 'key is required' }, { status: 400 });
+    }
+
+    const customs = loadCustomAgents();
+    const idx = customs.findIndex(c => c.key === key);
+
+    if (idx === -1) {
+      return NextResponse.json({ error: `Custom agent "${key}" not found` }, { status: 404 });
+    }
+
+    const existing = customs[idx];
+
+    // Validate enum fields
+    if (updates.format && !['json', 'toml'].includes(updates.format)) {
+      return NextResponse.json({ error: 'format must be "json" or "toml"' }, { status: 400 });
+    }
+    if (updates.preferredTransport && !['stdio', 'http'].includes(updates.preferredTransport)) {
+      return NextResponse.json({ error: 'preferredTransport must be "stdio" or "http"' }, { status: 400 });
+    }
+
+    // Validate baseDir if changed
+    if (updates.baseDir) {
+      const dir = updates.baseDir.trim();
+      if (!dir.startsWith('~/') && !dir.startsWith('/')) {
+        return NextResponse.json({ error: 'baseDir must be an absolute path' }, { status: 400 });
+      }
+    }
+
+    const updated: CustomAgentDef = {
+      ...existing,
+      ...(updates.name && { name: updates.name }),
+      ...(updates.baseDir && { baseDir: updates.baseDir }),
+      ...(updates.global && { global: updates.global }),
+      ...(updates.project !== undefined && { project: updates.project }),
+      ...(updates.configKey && { configKey: updates.configKey }),
+      ...(updates.format && { format: updates.format }),
+      ...(updates.preferredTransport && { preferredTransport: updates.preferredTransport }),
+      ...(updates.presenceCli !== undefined && { presenceCli: updates.presenceCli || undefined }),
+      ...(updates.globalNestedKey !== undefined && { globalNestedKey: updates.globalNestedKey || undefined }),
+      ...(updates.skillDir !== undefined && { skillDir: updates.skillDir || undefined }),
+    };
+
+    // Update presenceDirs: explicit override takes priority, then baseDir-derived default
+    if (updates.presenceDirs) {
+      updated.presenceDirs = updates.presenceDirs;
+    } else if (updates.baseDir) {
+      updated.presenceDirs = [updates.baseDir.endsWith('/') ? updates.baseDir : updates.baseDir + '/'];
+    }
+
+    // Update skillDir default when baseDir changes and no explicit skillDir
+    if (!updates.skillDir && updates.baseDir) {
+      const bd = updates.baseDir.endsWith('/') ? updates.baseDir : updates.baseDir + '/';
+      updated.skillDir = bd + 'skills/';
+    }
+
+    customs[idx] = updated;
+    saveCustomAgents(customs);
+
+    return NextResponse.json({ agent: updated });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}
+
+/** DELETE — Remove a custom agent. */
+export async function DELETE(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { key } = body as { key: string };
+
+    if (!key) {
+      return NextResponse.json({ error: 'key is required' }, { status: 400 });
+    }
+
+    const customs = loadCustomAgents();
+    const filtered = customs.filter(c => c.key !== key);
+
+    if (filtered.length === customs.length) {
+      return NextResponse.json({ error: `Custom agent "${key}" not found` }, { status: 404 });
+    }
+
+    saveCustomAgents(filtered);
+
+    return NextResponse.json({ removed: key });
+  } catch (err) {
+    return NextResponse.json({ error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/ask/route.ts

@@ -405,6 +405,143 @@ function toPiCustomToolDefinitions(tools: AgentTool<any>[]): ToolDefinition<any,
 // Non-streaming fallback for proxies that don't support stream + tools
 // ---------------------------------------------------------------------------
 
+/**
+ * Reassemble SSE chunks (from proxies that ignore stream:false) into a
+ * single OpenAI-style chat completion response.
+ *
+ * SSE format:  data: {"choices":[{"delta":{"content":"He"}}]}
+ * Output:      {"choices":[{"message":{"role":"assistant","content":"Hello!"},"finish_reason":"stop"}]}
+ */
+function reassembleSSE(sseText: string): any {
+  const lines = sseText.split('\n');
+  let content = '';
+  let role = 'assistant';
+  let finishReason = 'stop';
+  const toolCalls: Map<number, { id: string; type: string; function: { name: string; arguments: string } }> = new Map();
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('data:')) continue;
+    const payload = trimmed.slice(5).trim();
+    if (payload === '[DONE]') break;
+
+    let chunk: any;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      continue; // skip unparseable lines
+    }
+
+    const delta = chunk?.choices?.[0]?.delta;
+    if (!delta) continue;
+
+    if (delta.role) role = delta.role;
+    if (delta.content) content += delta.content;
+    if (chunk.choices[0].finish_reason) finishReason = chunk.choices[0].finish_reason;
+
+    // Accumulate tool calls (they arrive in incremental deltas)
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const idx = tc.index ?? 0;
+        const existing = toolCalls.get(idx);
+        if (!existing) {
+          toolCalls.set(idx, {
+            id: tc.id ?? '',
+            type: tc.type ?? 'function',
+            function: {
+              name: tc.function?.name ?? '',
+              arguments: tc.function?.arguments ?? '',
+            },
+          });
+        } else {
+          if (tc.id) existing.id = tc.id;
+          if (tc.function?.name) existing.function.name += tc.function.name;
+          if (tc.function?.arguments) existing.function.arguments += tc.function.arguments;
+        }
+      }
+    }
+  }
+
+  const message: any = { role, content: content || null };
+  if (toolCalls.size > 0) {
+    message.tool_calls = Array.from(toolCalls.values());
+  }
+
+  return {
+    choices: [{ message, finish_reason: finishReason }],
+  };
+}
+
+/**
+ * Convert pi-ai format messages to OpenAI API format.
+ * pi-ai messages have nested structures; OpenAI format is flatter with tool_calls array.
+ */
+function piMessagesToOpenAI(piMessages: any[]): any[] {
+  return piMessages.map(msg => {
+    const role = msg.role;
+
+    // Skip system role (will be added separately)
+    if (role === 'system') return null;
+
+    // Pass through user messages (simple string content)
+    if (role === 'user') {
+      return {
+        role: 'user',
+        content: typeof msg.content === 'string' ? msg.content : msg.content,
+      };
+    }
+
+    // Assistant messages: flatten content array into text + tool_calls
+    if (role === 'assistant') {
+      const content = msg.content;
+      let textContent = '';
+      const toolCalls: any[] = [];
+
+      if (Array.isArray(content)) {
+        for (const part of content) {
+          if (part.type === 'text' && part.text) {
+            textContent += part.text;
+          } else if (part.type === 'toolCall') {
+            toolCalls.push({
+              id: part.id ?? `call_${Date.now()}`,
+              type: 'function',
+              function: {
+                name: part.name ?? 'unknown',
+                arguments: JSON.stringify(part.arguments ?? {}),
+              },
+            });
+          }
+        }
+      }
+
+      const result: any = { role: 'assistant' };
+      // Always include content (even if empty) for tool-call-only messages
+      // OpenAI API may handle this differently, but it's safer to include empty string
+      result.content = textContent || '';
+      if (toolCalls.length > 0) result.tool_calls = toolCalls;
+      return result;
+    }
+
+    // Tool result messages
+    if (role === 'toolResult') {
+      const contentText = Array.isArray(msg.content)
+        ? msg.content
+            .filter((c: any) => c.type === 'text')
+            .map((c: any) => c.text ?? '')
+            .join('\n')
+        : String(msg.content ?? '');
+
+      return {
+        role: 'tool',
+        tool_call_id: msg.toolCallId ?? 'unknown',
+        content: contentText,
+      };
+    }
+
+    return null;
+  }).filter(Boolean);
+}
+
 /**
  * Mini agent loop using non-streaming OpenAI-compatible API.
  * Used when a proxy silently breaks stream+tools by returning plain text.
@@ -415,7 +552,7 @@ async function runNonStreamingFallback(opts: {
   apiKey: string;
   model: string;
   systemPrompt: string;
-  historyMessages: { role: string; content: unknown }[];
+  historyMessages: any[];
   userContent: string;
   tools: AgentTool<any>[];
   send: (event: MindOSSSEvent) => void;
@@ -433,9 +570,12 @@ async function runNonStreamingFallback(opts: {
     },
   }));
 
-  const messages: { role: string; content: unknown; tool_calls?: unknown; tool_call_id?: string }[] = [
+  // Convert pi-ai format messages to OpenAI format
+  const openaiMessages = piMessagesToOpenAI(historyMessages);
+
+  const messages: { role: string; content?: unknown; tool_calls?: unknown; tool_call_id?: string }[] = [
     { role: 'system', content: systemPrompt },
-    ...historyMessages,
+    ...openaiMessages,
     { role: 'user', content: userContent },
   ];
 
@@ -447,6 +587,9 @@ async function runNonStreamingFallback(opts: {
     if (signal.aborted) throw new Error('Request aborted');
     step++;
 
+    // Use stream:true and parse SSE ourselves.
+    // Many proxies ignore stream:false (returning SSE with empty choices or broken JSON).
+    // Using stream:true is the most universally compatible approach.
     const resp = await fetch(endpoint, {
       method: 'POST',
       headers: {
@@ -458,7 +601,7 @@ async function runNonStreamingFallback(opts: {
         messages,
         tools: openaiTools.length > 0 ? openaiTools : undefined,
         tool_choice: openaiTools.length > 0 ? 'auto' : undefined,
-        stream: false,
+        stream: true,
       }),
       signal,
     });
@@ -468,11 +611,28 @@ async function runNonStreamingFallback(opts: {
       throw new Error(`Non-streaming API error ${resp.status}: ${errText.slice(0, 200)}`);
     }
 
-    const data = await resp.json() as any;
+    // Read the full response body (SSE or JSON)
+    const rawText = await resp.text();
+    const trimmed = rawText.trimStart();
+
+    let data: any;
+    if (trimmed.startsWith('data:')) {
+      // Response is SSE — reassemble chunks into a single OpenAI response
+      data = reassembleSSE(trimmed);
+    } else {
+      // Some endpoints might still return plain JSON even with stream:true
+      try {
+        data = JSON.parse(rawText);
+      } catch {
+        throw new Error(`API returned invalid response: ${rawText.slice(0, 200)}`);
+      }
+    }
+
     const choice = data?.choices?.[0];
     if (!choice) throw new Error('Empty response from API');
 
-    const msg = choice.message;
+    // reassembleSSE always produces .message; standard JSON may use .message or .delta
+    const msg = choice.message ?? choice.delta ?? {};
     const finishReason: string = choice.finish_reason ?? 'stop';
 
     // Emit text content in chunks to simulate streaming appearance
@@ -1185,11 +1345,12 @@ export async function POST(req: NextRequest) {
             if (lastPromptError) throw lastPromptError;
 
             metrics.recordRequest(Date.now() - requestStartTime);
-            if (!hasContent && lastModelError) {
-              // No content received — check if this looks like a proxy stream+tools incompatibility.
-              // Only attempt fallback for OpenAI-compatible endpoints with a custom baseUrl.
+            if (!hasContent && (lastModelError || (baseUrl && provider === 'openai'))) {
+              // No content received — either a model error or proxy compatibility issue.
+              // For OpenAI-compatible endpoints with custom baseUrl, always try the fallback
+              // even without an explicit error (some proxies silently return empty responses).
               if (baseUrl && provider === 'openai') {
-                send({ type: 'status', message: t.proxyCompatDetecting });
+                send({ type: 'status', message: lastModelError ? t.proxyCompatDetecting : t.proxyCompatMode });
                 try {
                   await runNonStreamingFallback({
                     baseUrl,

package/app/app/api/file/import/route.ts

@@ -15,6 +15,19 @@ import { invalidateCache } from '@/lib/fs';
 const MAX_FILES = 20;
 const MAX_CONTENT_LENGTH = 5 * 1024 * 1024;
 
+/** File extensions that are binary and should be written as raw buffers, not text. */
+const BINARY_EXTENSIONS = new Set([
+  '.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.ico',
+  '.mp3', '.wav', '.m4a', '.ogg', '.flac', '.aac',
+  '.mp4', '.webm', '.mov', '.mkv',
+  '.pdf',
+]);
+
+function isBinaryFile(name: string): boolean {
+  const ext = path.extname(name).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+
 type ConflictMode = 'skip' | 'rename' | 'overwrite';
 
 interface ImportRequest {
@@ -136,6 +149,35 @@ export async function POST(req: NextRequest) {
 
       const sanitized = sanitizeFileName(entry.name);
       const encoding = entry.encoding === 'base64' ? 'base64' : 'text';
+
+      // Binary files (images, audio, video, PDF): write raw buffer, skip text conversion
+      if (encoding === 'base64' && isBinaryFile(sanitized)) {
+        const buf = Buffer.from(entry.content, 'base64');
+
+        let relPath = targetSpaceNorm
+          ? path.posix.join(targetSpaceNorm, sanitized)
+          : sanitized;
+
+        const { relPath: finalRel, resolved, skipped: skipReason } = resolveUniquePath(
+          mindRoot,
+          relPath,
+          conflict,
+        );
+
+        if (skipReason) {
+          skipped.push({ name: entry.name, reason: skipReason });
+          continue;
+        }
+
+        fs.mkdirSync(path.dirname(resolved), { recursive: true });
+        fs.writeFileSync(resolved, buf);
+
+        created.push({ original: entry.name, path: finalRel });
+        createdPaths.push(finalRel);
+        continue;
+      }
+
+      // Text files: decode and convert to markdown
       const raw = decodeFileContent(encoding, entry.content, sanitized);
       const convertResult = convertToMarkdown(sanitized, raw);
 

package/app/app/api/mcp/agents/route.ts

@@ -3,8 +3,10 @@ import os from 'os';
 import fs from 'fs';
 import path from 'path';
 import { NextResponse } from 'next/server';
+import { execSync } from 'child_process';
 import {
   MCP_AGENTS,
+  expandHome,
   detectInstalled,
   detectAgentPresence,
   detectAgentRuntimeSignals,
@@ -12,6 +14,7 @@ import {
   detectAgentInstalledSkills,
   resolveSkillWorkspaceProfile,
 } from '@/lib/mcp-agents';
+import { getAllAgents, loadCustomAgents, scanCustomAgentSkills } from '@/lib/custom-agents';
 import { readSettings } from '@/lib/settings';
 import { scanSkillDirs } from '@/lib/pi-integration/skills';
 import { getMindRoot } from '@/lib/fs';
@@ -59,13 +62,62 @@ function enrichMindOsAgent(agent: Record<string, unknown>) {
 
 export async function GET() {
   try {
-    const agents = Object.entries(MCP_AGENTS).map(([key, agent]) => {
-      const status = detectInstalled(key);
-      const present = detectAgentPresence(key);
-      const skillProfile = resolveSkillWorkspaceProfile(key);
-      const runtime = detectAgentRuntimeSignals(key);
-      const configuredMcp = detectAgentConfiguredMcpServers(key);
-      const installedSkills = detectAgentInstalledSkills(key);
+    const allAgents = getAllAgents();
+    const customDefs = loadCustomAgents();
+    const customKeySet = new Set(customDefs.map(c => c.key));
+    const customByKey = Object.fromEntries(customDefs.map(c => [c.key, c]));
+
+    const agents = Object.entries(allAgents).map(([key, agent]) => {
+      const isCustom = customKeySet.has(key) && !(key in MCP_AGENTS);
+
+      // Built-in agents: use standard detection. Custom agents: detect using their AgentDef directly.
+      let present: boolean;
+      let status: { installed: boolean; scope?: string; transport?: string; configPath?: string; url?: string };
+
+      if (isCustom) {
+        present = agent.presenceDirs?.some((d: string) => fs.existsSync(expandHome(d))) ?? false;
+        if (agent.presenceCli) {
+          try {
+            execSync(
+              process.platform === 'win32' ? `where ${agent.presenceCli}` : `which ${agent.presenceCli}`,
+              { stdio: 'pipe' },
+            );
+            present = true;
+          } catch { /* not in PATH */ }
+        }
+        status = { installed: false };
+        const globalPath = expandHome(agent.global);
+        try {
+          if (fs.existsSync(globalPath)) {
+            const raw = fs.readFileSync(globalPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const configObj = agent.globalNestedKey
+              ? agent.globalNestedKey.split('.').reduce((o: Record<string, unknown>, k: string) => (o?.[k] as Record<string, unknown>) ?? {}, parsed)
+              : parsed;
+            const servers = configObj?.[agent.key] ?? {};
+            if (servers && typeof servers === 'object' && 'mindos' in servers) {
+              status = { installed: true, scope: 'global', configPath: globalPath };
+            }
+          }
+        } catch { /* config not parseable */ }
+      } else {
+        present = detectAgentPresence(key);
+        status = detectInstalled(key);
+      }
+
+      const skillProfile = isCustom
+        ? { mode: 'additional' as const, skillAgentName: key, workspacePath: expandHome(customByKey[key]?.skillDir || agent.presenceDirs?.[0] + 'skills/') }
+        : resolveSkillWorkspaceProfile(key);
+      const runtime = isCustom
+        ? { hiddenRootPath: '', hiddenRootPresent: false, conversationSignal: false, usageSignal: false, lastActivityAt: undefined }
+        : detectAgentRuntimeSignals(key);
+      const configuredMcp = isCustom
+        ? { servers: [] as string[], sources: [] as string[] }
+        : detectAgentConfiguredMcpServers(key);
+      const installedSkills = isCustom
+        ? scanCustomAgentSkills(customByKey[key])
+        : detectAgentInstalledSkills(key);
+
       return {
         key,
         name: agent.name,
@@ -74,7 +126,7 @@ export async function GET() {
         scope: status.scope,
         transport: status.transport,
         configPath: status.configPath,
-        url: status.url, // Store URL for verification
+        url: status.url,
         hasProjectScope: !!agent.project,
         hasGlobalScope: !!agent.global,
         preferredTransport: agent.preferredTransport,
@@ -97,6 +149,8 @@ export async function GET() {
         installedSkillNames: installedSkills.skills,
         installedSkillCount: installedSkills.skills.length,
         installedSkillSourcePath: installedSkills.sourcePath,
+        isCustom,
+        customBaseDir: isCustom ? customByKey[key]?.baseDir : undefined,
       };
     });
 

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

@@ -1,7 +1,8 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
+import { getModels as piGetModels } from '@mariozechner/pi-ai';
 import { effectiveAiConfig } from '@/lib/settings';
-import { type ProviderId, isProviderId, PROVIDER_PRESETS, getDefaultBaseUrl } from '@/lib/agent/providers';
+import { type ProviderId, isProviderId, PROVIDER_PRESETS, toPiProvider, getDefaultBaseUrl } from '@/lib/agent/providers';
 
 const TIMEOUT = 10_000;
 
@@ -19,8 +20,11 @@ export async function POST(req: NextRequest) {
     }
 
     const preset = PROVIDER_PRESETS[provider as ProviderId];
+
+    // Providers without remote list-models API: return static list from pi-ai registry
     if (!preset.supportsListModels) {
-      return NextResponse.json({ ok: false, error: 'This provider does not support listing models' });
+      const models = getRegistryModels(provider as ProviderId);
+      return NextResponse.json({ ok: true, models });
     }
 
     const cfg = effectiveAiConfig(provider as ProviderId);
@@ -52,6 +56,16 @@ export async function POST(req: NextRequest) {
   }
 }
 
+/** Return model IDs from pi-ai's static registry for providers without a remote /models API. */
+function getRegistryModels(provider: ProviderId): string[] {
+  try {
+    const models = piGetModels(toPiProvider(provider) as any);
+    return models.map((m: any) => m.id as string).filter(Boolean).sort();
+  } catch {
+    return [];
+  }
+}
+
 async function fetchModels(provider: ProviderId, apiKey: string, baseUrl: string, signal: AbortSignal): Promise<string[]> {
   if (provider === 'anthropic') {
     return fetchAnthropicModels(apiKey, signal);

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

@@ -124,6 +124,15 @@ export async function POST(req: NextRequest) {
     };
 
     writeSettings(next);
+    // Clear proxy compat cache when AI config changes — stale cache causes
+    // the non-streaming fallback to be used even when streaming would work.
+    if (JSON.stringify(next.ai) !== JSON.stringify(current.ai)) {
+      const { readSettings: rs, writeSettings: ws } = await import('@/lib/settings');
+      const s = rs();
+      if (s.baseUrlCompat && Object.keys(s.baseUrlCompat).length > 0) {
+        ws({ ...s, baseUrlCompat: {} });
+      }
+    }
     if (next.mindRoot !== current.mindRoot) invalidateCache();
     return NextResponse.json({ ok: true });
   } catch (err) {

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

@@ -1,7 +1,7 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
 import { complete } from '@mariozechner/pi-ai';
-import { effectiveAiConfig } from '@/lib/settings';
+import { effectiveAiConfig, readBaseUrlCompat, writeSettings, readSettings } from '@/lib/settings';
 import { getModelConfig } from '@/lib/agent/model';
 import { type ProviderId, isProviderId } from '@/lib/agent/providers';
 
@@ -84,6 +84,18 @@ export async function POST(req: NextRequest) {
         signal: ctrl.signal,
       });
 
+      // Clear stale proxy compat cache for this baseUrl on successful test.
+      // Prevents stale 'non-streaming' cache from forcing the fallback path.
+      if (baseUrl) {
+        const compat = readBaseUrlCompat();
+        if (compat[baseUrl]) {
+          const s = readSettings();
+          const updated = { ...(s.baseUrlCompat ?? {}) };
+          delete updated[baseUrl];
+          writeSettings({ ...s, baseUrlCompat: updated });
+        }
+      }
+
       return NextResponse.json({ ok: true, latency: Date.now() - start });
     } catch (e) {
       return NextResponse.json({ ok: false, ...classifyPiAiError(e) });