nolo-cli 0.1.22 → 0.1.26

package/ai/agent/streamAgentChatTurn.ts

@@ -4,7 +4,7 @@ import { createDialogMessageKeyAndId } from "database/keys";
 import { DataType } from "create/types";
 
 import type { RootState } from "app/store";
-import { patch, read } from "database/dbSlice";
+import { patch, read, selectById } from "database/dbSlice";
 import { generateRequestBody } from "ai/llm/generateRequestBody";
 import {
     selectCurrentDialogConfig,
@@ -26,7 +26,7 @@ import {
     getFullChatContextKeys,
     deduplicateContextKeys,
 } from "ai/agent/getFullChatContextKeys";
-import type { Agent } from "app/types";
+import type { Agent, DialogConfig } from "app/types";
 import { isResponseAPIModel } from "ai/llm/isResponseAPIModel";
 import { getModelContextWindow } from "ai/llm/getModelContextWindow";
 import { resolveAgentImageInputSupport } from "ai/llm/agentCapabilities";
@@ -56,7 +56,11 @@ import {
 import { buildCliPrompt } from "./cliPrompt";
 import { createCliChatTurnStream } from "./cliChatClient";
 import { getCliChatSession, startCliChatSession } from "./cliChatClient";
-import { messageStreaming, prepareAndPersistUserMessage } from "chat/messages/messageSlice";
+import {
+    messageStreamEnd,
+    messageStreaming,
+    prepareAndPersistUserMessage,
+} from "chat/messages/messageSlice";
 import { selectCurrentToken, selectUserId } from "auth/authSlice";
 import { persistMessageWithFixedId } from "./persistMessageWithFixedId";
 import { updateTotalUsage } from "../chat/updateTotalUsage";
@@ -65,6 +69,11 @@ import {
     extractAgentRuntimeServerBase,
     normalizeServerOrigin,
 } from "./runtimeServerBase";
+import { getIsDesktopApp } from "app/utils/env";
+import { runDesktopAgentRuntimeTurn } from "app/utils/desktopAgentRuntimeTurnClient";
+
+const BUILTIN_NOLO_AGENT_ID = "01NOLOAPPBLD000000019KCKT0";
+const BUILTIN_NOLO_AGENT_KEY = `agent-pub-${BUILTIN_NOLO_AGENT_ID}`;
 
 const buildParallelMessageMetadata = (
     agentConfig: Pick<Agent, "dbKey" | "name">,
@@ -106,6 +115,25 @@ const filterMessagesForParallelBranch = (
     });
 };
 
+const isDesktopBuiltinNoloAgent = (
+    requestedAgentKey: string,
+    agentConfig: Partial<Agent> | null | undefined,
+) => {
+    if (!getIsDesktopApp()) return false;
+    const candidates = [
+        requestedAgentKey,
+        agentConfig?.dbKey,
+        agentConfig?.agentKey,
+        agentConfig?.id,
+    ];
+    return candidates.some((value) =>
+        typeof value === "string" &&
+        (value === BUILTIN_NOLO_AGENT_KEY ||
+            value === BUILTIN_NOLO_AGENT_ID ||
+            value.endsWith(`-${BUILTIN_NOLO_AGENT_ID}`))
+    );
+};
+
 const formatMachineAgentRunError = async (response: Response): Promise<string> => {
     const errorText = await response.text();
     let payload: any = null;
@@ -146,8 +174,174 @@ export interface StreamAgentChatTurnArgs {
     isStreaming?: boolean;
     parentMessageId?: string;
     runtimeOptions?: AgentRuntimeOptions;
+    quickChatPerfStartedAt?: number;
 }
 
+const QUICK_CHAT_AGENT_CONFIG_READ_TIMEOUT_MS = 10_000;
+const QUICK_CHAT_DYNAMIC_CONTEXT_TIMEOUT_MS = 5_000;
+const EMPTY_DYNAMIC_CONTEXTS = {
+    currentInputContext: null,
+    historyContext: "",
+    editingContext: null,
+    appWorkingMemory: null,
+    dialogSummary: null,
+    proactiveSummary: null,
+    referenceKeys: [],
+};
+
+function appendCliCapabilityWarnings(content: string, warnings: string[]): string {
+    if (!warnings.length) return content;
+    const warningBlock = `\n\n[CLI 能力提示]\n${warnings.map((warning) => `- ${warning}`).join("\n")}`;
+    return `${content}${warningBlock}`;
+}
+
+const logQuickChatPerfStage = (
+    startedAt: number | undefined,
+    stage: string,
+    details: Record<string, unknown> = {}
+) => {
+    if (!startedAt) return;
+    const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+    console.info("[QuickChatPerf]", {
+        stage,
+        elapsedMs: now - startedAt,
+        ...(typeof performance !== "undefined" ? { atMs: now } : {}),
+        ...details,
+    });
+};
+
+const readAgentConfigForTurn = async (
+    dispatch: any,
+    agentKey: string,
+    quickChatPerfStartedAt?: number,
+): Promise<Agent> => {
+    const readPromise = dispatch(read({ dbKey: agentKey })).unwrap() as Promise<Agent>;
+    if (!quickChatPerfStartedAt) return readPromise;
+
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+    try {
+        return await Promise.race([
+            readPromise,
+            new Promise<Agent>((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    logQuickChatPerfStage(
+                        quickChatPerfStartedAt,
+                        "quick-chat-agent-config-read-timeout",
+                        {
+                            agentKey,
+                            timeoutMs: QUICK_CHAT_AGENT_CONFIG_READ_TIMEOUT_MS,
+                        },
+                    );
+                    reject(
+                        new Error("读取 Agent 配置超时，未能启动模型回复。"),
+                    );
+                }, QUICK_CHAT_AGENT_CONFIG_READ_TIMEOUT_MS);
+            }),
+        ]);
+    } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+    }
+};
+
+const buildDynamicContextsForTurn = async (
+    state: RootState,
+    dispatch: any,
+    agentConfig: Agent,
+    userInput: string | any[],
+    runtimeOptions: AgentRuntimeOptions | undefined,
+    mergedContentCache: Map<string, any>,
+    dialogKey: string | undefined,
+    quickChatPerfStartedAt?: number,
+) => {
+    if (!quickChatPerfStartedAt) {
+        return buildDynamicContexts(
+            state,
+            dispatch,
+            agentConfig,
+            userInput,
+            runtimeOptions,
+            mergedContentCache,
+            dialogKey,
+        );
+    }
+
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+    try {
+        const timeoutPromise = new Promise<typeof EMPTY_DYNAMIC_CONTEXTS>((resolve) => {
+            timeoutId = setTimeout(() => {
+                logQuickChatPerfStage(
+                    quickChatPerfStartedAt,
+                    "quick-chat-dynamic-context-timeout",
+                    {
+                        agentKey: agentConfig.dbKey,
+                        dialogKey,
+                        timeoutMs: QUICK_CHAT_DYNAMIC_CONTEXT_TIMEOUT_MS,
+                    },
+                );
+                resolve(EMPTY_DYNAMIC_CONTEXTS);
+            }, QUICK_CHAT_DYNAMIC_CONTEXT_TIMEOUT_MS);
+        });
+
+        logQuickChatPerfStage(
+            quickChatPerfStartedAt,
+            "stream-agent-dynamic-context-starting",
+            {
+                responseApi: isResponseAPIModel(agentConfig),
+            },
+        );
+        const contextPromise = buildDynamicContexts(
+            state,
+            dispatch,
+            agentConfig,
+            userInput,
+            runtimeOptions,
+            mergedContentCache,
+            dialogKey,
+        );
+
+        return await Promise.race([
+            contextPromise,
+            timeoutPromise,
+        ]);
+    } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+    }
+};
+
+const finalizeQuickChatAgentTurnFailure = async (
+    dispatch: any,
+    dialogKey: string,
+    agentKey: string,
+    error: unknown,
+) => {
+    const dialogId = extractCustomId(dialogKey);
+    const { key: msgKey, messageId } = createDialogMessageKeyAndId(dialogId);
+    const reason =
+        error instanceof Error && error.message.trim()
+            ? error.message.trim()
+            : "未能启动模型回复，请重试。";
+
+    await dispatch(
+        messageStreamEnd({
+            finalContentBuffer: [
+                {
+                    type: "text",
+                    text: `[错误: ${reason}]`,
+                },
+            ],
+            totalUsage: null,
+            msgKey,
+            agentConfig: {
+                dbKey: agentKey,
+            },
+            dialogId,
+            dialogKey,
+            messageId,
+            reasoningBuffer: "",
+        })
+    ).unwrap?.();
+};
+
 const normalizeAgentRunUserInput = (userInput: string | any[]) => {
     if (typeof userInput === "string") {
         return userInput;
@@ -166,6 +360,75 @@ const normalizeAgentRunUserInput = (userInput: string | any[]) => {
     });
 };
 
