dominds 0.7.6 → 0.8.2

package/dist/llm/driver-v2/core.js

@@ -11,7 +11,7 @@ const diligence_1 = require("../../shared/diligence");
 const driver_messages_1 = require("../../shared/i18n/driver-messages");
 const runtime_language_1 = require("../../shared/runtime-language");
 const id_1 = require("../../shared/utils/id");
-const tellask_1 = require("../../tellask");
+const time_1 = require("../../shared/utils/time");
 const taskdoc_1 = require("../../utils/taskdoc");
 const client_1 = require("../client");
 const registry_1 = require("../gen/registry");
@@ -116,6 +116,103 @@ function resolveEffectiveOptimalMaxTokens(args) {
         criticalMaxTokensConfigured,
     };
 }
+const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
+    {
+        type: 'func',
+        name: 'tellaskBack',
+        description: 'Ask back to the requester dialog in sideline context.',
+        parameters: {
+            type: 'object',
+            properties: {
+                tellaskContent: { type: 'string' },
+            },
+            required: ['tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('tellaskBack is handled by driver-v2 tellask-special channel');
+        },
+    },
+    {
+        type: 'func',
+        name: 'tellask',
+        description: 'Create or resume a teammate sideline dialog with sessionSlug.',
+        parameters: {
+            type: 'object',
+            properties: {
+                targetAgentId: { type: 'string' },
+                sessionSlug: { type: 'string' },
+                tellaskContent: { type: 'string' },
+            },
+            required: ['targetAgentId', 'sessionSlug', 'tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('tellask is handled by driver-v2 tellask-special channel');
+        },
+    },
+    {
+        type: 'func',
+        name: 'tellaskSessionless',
+        description: 'Create a one-shot teammate sideline dialog.',
+        parameters: {
+            type: 'object',
+            properties: {
+                targetAgentId: { type: 'string' },
+                tellaskContent: { type: 'string' },
+            },
+            required: ['targetAgentId', 'tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('tellaskSessionless is handled by driver-v2 tellask-special channel');
+        },
+    },
+    {
+        type: 'func',
+        name: 'askHuman',
+        description: 'Ask for required clarification/decision from human.',
+        parameters: {
+            type: 'object',
+            properties: {
+                tellaskContent: { type: 'string' },
+            },
+            required: ['tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('askHuman is handled by driver-v2 tellask-special channel');
+        },
+    },
+    {
+        type: 'func',
+        name: 'freshBootsReasoning',
+        description: 'Start an FBR sideline dialog for tool-less fresh-boots reasoning.',
+        parameters: {
+            type: 'object',
+            properties: {
+                tellaskContent: { type: 'string' },
+            },
+            required: ['tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('freshBootsReasoning is handled by driver-v2 tellask-special channel');
+        },
+    },
+];
+function mergeTellaskSpecialVirtualTools(baseTools) {
+    const merged = [...baseTools];
+    const seen = new Set(merged.map((tool) => tool.name));
+    for (const virtualTool of TELLASK_SPECIAL_VIRTUAL_TOOLS) {
+        if (seen.has(virtualTool.name)) {
+            throw new Error(`driver-v2 tool invariant violation: function tool name '${virtualTool.name}' collides with tellask-special virtual tool`);
+        }
+        merged.push(virtualTool);
+        seen.add(virtualTool.name);
+    }
+    return merged;
+}
 function computeContextHealthSnapshot(args) {
     const modelInfo = args.providerCfg.models[args.model];
     const modelContextWindowText = modelInfo && typeof modelInfo.context_window === 'string'
@@ -242,7 +339,7 @@ async function executeFunctionCalls(args) {
             }
             catch (parseErr) {
                 rawArgs = null;
-                log_1.log.warn('driver-v2 failed to parse function arguments as JSON', {
+                log_1.log.warn('driver-v2 failed to parse function arguments as JSON', undefined, {
                     funcName: func.name,
                     arguments: func.arguments,
                     error: parseErr,
@@ -311,6 +408,248 @@ async function executeFunctionCalls(args) {
     });
     return await Promise.all(functionPromises);
 }
+async function executeRoutedFunctionCalls(args) {
+    const { dialog, agent, agentTools, funcCalls, callbacks, abortSignal } = args;
+    if (funcCalls.length === 0) {
+        return { suspendForHuman: false, pairedMessages: [], tellaskToolOutputs: [] };
+    }
+    const classified = (0, tellask_bridge_1.classifyTellaskSpecialFunctionCalls)(funcCalls);
+    const specialCallById = new Map(classified.specialCalls.map((call) => [call.callId, 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 };
+            case 'tellask':
+                return {
+                    targetAgentId: call.targetAgentId,
+                    sessionSlug: call.sessionSlug,
+                    tellaskContent: call.tellaskContent,
+                };
+            case 'tellaskSessionless':
+                return {
+                    targetAgentId: call.targetAgentId,
+                    tellaskContent: call.tellaskContent,
+                };
+        }
+    };
+    for (const callMsg of funcCalls) {
+        const special = specialCallById.get(callMsg.id);
+        if (!special) {
+            continue;
+        }
+        try {
+            await dialog.persistFunctionCall(callMsg.id, callMsg.name, toPersistedSpecialCallArgs(special), callMsg.genseq);
+        }
+        catch (err) {
+            log_1.log.warn('driver-v2 failed to persist special function call', err, {
+                dialogId: dialog.id.valueOf(),
+                callId: callMsg.id,
+                callName: callMsg.name,
+            });
+        }
+    }
+    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 dialog.receiveFuncResult(result);
+        issueResults.push(result);
+    }
+    const specialResult = await (0, tellask_bridge_1.executeTellaskSpecialCalls)({
+        dlg: dialog,
+        agent,
+        calls: classified.specialCalls,
+        callbacks,
+    });
+    const specialCallIds = new Set(classified.specialCalls.map((call) => call.callId));
+    const genericResults = await executeFunctionCalls({
+        dialog,
+        agent,
+        agentTools,
+        funcCalls: classified.normalCalls,
+        abortSignal,
+    });
+    const resultByCallId = new Map();
+    const register = (result) => {
+        const existing = resultByCallId.get(result.id);
+        if (existing) {
+            throw new Error(`driver-v2 function result invariant violation: duplicate call id '${result.id}'`);
+        }
+        resultByCallId.set(result.id, result);
+    };
+    for (const result of issueResults) {
+        register(result);
+    }
+    for (const result of genericResults) {
+        register(result);
+    }
+    const pairedMessages = [];
+    for (const call of funcCalls) {
+        pairedMessages.push(call);
+        const result = resultByCallId.get(call.id);
+        if (result) {
+            pairedMessages.push(result);
+            continue;
+        }
+        if (specialCallIds.has(call.id)) {
+            // Tellask-special calls get func_result via dynamic context projection instead of persisted records.
+            continue;
+        }
+        if (!result) {
+            throw new Error(`driver-v2 function result invariant violation: missing result for call id '${call.id}' (${call.name})`);
+        }
+    }
+    return {
+        suspendForHuman: specialResult.suspend,
+        pairedMessages,
+        tellaskToolOutputs: specialResult.toolOutputs,
+    };
+}
+function parseUnifiedTimestampMs(ts) {
+    const normalized = ts.trim();
+    if (normalized === '') {
+        return null;
+    }
+    const parsed = Date.parse(normalized.replace(' ', 'T'));
+    if (!Number.isFinite(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+function formatElapsedSecondsText(startedAtMs) {
+    const language = (0, runtime_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, runtime_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, runtime_language_1.getWorkLanguage)() === 'zh'
+        ? 'Q4H 已结束等待状态，请参考后续用户消息。'
+        : 'Q4H wait is resolved; refer to subsequent user messages.';
+}
+async function projectTellaskSpecialFuncResultsForContext(args) {
+    const hasSpecialFuncCall = args.dialogMsgsForContext.some((msg) => msg.type === 'func_call_msg' && (0, tellask_bridge_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();
+    for (const pending of pendingSubdialogs) {
+        const callId = pending.callId.trim();
+        if (callId === '') {
+            continue;
+        }
+        pendingSubByCallId.set(callId, { createdAt: pending.createdAt });
+    }
+    const pendingQ4H = await persistence_1.DialogPersistence.loadQuestions4HumanState(args.dialog.id, args.dialog.status);
+    const pendingQ4HByCallId = new Map();
+    for (const question of pendingQ4H) {
+        if (typeof question.callId !== 'string') {
+            continue;
+        }
+        const callId = question.callId.trim();
+        if (callId === '') {
+            continue;
+        }
+        pendingQ4HByCallId.set(callId, { askedAt: question.askedAt });
+    }
+    const settledByCallId = 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);
+            }
+            continue;
+        }
+        if (msg.type === 'func_result_msg' && (0, tellask_bridge_1.isTellaskSpecialFunctionName)(msg.name)) {
+            existingSpecialFuncResults.set(msg.id, msg);
+        }
+    }
+    const projected = [];
+    const specialCallIds = new Set();
+    for (const msg of args.dialogMsgsForContext) {
+        if (msg.type === 'func_result_msg' && specialCallIds.has(msg.id)) {
+            continue;
+        }
+        projected.push(msg);
+        if (msg.type !== 'func_call_msg') {
+            continue;
+        }
+        if (!(0, tellask_bridge_1.isTellaskSpecialFunctionName)(msg.name)) {
+            continue;
+        }
+        specialCallIds.add(msg.id);
+        const settled = settledByCallId.get(msg.id);
+        if (settled !== undefined) {
+            projected.push({
+                type: 'func_result_msg',
+                role: 'tool',
+                genseq: msg.genseq,
+                id: msg.id,
+                name: msg.name,
+                content: settled,
+            });
+            continue;
+        }
+        const existingResult = existingSpecialFuncResults.get(msg.id);
+        if (existingResult) {
+            projected.push(existingResult);
+            continue;
+        }
+        if (msg.name === 'askHuman') {
+            const pendingQ4HState = pendingQ4HByCallId.get(msg.id);
+            const content = pendingQ4HState
+                ? formatPendingSpecialFuncResult(msg.name, parseUnifiedTimestampMs(pendingQ4HState.askedAt))
+                : formatResolvedAskHumanResult();
+            projected.push({
+                type: 'func_result_msg',
+                role: 'tool',
+                genseq: msg.genseq,
+                id: msg.id,
+                name: msg.name,
+                content,
+            });
+            continue;
+        }
+        const pendingSubState = pendingSubByCallId.get(msg.id);
+        projected.push({
+            type: 'func_result_msg',
+            role: 'tool',
+            genseq: msg.genseq,
+            id: msg.id,
+            name: msg.name,
+            content: formatPendingSpecialFuncResult(msg.name, pendingSubState ? parseUnifiedTimestampMs(pendingSubState.createdAt) : null),
+        });
+    }
+    return projected;
+}
 async function resetDiligenceBudgetAfterQ4H(dlg, team) {
     try {
         if (!(await dlg.hasPendingQ4H())) {
@@ -399,6 +738,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
     await (0, dialog_run_state_1.setDialogRunState)(dlg.id, { kind: 'proceeding' });
     let pubRemindersVer = dlg.remindersVer;
     let lastAssistantSayingContent = null;
+    let lastAssistantSayingGenseq = null;
     let internalDrivePromptMsg;
     let genIterNo = 0;
     let pendingPrompt = humanPrompt;
@@ -434,7 +774,10 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                 throw new Error(`LLM generator not found: API type '${providerCfg.apiType}' for provider '${provider}' in agent '${dlg.agentId}'. Please check .minds/llm.yaml configuration.`);
             }
             const canonicalFuncTools = agentTools.filter((t) => t.type === 'func');
-            const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, canonicalFuncTools);
+            const effectiveFuncTools = policy.allowFunctionCalls
+                ? mergeTellaskSpecialVirtualTools(canonicalFuncTools)
+                : canonicalFuncTools;
+            const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, effectiveFuncTools);
             const funcTools = projected.tools;
             if (genIterNo > 1) {
                 const snapshot = dlg.getLastContextHealth();
@@ -446,7 +789,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     criticalCountdownRemaining,
                 });
                 if (healthDecision.kind === 'suspend') {
-                    log_1.log.info('driver-v2 suspend iterative generation due to critical context while waiting for human prompt', undefined, {
+                    log_1.log.debug('driver-v2 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,
@@ -504,7 +847,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     const promptOrigin = currentPrompt.origin ?? 'user';
                     const isDiligencePrompt = promptOrigin === 'diligence_push';
                     if (isDiligencePrompt && (dlg.disableDiligencePush || suppressDiligencePushForDrive)) {
-                        log_1.log.info('driver-v2 skip diligence prompt after disable toggle', undefined, {
+                        log_1.log.debug('driver-v2 skip diligence prompt after disable toggle', undefined, {
                             dialogId: dlg.id.valueOf(),
                             msgId: currentPrompt.msgId,
                         });
@@ -539,28 +882,30 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                             grammar: promptGrammar,
                         });
                         await dlg.persistUserMessage(promptContent, msgId, promptGrammar, persistedUserLanguageCode);
-                    }
-                    if (persistMode !== 'internal' && promptGrammar === 'tellask') {
-                        throwIfAborted(abortSignal, dlg);
-                        const collectedUserCalls = await (0, saying_events_1.emitSayingEvents)(dlg, promptContent);
-                        throwIfAborted(abortSignal, dlg);
-                        const userResult = await (0, tellask_bridge_1.executeTellaskCalls)({
-                            dlg,
-                            agent,
-                            collectedCalls: collectedUserCalls,
-                            callbacks,
-                        });
-                        if (dlg.hasUpNext()) {
-                            return { lastAssistantSayingContent, interrupted: false };
-                        }
-                        if (userResult.toolOutputs.length > 0) {
-                            await dlg.addChatMessages(...userResult.toolOutputs);
-                        }
-                        if (userResult.suspend) {
-                            suspendForHuman = true;
+                        if (currentPrompt.subdialogReplyTarget) {
+                            const normalizedCallId = currentPrompt.subdialogReplyTarget.callId.trim();
+                            if (normalizedCallId === '') {
+                                throw new Error(`driver-v2 assignment anchor invariant violation: empty callId for subdialogReplyTarget (dialog=${dlg.id.valueOf()})`);
+                            }
+                            const rawCourse = dlg.activeGenCourseOrUndefined ?? dlg.currentCourse;
+                            if (!Number.isFinite(rawCourse) || rawCourse <= 0) {
+                                throw new Error(`driver-v2 assignment anchor invariant violation: invalid course=${String(rawCourse)} (dialog=${dlg.id.valueOf()})`);
+                            }
+                            const rawGenseq = dlg.activeGenSeq;
+                            if (!Number.isFinite(rawGenseq) || rawGenseq <= 0) {
+                                throw new Error(`driver-v2 assignment anchor invariant violation: invalid genseq=${String(rawGenseq)} (dialog=${dlg.id.valueOf()})`);
+                            }
+                            const assignmentAnchor = {
+                                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
+                                type: 'teammate_call_anchor_record',
+                                anchorRole: 'assignment',
+                                callId: normalizedCallId,
+                                genseq: Math.floor(rawGenseq),
+                            };
+                            await persistence_1.DialogPersistence.appendEvent(dlg.id, Math.floor(rawCourse), assignmentAnchor);
                         }
                     }
-                    else if (persistMode !== 'internal') {
+                    if (persistMode !== 'internal') {
                         await emitUserMarkdown(dlg, promptContent);
                     }
                     if (persistMode !== 'internal') {
@@ -589,13 +934,17 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     const msgs = dlg.getCoursePrefixMsgs();
                     return msgs.length > 0 ? [...msgs] : [];
                 })();
-                const dialogMsgsForContext = dlg.msgs.filter((m) => {
+                const rawDialogMsgsForContext = dlg.msgs.filter((m) => {
                     if (!m)
                         return false;
                     if (m.type === 'ui_only_markdown_msg')
                         return false;
                     return true;
                 });
+                const dialogMsgsForContext = await projectTellaskSpecialFuncResultsForContext({
+                    dialog: dlg,
+                    dialogMsgsForContext: rawDialogMsgsForContext,
+                });
                 await dlg.processReminderUpdates();
                 const renderedReminders = dlg.reminders.length > 0
                     ? await Promise.all(dlg.reminders.map(async (reminder, index) => {
@@ -657,7 +1006,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     dlg.setLastContextHealth(contextHealthForGen);
                     const nonStreamMsgs = nonStreamResult.messages;
                     const assistantMsgs = nonStreamMsgs.filter((m) => m.type === 'saying_msg' || m.type === 'thinking_msg');
-                    const collectedAssistantCalls = [];
                     if (assistantMsgs.length > 0) {
                         await dlg.addChatMessages(...assistantMsgs);
                         for (const msg of assistantMsgs) {
@@ -666,9 +1014,9 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                                 (msg.type === 'thinking_msg' || msg.type === 'saying_msg')) {
                                 if (msg.type === 'saying_msg') {
                                     lastAssistantSayingContent = msg.content;
+                                    lastAssistantSayingGenseq = msg.genseq;
                                     await dlg.persistAgentMessage(msg.content, msg.genseq, 'saying_msg');
-                                    const calls = await (0, saying_events_1.emitSayingEvents)(dlg, msg.content);
-                                    collectedAssistantCalls.push(...calls);
+                                    await emitUserMarkdown(dlg, msg.content);
                                 }
                                 if (msg.type === 'thinking_msg') {
                                     await (0, saying_events_1.emitThinkingEvents)(dlg, msg.content);
@@ -676,48 +1024,10 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                             }
                         }
                     }
-                    const policyViolation = (0, policy_1.resolveDriverV2PolicyViolationKind)({
-                        policy,
-                        tellaskCalls: collectedAssistantCalls,
-                        functionCallCount: 0,
-                    });
-                    if (policyViolation === 'tellask') {
-                        const violationText = (0, driver_messages_1.formatDomindsNoteFbrToollessViolation)((0, runtime_language_1.getWorkLanguage)(), {
-                            kind: 'tellask',
-                        });
-                        const genseq = dlg.activeGenSeq ?? 0;
-                        await dlg.addChatMessages({
-                            type: 'saying_msg',
-                            role: 'assistant',
-                            genseq,
-                            content: violationText,
-                        });
-                        lastAssistantSayingContent = violationText;
-                        await dlg.persistAgentMessage(violationText, genseq, 'saying_msg');
-                        return { lastAssistantSayingContent, interrupted: false };
-                    }
-                    if (collectedAssistantCalls.length > 0) {
-                        throwIfAborted(abortSignal, dlg);
-                        const assistantResult = await (0, tellask_bridge_1.executeTellaskCalls)({
-                            dlg,
-                            agent,
-                            collectedCalls: collectedAssistantCalls,
-                            callbacks,
-                        });
-                        if (dlg.hasUpNext()) {
-                            return { lastAssistantSayingContent, interrupted: false };
-                        }
-                        if (assistantResult.toolOutputs.length > 0) {
-                            await dlg.addChatMessages(...assistantResult.toolOutputs);
-                        }
-                        if (assistantResult.suspend) {
-                            suspendForHuman = true;
-                        }
-                    }
                     const funcCalls = nonStreamMsgs.filter((m) => m.type === 'func_call_msg');
                     const toolPolicyViolation = (0, policy_1.resolveDriverV2PolicyViolationKind)({
                         policy,
-                        tellaskCalls: [],
+                        tellaskCallCount: 0,
                         functionCallCount: funcCalls.length,
                     });
                     if (toolPolicyViolation === 'tool') {
@@ -732,23 +1042,26 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                             content: violationText,
                         });
                         lastAssistantSayingContent = violationText;
+                        lastAssistantSayingGenseq = genseq;
                         await dlg.persistAgentMessage(violationText, genseq, 'saying_msg');
-                        return { lastAssistantSayingContent, interrupted: false };
+                        return { lastAssistantSayingContent, lastAssistantSayingGenseq, interrupted: false };
                     }
-                    const funcResults = await executeFunctionCalls({
+                    const routedFunctionResult = await executeRoutedFunctionCalls({
                         dialog: dlg,
                         agent,
                         agentTools,
                         funcCalls,
+                        callbacks,
                         abortSignal,
                     });
-                    if (funcCalls.length > 0) {
-                        const paired = [];
-                        for (let i = 0; i < funcCalls.length; i++) {
-                            paired.push(funcCalls[i]);
-                            paired.push(funcResults[i]);
-                        }
-                        await dlg.addChatMessages(...paired);
+                    if (routedFunctionResult.tellaskToolOutputs.length > 0) {
+                        await dlg.addChatMessages(...routedFunctionResult.tellaskToolOutputs);
+                    }
+                    if (routedFunctionResult.pairedMessages.length > 0) {
+                        await dlg.addChatMessages(...routedFunctionResult.pairedMessages);
+                    }
+                    if (routedFunctionResult.suspendForHuman) {
+                        suspendForHuman = true;
                     }
                     if (dlg.hasUpNext()) {
                         pendingPrompt = resolveUpNextPrompt(dlg);
@@ -758,7 +1071,9 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         await resetDiligenceBudgetAfterQ4H(dlg, team);
                         break;
                     }
-                    const shouldContinue = funcCalls.length > 0 || (funcResults.length > 0 && funcCalls.length === 0);
+                    const shouldContinue = funcCalls.length > 0 ||
+                        routedFunctionResult.pairedMessages.length > 0 ||
+                        routedFunctionResult.tellaskToolOutputs.length > 0;
                     if (!shouldContinue) {
                         const next = await maybeContinueWithDiligencePrompt({
                             dlg,
@@ -779,7 +1094,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                 let currentThinkingSignature = '';
                 let currentSayingContent = '';
                 let sawAnyStreamContent = false;
-                const parser = new tellask_1.TellaskStreamParser((0, saying_events_1.createSayingEventsReceiver)(dlg));
                 let streamActive = { kind: 'idle' };
                 const streamResult = await (0, runtime_utils_1.runLlmRequestWithRetry)({
                     dlg,
@@ -854,7 +1168,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                                 throwIfAborted(abortSignal, dlg);
                                 sawAnyStreamContent = true;
                                 currentSayingContent += chunk;
-                                await parser.takeUpstreamChunk(chunk);
                                 await dlg.sayingChunk(chunk);
                             },
                             sayingFinish: async () => {
@@ -865,7 +1178,6 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                                     throw new Error(detail);
                                 }
                                 streamActive = { kind: 'idle' };
-                                await parser.finalize();
                                 const sayingMessage = {
                                     type: 'saying_msg',
                                     role: 'assistant',
@@ -874,6 +1186,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                                 };
                                 newMsgs.push(sayingMessage);
                                 lastAssistantSayingContent = currentSayingContent;
+                                lastAssistantSayingGenseq = sayingMessage.genseq;
                                 await dlg.sayingFinish();
                             },
                             funcCall: async (callId, name, args) => {
@@ -910,10 +1223,9 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     usage: streamResult.usage,
                 });
                 dlg.setLastContextHealth(contextHealthForGen);
-                const collectedCalls = parser.getCollectedCalls();
                 const policyViolation = (0, policy_1.resolveDriverV2PolicyViolationKind)({
                     policy,
-                    tellaskCalls: collectedCalls,
+                    tellaskCallCount: 0,
                     functionCallCount: streamedFuncCalls.length,
                 });
                 if (policyViolation) {
@@ -928,39 +1240,27 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         content: violationText,
                     });
                     lastAssistantSayingContent = violationText;
+                    lastAssistantSayingGenseq = genseq;
                     await dlg.addChatMessages(...newMsgs);
                     await dlg.persistAgentMessage(violationText, genseq, 'saying_msg');
-                    return { lastAssistantSayingContent, interrupted: false };
-                }
-                const assistantResult = await (0, tellask_bridge_1.executeTellaskCalls)({
-                    dlg,
-                    agent,
-                    collectedCalls,
-                    callbacks,
-                });
-                if (dlg.hasUpNext()) {
-                    return { lastAssistantSayingContent, interrupted: false };
-                }
-                if (assistantResult.toolOutputs.length > 0) {
-                    newMsgs.push(...assistantResult.toolOutputs);
-                }
-                if (assistantResult.suspend) {
-                    suspendForHuman = true;
+                    return { lastAssistantSayingContent, lastAssistantSayingGenseq, interrupted: false };
                 }
-                const funcResults = await executeFunctionCalls({
+                const routedFunctionResult = await executeRoutedFunctionCalls({
                     dialog: dlg,
                     agent,
                     agentTools,
                     funcCalls: streamedFuncCalls,
+                    callbacks,
                     abortSignal,
                 });
-                if (streamedFuncCalls.length > 0) {
-                    for (let i = 0; i < streamedFuncCalls.length; i++) {
-                        newMsgs.push(streamedFuncCalls[i]);
-                        if (i < funcResults.length) {
-                            newMsgs.push(funcResults[i]);
-                        }
-                    }
+                if (routedFunctionResult.tellaskToolOutputs.length > 0) {
+                    newMsgs.push(...routedFunctionResult.tellaskToolOutputs);
+                }
+                if (routedFunctionResult.pairedMessages.length > 0) {
+                    newMsgs.push(...routedFunctionResult.pairedMessages);
+                }
+                if (routedFunctionResult.suspendForHuman) {
+                    suspendForHuman = true;
                 }
                 await dlg.addChatMessages(...newMsgs);
                 if (dlg.hasUpNext()) {
@@ -980,7 +1280,9 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     await resetDiligenceBudgetAfterQ4H(dlg, team);
                     break;
                 }
-                const shouldContinue = streamedFuncCalls.length > 0 || funcResults.length > 0;
+                const shouldContinue = streamedFuncCalls.length > 0 ||
+                    routedFunctionResult.pairedMessages.length > 0 ||
+                    routedFunctionResult.tellaskToolOutputs.length > 0;
                 if (!shouldContinue) {
                     const next = await maybeContinueWithDiligencePrompt({
                         dlg,
@@ -999,7 +1301,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
             }
         }
         finalRunState = await (0, dialog_run_state_1.computeIdleRunState)(dlg);
-        return { lastAssistantSayingContent, interrupted: false };
+        return { lastAssistantSayingContent, lastAssistantSayingGenseq, interrupted: false };
     }
     catch (err) {
         const stopRequested = (0, dialog_run_state_1.getStopRequestedReason)(dlg.id);
@@ -1015,7 +1317,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
         if (interruptedReason) {
             finalRunState = { kind: 'interrupted', reason: interruptedReason };
             (0, dialog_run_state_1.broadcastRunStateMarker)(dlg.id, { kind: 'interrupted', reason: interruptedReason });
-            return { lastAssistantSayingContent, interrupted: true };
+            return { lastAssistantSayingContent, lastAssistantSayingGenseq, interrupted: true };
         }
         const errText = (0, log_1.extractErrorDetails)(err).message;
         try {
@@ -1029,7 +1331,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
             kind: 'interrupted',
             reason: { kind: 'system_stop', detail: errText },
         });
-        return { lastAssistantSayingContent, interrupted: true };
+        return { lastAssistantSayingContent, lastAssistantSayingGenseq, interrupted: true };
     }
     finally {
         (0, dialog_run_state_1.clearActiveRun)(dlg.id);