@geminilight/mindos 0.6.17 → 0.6.19

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

@@ -27,6 +27,24 @@ import { assertNotProtected } from '@/lib/core';
 import { scanExtensionPaths } from '@/lib/pi-integration/extensions';
 import type { Message as FrontendMessage } from '@/lib/types';
 
+// ---------------------------------------------------------------------------
+// Streaming blacklist — caches provider+model combos that don't support SSE.
+// Auto-populated when streaming fails; entries expire after 10 minutes
+// so transient proxy issues don't permanently lock out streaming.
+// ---------------------------------------------------------------------------
+const streamingBlacklist = new Map<string, number>();
+const STREAMING_BLACKLIST_TTL = 10 * 60 * 1000;
+
+function isStreamingBlacklisted(key: string): boolean {
+  const ts = streamingBlacklist.get(key);
+  if (ts === undefined) return false;
+  if (Date.now() - ts > STREAMING_BLACKLIST_TTL) {
+    streamingBlacklist.delete(key);
+    return false;
+  }
+  return true;
+}
+
 // ---------------------------------------------------------------------------
 // MindOS SSE format — 6 event types (front-back contract)
 // ---------------------------------------------------------------------------
@@ -407,9 +425,25 @@ export async function POST(req: NextRequest) {
 
   const systemPrompt = promptParts.join('\n\n');
 
+  const useStreaming = agentConfig.useStreaming !== false;
+
   try {
     const { model, modelName, apiKey, provider } = getModelConfig();
 
+    // ── Non-streaming path (auto-detected or cached) ──
+    // When test-key detected streaming incompatibility, or a previous request
+    // failed and cached the result, go directly to non-streaming.
+    const cacheKey = `${provider}:${model.id}:${model.baseUrl ?? ''}`;
+    if (!useStreaming || isStreamingBlacklisted(cacheKey)) {
+      if (isStreamingBlacklisted(cacheKey)) {
+        console.log(`[ask] Using non-streaming mode (cached failure for ${cacheKey})`);
+      }
+      return await handleNonStreaming({
+        provider, apiKey, model, systemPrompt, messages, modelName,
+      });
+    }
+
+    // ── Streaming path (default) ──
     // Convert frontend messages to AgentMessage[]
     const agentMessages = toAgentMessages(messages);
 
@@ -492,12 +526,18 @@ export async function POST(req: NextRequest) {
           }
         }
 
+        let hasContent = false;
+        let lastModelError = '';
+
         session.subscribe((event: AgentEvent) => {
           if (isTextDeltaEvent(event)) {
+            hasContent = true;
             send({ type: 'text_delta', delta: getTextDelta(event) });
           } else if (isThinkingDeltaEvent(event)) {
+            hasContent = true;
             send({ type: 'thinking_delta', delta: getThinkingDelta(event) });
           } else if (isToolExecutionStartEvent(event)) {
+            hasContent = true;
             const { toolCallId, toolName, args } = getToolExecutionStart(event);
             const safeArgs = sanitizeToolArgs(toolName, args);
             send({
@@ -555,12 +595,47 @@ export async function POST(req: NextRequest) {
             }
 
             console.log(`[ask] Step ${stepCount}/${stepLimit}`);
+          } else if (event.type === 'agent_end') {
+            // Capture model errors from the last assistant message.
+            // pi-coding-agent resolves prompt() without throwing after retries;
+            // the error is only visible in agent_end event messages.
+            const msgs = (event as any).messages;
+            if (Array.isArray(msgs)) {
+              for (let i = msgs.length - 1; i >= 0; i--) {
+                const m = msgs[i];
+                if (m?.role === 'assistant' && m?.stopReason === 'error' && m?.errorMessage) {
+                  lastModelError = m.errorMessage;
+                  break;
+                }
+              }
+            }
           }
         });
 
-        session.prompt(lastUserContent).then(() => {
+        session.prompt(lastUserContent).then(async () => {
           metrics.recordRequest(Date.now() - requestStartTime);
-          send({ type: 'done' });
+          if (!hasContent && lastModelError) {
+            // Streaming failed — auto-retry with non-streaming fallback.
+            // Cache the failure so subsequent requests skip streaming entirely.
+            console.warn(`[ask] Streaming failed for ${modelName}, retrying non-streaming: ${lastModelError}`);
+            streamingBlacklist.set(cacheKey, Date.now());
+            // No visible hint needed — the fallback is transparent to the user
+            try {
+              const fallbackResult = await directNonStreamingCall({
+                provider, apiKey, model, systemPrompt, messages, modelName,
+              });
+              if (fallbackResult) {
+                send({ type: 'text_delta', delta: fallbackResult });
+                send({ type: 'done' });
+              } else {
+                send({ type: 'error', message: lastModelError });
+              }
+            } catch (fallbackErr) {
+              send({ type: 'error', message: lastModelError });
+            }
+          } else {
+            send({ type: 'done' });
+          }
           controller.close();
         }).catch((err) => {
           metrics.recordRequest(Date.now() - requestStartTime);
@@ -587,3 +662,146 @@ export async function POST(req: NextRequest) {
     return apiError(ErrorCodes.MODEL_INIT_FAILED, err instanceof Error ? err.message : 'Failed to initialize AI model', 500);
   }
 }
+
+// ---------------------------------------------------------------------------
+// Non-streaming — direct /chat/completions call (no SSE, no tools)
+// ---------------------------------------------------------------------------
+
+interface NonStreamingOpts {
+  provider: 'anthropic' | 'openai';
+  apiKey: string;
+  model: { id: string; baseUrl?: string; maxTokens?: number };
+  systemPrompt: string;
+  messages: FrontendMessage[];
+  modelName: string;
+}
+
+/**
+ * Core non-streaming API call. Returns the response text or throws.
+ * Used by both the direct non-streaming path and the auto-fallback.
+ */
+async function directNonStreamingCall(opts: NonStreamingOpts): Promise<string> {
+  const { provider, apiKey, model, systemPrompt, messages, modelName } = opts;
+  const ctrl = new AbortController();
+  const timeout = setTimeout(() => ctrl.abort(), 120_000);
+
+  try {
+    if (provider === 'openai') {
+      const baseUrl = (model.baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
+      const url = `${baseUrl}/chat/completions`;
+      const apiMessages = [
+        { role: 'system', content: systemPrompt },
+        ...messages.map(m => ({ role: m.role, content: m.content })),
+      ];
+
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          model: model.id,
+          messages: apiMessages,
+          stream: false,
+          max_tokens: model.maxTokens ?? 16_384,
+        }),
+        signal: ctrl.signal,
+      });
+
+      if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`API returned ${res.status}: ${body.slice(0, 500)}`);
+      }
+
+      const json = await res.json();
+      return json?.choices?.[0]?.message?.content ?? '';
+    }
+
+    // Anthropic
+    const url = 'https://api.anthropic.com/v1/messages';
+    const apiMessages = messages.map(m => ({ role: m.role, content: m.content }));
+
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model: model.id,
+        system: systemPrompt,
+        messages: apiMessages,
+        max_tokens: model.maxTokens ?? 8_192,
+      }),
+      signal: ctrl.signal,
+    });
+
+    if (!res.ok) {
+      const body = await res.text().catch(() => '');
+      throw new Error(`API returned ${res.status}: ${body.slice(0, 500)}`);
+    }
+
+    const json = await res.json();
+    const blocks = json?.content;
+    if (Array.isArray(blocks)) {
+      return blocks.filter((b: any) => b.type === 'text').map((b: any) => b.text).join('');
+    }
+    return '';
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Full non-streaming response handler — wraps directNonStreamingCall
+ * and returns an SSE-formatted Response for the client.
+ */
+async function handleNonStreaming(opts: NonStreamingOpts): Promise<Response> {
+  const { modelName } = opts;
+  const requestStartTime = Date.now();
+  const encoder = new TextEncoder();
+
+  try {
+    const text = await directNonStreamingCall(opts);
+    metrics.recordRequest(Date.now() - requestStartTime);
+
+    if (!text) {
+      metrics.recordError();
+      return sseResponse(encoder, { type: 'error', message: `[non-streaming] ${modelName} returned empty response` });
+    }
+
+    console.log(`[ask] Non-streaming response from ${modelName}: ${text.length} chars`);
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder.encode(`data:${JSON.stringify({ type: 'text_delta', delta: text })}\n\n`));
+        controller.enqueue(encoder.encode(`data:${JSON.stringify({ type: 'done' })}\n\n`));
+        controller.close();
+      },
+    });
+    return new Response(stream, { headers: sseHeaders() });
+  } catch (err) {
+    metrics.recordRequest(Date.now() - requestStartTime);
+    metrics.recordError();
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[ask] Non-streaming request failed:`, message);
+    return sseResponse(encoder, { type: 'error', message });
+  }
+}
+
+function sseResponse(encoder: TextEncoder, event: MindOSSSEvent): Response {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(`data:${JSON.stringify(event)}\n\n`));
+      controller.close();
+    },
+  });
+  return new Response(stream, { headers: sseHeaders() });
+}
+
+function sseHeaders(): HeadersInit {
+  return {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'Connection': 'keep-alive',
+    'X-Accel-Buffering': 'no',
+  };
+}

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

@@ -0,0 +1,96 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { effectiveAiConfig } from '@/lib/settings';
+
+const TIMEOUT = 10_000;
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { provider, apiKey, baseUrl } = body as {
+      provider?: string;
+      apiKey?: string;
+      baseUrl?: string;
+    };
+
+    if (provider !== 'anthropic' && provider !== 'openai') {
+      return NextResponse.json({ ok: false, error: 'Invalid provider' }, { status: 400 });
+    }
+
+    const cfg = effectiveAiConfig();
+    let resolvedKey = apiKey || '';
+    if (!resolvedKey || resolvedKey === '***set***') {
+      resolvedKey = provider === 'anthropic' ? cfg.anthropicApiKey : cfg.openaiApiKey;
+    }
+
+    if (!resolvedKey) {
+      return NextResponse.json({ ok: false, error: 'No API key configured' });
+    }
+
+    const ctrl = new AbortController();
+    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));
+        }
+      }
+
+      return NextResponse.json({ ok: true, models });
+    } catch (e: unknown) {
+      if (e instanceof Error && e.name === 'AbortError') {
+        return NextResponse.json({ ok: false, error: 'Request timed out' });
+      }
+      return NextResponse.json({ ok: false, error: e instanceof Error ? e.message : 'Network error' });
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch (err) {
+    return NextResponse.json({ ok: false, error: String(err) }, { status: 500 });
+  }
+}

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

@@ -46,7 +46,7 @@ async function testAnthropic(apiKey: string, model: string): Promise<{ ok: boole
   }
 }
 
-async function testOpenAI(apiKey: string, model: string, baseUrl: string): Promise<{ ok: boolean; latency?: number; code?: ErrorCode; error?: string }> {
+async function testOpenAI(apiKey: string, model: string, baseUrl: string): Promise<{ ok: boolean; latency?: number; code?: ErrorCode; error?: string; streamingSupported?: boolean }> {
   const start = Date.now();
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
@@ -62,10 +62,57 @@ async function testOpenAI(apiKey: string, model: string, baseUrl: string): Promi
       signal: ctrl.signal,
     });
     const latency = Date.now() - start;
-    if (res.ok) {
-      // `/api/ask` always sends tool definitions, so key test should verify this
-      // compatibility as well (not just plain chat completion).
-      const toolRes = await fetch(url, {
+    if (!res.ok) {
+      const body = await res.text();
+      return { ok: false, ...classifyError(res.status, body) };
+    }
+
+    // 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,
+        max_tokens: 1,
+        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}`,
+      };
+    }
+
+    // Streaming compatibility test — `/api/ask` uses SSE streaming by default.
+    // Many proxies pass non-streaming tests but fail at streaming.
+    // If streaming fails, we still report ok: true (basic chat works via non-streaming fallback).
+    let streamingSupported = true;
+    try {
+      const streamRes = await fetch(url, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
@@ -73,40 +120,37 @@ async function testOpenAI(apiKey: string, model: string, baseUrl: string): Promi
         },
         body: JSON.stringify({
           model,
-          max_tokens: 1,
-          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',
+          max_tokens: 5,
+          stream: true,
+          messages: [{ role: 'user', content: 'Say OK' }],
         }),
         signal: ctrl.signal,
       });