+const isSimpleTextInput = (userInput: string | any[]) => {
+    if (typeof userInput === "string") return true;
+    if (!Array.isArray(userInput)) return false;
+    return userInput.every(
+        (part) =>
+            part &&
+            typeof part === "object" &&
+            part.type === "text" &&
+            typeof part.text === "string",
+    );
+};
+
+const canUseQuickChatEmptyDynamicContexts = (
+    quickChatPerfStartedAt: number | undefined,
+    userInput: string | any[],
+    runtimeOptions: AgentRuntimeOptions | undefined,
+    dialogConfig: DialogConfig | null,
+) => {
+    if (!quickChatPerfStartedAt) return false;
+    if (runtimeOptions) return false;
+    if (!isSimpleTextInput(userInput)) return false;
+    if (dialogConfig?.referenceKeys?.length) return false;
+    return true;
+};
+
+const QUICK_CHAT_DIRECT_ANSWER_PATTERN =
+    /(只回复|只输出|只回答|直接回复|直接回答|不要解释|无需解释|不用解释|简短回答|一句话)/i;
+const QUICK_CHAT_TOOL_INTENT_PATTERN =
+    /(调用|转交|agent|助手|应用|网页|页面|图表|图片|生成图|画图|删除|清理|空间|商品|链接|https?:\/\/|www\.|@)/i;
+
+const shouldDisableQuickChatToolsForDirectAnswer = (
+    quickChatPerfStartedAt: number | undefined,
+    userInput: string | any[],
+    runtimeOptions: AgentRuntimeOptions | undefined,
+    dialogConfig: DialogConfig | null,
+) => {
+    if (!canUseQuickChatEmptyDynamicContexts(
+        quickChatPerfStartedAt,
+        userInput,
+        runtimeOptions,
+        dialogConfig,
+    )) {
+        return false;
+    }
+    const text = extractAgentRunUserText(userInput);
+    if (!text || text.length > 500) return false;
+    if (!QUICK_CHAT_DIRECT_ANSWER_PATTERN.test(text)) return false;
+    return !QUICK_CHAT_TOOL_INTENT_PATTERN.test(text);
+};
+
+const classifyQuickChatAccessError = (accessError: string) => {
+    if (accessError.includes("获取用户余额")) return "balance-loading";
+    if (accessError.includes("余额")) return "balance";
+    if (accessError.includes("白名单")) return "whitelist";
+    if (accessError.includes("定价")) return "pricing";
+    return "unknown";
+};
+
+const isUsableAgentConfig = (value: unknown): value is Agent =>
+    !!value &&
+    typeof value === "object" &&
+    (value as any).__ssrPreviewOnly !== true &&
+    typeof (value as Agent).dbKey === "string" &&
+    !!(value as Agent).dbKey &&
+    typeof (value as Agent).model === "string" &&
+    !!(value as Agent).model &&
+    typeof (value as Agent).provider === "string" &&
+    !!(value as Agent).provider;
+
 const extractAgentRunUserText = (userInput: string | any[]) => {
     if (typeof userInput === "string") {
         return userInput;
@@ -180,17 +443,6 @@ const extractAgentRunUserText = (userInput: string | any[]) => {
         .trim();
 };
 
-const requiresServerResolvedProviderConfig = (agentConfig: Agent): boolean => {
-    if (agentConfig.useServerProxy !== true) return false;
-
-    const provider = String(agentConfig.provider ?? "").toLowerCase();
-    const apiSource = String((agentConfig as any).apiSource ?? "").toLowerCase();
-    const isCustomProvider = provider === "custom" || apiSource === "custom";
-    if (!isCustomProvider) return false;
-
-    return !agentConfig.customProviderUrl?.trim() || !agentConfig.apiKey?.trim();
-};
-
 const hasAgentRunUserInputContent = (userInput: string | any[]) => {
     if (typeof userInput === "string") {
         return userInput.trim().length > 0;
@@ -209,7 +461,14 @@ export const streamAgentChatTurnHandler = async (
     args: StreamAgentChatTurnArgs,
     thunkApi: any,
 ) => {
-    const { agentKey, userInput, dialogKey: explicitDialogKey, parentMessageId, runtimeOptions } = args;
+    const {
+        agentKey,
+        userInput,
+        dialogKey: explicitDialogKey,
+        parentMessageId,
+        runtimeOptions,
+        quickChatPerfStartedAt,
+    } = args;
     const { getState, dispatch, rejectWithValue } = thunkApi;
     const state = getState() as RootState;
 
@@ -223,15 +482,34 @@ export const streamAgentChatTurnHandler = async (
     let runtimeDialogKey: string | null = explicitDialogKey ?? null;
     let remoteTransientMessageId: string | null = null;
     let remoteTransientMessageFinalized = false;
+    let modelRequestStarted = false;
 
     try {
         let totalTurnUsage: any = null;
         const agentRunUserInput = normalizeAgentRunUserInput(userInput);
-        // 1. 读取 Agent 配置
-        const agentConfig = (await dispatch(read({ dbKey: agentKey })).unwrap()) as Agent;
+        logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-entered", {
+            agentKey,
+            dialogKey: explicitDialogKey ?? null,
+        });
+        // 1. 读取 Agent 配置。Quick Chat 会提前预热默认 agent；命中 Redux DB 缓存时避免重复读。
+        const cachedAgentConfig = selectById(getState() as RootState, agentKey);
+        const agentConfig = isUsableAgentConfig(cachedAgentConfig)
+            ? cachedAgentConfig
+            : await readAgentConfigForTurn(
+                dispatch,
+                agentKey,
+                quickChatPerfStartedAt,
+            );
         if (!agentConfig) {
             return rejectWithValue(`Agent config not found for ID: ${agentKey}`);
         }
+        logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-config-read", {
+            agentKey,
+            model: agentConfig.model,
+            provider: agentConfig.provider,
+            apiSource: agentConfig.apiSource,
+            source: cachedAgentConfig === agentConfig ? "cache" : "read",
+        });
 
         // ── CLI Agent 专用路由 ────────────────────────────────────────────────
         // CLI 共享 prompt / model 这些入口能力，但不复用本地 tool-call 循环。
@@ -330,6 +608,8 @@ export const streamAgentChatTurnHandler = async (
                         userInput: agentRunUserInput,
                         messages: cleanedMessages,
                         stream: true,
+                        persistDialog: false,
+                        clientDialogId: dialogId,
                         runtimeContext: {
                             surface: "web",
                             host: "browser",
@@ -449,6 +729,14 @@ export const streamAgentChatTurnHandler = async (
                         cliProvider: agentConfig.cliProvider || "copilot",
                         model: agentConfig.model || undefined,
                         systemPrompt: agentConfig.prompt || undefined,
+                        reasoningEffort: agentConfig.reasoning_effort || undefined,
+                        temperature: agentConfig.temperature,
+                        topP: agentConfig.top_p,
+                        frequencyPenalty: agentConfig.frequency_penalty,
+                        presencePenalty: agentConfig.presence_penalty,
+                        maxTokens: agentConfig.max_tokens,
+                        enableThinking: agentConfig.enableThinking,
+                        thinkingBudget: agentConfig.thinkingBudget,
                     },
                 );
 
@@ -520,6 +808,7 @@ export const streamAgentChatTurnHandler = async (
             }
 
             let accumulated = "";
+            let cliCapabilityWarnings: string[] = [];
             const decoder = new TextDecoder();
             const buildCliAssistantMessage = () => ({
                 id: messageId,
@@ -579,7 +868,9 @@ export const streamAgentChatTurnHandler = async (
                                     ...cliMessageMetadata,
                                 }));
                             }
-                            // payload.done 时 stream 自然关闭，while loop 会退出
+                            if (payload.done && Array.isArray(payload.warnings)) {
+                                cliCapabilityWarnings = payload.warnings.filter((warning): warning is string => typeof warning === "string" && warning.trim().length > 0);
+                            }
                         } catch {
                             // 忽略解析失败的行
                         }
@@ -591,6 +882,18 @@ export const streamAgentChatTurnHandler = async (
                     return;
                 }
 
+                if (cliCapabilityWarnings.length > 0) {
+                    accumulated = appendCliCapabilityWarnings(accumulated, cliCapabilityWarnings);
+                    dispatch(messageStreaming({
+                        id: messageId,
+                        dialogId,
+                        dbKey: msgKey,
+                        content: accumulated,
+                        role: "assistant",
+                        ...cliMessageMetadata,
+                    }));
+                }
+
                 // 持久化最终消息：用已有 ID，避免 prepareAndPersistMessage 重新生成 ID 导致重复
                 await persistMessageWithFixedId(dispatch, buildCliAssistantMessage());
             } finally {
@@ -616,6 +919,53 @@ export const streamAgentChatTurnHandler = async (
         }
         runtimeDialogKey = dialogKey;
         const dialogId = extractCustomId(dialogKey);
+        logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-dialog-resolved", {
+            dialogKey,
+            dialogId,
+        });
+
+        if (isDesktopBuiltinNoloAgent(agentKey, agentConfig)) {
+            const { key: msgKey, messageId } = createDialogMessageKeyAndId(dialogId);
+            const desktopMessageMetadata = buildParallelMessageMetadata(
+                agentConfig,
+                runtimeOptions,
+            );
+            remoteTransientMessageId = messageId;
+            loopKey = `loop:${dialogId}`;
+            dispatch(addActiveController({ messageId: loopKey, controller: loopController, dialogKey }));
+            dispatch(messageStreaming({
+                id: messageId,
+                dialogId,
+                dbKey: msgKey,
+                content: "",
+                role: "assistant",
+                ...desktopMessageMetadata,
+            }));
+
+            const localResult = await runDesktopAgentRuntimeTurn({
+                agentRef: agentConfig.dbKey || agentKey,
+                input: userInput,
+                continueDialogId: dialogId,
+            });
+            if (!localResult.ok) {
+                dispatch(removeTransientMessage(messageId));
+                remoteTransientMessageFinalized = true;
+                return rejectWithValue(localResult.error);
+            }
+
+            dispatch(messageStreaming({
+                id: messageId,
+                dialogId,
+                dbKey: msgKey,
+                content: localResult.result.content || "",
+                role: "assistant",
+                ...desktopMessageMetadata,
+            }));
+            remoteTransientMessageFinalized = true;
+            return {
+                usage: localResult.result.usage ?? undefined,
+            };
+        }
 
         const userInputText = extractAgentRunUserText(userInput);
 
