@geminilight/mindos 0.6.18 → 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/OrganizeToast.tsx

@@ -5,6 +5,7 @@ import { useRouter } from 'next/navigation';
 import {
   Check, X, Loader2, Sparkles, AlertCircle, Undo2,
   ChevronDown, FilePlus, FileEdit, ExternalLink,
+  Maximize2, Minimize2, FileIcon,
 } from 'lucide-react';
 import { useLocale } from '@/lib/LocaleContext';
 import type { useAiOrganize } from '@/hooks/useAiOrganize';
@@ -84,6 +85,7 @@ export default function OrganizeToast({
   const { elapsed, displayHint } = useOrganizeTimer(isOrganizing, aiOrganize.stageHint);
 
   const [expanded, setExpanded] = useState(false);
+  const [maximized, setMaximized] = useState(false);
   const [undoing, setUndoing] = useState(false);
   const dismissTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const historyIdRef = useRef<string | null>(null);
@@ -197,7 +199,211 @@ export default function OrganizeToast({
 
   if (!isActive) return null;
 
-  // Expanded panel (file list with per-file undo)
+  // ── Shared file-change row renderer ──
+  function renderChangeRow(c: typeof aiOrganize.changes[number], idx: number) {
+    const wasUndone = c.undone;
+    const undoable = aiOrganize.canUndo(c.path);
+    const fileName = c.path.split('/').pop() ?? c.path;
+    return (
+      <div
+        key={`${c.path}-${idx}`}
+        className={`flex items-center gap-2 px-3 py-2 rounded-md text-sm transition-colors ${wasUndone ? 'bg-muted/30 opacity-50' : 'bg-muted/50'}`}
+      >
+        {wasUndone ? (
+          <Undo2 size={14} className="text-muted-foreground shrink-0" />
+        ) : c.action === 'create' ? (
+          <FilePlus size={14} className="text-success shrink-0" />
+        ) : (
+          <FileEdit size={14} className="text-[var(--amber)] shrink-0" />
+        )}
+        <span className={`truncate flex-1 ${wasUndone ? 'line-through text-muted-foreground' : 'text-foreground'}`}>
+          {fileName}
+        </span>
+        {wasUndone ? (
+          <span className="text-xs text-muted-foreground shrink-0">{fi.organizeUndone as string}</span>
+        ) : (
+          <span className={`text-xs shrink-0 ${c.ok ? 'text-muted-foreground' : 'text-error'}`}>
+            {!c.ok ? fi.organizeFailed as string
+              : c.action === 'create' ? fi.organizeCreated as string
+              : fi.organizeUpdated as string}
+          </span>
+        )}
+        {undoable && (
+          <button
+            type="button"
+            onClick={() => handleUndoOne(c.path)}
+            disabled={undoing}
+            className="text-2xs text-muted-foreground/60 hover:text-foreground transition-colors shrink-0 px-1 disabled:opacity-40"
+            title={fi.organizeUndoOne as string}
+          >
+            <Undo2 size={12} />
+          </button>
+        )}
+        {c.ok && !c.undone && (
+          <button
+            type="button"
+            onClick={() => handleViewFile(c.path)}
+            className="text-2xs text-muted-foreground/60 hover:text-[var(--amber)] transition-colors shrink-0 px-1"
+            title={fi.organizeViewFile as string}
+          >
+            <ExternalLink size={12} />
+          </button>
+        )}
+      </div>
+    );
+  }
+
+  // ── Shared footer actions ──
+  function renderActions() {
+    return (
+      <div className="flex items-center justify-end gap-3 px-4 py-3 border-t border-border">
+        {isDone && aiOrganize.hasAnyUndoable && (
+          <button
+            onClick={handleUndoAll}
+            disabled={undoing}
+            className="flex items-center gap-1.5 text-xs text-muted-foreground hover:text-foreground transition-colors px-2 py-1.5 disabled:opacity-50"
+          >
+            {undoing ? <Loader2 size={12} className="animate-spin" /> : <Undo2 size={12} />}
+            {fi.organizeUndoAll as string}
+          </button>
+        )}
+        <button
+          onClick={handleDismiss}
+          className="flex items-center gap-1.5 px-3 py-1.5 rounded-lg text-xs font-medium bg-[var(--amber)] text-[var(--amber-foreground)] hover:opacity-90 transition-all"
+        >
+          <Check size={12} />
+          {fi.organizeDone as string}
+        </button>
+      </div>
+    );
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  Maximized Modal — full detail view with source files, summary, changes
+  // ═══════════════════════════════════════════════════════════════════════════
+  if (maximized) {
+    return (
+      <div
+        className="fixed inset-0 z-50 overlay-backdrop flex items-center justify-center p-4"
+        onClick={(e) => { if (e.target === e.currentTarget) setMaximized(false); }}
+      >
+        <div
+          className="w-full max-w-xl max-h-[80vh] flex flex-col bg-card rounded-xl shadow-xl border border-border animate-in fade-in-0 zoom-in-95 duration-200"
+          onClick={handleUserAction}
+          role="dialog"
+          aria-modal="true"
+          aria-label={fi.organizeDetailTitle as string}
+        >
+          {/* Header */}
+          <div className="flex items-center justify-between px-5 pt-5 pb-3 shrink-0">
+            <div className="flex items-center gap-2">
+              {isOrganizing ? (
+                <div className="relative shrink-0">
+                  <Sparkles size={16} className="text-[var(--amber)]" />
+                  <Loader2 size={10} className="absolute -bottom-0.5 -right-0.5 text-[var(--amber)] animate-spin" />
+                </div>
+              ) : isDone ? (
+                <Check size={16} className="text-success" />
+              ) : (
+                <AlertCircle size={16} className="text-error" />
+              )}
+              <h2 className="text-base font-semibold text-foreground">
+                {fi.organizeDetailTitle as string}
+              </h2>
+              {isOrganizing && (
+                <span className="text-xs text-muted-foreground/60 tabular-nums">
+                  {(fi.organizeElapsed as (s: number) => string)(elapsed)}
+                </span>
+              )}
+            </div>
+            <div className="flex items-center gap-1">
+              <button
+                type="button"
+                onClick={() => setMaximized(false)}
+                className="p-1 rounded hover:bg-muted text-muted-foreground hover:text-foreground transition-colors"
+                title={fi.organizeMinimizeModal as string}
+              >
+                <Minimize2 size={14} />
+              </button>
+              <button
+                type="button"
+                onClick={handleDismiss}
+                className="p-1 rounded hover:bg-muted text-muted-foreground hover:text-foreground transition-colors"
+              >
+                <X size={14} />
+              </button>
+            </div>
+          </div>
+
+          {/* Scrollable body */}
+          <div className="flex-1 min-h-0 overflow-y-auto px-5 pb-2 space-y-4">
+            {/* Live progress during organizing */}
+            {isOrganizing && (
+              <div className="flex items-center gap-2 px-3 py-2.5 rounded-lg bg-[var(--amber-subtle)] border border-[var(--amber-dim)]">
+                <Loader2 size={14} className="text-[var(--amber)] animate-spin shrink-0" />
+                <span className="text-xs text-foreground">{stageText(t, displayHint)}</span>
+              </div>
+            )}
+
+            {/* Source files */}
+            {aiOrganize.sourceFileNames.length > 0 && (
+              <div>
+                <h3 className="text-xs font-medium text-muted-foreground mb-1.5">
+                  {fi.organizeSourceFiles as string}
+                </h3>
+                <div className="flex flex-wrap gap-1.5">
+                  {aiOrganize.sourceFileNames.map((name, i) => (
+                    <span key={i} className="inline-flex items-center gap-1 px-2 py-1 rounded-md bg-muted/60 text-xs text-foreground">
+                      <FileIcon size={11} className="text-muted-foreground shrink-0" />
+                      {name}
+                    </span>
+                  ))}
+                </div>
+              </div>
+            )}
+
+            {/* AI Summary */}
+            {(aiOrganize.summary || isOrganizing) && (
+              <div>
+                <h3 className="text-xs font-medium text-muted-foreground mb-1.5">
+                  {fi.organizeSummaryLabel as string}
+                </h3>
+                <div className="px-3 py-2.5 rounded-lg bg-muted/30 border border-border text-sm text-foreground leading-relaxed whitespace-pre-wrap">
+                  {aiOrganize.summary || (fi.organizeNoSummary as string)}
+                </div>
+              </div>
+            )}
+
+            {/* File changes */}
+            {aiOrganize.changes.length > 0 && (
+              <div>
+                <h3 className="text-xs font-medium text-muted-foreground mb-1.5">
+                  {(fi.organizeChangesLabel as (n: number) => string)(aiOrganize.changes.length)}
+                </h3>
+                <div className="space-y-0.5">
+                  {aiOrganize.changes.map((c, idx) => renderChangeRow(c, idx))}
+                </div>
+              </div>
+            )}
+
+            {/* Error detail */}
+            {isError && (
+              <div className="px-3 py-2.5 rounded-lg bg-error/5 border border-error/20 text-xs text-error">
+                {aiOrganize.error}
+              </div>
+            )}
+          </div>
+
+          {/* Footer actions */}
+          {(isDone || isError) && renderActions()}
+        </div>
+      </div>
+    );
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  Expanded panel (file list with per-file undo) — bottom toast size
+  // ═══════════════════════════════════════════════════════════════════════════
   if (expanded && (isDone || isError)) {
     return (
       <div
@@ -212,71 +418,29 @@ export default function OrganizeToast({
               {isDone ? fi.organizeReviewTitle as string : fi.organizeErrorTitle as string}
             </span>
           </div>
-          <button
-            type="button"
-            onClick={() => setExpanded(false)}
-            className="p-1 rounded hover:bg-muted text-muted-foreground hover:text-foreground transition-colors"
-          >
-            <ChevronDown size={14} />
-          </button>
+          <div className="flex items-center gap-1">
+            <button
+              type="button"
+              onClick={() => { setExpanded(false); setMaximized(true); }}
+              className="p-1 rounded hover:bg-muted text-muted-foreground hover:text-foreground transition-colors"
+              title={fi.organizeDetailTitle as string}
+            >
+              <Maximize2 size={13} />
+            </button>
+            <button
+              type="button"
+              onClick={() => setExpanded(false)}
+              className="p-1 rounded hover:bg-muted text-muted-foreground hover:text-foreground transition-colors"
+            >
+              <ChevronDown size={14} />
+            </button>
+          </div>
         </div>
 
         {/* File list */}
         {isDone && (
           <div className="max-h-[240px] overflow-y-auto p-2 space-y-0.5">
-            {aiOrganize.changes.map((c, idx) => {
-              const wasUndone = c.undone;
-              const undoable = aiOrganize.canUndo(c.path);
-              const fileName = c.path.split('/').pop() ?? c.path;
-
-              return (
-                <div
-                  key={`${c.path}-${idx}`}
-                  className={`flex items-center gap-2 px-3 py-2 rounded-md text-sm transition-colors ${wasUndone ? 'bg-muted/30 opacity-50' : 'bg-muted/50'}`}
-                >
-                  {wasUndone ? (
-                    <Undo2 size={14} className="text-muted-foreground shrink-0" />
-                  ) : c.action === 'create' ? (
-                    <FilePlus size={14} className="text-success shrink-0" />
-                  ) : (
-                    <FileEdit size={14} className="text-[var(--amber)] shrink-0" />
-                  )}
-                  <span className={`truncate flex-1 ${wasUndone ? 'line-through text-muted-foreground' : 'text-foreground'}`}>
-                    {fileName}
-                  </span>
-                  {wasUndone ? (
-                    <span className="text-xs text-muted-foreground shrink-0">{fi.organizeUndone as string}</span>
-                  ) : (
-                    <span className={`text-xs shrink-0 ${c.ok ? 'text-muted-foreground' : 'text-error'}`}>
-                      {!c.ok ? fi.organizeFailed as string
-                        : c.action === 'create' ? fi.organizeCreated as string
-                        : fi.organizeUpdated as string}
-                    </span>
-                  )}
-                  {undoable && (
-                    <button
-                      type="button"
-                      onClick={() => handleUndoOne(c.path)}
-                      disabled={undoing}
-                      className="text-2xs text-muted-foreground/60 hover:text-foreground transition-colors shrink-0 px-1 disabled:opacity-40"
-                      title={fi.organizeUndoOne as string}
-                    >
-                      <Undo2 size={12} />
-                    </button>
-                  )}
-                  {c.ok && !c.undone && (
-                    <button
-                      type="button"
-                      onClick={() => handleViewFile(c.path)}
-                      className="text-2xs text-muted-foreground/60 hover:text-[var(--amber)] transition-colors shrink-0 px-1"
-                      title={fi.organizeViewFile as string}
-                    >
-                      <ExternalLink size={12} />
-                    </button>
-                  )}
-                </div>
-              );
-            })}
+            {aiOrganize.changes.map((c, idx) => renderChangeRow(c, idx))}
           </div>
         )}
 
@@ -286,31 +450,14 @@ export default function OrganizeToast({
           </div>
         )}
 
-        {/* Actions */}
-        <div className="flex items-center justify-end gap-3 px-4 py-3 border-t border-border">
-          {isDone && aiOrganize.hasAnyUndoable && (
-            <button
-              onClick={handleUndoAll}
-              disabled={undoing}
-              className="flex items-center gap-1.5 text-xs text-muted-foreground hover:text-foreground transition-colors px-2 py-1.5 disabled:opacity-50"
-            >
-              {undoing ? <Loader2 size={12} className="animate-spin" /> : <Undo2 size={12} />}
-              {fi.organizeUndoAll as string}
-            </button>
-          )}
-          <button
-            onClick={handleDismiss}
-            className="flex items-center gap-1.5 px-3 py-1.5 rounded-lg text-xs font-medium bg-[var(--amber)] text-[var(--amber-foreground)] hover:opacity-90 transition-all"
-          >
-            <Check size={12} />
-            {fi.organizeDone as string}
-          </button>
-        </div>
+        {renderActions()}
       </div>
     );
   }
 
-  // Compact toast bar
+  // ═══════════════════════════════════════════════════════════════════════════
+  //  Compact toast bar
+  // ═══════════════════════════════════════════════════════════════════════════
   return (
     <div
       className="fixed bottom-4 left-1/2 -translate-x-1/2 z-50 flex items-center gap-3 bg-card border border-border rounded-xl shadow-lg px-4 py-3 max-w-md animate-in fade-in-0 slide-in-from-bottom-2 duration-200"
@@ -372,6 +519,14 @@ export default function OrganizeToast({
           <span className="text-xs text-muted-foreground/60 tabular-nums shrink-0">
             {(fi.organizeElapsed as (s: number) => string)(elapsed)}
           </span>
+          <button
+            type="button"
+            onClick={() => { setMaximized(true); handleUserAction(); }}
+            className="text-muted-foreground/50 hover:text-muted-foreground transition-colors shrink-0"
+            title={fi.organizeDetailTitle as string}
+          >
+            <Maximize2 size={13} />
+          </button>
           <button
             type="button"
             onClick={handleDismiss}

package/app/components/Panel.tsx

@@ -107,11 +107,12 @@ export default function Panel({
     };
   }, [newPopover]);
 
-  // Double-click hint: show only until user has used it once
-  const [dblHintSeen, setDblHintSeen] = useState(() => {
-    if (typeof window === 'undefined') return false;
-    return localStorage.getItem('mindos-tree-dblclick-hint') === '1';
-  });
+  // Double-click hint: show only until user has used it once.
+  // Initialize false to match SSR; hydrate from localStorage in useEffect.
+  const [dblHintSeen, setDblHintSeen] = useState(false);
+  useEffect(() => {
+    try { if (localStorage.getItem('mindos-tree-dblclick-hint') === '1') setDblHintSeen(true); } catch { /* ignore */ }
+  }, []);
   const markDblHintSeen = useCallback(() => {
     if (!dblHintSeen) {
       setDblHintSeen(true);

package/app/components/settings/AiTab.tsx

@@ -1,7 +1,7 @@
 'use client';
 
 import { useState, useRef, useCallback, useEffect } from 'react';
-import { AlertCircle, Loader2 } from 'lucide-react';
+import { AlertCircle, ChevronDown, Loader2 } from 'lucide-react';
 import type { AiSettings, AgentSettings, ProviderConfig, SettingsData, AiTabProps } from './types';
 import { Field, Select, Input, EnvBadge, ApiKeyInput, Toggle, SectionLabel } from './Primitives';
 import { useLocale } from '@/lib/LocaleContext';
@@ -14,6 +14,7 @@ interface TestResult {
   latency?: number;
   error?: string;
   code?: ErrorCode;
+  streamingSupported?: boolean;
 }
 
 function errorMessage(t: AiTabProps['t'], code?: ErrorCode): string {
@@ -72,12 +73,16 @@ export function AiTab({ data, updateAi, updateAgent, t }: AiTabProps) {
       const json = await res.json();
 
       if (json.ok) {
-        setTestResult(prev => ({ ...prev, [providerName]: { state: 'ok', latency: json.latency } }));
-        // Auto-clear after 5s
+        const streamingSupported = json.streamingSupported !== false;
+        setTestResult(prev => ({ ...prev, [providerName]: { state: 'ok', latency: json.latency, streamingSupported } }));
+        // Auto-persist streaming capability so /api/ask uses the right path
+        if (providerName === data.ai.provider) {
+          updateAgent({ useStreaming: streamingSupported });
+        }
         if (okTimerRef.current) clearTimeout(okTimerRef.current);
         okTimerRef.current = setTimeout(() => {
           setTestResult(prev => ({ ...prev, [providerName]: { state: 'idle' } }));
-        }, 5000);
+        }, 8000);
       } else {
         setTestResult(prev => ({
           ...prev,
@@ -139,7 +144,12 @@ export function AiTab({ data, updateAi, updateAgent, t }: AiTabProps) {
           )}
         </button>
         {result.state === 'ok' && result.latency != null && (
-          <span className="text-xs text-success">{t.settings.ai.testKeyOk(result.latency)}</span>
+          <span className="text-xs text-success">
+            {t.settings.ai.testKeyOk(result.latency)}
+            {result.streamingSupported === false && (
+              <span className="text-muted-foreground ml-1.5">{t.settings.ai.streamingFallback}</span>
+            )}
+          </span>
         )}
         {result.state === 'error' && (
           <span className="text-xs text-error">✗ {errorMessage(t, result.code)}</span>
@@ -163,10 +173,14 @@ export function AiTab({ data, updateAi, updateAgent, t }: AiTabProps) {
       {provider === 'anthropic' ? (
         <>
           <Field label={<>{t.settings.ai.model} <EnvBadge overridden={env.ANTHROPIC_MODEL} /></>}>
-            <Input
+            <ModelInput
               value={anthropic.model}
-              onChange={e => patchProvider('anthropic', { model: e.target.value })}
+              onChange={v => patchProvider('anthropic', { model: v })}
               placeholder={envVal.ANTHROPIC_MODEL || 'claude-sonnet-4-6'}
+              provider="anthropic"
+              apiKey={anthropic.apiKey}
+              envKey={env.ANTHROPIC_API_KEY}
+              t={t}
             />
           </Field>
           <Field
@@ -183,10 +197,15 @@ export function AiTab({ data, updateAi, updateAgent, t }: AiTabProps) {
       ) : (
         <>
           <Field label={<>{t.settings.ai.model} <EnvBadge overridden={env.OPENAI_MODEL} /></>}>
-            <Input
+            <ModelInput
               value={openai.model}
-              onChange={e => patchProvider('openai', { model: e.target.value })}
+              onChange={v => patchProvider('openai', { model: v })}
               placeholder={envVal.OPENAI_MODEL || 'gpt-5.4'}
+              provider="openai"
+              apiKey={openai.apiKey}
+              envKey={env.OPENAI_API_KEY}
+              baseUrl={openai.baseUrl}
+              t={t}
             />
           </Field>
           <Field
@@ -309,6 +328,111 @@ export function AiTab({ data, updateAi, updateAgent, t }: AiTabProps) {
   );
 }
 
+/* ── Model Input with "List models" picker ── */
+
+function ModelInput({
+  value, onChange, placeholder, provider, apiKey, envKey, baseUrl, t,
+}: {
+  value: string;
+  onChange: (v: string) => void;
+  placeholder: string;
+  provider: 'anthropic' | 'openai';
+  apiKey: string;
+  envKey?: boolean;
+  baseUrl?: string;
+  t: AiTabProps['t'];
+}) {
+  const [models, setModels] = useState<string[] | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [open, setOpen] = useState(false);
+  const [error, setError] = useState('');
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  const hasKey = !!apiKey || !!envKey;
+
+  const fetchModels = useCallback(async () => {
+    if (loading) return;
+    setLoading(true);
+    setError('');
+    try {
+      const body: Record<string, string> = { provider };
+      if (apiKey) body.apiKey = apiKey;
+      if (baseUrl) body.baseUrl = baseUrl;
+
+      const res = await fetch('/api/settings/list-models', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const json = await res.json();
+      if (json.ok && Array.isArray(json.models)) {
+        setModels(json.models);
+        setOpen(true);
+      } else {
+        setError(json.error || 'Failed to fetch models');
+      }
+    } catch {
+      setError('Network error');
+    } finally {
+      setLoading(false);
+    }
+  }, [provider, apiKey, baseUrl, loading]);
+
+  useEffect(() => {
+    if (!open) return;
+    function handleClickOutside(e: MouseEvent) {
+      if (containerRef.current && !containerRef.current.contains(e.target as Node)) {
+        setOpen(false);
+      }
+    }
+    document.addEventListener('mousedown', handleClickOutside);
+    return () => document.removeEventListener('mousedown', handleClickOutside);
+  }, [open]);
+
+  return (
+    <div ref={containerRef} className="relative">
+      <div className="flex gap-1.5">
+        <Input
+          value={value}
+          onChange={e => onChange(e.target.value)}
+          placeholder={placeholder}
+          className="flex-1"
+        />
+        <button
+          type="button"
+          disabled={!hasKey || loading}
+          onClick={fetchModels}
+          title={t.settings.ai.listModels}
+          className="inline-flex items-center gap-1 px-2 py-1 text-xs rounded-lg border border-border text-muted-foreground hover:text-foreground hover:border-foreground/20 transition-colors disabled:opacity-40 disabled:cursor-not-allowed shrink-0"
+        >
+          {loading ? <Loader2 size={12} className="animate-spin" /> : <ChevronDown size={12} />}
+          {t.settings.ai.listModels}
+        </button>
+      </div>
+      {error && <p className="text-xs text-error mt-1">{error}</p>}
+      {open && models && models.length > 0 && (
+        <div className="absolute z-50 mt-1 w-full max-h-48 overflow-y-auto rounded-lg border border-border bg-popover shadow-lg">
+          {models.map(m => (
+            <button
+              key={m}
+              type="button"
+              className={`w-full text-left px-3 py-1.5 text-xs hover:bg-accent transition-colors ${m === value ? 'bg-accent/60 font-medium' : ''}`}
+              onClick={() => { onChange(m); setOpen(false); }}
+            >
+              {m}
+            </button>
+          ))}
+        </div>
+      )}
+      {open && models && models.length === 0 && (
+        <div className="absolute z-50 mt-1 w-full rounded-lg border border-border bg-popover shadow-lg px-3 py-2 text-xs text-muted-foreground">
+          {t.settings.ai.noModelsFound}
+        </div>
+      )}
+    </div>
+  );
+}
+
 /* ── Ask AI Display Mode (localStorage-based, no server roundtrip) ── */
 
 function AskDisplayMode() {

package/app/components/settings/types.ts

@@ -21,6 +21,7 @@ export interface AgentSettings {
   thinkingBudget?: number;
   contextStrategy?: 'auto' | 'off';
   reconnectRetries?: number;
+  useStreaming?: boolean;
 }
 
 export interface SettingsData {

package/app/lib/i18n-en.ts

@@ -144,7 +144,7 @@ export const en = {
     searching: 'Searching knowledge base...',
     generating: 'Generating response...',
     stopped: 'Generation stopped.',
-    errorNoResponse: 'No response from AI. Please check your API key and provider settings.',
+    errorNoResponse: 'AI returned no content. Possible causes: model does not support streaming, proxy compatibility issue, or request exceeds context limit.',
     reconnecting: (attempt: number, max: number) => `Connection lost. Reconnecting (${attempt}/${max})...`,
     reconnectFailed: 'Connection failed after multiple attempts.',
     retry: 'Retry',
@@ -789,6 +789,12 @@ export const en = {
     organizeUndone: 'Undone',
     organizeViewFile: 'View file',
     organizeUndoSuccess: (n: number) => `Reverted ${n} file${n !== 1 ? 's' : ''}`,
+    organizeDetailTitle: 'AI Organize Details',
+    organizeSourceFiles: 'Source Files',
+    organizeSummaryLabel: 'AI Summary',
+    organizeChangesLabel: (n: number) => `Changes (${n})`,
+    organizeNoSummary: 'AI is working...',
+    organizeMinimizeModal: 'Minimize',
   },
   importHistory: {
     title: 'Import History',
@@ -836,6 +842,9 @@ export const en = {
       testKeyNetworkError: 'Network error',
       testKeyNoKey: 'No API key configured',
       testKeyUnknown: 'Test failed',
+      listModels: 'Browse',
+      noModelsFound: 'No models found',
+      streamingFallback: '(will use standard mode)',
     },
     agent: {
       title: 'Agent Behavior',

package/app/lib/i18n-zh.ts

@@ -169,7 +169,7 @@ export const zh = {
     searching: '正在搜索知识库...',
     generating: '正在生成回复...',
     stopped: '已停止生成。',
-    errorNoResponse: 'AI 未返回响应，请检查 API Key 和服务商设置。',
+    errorNoResponse: 'AI 未返回有效内容。可能原因：模型不支持流式输出、中转站兼容性问题、或请求超出上下文限制。',
     reconnecting: (attempt: number, max: number) => `连接中断，正在重连 (${attempt}/${max})...`,
     reconnectFailed: '多次重连失败，请检查网络后重试。',
     retry: '重试',
@@ -813,6 +813,12 @@ export const zh = {
     organizeUndone: '已撤销',
     organizeViewFile: '查看文件',
     organizeUndoSuccess: (n: number) => `已撤销 ${n} 个文件`,
+    organizeDetailTitle: 'AI 整理详情',
+    organizeSourceFiles: '源文件',
+    organizeSummaryLabel: 'AI 总结',
+    organizeChangesLabel: (n: number) => `变更列表 (${n})`,
+    organizeNoSummary: 'AI 正在处理中...',
+    organizeMinimizeModal: '最小化',
   },
   importHistory: {
     title: '导入历史',
@@ -860,6 +866,9 @@ export const zh = {
       testKeyNetworkError: '网络错误',
       testKeyNoKey: '未配置 API Key',
       testKeyUnknown: '测试失败',
+      listModels: '选择模型',
+      noModelsFound: '未找到可用模型',
+      streamingFallback: '（将使用标准模式）',
     },
     agent: {
       title: 'Agent 行为',

package/app/lib/settings.ts

@@ -24,6 +24,7 @@ export interface AgentConfig {
   thinkingBudget?: number;    // default 5000
   contextStrategy?: 'auto' | 'off'; // default 'auto'
   reconnectRetries?: number;  // default 3, range 0-10 (0 = disabled)
+  useStreaming?: boolean;     // default true; false = non-streaming fallback for proxy compat
 }
 
 export interface GuideState {
@@ -130,6 +131,7 @@ function parseAgent(raw: unknown): AgentConfig | undefined {
   if (typeof obj.thinkingBudget === 'number') result.thinkingBudget = Math.min(50000, Math.max(1000, obj.thinkingBudget));
   if (obj.contextStrategy === 'auto' || obj.contextStrategy === 'off') result.contextStrategy = obj.contextStrategy;
   if (typeof obj.reconnectRetries === 'number') result.reconnectRetries = Math.min(10, Math.max(0, obj.reconnectRetries));
+  if (typeof obj.useStreaming === 'boolean') result.useStreaming = obj.useStreaming;
   return Object.keys(result).length > 0 ? result : undefined;
 }
 

package/app/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.6.18",
+  "version": "0.6.19",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",