nolo-cli 0.1.23 → 0.1.26

package/ai/agent/streamAgentChatTurn.ts

@@ -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;
@@ -149,20 +177,171 @@ export interface StreamAgentChatTurnArgs {
     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: Date.now() - startedAt,
-        ...(typeof performance !== "undefined" ? { atMs: performance.now() } : {}),
+        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;
@@ -181,9 +360,68 @@ 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" &&
@@ -244,6 +482,7 @@ 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;
@@ -256,7 +495,11 @@ export const streamAgentChatTurnHandler = async (
         const cachedAgentConfig = selectById(getState() as RootState, agentKey);
         const agentConfig = isUsableAgentConfig(cachedAgentConfig)
             ? cachedAgentConfig
-            : ((await dispatch(read({ dbKey: agentKey })).unwrap()) as Agent);
+            : await readAgentConfigForTurn(
+                dispatch,
+                agentKey,
+                quickChatPerfStartedAt,
+            );
         if (!agentConfig) {
             return rejectWithValue(`Agent config not found for ID: ${agentKey}`);
         }
@@ -486,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,
                     },
                 );
 
@@ -557,6 +808,7 @@ export const streamAgentChatTurnHandler = async (
             }
 
             let accumulated = "";
+            let cliCapabilityWarnings: string[] = [];
             const decoder = new TextDecoder();
             const buildCliAssistantMessage = () => ({
                 id: messageId,
@@ -616,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 {
                             // 忽略解析失败的行
                         }
@@ -628,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 {
@@ -658,6 +924,49 @@ export const streamAgentChatTurnHandler = async (
             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);
 
         const explicitServerBase =
@@ -956,6 +1265,9 @@ export const streamAgentChatTurnHandler = async (
                 model: agentConfigForCall.model,
                 responseApi: true,
             });
+            logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-post-static-entered", {
+                responseApi: true,
+            });
 
             let appendTempUserInput = true;
             let currentParentMessageId = parentMessageId ?? undefined;
@@ -964,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;
                 }
@@ -976,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;
                 }
@@ -985,18 +1316,60 @@ 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,
                 });
@@ -1072,6 +1445,7 @@ export const streamAgentChatTurnHandler = async (
                     dynamicMessageCount: dynamicMessages.length,
                     stableMessageCount: stableMessages.length,
                 });
+                modelRequestStarted = true;
 
                 const meta: CompletionMeta = await sendOpenAIResponseRequest({
                     bodyData,
@@ -1162,6 +1536,9 @@ export const streamAgentChatTurnHandler = async (
             model: agentConfigForCall.model,
             responseApi: false,
         });
+        logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-post-static-entered", {
+            responseApi: false,
+        });
 
         let appendTempUserInput = true;
         let currentParentMessageId = parentMessageId ?? undefined;
@@ -1171,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;
             }
@@ -1185,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;
             }
@@ -1195,19 +1591,61 @@ 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,
             });
@@ -1286,6 +1724,27 @@ export const streamAgentChatTurnHandler = async (
                 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,
@@ -1297,6 +1756,7 @@ export const streamAgentChatTurnHandler = async (
                     agentConfigForCall,
                     runtimeOptions,
                 ),
+                disableToolsForThisRequest,
                 quickChatPerfStartedAt,
             });
             logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-model-request-finished", {
@@ -1383,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 ||