@@ -625,12 +975,10 @@ export const streamAgentChatTurnHandler = async (
                 : null;
         const currentServer = selectCurrentServer(state);
         const declaredRuntimeServerBase = extractAgentRuntimeServerBase(agentConfig);
-        const needsServerResolvedProviderConfig =
-            requiresServerResolvedProviderConfig(agentConfig);
         const requestedServerBase =
             explicitServerBase ??
             declaredRuntimeServerBase ??
-            (needsServerResolvedProviderConfig ? currentServer : null);
+            null;
         const normalizedRequestedServerBase =
             requestedServerBase && normalizeServerOrigin(requestedServerBase);
         const normalizedCurrentServer = normalizeServerOrigin(
@@ -643,12 +991,13 @@ export const streamAgentChatTurnHandler = async (
             !runtimeOptions?.imageConfigOverride;
         if (requestedServerBase && canAutoRouteRemotely) {
             if (
-                !needsServerResolvedProviderConfig &&
                 normalizedRequestedServerBase &&
                 normalizedCurrentServer &&
                 normalizedRequestedServerBase === normalizedCurrentServer
             ) {
-                // same server as current workspace; keep local flow
+                // Same server as the current workspace; keep the UI-managed
+                // chat/tool loop and let /api/chat hydrate redacted provider
+                // credentials server-side when needed.
             } else {
                 const token = selectCurrentToken(state);
                 const authHeader = token ? `Bearer ${token}` : "";
@@ -711,6 +1060,8 @@ export const streamAgentChatTurnHandler = async (
                         userInput: agentRunUserInput,
                         messages: cleanedMessages,
                         stream: true,
+                        persistDialog: false,
+                        clientDialogId: dialogId,
                         runtimeContext: {
                             surface: "web",
                             host: "browser",
@@ -811,6 +1162,10 @@ export const streamAgentChatTurnHandler = async (
             recommendedSkillHints: referenceRecommendedSkillHints,
             skillPromptPatches: referenceSkillPromptPatches,
         } = await resolveReferenceAssets(agentConfig.references, dispatch);
+        logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-references-resolved", {
+            referenceCount: normalizedReferences?.length ?? 0,
+            referencedToolCount: referenceTools?.length ?? 0,
+        });
 
         const agentConfigWithReferences = {
             ...agentConfig,
@@ -906,6 +1261,13 @@ export const streamAgentChatTurnHandler = async (
                 currentDialog ?? undefined,
                 mergedContentCache,
             );
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-static-context-ready", {
+                model: agentConfigForCall.model,
+                responseApi: true,
+            });
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-post-static-entered", {
+                responseApi: true,
+            });
 
             let appendTempUserInput = true;
             let currentParentMessageId = parentMessageId ?? undefined;
@@ -914,11 +1276,25 @@ export const streamAgentChatTurnHandler = async (
             if (w) w.__LOOP_STOP_REASON__ = null;
 
             loopKey = `loop:${dialogId}`;
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-active-controller-adding", {
+                responseApi: true,
+            });
             dispatch(addActiveController({ messageId: loopKey, controller: loopController, dialogKey }));
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-active-controller-added", {
+                responseApi: true,
+            });
 
             for (;;) {
+                logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-loop-entered", {
+                    responseApi: true,
+                });
                 const requestParentMessageId = currentParentMessageId;
                 if (loopController.signal.aborted || thunkApi.signal.aborted) {
+                    logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-loop-aborted-before-context", {
+                        loopControllerAborted: loopController.signal.aborted,
+                        thunkSignalAborted: thunkApi.signal.aborted,
+                        responseApi: true,
+                    });
                     if (w) w.__LOOP_STOP_REASON__ = "aborted";
                     break;
                 }