-
-      if (toolRes.ok) return { ok: true, latency };
-
-      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 (!streamRes.ok) {
+        streamingSupported = false;
+      } else {
+        const reader = streamRes.body?.getReader();
+        if (reader) {
+          const decoder = new TextDecoder();
+          let gotData = false;
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              const text = decoder.decode(value, { stream: true });
+              if (text.includes('data:')) { gotData = true; break; }
+            }
+          } finally {
+            reader.releaseLock();
+          }
+          if (!gotData) streamingSupported = false;
+        }
+      }
+    } catch {
+      streamingSupported = false;
     }
-    const body = await res.text();
-    return { ok: false, ...classifyError(res.status, body) };
+
+    return { ok: true, latency, streamingSupported };
   } 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' };

package/app/components/ActivityBar.tsx

@@ -2,13 +2,13 @@
 
 import { useRef, useCallback, useState, useEffect } from 'react';
 import Link from 'next/link';
-import { FolderTree, Search, Settings, RefreshCw, Bot, Compass, HelpCircle, ChevronLeft, ChevronRight, Radio, History } from 'lucide-react';
+import { FolderTree, Search, Settings, RefreshCw, Bot, Compass, HelpCircle, ChevronLeft, ChevronRight, Radio } from 'lucide-react';
 import { useLocale } from '@/lib/LocaleContext';
 import { DOT_COLORS, getStatusLevel } from './SyncStatusBar';
 import type { SyncStatus } from './settings/SyncTab';
 import Logo from './Logo';
 
