dominds 1.23.2 → 1.23.4

package/dist/llm/kernel-driver/drive.js

@@ -165,7 +165,56 @@ function normalizeQ4HAnswerCallId(raw) {
 function isUserOriginPrompt(prompt) {
     if (!prompt)
         return false;
-    return prompt.origin === 'user';
+    return prompt.origin === 'user' && normalizeQ4HAnswerCallId(prompt.q4hAnswerCallId) === undefined;
+}
+function resolveReminderContextFollowingDialogState(prompt, currentTurnDialogMsgsForContext) {
+    if (prompt === undefined || currentTurnDialogMsgsForContext.length === 0)
+        return 'none';
+    return prompt.origin === 'user' ? 'user_message' : 'runtime_notice';
+}
+function splitDialogMsgsForReminderInsertion(args) {
+    const msgId = args.currentPrompt?.msgId;
+    if (typeof msgId !== 'string' || msgId.trim() === '') {
+        return {
+            historicalDialogMsgsForContext: [...args.msgs],
+            currentTurnDialogMsgsForContext: [],
+        };
+    }
+    const currentTurnStart = args.msgs.findIndex((msg) => msg.type === 'prompting_msg' && msg.msgId === msgId);
+    if (currentTurnStart < 0) {
+        return {
+            historicalDialogMsgsForContext: [...args.msgs],
+            currentTurnDialogMsgsForContext: [],
+        };
+    }
+    return {
+        historicalDialogMsgsForContext: args.msgs.slice(0, currentTurnStart),
+        currentTurnDialogMsgsForContext: args.msgs.slice(currentTurnStart),
+    };
+}
+function getUserOriginPromptMsgId(prompt) {
+    if (!prompt)
+        return undefined;
+    return prompt.origin === 'user' && normalizeQ4HAnswerCallId(prompt.q4hAnswerCallId) === undefined
+        ? prompt.msgId
+        : undefined;
+}
+async function persistAndEmitRuntimeGuide(dlg, content) {
+    await dlg.addChatMessages({
+        type: 'transient_guide_msg',
+        role: 'assistant',
+        content,
+    });
+    await persistAndPostRuntimeGuide(dlg, content);
+}
+async function persistAndPostRuntimeGuide(dlg, content) {
+    await persistence_1.DialogPersistence.persistRuntimeGuide(dlg, content, dlg.activeGenSeq);
+    (0, evt_registry_1.postDialogEvent)(dlg, {
+        type: 'runtime_guide_evt',
+        course: dlg.currentCourse,
+        genseq: dlg.activeGenSeq,
+        content,
+    });
 }
 function resolveToolUseRequirement(dlg, policy) {
     // FBR middle rounds are deliberately isolated from callable tools. Final closure is the opposite:
@@ -255,6 +304,9 @@ function hasMeaningfulBatchOutput(batch) {
             if (output.kind === 'user_image_ingest') {
                 continue;
             }
+            if (output.kind === 'invalid_func_call') {
+                return true;
+            }
             if (output.kind !== 'message') {
                 return true;
             }
@@ -804,26 +856,28 @@ async function projectTellaskFuncResultsForContext(args) {
         messages: projected,
     };
 }
+async function buildActiveReplyObligationContext(dlg) {
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dlg.id, dlg.status);
+    if (activeReplyObligation === undefined)
+        return [];
+    return [
+        {
+            type: 'environment_msg',
+            role: 'user',
+            content: (0, reply_prompt_copy_1.buildActiveReplyObligationContextText)({
+                language: (0, work_language_1.getWorkLanguage)(),
+                directive: activeReplyObligation,
+            }),
+        },
+    ];
+}
 async function buildDialogMsgsForContext(dlg) {
     const rawDialogMsgsForContext = dlg.msgs.filter((m) => !!m);
     const projected = await projectTellaskFuncResultsForContext({
         dialog: dlg,
         dialogMsgsForContext: rawDialogMsgsForContext,
     });
-    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dlg.id, dlg.status);
-    const activeReplyObligationContext = activeReplyObligation === undefined
-        ? []
-        : [
-            {
-                type: 'environment_msg',
-                role: 'user',
-                content: (0, reply_prompt_copy_1.buildActiveReplyObligationContextText)({
-                    language: (0, work_language_1.getWorkLanguage)(),
-                    directive: activeReplyObligation,
-                }),
-            },
-        ];
-    const businessFiltered = [...activeReplyObligationContext, ...projected.messages].filter((msg) => {
+    const businessFiltered = projected.messages.filter((msg) => {
         return msg.type !== 'tellask_result_msg' || msg.content.trim() !== '';
     });
     const sanitized = (0, tool_call_context_1.sanitizeToolContextForProvider)(businessFiltered);
@@ -862,6 +916,75 @@ async function emitAssistantSaying(dlg, content) {
     await dlg.sayingChunk(content);
     await dlg.sayingFinish();
 }
+function formatInvalidFuncCallRuntimeGuide(language, call) {
+    const rawName = call.rawFunctionName !== undefined && call.rawFunctionName.trim() !== ''
+        ? call.rawFunctionName.trim()
+        : '<missing>';
+    const rawArguments = call.rawArgumentsText !== undefined && call.rawArgumentsText.trim() !== ''
+        ? call.rawArgumentsText
+        : '<empty>';
+    const indexLine = call.toolCallIndex === undefined ? undefined : `- toolCallIndex: ${String(call.toolCallIndex)}`;
+    if (language === 'en') {
+        return [
+            '[Runtime notice] The previous model output contained an invalid tool-call payload that could not be represented as a normal provider tool call in the next generation context.',
+            '',
+            `- provider: ${call.provider}`,
+            `- callId: ${call.callId}`,
+            `- problem: ${call.detail}`,
+            `- rawFunctionName: ${rawName}`,
+            `- rawArgumentsText:`,
+            '```json',
+            rawArguments,
+            '```',
+            ...(indexLine === undefined ? [] : [indexLine]),
+            '',
+            'Treat that payload as failed. Do not assume the tool ran. Continue from the current task, and if a tool call is still needed, emit a new valid tool call with a non-empty function name and valid arguments.',
+        ]
+            .filter((line) => line.length > 0)
+            .join('\n');
+    }
+    return [
+        '[运行时提示] 上一轮模型输出包含一个无效工具调用载荷，无法按正常 provider tool call 形态进入下一轮生成上下文。',
+        '',
+        `- provider: ${call.provider}`,
+        `- callId: ${call.callId}`,
+        `- 问题: ${call.detail}`,
+        `- rawFunctionName: ${rawName}`,
+        `- rawArgumentsText:`,
+        '```json',
+        rawArguments,
+        '```',
+        ...(indexLine === undefined ? [] : [indexLine]),
+        '',
+        '请把该载荷视为调用失败，不要假设工具已经执行。继续当前任务；如果仍需要调用工具，请重新发起一个函数名非空、参数有效的新工具调用。',
+    ]
+        .filter((line) => line.length > 0)
+        .join('\n');
+}
+async function persistInvalidFuncCallRuntimeGuide(args) {
+    const { dlg, call } = args;
+    const sourceText = args.source === 'streamed' ? 'streamed' : 'batch';
+    log_1.log.error(`kernel-driver received invalid ${sourceText} function call payload`, new Error(`kernel_driver_invalid_${sourceText}_function_call_payload`), {
+        rootId: dlg.id.rootId,
+        selfId: dlg.id.selfId,
+        course: dlg.activeGenCourseOrUndefined ?? dlg.currentCourse,
+        genseq: dlg.activeGenSeq,
+        callId: call.callId,
+        provider: call.provider,
+        detail: call.detail,
+        toolCallIndex: call.toolCallIndex,
+    });
+    if (args.emitStreamError) {
+        await dlg.streamError(call.detail);
+    }
+    const content = formatInvalidFuncCallRuntimeGuide((0, work_language_1.getWorkLanguage)(), call);
+    args.newMsgs.push({
+        type: 'transient_guide_msg',
+        role: 'assistant',
+        content,
+    });
+    await persistAndPostRuntimeGuide(dlg, content);
+}
 function resolveFuncToolFollowupMode(tool) {
     return tool?.followupMode ?? 'immediate';
 }
@@ -1252,38 +1375,39 @@ async function preserveDiligenceBudgetAcrossQ4H(dlg) {
 }
 async function maybeContinueWithDiligencePrompt(args) {
     const { dlg, team, suppressDiligencePushForDrive, allowPendingSideDialogs, ignoreBudgetExhaustion, } = args;
-    if (!(dlg instanceof dialog_1.MainDialog)) {
-        return { kind: 'break' };
-    }
     const suspension = await dlg.getSuspensionStatus({
         allowPendingSideDialogs: allowPendingSideDialogs === true,
     });
     if (!suspension.canDrive) {
-        if (suspension.q4h) {
+        if (suspension.q4h && dlg instanceof dialog_1.MainDialog) {
             await preserveDiligenceBudgetAcrossQ4H(dlg);
         }
         return { kind: 'break' };
     }
     const prepared = await (0, runtime_1.maybePrepareDiligenceAutoContinuePrompt)({
         dlg,
-        isMainDialog: true,
         remainingBudget: dlg.diligencePushRemainingBudget,
         diligencePushMax: resolveMemberDiligencePushMax(team, dlg.agentId),
         suppressDiligencePush: suppressDiligencePushForDrive,
         ignoreBudgetExhaustion,
     });
-    dlg.diligencePushRemainingBudget = prepared.nextRemainingBudget;
-    void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
-        kind: 'patch',
-        patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
-    }));
-    if (prepared.kind !== 'disabled') {
+    if (dlg instanceof dialog_1.MainDialog) {
+        dlg.diligencePushRemainingBudget = prepared.nextRemainingBudget;
+        void persistence_1.DialogPersistence.mutateDialogLatest(dlg.id, () => ({
+            kind: 'patch',
+            patch: { diligencePushRemainingBudget: dlg.diligencePushRemainingBudget },
+        }));
+    }
+    if (dlg instanceof dialog_1.MainDialog && prepared.kind !== 'disabled') {
         emitDiligenceBudgetEvent(dlg, {
             maxInjectCount: prepared.maxInjectCount,
             nextRemainingBudget: prepared.nextRemainingBudget,
         });
     }
     if (prepared.kind === 'budget_exhausted') {
+        if (!(dlg instanceof dialog_1.MainDialog)) {
+            throw new Error(`kernel-driver Diligence Push invariant violation: non-main dialog returned budget_exhausted (${dlg.id.valueOf()})`);
+        }
         await (0, runtime_1.suspendForKeepGoingBudgetExhausted)({
             dlg,
             maxInjectCount: prepared.maxInjectCount,
@@ -1333,9 +1457,6 @@ async function maybeContinueWithHealthPromptBeforeDiligence(args) {
         cautionRemediationCadenceGenerations,
         criticalCountdownRemaining,
     });
-    if (healthDecision.kind === 'suspend') {
-        return { kind: 'health_suspend' };
-    }
     if (healthDecision.kind !== 'continue') {
         return { kind: 'no_health_prompt' };
     }
@@ -1389,13 +1510,22 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     const suppressDiligencePushForDrive = driveOptions?.suppressDiligencePush === true && dlg.disableDiligencePush;
     const abortSignal = (0, dialog_display_state_1.getActiveRunSignal)(dlg.id) ?? (0, dialog_display_state_1.createActiveRun)(dlg.id);
     let finalDisplayState;
+    let criticalUserInterjectionRuntimeGuide = driveOptions?.criticalUserInterjectionRuntimeGuide;
     let lastAssistantSayingContent = null;
     let lastAssistantSayingGenseq = null;
+    let lastAssistantThinkingContent = null;
+    let lastAssistantThinkingGenseq = null;
     let lastFunctionCallGenseq = null;
     let lastAssistantReplyTarget;
     let fbrConclusion;
     let pubRemindersVer = dlg.remindersVer;
     let pendingPrompt = humanPrompt;
+    let resolvingImmediateToolResultForUserPrompt = false;
+    let resolvingImmediateToolResultUserPromptMsgId;
+    let criticalRemediationAppliedUserPromptMsgId = driveOptions?.criticalUserInterjectionRuntimeGuide !== undefined &&
+        humanPrompt?.origin === 'user'
+        ? humanPrompt.msgId
+        : undefined;
     let retryStoppedRecoveryPrompt;
     let skipTaskdocForThisDrive = humanPrompt?.skipTaskdoc === true;
     let genIterNo = 0;
@@ -1507,7 +1637,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     : canonicalFuncTools;
                 const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, effectiveFuncTools);
                 const funcTools = projected.tools;
+                const currentPendingPrompt = pendingPrompt;
+                let currentGenerationBelongsToUserPrompt = isUserOriginPrompt(currentPendingPrompt);
+                let currentGenerationBelongsToUserToolChain = false;
+                let currentUserPromptMsgId = getUserOriginPromptMsgId(currentPendingPrompt);
                 if (genIterNo > 1) {
+                    currentGenerationBelongsToUserToolChain = resolvingImmediateToolResultForUserPrompt;
+                    if (currentUserPromptMsgId === undefined) {
+                        currentUserPromptMsgId = resolvingImmediateToolResultUserPromptMsgId;
+                    }
+                    resolvingImmediateToolResultForUserPrompt = false;
+                    resolvingImmediateToolResultUserPromptMsgId = undefined;
                     const snapshot = dlg.getLastContextHealth();
                     const hasQueuedUpNext = dlg.hasUpNext() || pendingPrompt !== undefined;
                     const modelInfoForRemediation = resolveModelInfo(providerCfg, model);
@@ -1516,21 +1656,14 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     const healthDecision = (0, context_health_1.decideKernelDriverContextHealth)({
                         dialogKey: dlg.id.key(),
                         snapshot,
-                        hadUserPromptThisGen: isUserOriginPrompt(pendingPrompt),
+                        hadUserPromptThisGen: currentGenerationBelongsToUserPrompt,
+                        hadUserPromptInImmediateToolChain: currentGenerationBelongsToUserToolChain,
+                        userPromptCriticalRemediationAlreadyApplied: criticalRemediationAppliedUserPromptMsgId !== undefined &&
+                            criticalRemediationAppliedUserPromptMsgId === currentUserPromptMsgId,
                         canInjectPromptThisGen: !hasQueuedUpNext,
                         cautionRemediationCadenceGenerations,
                         criticalCountdownRemaining,
                     });
-                    if (healthDecision.kind === 'suspend') {
-                        log_1.log.debug('kernel-driver suspend iterative generation due to critical context while waiting for human prompt', undefined, {
-                            dialogId: dlg.id.valueOf(),
-                            rootId: dlg.id.rootId,
-                            selfId: dlg.id.selfId,
-                            genIterNo,
-                            pendingPromptOrigin: pendingPrompt?.origin ?? null,
-                        });
-                        break;
-                    }
                     if (healthDecision.kind === 'continue') {
                         if (healthDecision.reason === 'critical_force_new_course') {
                             const language = (0, work_language_1.getWorkLanguage)();
@@ -1548,6 +1681,16 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             pendingPrompt = nextPrompt;
                             skipTaskdocForThisDrive = false;
                         }
+                        else if (healthDecision.reason === 'critical_user_prompt_remediation') {
+                            const language = (0, work_language_1.getWorkLanguage)();
+                            const dialogScope = dlg instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
+                            criticalUserInterjectionRuntimeGuide =
+                                (0, driver_messages_1.formatAgentFacingCriticalUserInterjectionRemediationGuide)(language, {
+                                    dialogScope,
+                                    promptsRemainingAfterThis: (0, context_health_1.consumeCriticalCountdown)(dlg.id.key()),
+                                });
+                            criticalRemediationAppliedUserPromptMsgId = currentUserPromptMsgId;
+                        }
                         else if (!hasQueuedUpNext) {
                             const language = (0, work_language_1.getWorkLanguage)();
                             const dialogScope = dlg instanceof dialog_1.SideDialog ? 'sideDialog' : 'mainDialog';
@@ -1586,6 +1729,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 pendingPrompt = undefined;
                 await dlg.notifyGeneratingStart(currentPrompt?.msgId);
                 try {
+                    if (criticalUserInterjectionRuntimeGuide !== undefined) {
+                        await persistAndEmitRuntimeGuide(dlg, criticalUserInterjectionRuntimeGuide);
+                        criticalUserInterjectionRuntimeGuide = undefined;
+                    }
                     if (currentPrompt) {
                         const origin = currentPrompt.origin;
                         if (origin === 'diligence_push' &&
@@ -1665,14 +1812,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         const renderPromptAsRuntimeGuideBubble = origin === 'runtime' &&
                             (0, reply_prompt_copy_1.isStandaloneRuntimeGuidePromptContent)(replyGuidance.promptContent);
                         if (currentRuntimeGuideMsg) {
-                            await dlg.addChatMessages(currentRuntimeGuideMsg);
-                            await persistence_1.DialogPersistence.persistRuntimeGuide(dlg, currentRuntimeGuideMsg.content, dlg.activeGenSeq);
-                            (0, evt_registry_1.postDialogEvent)(dlg, {
-                                type: 'runtime_guide_evt',
-                                course: dlg.currentCourse,
-                                genseq: dlg.activeGenSeq,
-                                content: currentRuntimeGuideMsg.content,
-                            });
+                            await persistAndEmitRuntimeGuide(dlg, currentRuntimeGuideMsg.content);
                             currentRuntimeGuideMsg = undefined;
                         }
                         if (isQ4HAnswerPrompt) {
@@ -1796,13 +1936,18 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         : undefined;
                     const renderedReminders = await renderRemindersForContext(dlg);
                     const dialogMsgsForContext = await buildDialogMsgsForContext(dlg);
+                    const activeReplyObligationContext = await buildActiveReplyObligationContext(dlg);
+                    const splitDialogMsgs = splitDialogMsgsForReminderInsertion({
+                        msgs: dialogMsgsForContext,
+                        currentPrompt,
+                    });
                     const reminderContextBlock = renderedReminders.length > 0
                         ? [
                             ...renderedReminders,
                             {
                                 type: 'environment_msg',
                                 role: 'user',
-                                content: (0, driver_messages_1.formatReminderContextFooter)((0, work_language_1.getWorkLanguage)()),
+                                content: (0, driver_messages_1.formatReminderContextFooter)((0, work_language_1.getWorkLanguage)(), resolveReminderContextFollowingDialogState(currentPrompt, splitDialogMsgs.currentTurnDialogMsgsForContext)),
                             },
                         ]
                         : renderedReminders;
@@ -1812,17 +1957,20 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             memories: minds.memories,
                             taskDocMsg,
                             coursePrefixMsgs: dlg.getCoursePrefixMsgs(),
-                            dialogMsgsForContext,
+                            historicalDialogMsgsForContext: splitDialogMsgs.historicalDialogMsgsForContext,
+                            currentTurnDialogMsgsForContext: splitDialogMsgs.currentTurnDialogMsgsForContext,
                         },
-                        ephemeral: {
-                            runtimeGuideMsgs: currentRuntimeGuideMsg ? [currentRuntimeGuideMsg] : undefined,
+                        tail: {
+                            renderedReminders: reminderContextBlock,
+                            activeReplyObligationContext,
+                            runtimeGuideMsgs: currentRuntimeGuideMsg ? [currentRuntimeGuideMsg] : [],
                         },
-                        tail: { renderedReminders: reminderContextBlock },
                     });
                     const newMsgs = [];
                     const streamedFuncCalls = [];
                     let sawWebSearchSideChannelOutput = false;
                     let sawNativeToolSideChannelOutput = false;
+                    let invalidFuncCallCount = 0;
                     const streamOrBatch = async () => {
                         let batchAttemptCourse;
                         let batchAttemptCheckpointOffset;
@@ -1839,6 +1987,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             });
                             sawWebSearchSideChannelOutput = false;
                             sawNativeToolSideChannelOutput = false;
+                            invalidFuncCallCount = 0;
                             streamedFuncCalls.length = 0;
                             newMsgs.length = 0;
                         };
@@ -1906,6 +2055,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         let streamAttemptCheckpointOffset;
                         let streamAttemptSayingContent;
                         let streamAttemptSayingGenseq;
+                        let streamAttemptThinkingContent;
+                        let streamAttemptThinkingGenseq;
                         let streamActive = { kind: 'idle' };
                         const rollbackStreamAttempt = async () => {
                             if (streamAttemptCourse === undefined ||
@@ -1925,9 +2076,12 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             currentSayingContent = '';
                             streamAttemptSayingContent = undefined;
                             streamAttemptSayingGenseq = undefined;
+                            streamAttemptThinkingContent = undefined;
+                            streamAttemptThinkingGenseq = undefined;
                             sawWebSearchSideChannelOutput = false;
                             sawNativeToolSideChannelOutput = false;
                             streamedFuncCalls.length = 0;
+                            invalidFuncCallCount = 0;
                             newMsgs.length = 0;
                         };
                         const receiver = {
@@ -1975,13 +2129,16 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                     currentThinkingReasoning = reasoning;
                                 await dlg.thinkingFinish(reasoning);
                                 if (currentThinkingContent.length > 0 || currentThinkingReasoning !== undefined) {
-                                    newMsgs.push({
+                                    const thinkingMessage = {
                                         type: 'thinking_msg',
                                         role: 'assistant',
                                         genseq: dlg.activeGenSeq,
                                         content: currentThinkingContent,
                                         reasoning: currentThinkingReasoning,
-                                    });
+                                    };
+                                    newMsgs.push(thinkingMessage);
+                                    streamAttemptThinkingContent = currentThinkingContent;
+                                    streamAttemptThinkingGenseq = thinkingMessage.genseq;
                                 }
                                 currentThinkingContent = '';
                                 currentThinkingReasoning = undefined;
@@ -2048,6 +2205,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                     arguments: argsStr,
                                 });
                             },
+                            invalidFuncCall: async (call) => {
+                                throwIfAborted(abortSignal, dlg);
+                                invalidFuncCallCount += 1;
+                                await persistInvalidFuncCallRuntimeGuide({
+                                    dlg,
+                                    call,
+                                    source: 'streamed',
+                                    newMsgs,
+                                    emitStreamError: true,
+                                });
+                            },
                             webSearchCall: async (call) => {
                                 throwIfAborted(abortSignal, dlg);
                                 sawWebSearchSideChannelOutput = true;
@@ -2093,9 +2261,12 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 currentSayingContent = '';
                                 streamAttemptSayingContent = undefined;
                                 streamAttemptSayingGenseq = undefined;
+                                streamAttemptThinkingContent = undefined;
+                                streamAttemptThinkingGenseq = undefined;
                                 sawWebSearchSideChannelOutput = false;
                                 sawNativeToolSideChannelOutput = false;
                                 streamedFuncCalls.length = 0;
+                                invalidFuncCallCount = 0;
                                 newMsgs.length = 0;
                                 const promptCacheKey = prepareLlmRequestContextKey();
                                 const streamResult = await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, {
@@ -2111,6 +2282,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 const hasFunctionCall = streamedFuncCalls.length > 0;
                                 if (!hasFinishedMessageContent &&
                                     !hasFunctionCall &&
+                                    invalidFuncCallCount === 0 &&
                                     !sawWebSearchSideChannelOutput &&
                                     !sawNativeToolSideChannelOutput) {
                                     throw {
@@ -2128,6 +2300,14 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 streamAttemptSayingGenseq === undefined ? null : streamAttemptSayingGenseq;
                             lastAssistantReplyTarget = currentReplyTarget;
                         }
+                        if (streamAttemptThinkingContent !== undefined) {
+                            lastAssistantThinkingContent = streamAttemptThinkingContent;
+                            lastAssistantThinkingGenseq =
+                                streamAttemptThinkingGenseq === undefined ? null : streamAttemptThinkingGenseq;
+                            if (streamAttemptSayingContent === undefined) {
+                                lastAssistantReplyTarget = currentReplyTarget;
+                            }
+                        }
                         return { usage: res.usage, llmGenModel: res.llmGenModel };
                     };
                     const llmOutput = await streamOrBatch();
@@ -2152,6 +2332,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 if (msg.type === 'thinking_msg' || msg.type === 'saying_msg') {
                                     newMsgs.push(msg);
                                     if (msg.type === 'thinking_msg') {
+                                        lastAssistantThinkingContent = msg.content;
+                                        lastAssistantThinkingGenseq = msg.genseq;
+                                        lastAssistantReplyTarget = currentReplyTarget;
                                         await (0, events_1.emitThinkingEvents)(dlg, msg.content, msg.reasoning);
                                     }
                                     else {
@@ -2167,6 +2350,17 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                                 }
                                 break;
                             }
+                            case 'invalid_func_call': {
+                                invalidFuncCallCount += 1;
+                                await persistInvalidFuncCallRuntimeGuide({
+                                    dlg,
+                                    call: output.call,
+                                    source: 'batch',
+                                    newMsgs,
+                                    emitStreamError: true,
+                                });
+                                break;
+                            }
                             case 'web_search_call': {
                                 sawWebSearchSideChannelOutput = true;
                                 await dlg.webSearchCall(projectLlmWebSearchCall(output.call));
@@ -2225,6 +2419,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             return {
                                 lastAssistantSayingContent,
                                 lastAssistantSayingGenseq,
+                                lastAssistantThinkingContent,
+                                lastAssistantThinkingGenseq,
                                 lastFunctionCallGenseq,
                                 lastAssistantReplyTarget,
                             };
@@ -2374,7 +2570,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     // warrant same-drive LLM reaction right away. Provider-native side-channel UI events are
                     // meaningful output, but they are not transcript/context inputs and therefore must not
                     // trigger another immediate generation round by themselves.
-                    const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls || routed.tellaskToolOutputs.length > 0;
+                    const shouldStartImmediatePostToolGeneration = routed.hasImmediateFollowupToolCalls ||
+                        routed.tellaskToolOutputs.length > 0 ||
+                        invalidFuncCallCount > 0;
                     if (!shouldStartImmediatePostToolGeneration) {
                         const healthFirst = await maybeContinueWithHealthPromptBeforeDiligence({
                             dlg,
@@ -2388,9 +2586,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             }
                             continue;
                         }
-                        if (healthFirst.kind === 'health_suspend') {
-                            break;
-                        }
                         const next = await maybeContinueWithDiligencePrompt({
                             dlg,
                             team,
@@ -2403,6 +2598,13 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         break;
                     }
                     if (shouldStartImmediatePostToolGeneration) {
+                        resolvingImmediateToolResultForUserPrompt =
+                            currentGenerationBelongsToUserPrompt ||
+                                currentGenerationBelongsToUserToolChain ||
+                                isUserOriginPrompt(currentPrompt);
+                        resolvingImmediateToolResultUserPromptMsgId = resolvingImmediateToolResultForUserPrompt
+                            ? currentUserPromptMsgId
+                            : undefined;
                         continue;
                     }
                 }
@@ -2543,6 +2745,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
     return {
         lastAssistantSayingContent,
         lastAssistantSayingGenseq,
+        lastAssistantThinkingContent,
+        lastAssistantThinkingGenseq,
         lastFunctionCallGenseq,
         lastAssistantReplyTarget,
         fbrConclusion,

package/dist/llm/kernel-driver/engine.d.ts

@@ -7,4 +7,4 @@ export declare function driveDialogStreamCore(dlg: Dialog, callbacks: KernelDriv
 export declare function supplyResponseToSideDialogBridge(parentDialog: Dialog, sideDialogId: DialogID, responseText: string, callType: 'A' | 'B' | 'C', callId?: string, status?: 'completed' | 'failed', calleeResponseRef?: {
     course: number;
     genseq: number;
-}): Promise<void>;
+}, directFallbackSource?: 'saying' | 'thinking_only'): Promise<void>;

package/dist/llm/kernel-driver/engine.js

@@ -25,7 +25,7 @@ async function driveDialogStream(...driveArgs) {
             void dispatchDrive(dialog, options);
         },
         driveDialog: async (dialog, options) => {
-            await dispatchDrive(dialog, options);
+            return await dispatchDrive(dialog, options);
         },
     });
 }
@@ -34,7 +34,7 @@ async function emitSayingEventsBridge(...args) {
     return await (0, events_1.emitSayingEvents)(dlg, content);
 }
 async function supplyResponseToAskerDialog(...args) {
-    const [parentDialog, sideDialogId, responseText, callType, callId, status, calleeResponseRef] = args;
+    const [parentDialog, sideDialogId, responseText, callType, callId, status, calleeResponseRef, directFallbackSource,] = args;
     return await (0, sideDialog_1.supplyResponseToAskerDialog)({
         parentDialog,
         sideDialogId,
@@ -43,6 +43,7 @@ async function supplyResponseToAskerDialog(...args) {
         callId,
         status,
         calleeResponseRef,
+        directFallbackSource,
         scheduleDrive: (dialog, options) => {
             void dispatchDrive(dialog, options);
         },
@@ -51,7 +52,7 @@ async function supplyResponseToAskerDialog(...args) {
 async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions) {
     return await (0, drive_1.driveDialogStreamCore)(dlg, callbacks, humanPrompt, driveOptions);
 }
-async function supplyResponseToSideDialogBridge(parentDialog, sideDialogId, responseText, callType, callId, status, calleeResponseRef) {
+async function supplyResponseToSideDialogBridge(parentDialog, sideDialogId, responseText, callType, callId, status, calleeResponseRef, directFallbackSource) {
     await (0, sideDialog_1.supplyResponseToAskerDialog)({
         parentDialog,
         sideDialogId,
@@ -60,6 +61,7 @@ async function supplyResponseToSideDialogBridge(parentDialog, sideDialogId, resp
         callId,
         status,
         calleeResponseRef,
+        directFallbackSource,
         scheduleDrive: (dialog, options) => {
             void dispatchDrive(dialog, options);
         },