@@ -926,6 +1302,11 @@ export const streamAgentChatTurnHandler = async (
                 const loopState = getState() as RootState;
                 const now = Date.now();
                 if (now - startTime > MAX_TIME_MS) {
+                    logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-loop-timeout-before-context", {
+                        maxTimeMs: MAX_TIME_MS,
+                        elapsedMs: now - startTime,
+                        responseApi: true,
+                    });
                     if (w) w.__LOOP_STOP_REASON__ = "timeout";
                     break;
                 }
@@ -935,18 +1316,63 @@ export const streamAgentChatTurnHandler = async (
                     loopState,
                 );
                 if (accessError) {
+                    const accessErrorReason = classifyQuickChatAccessError(accessError);
+                    logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-access-error-before-context", {
+                        hasAccessError: true,
+                        reason: accessErrorReason,
+                        responseApi: true,
+                    });
+                    if (quickChatPerfStartedAt && runtimeDialogKey && !modelRequestStarted) {
+                        logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-access-error-finalized", {
+                            reason: accessErrorReason,
+                            responseApi: true,
+                        });
+                        await finalizeQuickChatAgentTurnFailure(
+                            dispatch,
+                            runtimeDialogKey,
+                            agentKey,
+                            new Error(accessError),
+                        );
+                    }
                     return rejectWithValue(accessError);
                 }
 
