dominds 1.13.2 → 1.15.2

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

@@ -18,6 +18,7 @@ const tool_1 = require("../../tool");
 const taskdoc_1 = require("../../utils/taskdoc");
 const client_1 = require("../client");
 const registry_1 = require("../gen/registry");
+const tool_call_context_1 = require("../gen/tool-call-context");
 const tools_projection_1 = require("../tools-projection");
 const context_1 = require("./context");
 const context_health_1 = require("./context-health");
@@ -35,6 +36,57 @@ const KERNEL_DRIVER_DEFAULT_RETRY_POLICY = {
     maxDelayMs: 30 * 60 * 1000, // 30 minutes
 };
 const KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE = 'DOMINDS_LLM_EMPTY_RESPONSE';
+// Wrapper isolation boundary:
+// - Wrappers emit provider-native web-search events.
+// - The driver is the first place allowed to project them into a narrower shared dialog shape.
+function projectLlmWebSearchCall(call) {
+    if (call.source === 'codex') {
+        return call;
+    }
+    const action = call.action;
+    if (!action) {
+        return {
+            source: call.source,
+            phase: call.phase,
+            itemId: call.itemId,
+            status: call.status,
+        };
+    }
+    if (action.type === 'search') {
+        const query = typeof action.query === 'string' && action.query.trim().length > 0
+            ? action.query
+            : Array.isArray(action.queries)
+                ? action.queries.find((entry) => entry.trim().length > 0)
+                : undefined;
+        return {
+            source: call.source,
+            phase: call.phase,
+            itemId: call.itemId,
+            status: call.status,
+            action: query !== undefined ? { type: 'search', query } : { type: 'search' },
+        };
+    }
+    if (action.type === 'open_page') {
+        return {
+            source: call.source,
+            phase: call.phase,
+            itemId: call.itemId,
+            status: call.status,
+            action: typeof action.url === 'string' ? { type: 'open_page', url: action.url } : action,
+        };
+    }
+    return {
+        source: call.source,
+        phase: call.phase,
+        itemId: call.itemId,
+        status: call.status,
+        action: {
+            type: 'find_in_page',
+            ...(typeof action.url === 'string' ? { url: action.url } : {}),
+            ...(typeof action.pattern === 'string' ? { pattern: action.pattern } : {}),
+        },
+    };
+}
 class KernelDriverInterruptedError extends Error {
     constructor(reason) {
         super('Dialog interrupted');
@@ -86,19 +138,11 @@ function buildKernelDriverFbrPrompt(dlg, state) {
         origin: 'runtime',
     };
 }
-function normalizeQ4HAnswerCallIds(raw) {
-    if (!raw || raw.length === 0)
+function normalizeQ4HAnswerCallId(raw) {
+    if (typeof raw !== 'string')
         return undefined;
-    const seen = new Set();
-    const normalized = [];
-    for (const value of raw) {
-        const callId = value.trim();
-        if (callId === '' || seen.has(callId))
-            continue;
-        seen.add(callId);
-        normalized.push(callId);
-    }
-    return normalized.length > 0 ? normalized : undefined;
+    const callId = raw.trim();
+    return callId !== '' ? callId : undefined;
 }
 function isUserOriginPrompt(prompt) {
     if (!prompt)
@@ -171,8 +215,23 @@ function resolveKernelDriverRetryPolicy(providerCfg) {
         maxDelayMs: Math.max(initialDelayMs, conservativeDelayMs, maxDelayMs),
     };
 }
-function hasMeaningfulBatchOutput(messages) {
-    for (const msg of messages) {
+function hasMeaningfulBatchOutput(batch) {
+    if (Array.isArray(batch.outputs) && batch.outputs.length > 0) {
+        for (const output of batch.outputs) {
+            if (output.kind !== 'message') {
+                return true;
+            }
+            const msg = output.message;
+            if (msg.type === 'func_call_msg') {
+                return true;
+            }
+            if ((msg.type === 'saying_msg' || msg.type === 'thinking_msg') && msg.content.trim() !== '') {
+                return true;
+            }
+        }
+        return false;
+    }
+    for (const msg of batch.messages) {
         if (msg.type === 'func_call_msg') {
             return true;
         }
@@ -380,7 +439,7 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
         },
     },
 ];
-function mergeTellaskSpecialVirtualTools(baseTools, options) {
+function mergeTellaskVirtualTools(baseTools, options) {
     const merged = [...baseTools];
     const seen = new Set(merged.map((tool) => tool.name));
     const freshBootsReasoning = createFreshBootsReasoningTool({
@@ -492,7 +551,7 @@ function resolveUpNextPrompt(dlg) {
         grammar: upNext.grammar ?? 'markdown',
         origin: upNext.origin,
         userLanguageCode: upNext.userLanguageCode,
-        q4hAnswerCallIds: upNext.q4hAnswerCallIds,
+        q4hAnswerCallId: upNext.q4hAnswerCallId,
         tellaskReplyDirective: upNext.tellaskReplyDirective,
         skipTaskdoc: upNext.skipTaskdoc,
         subdialogReplyTarget: upNext.subdialogReplyTarget,
@@ -551,48 +610,30 @@ function hasSameReplyDirective(left, right) {
     }
     return true;
 }
-function formatElapsedSecondsText(startedAtMs) {
-    const language = (0, work_language_1.getWorkLanguage)();
-    if (startedAtMs === null) {
-        return language === 'zh' ? '未知时长' : 'unknown elapsed time';
-    }
-    const elapsedMs = Math.max(0, Date.now() - startedAtMs);
-    const elapsedSec = Math.floor(elapsedMs / 1000);
-    return language === 'zh' ? `${elapsedSec} 秒` : `${elapsedSec}s`;
-}
-function formatPendingSpecialFuncResult(name, startedAtMs) {
-    const language = (0, work_language_1.getWorkLanguage)();
-    const elapsed = formatElapsedSecondsText(startedAtMs);
-    if (name === 'askHuman') {
-        return language === 'zh'
-            ? `Q4H 仍在等待人类回复，已持续 ${elapsed}。`
-            : `Q4H is still waiting for human reply (elapsed ${elapsed}).`;
-    }
-    return language === 'zh'
-        ? `支线对话仍在进行中，已持续 ${elapsed}。`
-        : `Sideline dialog is still running (elapsed ${elapsed}).`;
-}
-function formatResolvedAskHumanResult() {
-    return (0, work_language_1.getWorkLanguage)() === 'zh'
-        ? 'Q4H 已结束等待状态，请参考后续用户消息。'
-        : 'Q4H wait is resolved; refer to subsequent user messages.';
+function buildPendingTellaskFuncResult(args) {
+    return {
+        type: 'func_result_msg',
+        role: 'tool',
+        genseq: args.genseq,
+        id: args.callId,
+        name: args.callName,
+        content: (0, tellask_special_1.formatPendingTellaskFuncResultContent)(args.callName, null),
+    };
 }
-async function projectTellaskSpecialFuncResultsForContext(args) {
-    const hasSpecialFuncCall = args.dialogMsgsForContext.some((msg) => msg.type === 'func_call_msg' && (0, tellask_special_1.isTellaskSpecialFunctionName)(msg.name));
-    if (!hasSpecialFuncCall) {
-        return [...args.dialogMsgsForContext];
-    }
-    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(args.dialog.id, args.dialog.status);
-    const pendingSubByCallId = new Map();
+async function loadPendingTellaskSpecialStates(dialog) {
+    const pendingByCallId = new Map();
+    const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(dialog.id, dialog.status);
     for (const pending of pendingSubdialogs) {
         const callId = pending.callId.trim();
         if (callId === '') {
             continue;
         }
-        pendingSubByCallId.set(callId, { createdAt: pending.createdAt });
+        pendingByCallId.set(callId, {
+            callName: pending.callName,
+            startedAtMs: parseUnifiedTimestampMs(pending.createdAt),
+        });
     }
-    const pendingQ4H = await persistence_1.DialogPersistence.loadQuestions4HumanState(args.dialog.id, args.dialog.status);
-    const pendingQ4HByCallId = new Map();
+    const pendingQ4H = await persistence_1.DialogPersistence.loadQuestions4HumanState(dialog.id, dialog.status);
     for (const question of pendingQ4H) {
         if (typeof question.callId !== 'string') {
             continue;
@@ -601,23 +642,42 @@ async function projectTellaskSpecialFuncResultsForContext(args) {
         if (callId === '') {
             continue;
         }
-        pendingQ4HByCallId.set(callId, { askedAt: question.askedAt });
+        pendingByCallId.set(callId, {
+            callName: 'askHuman',
+            startedAtMs: parseUnifiedTimestampMs(question.askedAt),
+        });
     }
-    const settledByCallId = new Map();
+    return pendingByCallId;
+}
+async function projectTellaskFuncResultsForContext(args) {
+    const hasSpecialFuncCall = args.dialogMsgsForContext.some((msg) => msg.type === 'func_call_msg' && (0, tellask_special_1.isTellaskCallFunctionName)(msg.name));
+    if (!hasSpecialFuncCall) {
+        return {
+            messages: [...args.dialogMsgsForContext],
+            projectedResultCallIds: new Set(),
+        };
+    }
+    const pendingSpecialByCallId = await loadPendingTellaskSpecialStates(args.dialog);
+    // Only technical tool-result-shaped messages can satisfy provider tool-call adjacency. A
+    // carryover message is different: it is already the canonical latest-course business context and
+    // intentionally does not act as a tool-result surrogate for an older-course call that is no
+    // longer present in current context.
+    const pairedToolResultContentByCallId = new Map();
     const existingSpecialFuncResults = new Map();
     for (const msg of args.dialogMsgsForContext) {
         if (msg.type === 'tellask_result_msg') {
             const callId = typeof msg.callId === 'string' ? msg.callId.trim() : '';
             if (callId !== '') {
-                settledByCallId.set(callId, msg.content);
+                pairedToolResultContentByCallId.set(callId, msg.content);
             }
             continue;
         }
-        if (msg.type === 'func_result_msg' && (0, tellask_special_1.isTellaskSpecialFunctionName)(msg.name)) {
+        if (msg.type === 'func_result_msg' && (0, tellask_special_1.isTellaskCallFunctionName)(msg.name)) {
             existingSpecialFuncResults.set(msg.id, msg);
         }
     }
     const projected = [];
+    const projectedResultCallIds = new Set();
     const specialCallIds = new Set();
     for (const msg of args.dialogMsgsForContext) {
         if (msg.type === 'func_result_msg' && specialCallIds.has(msg.id)) {
@@ -627,67 +687,98 @@ async function projectTellaskSpecialFuncResultsForContext(args) {
         if (msg.type !== 'func_call_msg') {
             continue;
         }
-        if (!(0, tellask_special_1.isTellaskSpecialFunctionName)(msg.name)) {
+        if (!(0, tellask_special_1.isTellaskCallFunctionName)(msg.name)) {
             continue;
         }
         specialCallIds.add(msg.id);
-        const settled = settledByCallId.get(msg.id);
-        if (settled !== undefined) {
+        const pairedToolResultContent = pairedToolResultContentByCallId.get(msg.id);
+        if (pairedToolResultContent !== undefined) {
+            projectedResultCallIds.add(msg.id);
             projected.push({
                 type: 'func_result_msg',
                 role: 'tool',
                 genseq: msg.genseq,
                 id: msg.id,
                 name: msg.name,
-                content: settled,
+                content: pairedToolResultContent,
             });
             continue;
         }
         const existingResult = existingSpecialFuncResults.get(msg.id);
         if (existingResult) {
+            projectedResultCallIds.add(msg.id);
             projected.push(existingResult);
             continue;
         }
-        if (msg.name === 'askHuman') {
-            const pendingQ4HState = pendingQ4HByCallId.get(msg.id);
-            const content = pendingQ4HState
-                ? formatPendingSpecialFuncResult(msg.name, parseUnifiedTimestampMs(pendingQ4HState.askedAt))
-                : formatResolvedAskHumanResult();
+        const pendingSpecialState = pendingSpecialByCallId.get(msg.id);
+        if (pendingSpecialState?.callName === msg.name) {
+            projectedResultCallIds.add(msg.id);
             projected.push({
                 type: 'func_result_msg',
                 role: 'tool',
                 genseq: msg.genseq,
                 id: msg.id,
                 name: msg.name,
-                content,
+                content: (0, tellask_special_1.formatPendingTellaskFuncResultContent)(msg.name, pendingSpecialState.startedAtMs),
             });
             continue;
         }
-        const pendingSubState = pendingSubByCallId.get(msg.id);
-        projected.push({
-            type: 'func_result_msg',
-            role: 'tool',
+        projectedResultCallIds.add(msg.id);
+        projected.push(buildPendingTellaskFuncResult({
+            callId: msg.id,
+            callName: msg.name,
             genseq: msg.genseq,
-            id: msg.id,
-            name: msg.name,
-            content: formatPendingSpecialFuncResult(msg.name, pendingSubState ? parseUnifiedTimestampMs(pendingSubState.createdAt) : null),
-        });
+        }));
     }
-    return projected;
+    return {
+        messages: projected,
+        projectedResultCallIds,
+    };
 }
 async function buildDialogMsgsForContext(dlg) {
-    const rawDialogMsgsForContext = dlg.msgs.filter((m) => {
-        if (!m)
-            return false;
-        if (m.type === 'ui_only_markdown_msg')
-            return false;
-        return true;
-    });
-    const projected = await projectTellaskSpecialFuncResultsForContext({
+    const rawDialogMsgsForContext = dlg.msgs.filter((m) => !!m);
+    const projected = await projectTellaskFuncResultsForContext({
         dialog: dlg,
         dialogMsgsForContext: rawDialogMsgsForContext,
     });
-    return projected.filter((msg) => msg.type !== 'tellask_result_msg');
+    const businessFiltered = projected.messages.filter((msg) => {
+        if (msg.type !== 'tellask_result_msg') {
+            return true;
+        }
+        // Business tellask result bubbles stay in storage/UI, but when the same latest-course call is
+        // also projected into an adjacent technical tool result for provider context we omit the
+        // duplicate bubble form here. Carryover messages are intentionally not filtered by this branch:
+        // they are already the canonical latest-course context, not a tool-pair surrogate.
+        return !projected.projectedResultCallIds.has(msg.callId);
+    });
+    const sanitized = (0, tool_call_context_1.sanitizeToolContextForProvider)(businessFiltered);
+    if (sanitized.droppedViolations.length > 0) {
+        const details = sanitized.droppedViolations.map((violation) => (0, tool_call_context_1.formatToolCallAdjacencyViolation)(violation, 'kernel-driver provider context sanitization'));
+        const summary = `kernel-driver dropped ${sanitized.droppedViolations.length} unpaired persisted tool ` +
+            `message(s) before provider projection for dialog=${dlg.id.valueOf()}; see logs for details.`;
+        log_1.log.error(summary, new Error('kernel_driver_provider_context_sanitized_unpaired_tool_msgs'), {
+            rootId: dlg.id.rootId,
+            selfId: dlg.id.selfId,
+            droppedViolationCount: sanitized.droppedViolations.length,
+            droppedViolations: sanitized.droppedViolations.map((violation) => ({
+                kind: violation.kind,
+                callId: violation.callId,
+                toolName: violation.toolName,
+                index: violation.index,
+            })),
+            detailPreview: details.slice(0, 3),
+        });
+        try {
+            await dlg.streamError(`${summary} ${details.slice(0, 3).join(' ')}`);
+        }
+        catch (error) {
+            log_1.log.warn('kernel-driver failed to emit stream_error_evt for sanitized tool context', error, {
+                rootId: dlg.id.rootId,
+                selfId: dlg.id.selfId,
+            });
+        }
+    }
+    return sanitized.messages;
 }
 async function emitAssistantSaying(dlg, content) {
     if (content.trim() === '')
@@ -696,146 +787,94 @@ async function emitAssistantSaying(dlg, content) {
     await dlg.sayingChunk(content);
     await dlg.sayingFinish();
 }
-function isReplyTellaskCallName(name) {
-    return (name === 'replyTellask' || name === 'replyTellaskSessionless' || name === 'replyTellaskBack');
-}
-function isToolArgumentsObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function prepareFuncCallArguments(argumentsStr) {
-    if (argumentsStr.trim() === '') {
-        return {
-            ok: true,
-            raw: {},
-            contextArguments: '{}',
-        };
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(argumentsStr);
-    }
-    catch (err) {
-        return {
-            ok: false,
-            error: `Arguments must be valid JSON: ${err instanceof Error ? err.message : String(err)}`,
-            contextArguments: '{}',
-        };
-    }
-    if (!isToolArgumentsObject(parsed)) {
-        return {
-            ok: false,
-            error: 'Arguments must be an object',
-            contextArguments: '{}',
-        };
-    }
-    return {
-        ok: true,
-        raw: parsed,
-        contextArguments: argumentsStr,
-    };
-}
 async function executeFunctionCalls(args) {
     const functionPromises = args.funcCalls.map(async (func) => {
         throwIfAborted(args.abortSignal, args.dlg);
         const callGenseq = func.genseq;
         const argsStr = typeof func.arguments === 'string' ? func.arguments : JSON.stringify(func.arguments ?? {});
-        const preparedArgs = prepareFuncCallArguments(argsStr);
-        const persistedArguments = preparedArgs.ok ? preparedArgs.raw : {};
-        await args.dlg.funcCallRequested(func.id, func.name, preparedArgs.contextArguments);
-        await args.dlg.persistFunctionCall(func.id, func.name, persistedArguments, callGenseq);
         const tool = args.agentTools.find((t) => t.type === 'func' && t.name === func.name);
-        if (!tool) {
-            const errorResult = {
-                type: 'func_result_msg',
-                id: func.id,
-                name: func.name,
-                content: `Tool '${func.name}' not found`,
-                role: 'tool',
-                genseq: callGenseq,
-            };
-            await args.dlg.receiveFuncResult(errorResult);
-            return errorResult;
-        }
+        const preparedInvocationArgs = tool !== undefined ? (0, tool_1.resolveFuncToolInvocationArguments)(tool, argsStr) : null;
+        await args.dlg.funcCallRequested(func.id, func.name, argsStr);
         let result;
-        let resultPersisted = false;
-        if (!preparedArgs.ok) {
-            log_1.log.warn('kernel-driver rejected function call arguments before execution', undefined, {
-                funcName: func.name,
-                arguments: argsStr,
-                error: preparedArgs.error,
-            });
+        let rethrowError;
+        if (!tool) {
             result = {
                 type: 'func_result_msg',
                 id: func.id,
                 name: func.name,
-                content: `Invalid arguments: ${preparedArgs.error}`,
+                content: `Tool '${func.name}' not found`,
                 role: 'tool',
                 genseq: callGenseq,
             };
         }
         else {
-            const argsValidation = (0, runtime_1.validateFuncToolArguments)(tool, preparedArgs.raw);
-            if (!argsValidation.ok) {
+            if (!preparedInvocationArgs || !preparedInvocationArgs.ok) {
+                const errorText = preparedInvocationArgs?.error ?? 'Arguments could not be prepared for tool invocation';
+                log_1.log.warn('kernel-driver rejected function call arguments before execution', undefined, {
+                    funcName: func.name,
+                    arguments: argsStr,
+                    error: errorText,
+                });
                 result = {
                     type: 'func_result_msg',
                     id: func.id,
                     name: func.name,
-                    content: `Invalid arguments: ${argsValidation.error}`,
+                    content: `Invalid arguments: ${errorText}`,
                     role: 'tool',
                     genseq: callGenseq,
                 };
-                await args.dlg.receiveFuncResult(result);
-                return result;
             }
-            const argsObj = argsValidation.args;
-            try {
-                throwIfAborted(args.abortSignal, args.dlg);
-                const output = await tool.call(args.dlg, args.agent, argsObj);
-                throwIfAborted(args.abortSignal, args.dlg);
-                const normalized = typeof output === 'string'
-                    ? { content: output, contentItems: undefined }
-                    : {
-                        content: typeof output.content === 'string' ? output.content : String(output),
-                        contentItems: Array.isArray(output.contentItems) ? output.contentItems : undefined,
+            else {
+                try {
+                    throwIfAborted(args.abortSignal, args.dlg);
+                    const output = await tool.call(args.dlg, args.agent, preparedInvocationArgs.args);
+                    throwIfAborted(args.abortSignal, args.dlg);
+                    const normalized = typeof output === 'string'
+                        ? { content: output, contentItems: undefined }
+                        : {
+                            content: typeof output.content === 'string' ? output.content : String(output),
+                            contentItems: Array.isArray(output.contentItems)
+                                ? output.contentItems
+                                : undefined,
+                        };
+                    result = {
+                        type: 'func_result_msg',
+                        id: func.id,
+                        name: func.name,
+                        content: String(normalized.content),
+                        contentItems: normalized.contentItems,
+                        role: 'tool',
+                        genseq: callGenseq,
                     };
-                result = {
-                    type: 'func_result_msg',
-                    id: func.id,
-                    name: func.name,
-                    content: String(normalized.content),
-                    contentItems: normalized.contentItems,
-                    role: 'tool',
-                    genseq: callGenseq,
-                };
-            }
-            catch (err) {
-                const errText = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
-                result = {
-                    type: 'func_result_msg',
-                    id: func.id,
-                    name: func.name,
-                    content: `Function '${func.name}' execution failed: ${errText}`,
-                    role: 'tool',
-                    genseq: callGenseq,
-                };
-                if (args.abortSignal?.aborted || err instanceof KernelDriverInterruptedError) {
-                    if (!resultPersisted) {
-                        await args.dlg.receiveFuncResult({
+                }
+                catch (err) {
+                    const errText = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+                    result = {
+                        type: 'func_result_msg',
+                        id: func.id,
+                        name: func.name,
+                        content: `Function '${func.name}' execution failed: ${errText}`,
+                        role: 'tool',
+                        genseq: callGenseq,
+                    };
+                    if (args.abortSignal?.aborted || err instanceof KernelDriverInterruptedError) {
+                        result = {
                             type: 'func_result_msg',
                             id: func.id,
                             name: func.name,
-                            content: `Function '${func.name}' interrupted after call was persisted: ${errText}`,
+                            content: `Function '${func.name}' interrupted before completion: ${errText}`,
                             role: 'tool',
                             genseq: callGenseq,
-                        });
-                        resultPersisted = true;
+                        };
+                        rethrowError = err;
                     }
-                    throw err;
                 }
             }
         }
-        await args.dlg.receiveFuncResult(result);
-        resultPersisted = true;
+        await args.dlg.persistFunctionCallResultPair(func.id, func.name, argsStr, callGenseq, result);
+        if (rethrowError !== undefined) {
+            throw rethrowError;
+        }
         return result;
     });
     return await Promise.all(functionPromises);
@@ -850,8 +889,8 @@ async function executeFunctionRound(args) {
         };
     }
     throwIfAborted(args.abortSignal, args.dlg);
-    const allowTellaskBack = args.allowTellaskSpecialFunctions && args.dlg.id.rootId !== args.dlg.id.selfId;
-    const allowedSpecials = args.allowTellaskSpecialFunctions
+    const allowTellaskBack = args.allowTellaskFunctions && args.dlg.id.rootId !== args.dlg.id.selfId;
+    const allowedSpecials = args.allowTellaskFunctions
         ? new Set([
             'tellask',
             'tellaskSessionless',
@@ -863,114 +902,19 @@ async function executeFunctionRound(args) {
             ...(allowTellaskBack ? ['tellaskBack'] : []),
         ])
         : new Set();
-    const classified = (0, tellask_special_1.classifyTellaskSpecialFunctionCalls)(args.funcCalls, { allowedSpecials });
-    const specialCallById = new Map(classified.specialCalls.map((call) => [call.callId, call]));
-    const originalCallById = new Map(args.funcCalls.map((call) => [call.id, call]));
-    const toPersistedSpecialCallArgs = (call) => {
-        switch (call.callName) {
-            case 'tellaskBack':
-                return { tellaskContent: call.tellaskContent };
-            case 'askHuman':
-                return { tellaskContent: call.tellaskContent };
-            case 'freshBootsReasoning':
-                return {
-                    tellaskContent: call.tellaskContent,
-                    ...(call.effort !== undefined ? { effort: call.effort } : {}),
-                };
-            case 'tellask':
-                return {
-                    targetAgentId: call.targetAgentId,
-                    sessionSlug: call.sessionSlug,
-                    tellaskContent: call.tellaskContent,
-                };
-            case 'tellaskSessionless':
-                return {
-                    targetAgentId: call.targetAgentId,
-                    tellaskContent: call.tellaskContent,
-                };
-            case 'replyTellask':
-            case 'replyTellaskSessionless':
-            case 'replyTellaskBack':
-                return { replyContent: call.replyContent };
-        }
-    };
-    for (const callMsg of args.funcCalls) {
-        throwIfAborted(args.abortSignal, args.dlg);
-        const special = specialCallById.get(callMsg.id);
-        if (!special) {
-            continue;
-        }
-        const argumentsStr = typeof callMsg.arguments === 'string'
-            ? callMsg.arguments
-            : JSON.stringify(callMsg.arguments ?? {});
-        if (isReplyTellaskCallName(callMsg.name)) {
-            await args.dlg.funcCallRequested(callMsg.id, callMsg.name, argumentsStr);
-        }
-        await args.dlg.persistTellaskSpecialCall(callMsg.id, special.callName, toPersistedSpecialCallArgs(special), callMsg.genseq);
-    }
-    const issueResults = [];
-    for (const issue of classified.parseIssues) {
-        const result = {
-            type: 'func_result_msg',
-            id: issue.call.id,
-            name: issue.call.name,
-            content: `Invalid arguments for tellask special function '${issue.call.name}': ${issue.error}`,
-            role: 'tool',
-            genseq: issue.call.genseq,
-        };
-        await args.dlg.receiveFuncResult(result);
-        issueResults.push(result);
-    }
     throwIfAborted(args.abortSignal, args.dlg);
-    let tellaskExecution;
-    try {
-        tellaskExecution = await (0, tellask_special_1.executeTellaskSpecialCalls)({
-            dlg: args.dlg,
-            calls: classified.specialCalls,
-            callbacks: args.callbacks,
-        });
-    }
-    catch (err) {
-        const errText = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
-        for (const call of classified.specialCalls) {
-            if (issueResults.some((result) => result.id === call.callId)) {
-                continue;
-            }
-            const originalCall = originalCallById.get(call.callId);
-            if (!originalCall) {
-                throw new Error(`kernel-driver tellask special call invariant violation: missing original call for '${call.callId}'`);
-            }
-            await args.dlg.receiveFuncResult({
-                type: 'func_result_msg',
-                id: call.callId,
-                name: call.callName,
-                content: args.abortSignal?.aborted || err instanceof KernelDriverInterruptedError
-                    ? `Special function '${call.callName}' interrupted after call was persisted: ${errText}`
-                    : `Special function '${call.callName}' execution failed after call was persisted: ${errText}`,
-                role: 'tool',
-                genseq: originalCall.genseq,
-            });
-        }
-        throw err;
-    }
-    const tellaskFuncResults = [];
-    const tellaskToolOutputs = [];
-    for (const output of tellaskExecution.toolOutputs) {
-        if (output.type === 'func_result_msg') {
-            await args.dlg.receiveFuncResult(output);
-            tellaskFuncResults.push(output);
-            continue;
-        }
-        tellaskToolOutputs.push(output);
-    }
-    const shouldStopAfterReplyTool = tellaskExecution.successfulReplyCallIds.length > 0;
+    const tellaskRound = await (0, tellask_special_1.processTellaskFunctionRound)({
+        dlg: args.dlg,
+        funcCalls: args.funcCalls,
+        allowedSpecials,
+        callbacks: args.callbacks,
+    });
     throwIfAborted(args.abortSignal, args.dlg);
-    const specialCallIds = new Set(classified.specialCalls.map((call) => call.callId));
     const genericResults = await executeFunctionCalls({
         dlg: args.dlg,
         agent: args.agent,
         agentTools: args.agentTools,
-        funcCalls: classified.normalCalls,
+        funcCalls: tellaskRound.normalCalls,
         abortSignal: args.abortSignal,
     });
     const resultByCallId = new Map();
@@ -981,42 +925,46 @@ async function executeFunctionRound(args) {
         }
         resultByCallId.set(result.id, result);
     };
-    for (const result of issueResults) {
-        register(result);
-    }
-    for (const result of tellaskFuncResults) {
+    for (const result of tellaskRound.tellaskResults) {
         register(result);
     }
     for (const result of genericResults) {
         register(result);
     }
     const pairedMessages = [];
+    const tellaskCallMsgById = new Map(tellaskRound.tellaskCallMessages.map((msg) => [msg.id, msg]));
+    const specialCallIds = new Set(tellaskRound.handledCallIds);
     for (const call of args.funcCalls) {
-        const originalArgsStr = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
-        const preparedArgs = prepareFuncCallArguments(originalArgsStr);
-        pairedMessages.push({
-            type: 'func_call_msg',
-            role: 'assistant',
-            genseq: call.genseq,
-            id: call.id,
-            name: call.name,
-            arguments: preparedArgs.contextArguments,
-        });
+        const tellaskCallMsg = tellaskCallMsgById.get(call.id);
+        if (tellaskCallMsg) {
+            pairedMessages.push(tellaskCallMsg);
+        }
+        else {
+            const originalArgsStr = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
+            pairedMessages.push({
+                type: 'func_call_msg',
+                role: 'assistant',
+                genseq: call.genseq,
+                id: call.id,
+                name: call.name,
+                arguments: originalArgsStr,
+            });
+        }
         const result = resultByCallId.get(call.id);
         if (result) {
             pairedMessages.push(result);
             continue;
         }
         if (specialCallIds.has(call.id)) {
-            continue;
+            throw new Error(`kernel-driver tellask result invariant violation: missing tellask result for call id '${call.id}' (${call.name})`);
         }
         throw new Error(`kernel-driver function result invariant violation: missing result for call id '${call.id}' (${call.name})`);
     }
     return {
-        hadNormalToolCalls: classified.normalCalls.length > 0,
-        shouldStopAfterReplyTool,
+        hadNormalToolCalls: tellaskRound.normalCalls.length > 0,
+        shouldStopAfterReplyTool: tellaskRound.shouldStopAfterReplyTool,
         pairedMessages,
-        tellaskToolOutputs,
+        tellaskToolOutputs: [...tellaskRound.toolOutputs],
     };
 }
 async function resetDiligenceBudgetAfterQ4H(dlg, team) {
@@ -1233,7 +1181,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
             const isSubdialog = dlg.id.rootId !== dlg.id.selfId;
             const fbrEffortDefault = resolveFbrEffortDefaultForTool(agent);
             const effectiveFuncTools = policy.mode === 'default'
-                ? mergeTellaskSpecialVirtualTools(canonicalFuncTools, {
+                ? mergeTellaskVirtualTools(canonicalFuncTools, {
                     includeTellaskBack: isSubdialog,
                     fbrEffortDefault,
                 })
@@ -1330,7 +1278,10 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         skipTaskdocForThisDrive = true;
                     }
                     const persistedUserLanguageCode = currentPrompt.userLanguageCode ?? dlg.getLastUserLanguageCode();
-                    const q4hAnswerCallIds = normalizeQ4HAnswerCallIds(currentPrompt.q4hAnswerCallIds);
+                    const q4hAnswerCallId = normalizeQ4HAnswerCallId(currentPrompt.q4hAnswerCallId);
+                    // `q4hAnswerCallId` marks a continuation input for an already-materialized askHuman
+                    // answer. It is not a second business-level user prompt that should re-enter transcript.
+                    const isQ4HAnswerPrompt = q4hAnswerCallId !== undefined;
                     const promptLanguage = persistedUserLanguageCode === 'zh' || persistedUserLanguageCode === 'en'
                         ? persistedUserLanguageCode
                         : (0, work_language_1.getWorkLanguage)();
@@ -1390,15 +1341,26 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         });
                         currentRuntimeGuideMsg = undefined;
                     }
-                    await dlg.addChatMessages({
-                        type: 'prompting_msg',
-                        role: 'user',
-                        genseq: dlg.activeGenSeq,
-                        msgId: currentPrompt.msgId,
-                        grammar: 'markdown',
-                        content: replyGuidance.promptContent,
-                    });
-                    await dlg.persistUserMessage(replyGuidance.promptContent, currentPrompt.msgId, 'markdown', origin, persistedUserLanguageCode, q4hAnswerCallIds, replyGuidance.persistedTellaskReplyDirective);
+                    if (isQ4HAnswerPrompt) {
+                        // Record only the answered call correlation / user language for the resumed round.
+                        // The actual human answer fact was already persisted via askHuman tellask result flow.
+                        await dlg.receiveHumanReply({
+                            content: replyGuidance.promptContent,
+                            userLanguageCode: persistedUserLanguageCode,
+                            q4hAnswerCallId,
+                        });
+                    }
+                    else {
+                        await dlg.addChatMessages({
+                            type: 'prompting_msg',
+                            role: 'user',
+                            genseq: dlg.activeGenSeq,
+                            msgId: currentPrompt.msgId,
+                            grammar: 'markdown',
+                            content: replyGuidance.promptContent,
+                        });
+                        await dlg.persistUserMessage(replyGuidance.promptContent, currentPrompt.msgId, 'markdown', origin, persistedUserLanguageCode, q4hAnswerCallId, replyGuidance.persistedTellaskReplyDirective);
+                    }
                     if (renderPromptAsRuntimeGuideBubble) {
                         (0, evt_registry_1.postDialogEvent)(dlg, {
                             type: 'runtime_guide_evt',
@@ -1407,10 +1369,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             content: replyGuidance.promptContent,
                         });
                     }
-                    else {
+                    else if (!isQ4HAnswerPrompt) {
                         // Emit the live user-side boundary event for UI generation bubbles.
-                        // Without this, realtime turns can miss user content + divider (<hr/>),
-                        // while replay (from persisted human_text_record) still looks correct.
+                        // Without this, realtime turns can miss user content + divider (<hr/>).
                         (0, evt_registry_1.postDialogEvent)(dlg, {
                             type: 'end_of_user_saying_evt',
                             course: dlg.currentCourse,
@@ -1420,7 +1381,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             grammar: 'markdown',
                             origin,
                             userLanguageCode: persistedUserLanguageCode,
-                            q4hAnswerCallIds,
+                            q4hAnswerCallId,
                         });
                     }
                     if (currentPromptFromFbrState && currentFbrState) {
@@ -1469,7 +1430,27 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                 });
                 const newMsgs = [];
                 const streamedFuncCalls = [];
+                let sawWebSearchSideChannelOutput = false;
+                let sawNativeToolSideChannelOutput = false;
                 const streamOrBatch = async () => {
+                    let batchAttemptCourse;
+                    let batchAttemptCheckpointOffset;
+                    const rollbackBatchAttempt = async () => {
+                        if (batchAttemptCourse === undefined || batchAttemptCheckpointOffset === undefined) {
+                            throw new Error(`kernel-driver batch retry invariant violation: missing checkpoint (dialog=${dlg.id.valueOf()})`);
+                        }
+                        await persistence_1.DialogPersistence.rollbackCourseFileToOffset(dlg.id, batchAttemptCourse, batchAttemptCheckpointOffset, dlg.status);
+                        (0, evt_registry_1.postDialogEvent)(dlg, {
+                            type: 'genseq_discard_evt',
+                            course: batchAttemptCourse,
+                            genseq: dlg.activeGenSeq,
+                            reason: 'retry',
+                        });
+                        sawWebSearchSideChannelOutput = false;
+                        sawNativeToolSideChannelOutput = false;
+                        streamedFuncCalls.length = 0;
+                        newMsgs.length = 0;
+                    };
                     if (agent.streaming === false) {
                         const batch = await (0, runtime_1.runLlmRequestWithRetry)({
                             dlg,
@@ -1482,13 +1463,21 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             retryMaxDelayMs: retryPolicy.maxDelayMs,
                             classifyFailure: llmGen.classifyFailure?.bind(llmGen),
                             canRetry: () => true,
+                            onRetry: rollbackBatchAttempt,
+                            onGiveUp: rollbackBatchAttempt,
                             doRequest: async () => {
+                                batchAttemptCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+                                batchAttemptCheckpointOffset = await persistence_1.DialogPersistence.captureCourseFileOffset(dlg.id, batchAttemptCourse, dlg.status);
+                                sawWebSearchSideChannelOutput = false;
+                                sawNativeToolSideChannelOutput = false;
+                                streamedFuncCalls.length = 0;
+                                newMsgs.length = 0;
                                 const batchResult = await llmGen.genMoreMessages(providerCfg, agent, systemPrompt, funcTools, {
                                     dialogSelfId: dlg.id.selfId,
                                     dialogRootId: dlg.id.rootId,
                                     promptCacheKey: `${dlg.id.selfId}:c${String(dlg.currentCourse)}`,
                                 }, ctxMsgs, dlg.activeGenSeq, abortSignal);
-                                if (!hasMeaningfulBatchOutput(batchResult.messages)) {
+                                if (!hasMeaningfulBatchOutput(batchResult)) {
                                     throw {
                                         status: 503,
                                         code: KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE,
@@ -1502,6 +1491,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             usage: batch.usage,
                             llmGenModel: batch.llmGenModel,
                             batchMessages: batch.messages,
+                            batchOutputs: batch.outputs,
                         };
                     }
                     let currentSayingContent = '';
@@ -1511,7 +1501,6 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     let streamAttemptCheckpointOffset;
                     let streamAttemptSayingContent;
                     let streamAttemptSayingGenseq;
-                    let streamSawWebSearchCall = false;
                     let streamActive = { kind: 'idle' };
                     const rollbackStreamAttempt = async () => {
                         if (streamAttemptCourse === undefined || streamAttemptCheckpointOffset === undefined) {
@@ -1530,7 +1519,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         currentSayingContent = '';
                         streamAttemptSayingContent = undefined;
                         streamAttemptSayingGenseq = undefined;
-                        streamSawWebSearchCall = false;
+                        sawWebSearchSideChannelOutput = false;
+                        sawNativeToolSideChannelOutput = false;
                         streamedFuncCalls.length = 0;
                         newMsgs.length = 0;
                     };
@@ -1626,8 +1616,13 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                         },
                         webSearchCall: async (call) => {
                             throwIfAborted(abortSignal, dlg);
-                            streamSawWebSearchCall = true;
-                            await dlg.webSearchCall(call);
+                            sawWebSearchSideChannelOutput = true;
+                            await dlg.webSearchCall(projectLlmWebSearchCall(call));
+                        },
+                        nativeToolCall: async (call) => {
+                            throwIfAborted(abortSignal, dlg);
+                            sawNativeToolSideChannelOutput = true;
+                            await dlg.nativeToolCall(call);
                         },
                     };
                     const res = await (0, runtime_1.runLlmRequestWithRetry)({
@@ -1652,7 +1647,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             currentSayingContent = '';
                             streamAttemptSayingContent = undefined;
                             streamAttemptSayingGenseq = undefined;
-                            streamSawWebSearchCall = false;
+                            sawWebSearchSideChannelOutput = false;
+                            sawNativeToolSideChannelOutput = false;
                             streamedFuncCalls.length = 0;
                             newMsgs.length = 0;
                             const streamResult = await llmGen.genToReceiver(providerCfg, agent, systemPrompt, funcTools, {
@@ -1666,7 +1662,8 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                             if (!hasThinkingContent &&
                                 !hasSayingContent &&
                                 !hasFunctionCall &&
-                                !streamSawWebSearchCall) {
+                                !sawWebSearchSideChannelOutput &&
+                                !sawNativeToolSideChannelOutput) {
                                 throw {
                                     status: 503,
                                     code: KERNEL_DRIVER_EMPTY_LLM_RESPONSE_ERROR_CODE,
@@ -1694,24 +1691,50 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     usage: llmOutput.usage,
                 });
                 dlg.setLastContextHealth(contextHealthForGen);
-                if (Array.isArray(llmOutput.batchMessages)) {
-                    const assistantMsgs = llmOutput.batchMessages.filter((m) => m.type === 'saying_msg' || m.type === 'thinking_msg');
-                    for (const msg of assistantMsgs) {
-                        newMsgs.push(msg);
-                        if (msg.type === 'thinking_msg') {
-                            await (0, events_1.emitThinkingEvents)(dlg, msg.content, msg.reasoning);
+                const batchOutputs = Array.isArray(llmOutput.batchOutputs) && llmOutput.batchOutputs.length > 0
+                    ? llmOutput.batchOutputs
+                    : Array.isArray(llmOutput.batchMessages)
+                        ? llmOutput.batchMessages.map((message) => ({ kind: 'message', message }))
+                        : [];
+                for (const output of batchOutputs) {
+                    switch (output.kind) {
+                        case 'message': {
+                            const msg = output.message;
+                            if (msg.type === 'thinking_msg' || msg.type === 'saying_msg') {
+                                newMsgs.push(msg);
+                                if (msg.type === 'thinking_msg') {
+                                    await (0, events_1.emitThinkingEvents)(dlg, msg.content, msg.reasoning);
+                                }
+                                else {
+                                    lastAssistantSayingContent = msg.content;
+                                    lastAssistantSayingGenseq = msg.genseq;
+                                    lastAssistantReplyTarget = currentReplyTarget;
+                                    await emitAssistantSaying(dlg, msg.content);
+                                }
+                                break;
+                            }
+                            if (msg.type === 'func_call_msg') {
+                                streamedFuncCalls.push(msg);
+                            }
+                            break;
+                        }
+                        case 'web_search_call': {
+                            sawWebSearchSideChannelOutput = true;
+                            await dlg.webSearchCall(projectLlmWebSearchCall(output.call));
+                            break;
+                        }
+                        case 'native_tool_call': {
+                            sawNativeToolSideChannelOutput = true;
+                            await dlg.nativeToolCall(output.call);
+                            break;
                         }
-                        else if (msg.type === 'saying_msg') {
-                            lastAssistantSayingContent = msg.content;
-                            lastAssistantSayingGenseq = msg.genseq;
-                            lastAssistantReplyTarget = currentReplyTarget;
-                            await emitAssistantSaying(dlg, msg.content);
+                        default: {
+                            const _exhaustive = output;
+                            throw new Error(`Unhandled batch output kind: ${String(_exhaustive)}`);
                         }
                     }
-                    const funcCalls = llmOutput.batchMessages.filter((m) => m.type === 'func_call_msg');
-                    streamedFuncCalls.push(...funcCalls);
                 }
-                const tellaskCallCount = policy.allowTellaskSpecialFunctions
+                const tellaskCallCount = policy.allowTellaskFunctions
                     ? streamedFuncCalls.filter((c) => c.name === 'tellask' ||
                         c.name === 'tellaskSessionless' ||
                         c.name === 'tellaskBack' ||
@@ -1789,7 +1812,7 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     funcCalls: streamedFuncCalls,
                     callbacks,
                     abortSignal,
-                    allowTellaskSpecialFunctions: policy.allowTellaskSpecialFunctions,
+                    allowTellaskFunctions: policy.allowTellaskFunctions,
                 });
                 if (routed.tellaskToolOutputs.length > 0) {
                     newMsgs.push(...routed.tellaskToolOutputs);
@@ -1883,6 +1906,9 @@ async function driveDialogStreamCore(dlg, callbacks, humanPrompt, driveOptions)
                     await resetDiligenceBudgetAfterQ4H(dlg, team);
                     break;
                 }
+                // Continue only when this round produced new context that must be fed back into the next
+                // LLM turn. Provider-native side-channel UI events are meaningful output, but they are not
+                // transcript/context inputs and therefore must not trigger another generation round.
                 const shouldContinue = streamedFuncCalls.length > 0 ||
                     routed.pairedMessages.length > 0 ||
                     routed.tellaskToolOutputs.length > 0;