-export type PanelId = 'files' | 'search' | 'echo' | 'agents' | 'discover' | 'history';
+export type PanelId = 'files' | 'search' | 'echo' | 'agents' | 'discover';
 
 export const RAIL_WIDTH_COLLAPSED = 48;
 export const RAIL_WIDTH_EXPANDED = 180;
@@ -16,7 +16,9 @@ export const RAIL_WIDTH_EXPANDED = 180;
 interface ActivityBarProps {
   activePanel: PanelId | null;
   onPanelChange: (id: PanelId | null) => void;
+  onEchoClick?: () => void;
   onAgentsClick?: () => void;
+  onDiscoverClick?: () => void;
   syncStatus: SyncStatus | null;
   expanded: boolean;
   onExpandedChange: (expanded: boolean) => void;
@@ -77,7 +79,9 @@ function RailButton({ icon, label, shortcut, active = false, expanded, onClick,
 export default function ActivityBar({
   activePanel,
   onPanelChange,
+  onEchoClick,
   onAgentsClick,
+  onDiscoverClick,
   syncStatus,
   expanded,
   onExpandedChange,
@@ -188,7 +192,7 @@ export default function ActivityBar({
         <div className={`flex flex-col ${expanded ? 'px-1.5' : 'items-center'} gap-1 py-2`}>
           <RailButton icon={<FolderTree size={18} />} label={t.sidebar.files} active={activePanel === 'files'} expanded={expanded} onClick={() => toggle('files')} walkthroughId="files-panel" />
           <RailButton icon={<Search size={18} />} label={t.sidebar.searchTitle} shortcut="⌘K" active={activePanel === 'search'} expanded={expanded} onClick={() => toggle('search')} />
-          <RailButton icon={<Radio size={18} />} label={t.sidebar.echo} active={activePanel === 'echo'} expanded={expanded} onClick={() => toggle('echo')} walkthroughId="echo-panel" />
+          <RailButton icon={<Radio size={18} />} label={t.sidebar.echo} active={activePanel === 'echo'} expanded={expanded} onClick={() => onEchoClick ? debounced(onEchoClick) : toggle('echo')} walkthroughId="echo-panel" />
           <RailButton
             icon={<Bot size={18} />}
             label={t.sidebar.agents}
@@ -197,8 +201,7 @@ export default function ActivityBar({
             onClick={() => onAgentsClick ? debounced(onAgentsClick) : toggle('agents')}
             walkthroughId="agents-panel"
           />
-          <RailButton icon={<Compass size={18} />} label={t.sidebar.discover} active={activePanel === 'discover'} expanded={expanded} onClick={() => toggle('discover')} />
-          <RailButton icon={<History size={18} />} label={t.sidebar.history} active={activePanel === 'history'} expanded={expanded} onClick={() => toggle('history')} />
+          <RailButton icon={<Compass size={18} />} label={t.sidebar.discover} active={activePanel === 'discover'} expanded={expanded} onClick={() => onDiscoverClick ? debounced(onDiscoverClick) : toggle('discover')} />
         </div>
 
         {/* ── Spacer ── */}

package/app/components/JsonView.tsx

@@ -16,11 +16,8 @@ export default function JsonView({ content }: JsonViewProps) {
   }, [content]);
 
   return (
-    <pre
-      className="rounded-xl border border-border bg-card px-4 py-3 overflow-x-auto text-sm leading-relaxed font-display"
-      suppressHydrationWarning
-    >
-      <code>{pretty}</code>
+    <pre className="rounded-xl border border-border bg-card px-4 py-3 overflow-x-auto text-sm leading-relaxed font-display">
+      <code suppressHydrationWarning>{pretty}</code>
     </pre>
   );
 }