-                const dynamicContexts = await buildDynamicContexts(
-                    loopState,
-                    dispatch,
-                    agentConfigForCall,
+                const willSkipDynamicContext = canUseQuickChatEmptyDynamicContexts(
+                    quickChatPerfStartedAt,
                     userInput,
                     runtimeOptions,
-                    mergedContentCache,
-                    dialogKey,
+                    currentDialog,
                 );
+                logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-dynamic-context-decision", {
+                    hasRuntimeOptions: !!runtimeOptions,
+                    isSimpleTextInput: isSimpleTextInput(userInput),
+                    referenceKeyCount: currentDialog?.referenceKeys?.length ?? 0,
+                    willSkipDynamicContext,
+                    responseApi: true,
+                });
+
+                const dynamicContexts = willSkipDynamicContext
+                    ? (logQuickChatPerfStage(
+                        quickChatPerfStartedAt,
+                        "stream-agent-dynamic-context-skipped",
+                        {
+                            reason: "simple-quick-chat-first-turn",
+                            responseApi: true,
+                        },
+                    ), EMPTY_DYNAMIC_CONTEXTS)
+                    : await buildDynamicContextsForTurn(
+                        loopState,
+                        dispatch,
+                        agentConfigForCall,
+                        userInput,
+                        runtimeOptions,
+                        mergedContentCache,
+                        dialogKey,
+                        quickChatPerfStartedAt,
+                    );
+                logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-dynamic-context-ready", {
+                    responseApi: true,
+                });
                 const contexts = mergeContexts(staticContexts, dynamicContexts);
 
                 const rawMessages = filterMessagesForParallelBranch(
@@ -1014,6 +1440,12 @@ export const streamAgentChatTurnHandler = async (
                     userInput: userInputText,
                     contexts,
                 });
+                logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-model-request-starting", {
+                    responseApi: true,
+                    dynamicMessageCount: dynamicMessages.length,
+                    stableMessageCount: stableMessages.length,
+                });
+                modelRequestStarted = true;
 
                 const meta: CompletionMeta = await sendOpenAIResponseRequest({
                     bodyData,
@@ -1025,6 +1457,13 @@ export const streamAgentChatTurnHandler = async (
                         agentConfigForCall,
                         runtimeOptions,
                     ),
+                    quickChatPerfStartedAt,
+                });
+                logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-model-request-finished", {
+                    responseApi: true,
+                    hasToolCalls: meta.hasToolCalls,
+                    hasHandedOff: meta.hasHandedOff,
+                    hasPendingInteraction: meta.hasPendingInteraction,
                 });
 
                 appendTempUserInput = false;
@@ -1093,6 +1532,13 @@ export const streamAgentChatTurnHandler = async (
             currentDialog ?? undefined,
             mergedContentCache,
         );
+        logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-static-context-ready", {
+            model: agentConfigForCall.model,
+            responseApi: false,
+        });
+        logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-post-static-entered", {
+            responseApi: false,
+        });
 
         let appendTempUserInput = true;
         let currentParentMessageId = parentMessageId ?? undefined;
@@ -1102,13 +1548,27 @@ export const streamAgentChatTurnHandler = async (
 
         if (!isRespModel) {
             loopKey = `loop:${dialogId}`;
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-active-controller-adding", {
+                responseApi: false,
+            });
             dispatch(addActiveController({ messageId: loopKey, controller: loopController, dialogKey }));
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-active-controller-added", {
+                responseApi: false,
+            });
         }
 
         for (;;) {
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-loop-entered", {
+                responseApi: false,
+            });
             const requestParentMessageId = currentParentMessageId;
             // 每轮开始前检查是否已中止
             if (loopController.signal.aborted || thunkApi.signal.aborted) {
+                logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-loop-aborted-before-context", {
+                    loopControllerAborted: loopController.signal.aborted,
+                    thunkSignalAborted: thunkApi.signal.aborted,
+                    responseApi: false,
+                });
                 if (w) w.__LOOP_STOP_REASON__ = "aborted";
                 break;
             }
@@ -1116,6 +1576,11 @@ export const streamAgentChatTurnHandler = async (
             const loopState = getState() as RootState;
             const now = Date.now();
             if (now - startTime > MAX_TIME_MS) {
+                logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-loop-timeout-before-context", {
+                    maxTimeMs: MAX_TIME_MS,
+                    elapsedMs: now - startTime,
+                    responseApi: false,
+                });
                 if (w) w.__LOOP_STOP_REASON__ = "timeout";
                 break;
             }
@@ -1126,19 +1591,64 @@ export const streamAgentChatTurnHandler = async (
                 loopState,
             );
             if (accessError) {
+                const accessErrorReason = classifyQuickChatAccessError(accessError);
+                logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-access-error-before-context", {
+                    hasAccessError: true,
+                    reason: accessErrorReason,
+                    responseApi: false,
+                });
+                if (quickChatPerfStartedAt && runtimeDialogKey && !modelRequestStarted) {
+                    logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-access-error-finalized", {
+                        reason: accessErrorReason,
+                        responseApi: false,
+                    });
+                    await finalizeQuickChatAgentTurnFailure(
+                        dispatch,
+                        runtimeDialogKey,
+                        agentKey,
+                        new Error(accessError),
+                    );
+                }
                 return rejectWithValue(accessError);
             }
 
-            // 🚀 优化：每轮只构建动态上下文（currentInput、history、editingContext、dialogSummary）
-            const dynamicContexts = await buildDynamicContexts(
-                loopState,
-                dispatch,
-                agentConfigForCall,
+            const willSkipDynamicContext = canUseQuickChatEmptyDynamicContexts(
+                quickChatPerfStartedAt,
                 userInput,
                 runtimeOptions,
-                mergedContentCache,
-                dialogKey,
+                currentDialog,
             );
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-dynamic-context-decision", {
+                hasRuntimeOptions: !!runtimeOptions,
+                isSimpleTextInput: isSimpleTextInput(userInput),
+                referenceKeyCount: currentDialog?.referenceKeys?.length ?? 0,
+                willSkipDynamicContext,
+                responseApi: false,
+            });
+
+            // 🚀 优化：每轮只构建动态上下文（currentInput、history、editingContext、dialogSummary）
+            const dynamicContexts = willSkipDynamicContext
+                ? (logQuickChatPerfStage(
+                    quickChatPerfStartedAt,
+                    "stream-agent-dynamic-context-skipped",
+                    {
+                        reason: "simple-quick-chat-first-turn",
+                        responseApi: false,
+                    },
+                ), EMPTY_DYNAMIC_CONTEXTS)
+                : await buildDynamicContextsForTurn(
+                    loopState,
+                    dispatch,
+                    agentConfigForCall,
+                    userInput,
+                    runtimeOptions,
+                    mergedContentCache,
+                    dialogKey,
+                    quickChatPerfStartedAt,
+                );
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-dynamic-context-ready", {
+                responseApi: false,
+            });
 
             // 合并静态和动态上下文
             const contexts = mergeContexts(staticContexts, dynamicContexts);
@@ -1209,6 +1719,32 @@ export const streamAgentChatTurnHandler = async (
                 userInput: userInputText,
                 contexts,
             });
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-model-request-starting", {
+                responseApi: false,
+                dynamicMessageCount: dynamicMessages.length,
+                stableMessageCount: stableMessages.length,
+            });
+            modelRequestStarted = true;
+
+            const disableToolsForThisRequest =
+                shouldDisableQuickChatToolsForDirectAnswer(
+                    quickChatPerfStartedAt,
+                    userInput,
+                    runtimeOptions,
+                    currentDialog,
+                );
+            if (disableToolsForThisRequest) {
+                logQuickChatPerfStage(
+                    quickChatPerfStartedAt,
+                    "stream-agent-tools-disabled-for-direct-answer",
+                    {
+                        responseApi: false,
+                        toolCount: Array.isArray(agentConfigForCall.tools)
+                            ? agentConfigForCall.tools.length
+                            : 0,
+                    },
+                );
+            }
 
             const meta: CompletionMeta = await sendOpenAICompletionsRequest({
                 bodyData,
@@ -1220,6 +1756,14 @@ export const streamAgentChatTurnHandler = async (
                     agentConfigForCall,
                     runtimeOptions,
                 ),
+                disableToolsForThisRequest,
+                quickChatPerfStartedAt,
+            });
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-model-request-finished", {
+                responseApi: false,
+                hasToolCalls: meta.hasToolCalls,
+                hasHandedOff: meta.hasHandedOff,
+                hasPendingInteraction: meta.hasPendingInteraction,
             });
 
             appendTempUserInput = false;
@@ -1299,6 +1843,19 @@ export const streamAgentChatTurnHandler = async (
             dispatch(removeTransientMessage(remoteTransientMessageId));
             remoteTransientMessageFinalized = true;
         }
+        if (
+            quickChatPerfStartedAt &&
+            runtimeDialogKey &&
+            !modelRequestStarted &&
+            !remoteTransientMessageId
+        ) {
+            await finalizeQuickChatAgentTurnFailure(
+                dispatch,
+                runtimeDialogKey,
+                agentKey,
+                error,
+            );
+        }
 
         return rejectWithValue(
             error?.message ||