dominds 1.13.2 → 1.15.2

package/dist/llm/kernel-driver/tellask-special.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTellaskSpecialFunctionName = isTellaskSpecialFunctionName;
+exports.isTellaskCallFunctionName = isTellaskCallFunctionName;
 exports.loadLatestActiveTellaskReplyDirective = loadLatestActiveTellaskReplyDirective;
 exports.deliverTellaskBackReplyFromDirective = deliverTellaskBackReplyFromDirective;
 exports.recoverPendingReplyTellaskCalls = recoverPendingReplyTellaskCalls;
-exports.classifyTellaskSpecialFunctionCalls = classifyTellaskSpecialFunctionCalls;
-exports.executeTellaskSpecialCalls = executeTellaskSpecialCalls;
+exports.resolveTellaskFunctionCalls = resolveTellaskFunctionCalls;
+exports.formatTellaskInvalidCallResult = formatTellaskInvalidCallResult;
+exports.formatPendingTellaskFuncResultContent = formatPendingTellaskFuncResultContent;
+exports.formatResolvedAskHumanResultContent = formatResolvedAskHumanResultContent;
+exports.executeTellaskCalls = executeTellaskCalls;
+exports.processTellaskFunctionRound = processTellaskFunctionRound;
 const util_1 = require("util");
 const storage_1 = require("@longrun-ai/kernel/types/storage");
 const id_1 = require("@longrun-ai/kernel/utils/id");
@@ -33,7 +37,8 @@ const TELLASK_SPECIAL_FUNCTION_NAMES = [
     'askHuman',
     'freshBootsReasoning',
 ];
-function isTellaskSpecialFunctionName(name) {
+const MULTIPLE_ASKHUMAN_CALLS_ERROR = '不允许一轮多次调用 askHuman，必须单次调用问所有问题。 Do not call askHuman multiple times in one round; ask all questions in a single askHuman call.';
+function isTellaskCallFunctionName(name) {
     return TELLASK_SPECIAL_FUNCTION_NAMES.includes(name);
 }
 function isReplyTellaskCallName(name) {
@@ -156,17 +161,39 @@ async function deliverTellaskBackReplyFromDirective(args) {
         deliveryMode: args.deliveryMode,
         language: (0, work_language_1.getWorkLanguage)(),
     });
-    await targetDialog.receiveTellaskResponse(args.dlg.agentId, 'tellaskBack', undefined, args.directive.tellaskContent, 'completed', args.dlg.id, {
+    const replyMirror = await targetDialog.receiveTellaskResponse(args.dlg.agentId, 'tellaskBack', undefined, args.directive.tellaskContent, 'completed', args.dlg.id, {
         response,
         agentId: args.dlg.agentId,
         callId: args.directive.targetCallId,
         originMemberId: targetDialog.agentId,
     });
+    await targetDialog.addChatMessages(replyMirror);
     await reviveDialogIfUnblocked(targetDialog, args.callbacks, 'reply_tellask_back_delivered');
 }
-function isReplyTellaskSpecialCallRecord(record) {
+function isReplyTellaskCallRecord(record) {
     return isReplyTellaskCallName(record.name);
 }
+function parseReplyTellaskCallRecord(record) {
+    const parsed = parseTellaskCall({
+        type: 'func_call_msg',
+        role: 'assistant',
+        genseq: record.genseq,
+        id: record.id,
+        name: record.name,
+        arguments: record.rawArgumentsText,
+    });
+    if (!parsed.ok) {
+        throw new Error(`reply recovery invariant violation: invalid persisted raw arguments for ${record.name} (callId=${record.id})`);
+    }
+    switch (parsed.value.callName) {
+        case 'replyTellask':
+        case 'replyTellaskSessionless':
+        case 'replyTellaskBack':
+            return parsed.value;
+        default:
+            throw new Error(`reply recovery invariant violation: unexpected persisted call type ${parsed.value.callName} (callId=${record.id})`);
+    }
+}
 function formatReplyRecoveryFailureResult(args) {
     return (0, work_language_1.getWorkLanguage)() === 'zh'
         ? `恢复重试 \`${args.callName}\` 失败：${args.errorText}`
@@ -181,8 +208,8 @@ async function recoverPendingReplyTellaskCalls(args) {
     const resolvedReplyCallIds = new Set();
     const replyCalls = [];
     for (const event of events) {
-        if (event.type === 'func_result_record') {
-            const callId = event.id.trim();
+        if (event.type === 'func_result_record' || event.type === 'tellask_result_record') {
+            const callId = event.type === 'func_result_record' ? event.id.trim() : event.callId.trim();
             if (callId !== '') {
                 funcResultIds.add(callId);
             }
@@ -195,10 +222,10 @@ async function recoverPendingReplyTellaskCalls(args) {
             }
             continue;
         }
-        if (event.type !== 'tellask_special_call_record') {
+        if (event.type !== 'tellask_call_record') {
             continue;
         }
-        if (!isReplyTellaskSpecialCallRecord(event)) {
+        if (!isReplyTellaskCallRecord(event)) {
             continue;
         }
         replyCalls.push(event);
@@ -209,6 +236,7 @@ async function recoverPendingReplyTellaskCalls(args) {
         if (callId === '' || funcResultIds.has(callId)) {
             continue;
         }
+        const parsedCall = parseReplyTellaskCallRecord(call);
         if (resolvedReplyCallIds.has(callId)) {
             await args.dlg.receiveFuncResult({
                 type: 'func_result_msg',
@@ -218,7 +246,7 @@ async function recoverPendingReplyTellaskCalls(args) {
                 name: call.name,
                 content: formatReplyFuncResult({
                     replyCallName: call.name,
-                    replyContent: call.replyContent,
+                    replyContent: parsedCall.replyContent,
                 }),
             });
             funcResultIds.add(callId);
@@ -228,11 +256,7 @@ async function recoverPendingReplyTellaskCalls(args) {
         try {
             const execution = await executeReplyTellaskCall({
                 dlg: args.dlg,
-                call: {
-                    callId: call.id,
-                    callName: call.name,
-                    replyContent: call.replyContent,
-                },
+                call: parsedCall,
                 callbacks: args.callbacks,
             });
             for (const message of execution.messages) {
@@ -240,8 +264,13 @@ async function recoverPendingReplyTellaskCalls(args) {
                     throw new Error(`reply recovery invariant violation: unexpected message type ${message.type}`);
                 }
                 await args.dlg.receiveFuncResult({
-                    ...message,
+                    type: 'func_result_msg',
+                    role: 'tool',
                     genseq: call.genseq,
+                    id: message.id,
+                    name: message.name,
+                    content: message.content,
+                    contentItems: message.contentItems,
                 });
             }
             funcResultIds.add(callId);
@@ -353,8 +382,8 @@ function normalizeTeammateTargetAgentId(rawTarget) {
     }
     return { ok: true, value: withoutAt };
 }
-function parseTellaskSpecialCall(call) {
-    if (!isTellaskSpecialFunctionName(call.name)) {
+function parseTellaskCall(call) {
+    if (!isTellaskCallFunctionName(call.name)) {
         return { ok: false, error: `unsupported tellask special function '${call.name}'` };
     }
     const argsResult = parseFuncCallArgsObject(call);
@@ -487,13 +516,16 @@ function parseTellaskSpecialCall(call) {
         }
     }
 }
-function classifyTellaskSpecialFunctionCalls(funcCalls, options) {
-    const specialCalls = [];
+function getRawArgumentsText(call) {
+    return typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
+}
+function resolveTellaskFunctionCalls(funcCalls, options) {
+    const validCalls = [];
+    const invalidCalls = [];
     const normalCalls = [];
-    const parseIssues = [];
     const allowed = options?.allowedSpecials ?? null;
     for (const call of funcCalls) {
-        if (!isTellaskSpecialFunctionName(call.name)) {
+        if (!isTellaskCallFunctionName(call.name)) {
             normalCalls.push(call);
             continue;
         }
@@ -501,14 +533,147 @@ function classifyTellaskSpecialFunctionCalls(funcCalls, options) {
             normalCalls.push(call);
             continue;
         }
-        const parsed = parseTellaskSpecialCall(call);
+        const rawArgumentsText = getRawArgumentsText(call);
+        const parsed = parseTellaskCall(call);
         if (!parsed.ok) {
-            parseIssues.push({ call, error: parsed.error });
+            invalidCalls.push({
+                originalCall: call,
+                error: parsed.error,
+                rawArgumentsText,
+                contextArguments: rawArgumentsText,
+            });
             continue;
         }
-        specialCalls.push(parsed.value);
+        validCalls.push({
+            originalCall: call,
+            call: parsed.value,
+        });
+    }
+    return { validCalls, invalidCalls, normalCalls };
+}
+function formatTellaskInvalidCallResult(args) {
+    return {
+        type: 'func_result_msg',
+        id: args.call.id,
+        name: args.call.name,
+        content: args.call.name === 'askHuman' && args.error === MULTIPLE_ASKHUMAN_CALLS_ERROR
+            ? args.error
+            : `Invalid arguments for tellask special function '${args.call.name}': ${args.error}`,
+        role: 'tool',
+        genseq: args.call.genseq,
+    };
+}
+function formatPendingTellaskFuncResultContent(name, startedAtMs) {
+    const language = (0, work_language_1.getWorkLanguage)();
+    const elapsed = (() => {
+        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`;
+    })();
+    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 formatResolvedAskHumanResultContent() {
+    return (0, work_language_1.getWorkLanguage)() === 'zh'
+        ? 'Q4H 已结束等待状态，请参考 askHuman 结果气泡。'
+        : 'Q4H wait is resolved; refer to the askHuman result bubble.';
+}
+function buildPendingTellaskFuncResult(args) {
+    return {
+        type: 'func_result_msg',
+        role: 'tool',
+        genseq: args.genseq,
+        id: args.callId,
+        name: args.callName,
+        content: formatPendingTellaskFuncResultContent(args.callName, null),
+    };
+}
+async function persistTellaskFuncResult(dlg, result) {
+    if (!isTellaskCallFunctionName(result.name)) {
+        throw new Error(`persistTellaskFuncResult invariant violation: ${result.name} is not tellask special`);
     }
-    return { specialCalls, normalCalls, parseIssues };
+    await dlg.receiveFuncResult(result);
+}
+function buildTellaskResultToolOutput(args) {
+    return {
+        type: 'tellask_result_msg',
+        role: 'tool',
+        genseq: args.genseq,
+        callId: args.callId,
+        callName: args.callName,
+        status: args.status,
+        content: args.content,
+        call: args.callName === 'tellask'
+            ? {
+                tellaskContent: args.tellaskContent,
+                mentionList: args.mentionList ?? [],
+                ...(args.sessionSlug ? { sessionSlug: args.sessionSlug } : {}),
+            }
+            : args.callName === 'tellaskSessionless'
+                ? {
+                    tellaskContent: args.tellaskContent,
+                    mentionList: args.mentionList ?? [],
+                }
+                : {
+                    tellaskContent: args.tellaskContent,
+                },
+        responder: {
+            responderId: args.responderId,
+            ...(args.agentId ? { agentId: args.agentId } : {}),
+            ...(args.originMemberId ? { originMemberId: args.originMemberId } : {}),
+        },
+        ...(args.calleeDialogId !== undefined ||
+            args.calleeCourse !== undefined ||
+            args.calleeGenseq !== undefined
+            ? {
+                route: {
+                    ...(args.calleeDialogId ? { calleeDialogId: args.calleeDialogId } : {}),
+                    ...(typeof args.calleeCourse === 'number' ? { calleeCourse: args.calleeCourse } : {}),
+                    ...(typeof args.calleeGenseq === 'number' ? { calleeGenseq: args.calleeGenseq } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function buildTellaskCarryoverToolOutput(args) {
+    return {
+        type: 'tellask_carryover_msg',
+        role: 'user',
+        genseq: args.genseq,
+        content: args.content,
+        originCourse: args.originCourse,
+        carryoverCourse: args.carryoverCourse,
+        responderId: args.responderId,
+        callName: args.callName,
+        tellaskContent: args.tellaskContent,
+        status: args.status,
+        response: args.response,
+        agentId: args.agentId,
+        callId: args.callId,
+        originMemberId: args.originMemberId,
+        ...(args.callName === 'tellask'
+            ? {
+                mentionList: args.mentionList ?? [],
+                sessionSlug: args.sessionSlug ?? '',
+            }
+            : args.callName === 'tellaskSessionless'
+                ? {
+                    mentionList: args.mentionList ?? [],
+                }
+                : {}),
+        ...(args.calleeDialogId ? { calleeDialogId: args.calleeDialogId } : {}),
+        ...(typeof args.calleeCourse === 'number' ? { calleeCourse: args.calleeCourse } : {}),
+        ...(typeof args.calleeGenseq === 'number' ? { calleeGenseq: args.calleeGenseq } : {}),
+    };
 }
 function showErrorToAi(err) {
     try {
@@ -644,27 +809,37 @@ async function finishRegisteredTellaskReplacement(args) {
         sessionSlug: pendingRecord.sessionSlug,
     });
     const immediateMirror = carryoverContent !== undefined
-        ? {
-            type: 'tellask_carryover_result_msg',
-            role: 'user',
+        ? buildTellaskCarryoverToolOutput({
+            genseq: ownerDialog.activeGenSeqOrUndefined ?? 1,
             content: carryoverContent,
             originCourse: carryoverOriginCourse,
+            carryoverCourse: ownerDialog.currentCourse,
             responderId: subdialog.agentId,
             callName: pendingRecord.callName,
             tellaskContent: pendingRecord.tellaskContent,
             status: 'failed',
+            response,
+            agentId: subdialog.agentId,
             callId: pendingRecord.callId,
-        }
-        : {
-            type: 'tellask_result_msg',
-            role: 'tool',
-            responderId: subdialog.agentId,
+            originMemberId: requesterId,
             mentionList: pendingRecord.mentionList,
-            tellaskContent: pendingRecord.tellaskContent,
-            status: 'failed',
+            sessionSlug: pendingRecord.sessionSlug,
+            calleeDialogId: subdialog.id.selfId,
+        })
+        : buildTellaskResultToolOutput({
+            genseq: ownerDialog.activeGenSeqOrUndefined ?? 1,
             callId: pendingRecord.callId,
+            callName: pendingRecord.callName,
             content: response,
-        };
+            status: 'failed',
+            responderId: subdialog.agentId,
+            tellaskContent: pendingRecord.tellaskContent,
+            mentionList: pendingRecord.mentionList,
+            sessionSlug: pendingRecord.sessionSlug,
+            agentId: subdialog.agentId,
+            originMemberId: requesterId,
+            calleeDialogId: subdialog.id.selfId,
+        });
     await ownerDialog.addChatMessages(immediateMirror);
 }
 async function reviveDialogIfUnblocked(dialog, callbacks, reason) {
@@ -733,15 +908,11 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 throw new Error(`Q4H call invariant violation: empty callId (rootId=${dlg.id.rootId} selfId=${dlg.id.selfId})`);
             }
             const questionId = `q4h-${dlg.id.rootId}-${dlg.id.selfId}-c${dlg.currentCourse}-${normalizedCallId}`;
-            const normalizedRemainingCallIds = Array.from(new Set((options?.q4hRemainingCallIds ?? [])
-                .map((value) => value.trim())
-                .filter((value) => value !== '' && value !== normalizedCallId)));
             const question = {
                 id: questionId,
                 tellaskContent: body.trim(),
                 askedAt: (0, time_1.formatUnifiedTimestamp)(new Date()),
                 callId: normalizedCallId,
-                remainingCallIds: normalizedRemainingCallIds.length > 0 ? normalizedRemainingCallIds : undefined,
                 callSiteRef: {
                     course: dlg.currentCourse,
                     messageIndex: dlg.msgs.length,
@@ -756,7 +927,6 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     tellaskContent: question.tellaskContent,
                     askedAt: question.askedAt,
                     callId: question.callId,
-                    remainingCallIds: question.remainingCallIds,
                     callSiteRef: question.callSiteRef,
                     rootId: dlg.id.rootId,
                     agentId: dlg.agentId,
@@ -783,16 +953,18 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
             });
             const msg = (0, driver_messages_1.formatDomindsNoteQ4HRegisterFailed)((0, work_language_1.getWorkLanguage)(), { error: errMsg });
             toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-            toolOutputs.push({
-                type: 'tellask_result_msg',
-                role: 'tool',
-                responderId: 'dominds',
-                mentionList: normalizedMentionList,
-                tellaskContent: body,
-                status: 'failed',
+            toolOutputs.push(buildTellaskResultToolOutput({
+                genseq: dlg.activeGenSeqOrUndefined ?? 1,
                 callId,
+                callName,
                 content: msg,
-            });
+                status: 'failed',
+                responderId: 'dominds',
+                tellaskContent: body,
+                mentionList: normalizedMentionList,
+                agentId: 'dominds',
+                originMemberId: dlg.agentId,
+            }));
             await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
             dlg.clearCurrentCallId();
             return toolOutputs;
@@ -813,16 +985,18 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                 firstMention: firstMentionForError,
             });
             toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-            toolOutputs.push({
-                type: 'tellask_result_msg',
-                role: 'tool',
-                responderId: 'dominds',
-                mentionList: normalizedMentionList,
-                tellaskContent: body,
-                status: 'failed',
+            toolOutputs.push(buildTellaskResultToolOutput({
+                genseq: dlg.activeGenSeqOrUndefined ?? 1,
                 callId,
+                callName,
                 content: msg,
-            });
+                status: 'failed',
+                responderId: 'dominds',
+                tellaskContent: body,
+                mentionList: normalizedMentionList,
+                agentId: 'dominds',
+                originMemberId: dlg.agentId,
+            }));
             await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
             dlg.clearCurrentCallId();
             return toolOutputs;
@@ -832,16 +1006,18 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
             if (memberFbrEffort < 1) {
                 const msg = (0, driver_messages_1.formatDomindsNoteFbrDisabled)((0, work_language_1.getWorkLanguage)());
                 toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-                toolOutputs.push({
-                    type: 'tellask_result_msg',
-                    role: 'tool',
-                    responderId: 'dominds',
-                    mentionList: normalizedMentionList,
-                    tellaskContent: body,
-                    status: 'failed',
+                toolOutputs.push(buildTellaskResultToolOutput({
+                    genseq: dlg.activeGenSeqOrUndefined ?? 1,
                     callId,
+                    callName,
                     content: msg,
-                });
+                    status: 'failed',
+                    responderId: 'dominds',
+                    tellaskContent: body,
+                    mentionList: normalizedMentionList,
+                    agentId: 'dominds',
+                    originMemberId: dlg.agentId,
+                }));
                 await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
                 dlg.clearCurrentCallId();
                 return toolOutputs;
@@ -858,16 +1034,18 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
             if (fbrEffort < 1) {
                 const msg = (0, driver_messages_1.formatDomindsNoteFbrDisabled)((0, work_language_1.getWorkLanguage)());
                 toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-                toolOutputs.push({
-                    type: 'tellask_result_msg',
-                    role: 'tool',
-                    responderId: 'dominds',
-                    mentionList: normalizedMentionList,
-                    tellaskContent: body,
-                    status: 'failed',
+                toolOutputs.push(buildTellaskResultToolOutput({
+                    genseq: dlg.activeGenSeqOrUndefined ?? 1,
                     callId,
+                    callName,
                     content: msg,
-                });
+                    status: 'failed',
+                    responderId: 'dominds',
+                    tellaskContent: body,
+                    mentionList: normalizedMentionList,
+                    agentId: 'dominds',
+                    originMemberId: dlg.agentId,
+                }));
                 await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
                 dlg.clearCurrentCallId();
                 return toolOutputs;
@@ -880,16 +1058,18 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                     kind: 'internal_error',
                 });
                 toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-                toolOutputs.push({
-                    type: 'tellask_result_msg',
-                    role: 'tool',
-                    responderId: 'dominds',
-                    mentionList: normalizedMentionList,
-                    tellaskContent: body,
-                    status: 'failed',
+                toolOutputs.push(buildTellaskResultToolOutput({
+                    genseq: dlg.activeGenSeqOrUndefined ?? 1,
                     callId,
+                    callName,
                     content: msg,
-                });
+                    status: 'failed',
+                    responderId: 'dominds',
+                    tellaskContent: body,
+                    mentionList: normalizedMentionList,
+                    agentId: 'dominds',
+                    originMemberId: dlg.agentId,
+                }));
                 await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
                 dlg.clearCurrentCallId();
                 return toolOutputs;
@@ -960,16 +1140,18 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
         if (isDirectSelfCall) {
             const msg = (0, driver_messages_1.formatDomindsNoteDirectSelfCall)((0, work_language_1.getWorkLanguage)());
             toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-            toolOutputs.push({
-                type: 'tellask_result_msg',
-                role: 'tool',
-                responderId: 'dominds',
-                mentionList: normalizedMentionList,
-                tellaskContent: body,
-                status: 'failed',
+            toolOutputs.push(buildTellaskResultToolOutput({
+                genseq: dlg.activeGenSeqOrUndefined ?? 1,
                 callId,
+                callName,
                 content: msg,
-            });
+                status: 'failed',
+                responderId: 'dominds',
+                tellaskContent: body,
+                mentionList: normalizedMentionList,
+                agentId: 'dominds',
+                originMemberId: dlg.agentId,
+            }));
             await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
             dlg.clearCurrentCallId();
             return toolOutputs;
@@ -1025,16 +1207,19 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         language: (0, work_language_1.getWorkLanguage)(),
                     });
                     dlg.setSuspensionState('resumed');
-                    toolOutputs.push({
-                        type: 'tellask_result_msg',
-                        role: 'tool',
-                        responderId: parseResult.agentId,
-                        mentionList,
-                        tellaskContent: body,
-                        status: 'completed',
+                    toolOutputs.push(buildTellaskResultToolOutput({
+                        genseq: dlg.activeGenSeqOrUndefined ?? 1,
                         callId,
+                        callName,
                         content: responseContent,
-                    });
+                        status: 'completed',
+                        responderId: parseResult.agentId,
+                        tellaskContent: body,
+                        mentionList,
+                        agentId: parseResult.agentId,
+                        originMemberId: dlg.agentId,
+                        calleeDialogId: supdialog.id.selfId,
+                    }));
                     await dlg.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'completed', supdialog.id, {
                         response: responseContent,
                         agentId: parseResult.agentId,
@@ -1056,16 +1241,19 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                         status: 'failed',
                         language: (0, work_language_1.getWorkLanguage)(),
                     });
-                    toolOutputs.push({
-                        type: 'tellask_result_msg',
-                        role: 'tool',
-                        responderId: parseResult.agentId,
-                        mentionList,
-                        tellaskContent: body,
-                        status: 'failed',
+                    toolOutputs.push(buildTellaskResultToolOutput({
+                        genseq: dlg.activeGenSeqOrUndefined ?? 1,
                         callId,
+                        callName,
                         content: errorContent,
-                    });
+                        status: 'failed',
+                        responderId: parseResult.agentId,
+                        tellaskContent: body,
+                        mentionList,
+                        agentId: parseResult.agentId,
+                        originMemberId: dlg.agentId,
+                        calleeDialogId: supdialog.id.selfId,
+                    }));
                     await dlg.receiveTellaskResponse(parseResult.agentId, callName, mentionList, body, 'failed', supdialog.id, {
                         response: errorContent,
                         agentId: parseResult.agentId,
@@ -1320,7 +1508,7 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
                             msgId: resumePrompt.msgId,
                             grammar: resumePrompt.grammar,
                             userLanguageCode: resumePrompt.userLanguageCode,
-                            q4hAnswerCallIds: resumePrompt.q4hAnswerCallIds,
+                            q4hAnswerCallId: resumePrompt.q4hAnswerCallId,
                             tellaskReplyDirective: resumePrompt.tellaskReplyDirective,
                             skipTaskdoc: resumePrompt.skipTaskdoc,
                             subdialogReplyTarget: resumePrompt.subdialogReplyTarget,
@@ -1464,22 +1652,24 @@ async function executeTellaskCall(dlg, mentionList, body, callId, callbacks, opt
             firstMention: options.targetForError ?? 'unknown',
         });
         toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
-        toolOutputs.push({
-            type: 'tellask_result_msg',
-            role: 'tool',
-            responderId: 'dominds',
-            mentionList: normalizedMentionList,
-            tellaskContent: body,
-            status: 'failed',
+        toolOutputs.push(buildTellaskResultToolOutput({
+            genseq: dlg.activeGenSeqOrUndefined ?? 1,
             callId,
+            callName,
             content: msg,
-        });
+            status: 'failed',
+            responderId: 'dominds',
+            tellaskContent: body,
+            mentionList: normalizedMentionList,
+            agentId: 'dominds',
+            originMemberId: dlg.agentId,
+        }));
         await dlg.receiveTellaskCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
         dlg.clearCurrentCallId();
     }
     return toolOutputs;
 }
-async function emitTellaskSpecialCallEvents(args) {
+async function emitTellaskCallEvents(args) {
     await args.dlg.callingStart({
         callName: args.callName,
         callId: args.callId,
@@ -1667,69 +1857,10 @@ function toExecutableValidTellaskCall(call) {
             };
     }
 }
-function normalizeQ4HCalls(calls, dlg) {
-    const q4hCalls = calls.filter((call) => call.callName === 'askHuman');
-    const nonQ4HCalls = calls
-        .filter((call) => call.callName !== 'askHuman')
-        .map((call) => {
-        switch (call.callName) {
-            case 'tellask':
-            case 'tellaskSessionless':
-                return { ...call, mentionList: [...call.mentionList] };
-            case 'tellaskBack':
-            case 'replyTellask':
-            case 'replyTellaskSessionless':
-            case 'replyTellaskBack':
-            case 'freshBootsReasoning':
-                return { ...call };
-        }
-    });
-    if (q4hCalls.length <= 1) {
-        return q4hCalls.length === 1 ? [...nonQ4HCalls, { ...q4hCalls[0] }] : nonQ4HCalls;
-    }
-    const primary = q4hCalls[0];
-    const remainingCallIds = q4hCalls
-        .slice(1)
-        .map((call) => call.callId.trim())
-        .filter((callId) => callId !== '');
-    const language = (0, work_language_1.getWorkLanguage)();
-    const intro = language === 'zh'
-        ? `我这次有 ${q4hCalls.length} 个问题，想请你一次性回复：`
-        : `I have ${q4hCalls.length} questions this round. Please answer them in one response:`;
-    const mergedBody = [
-        intro,
-        ...q4hCalls.map((call, index) => {
-            const body = call.tellaskContent.trim();
-            const normalizedBody = body !== ''
-                ? body
-                : language === 'zh'
-                    ? '请结合当前上下文补充这一项。'
-                    : 'Please provide this item based on the current context.';
-            return language === 'zh'
-                ? `问题 ${index + 1}：\n${normalizedBody}`
-                : `Question ${index + 1}:\n${normalizedBody}`;
-        }),
-    ].join('\n\n');
-    const mergedQ4HCall = {
-        callName: 'askHuman',
-        callId: primary.callId,
-        tellaskContent: mergedBody,
-        q4hRemainingCallIds: remainingCallIds.length > 0 ? remainingCallIds : undefined,
-    };
-    log_1.log.debug('Q4H multi-question normalized into a single prompt', undefined, {
-        rootId: dlg.id.rootId,
-        selfId: dlg.id.selfId,
-        mergedCount: q4hCalls.length,
-        primaryCallId: primary.callId,
-        remainingCallIds,
-    });
-    return [...nonQ4HCalls, mergedQ4HCall];
-}
 async function executeValidTellaskCalls(args) {
-    const executionCalls = normalizeQ4HCalls(args.calls, args.dlg);
     const results = [];
     const successfulReplyCallIds = [];
-    for (const call of executionCalls) {
+    for (const call of args.calls) {
         const runtimeMentionList = (() => {
             switch (call.callName) {
                 case 'tellask':
@@ -1747,7 +1878,7 @@ async function executeValidTellaskCalls(args) {
         if (!isReplyTellaskCallName(call.callName)) {
             const nonReplyCall = call;
             const sessionSlug = nonReplyCall.callName === 'tellask' ? nonReplyCall.sessionSlug : undefined;
-            await emitTellaskSpecialCallEvents({
+            await emitTellaskCallEvents({
                 dlg: args.dlg,
                 callName: nonReplyCall.callName,
                 mentionList: runtimeMentionList,
@@ -1818,7 +1949,6 @@ async function executeValidTellaskCalls(args) {
             callName: call.callName,
             parseResult,
             targetForError,
-            q4hRemainingCallIds: call.q4hRemainingCallIds,
             fbrEffortOverride: call.callName === 'freshBootsReasoning' ? call.effort : undefined,
         });
         results.push(toolOutputs);
@@ -1828,7 +1958,7 @@ async function executeValidTellaskCalls(args) {
         successfulReplyCallIds,
     };
 }
-async function executeTellaskSpecialCalls(args) {
+async function executeTellaskCalls(args) {
     if (args.calls.length === 0) {
         return { toolOutputs: [], successfulReplyCallIds: [] };
     }
@@ -1838,3 +1968,182 @@ async function executeTellaskSpecialCalls(args) {
         callbacks: args.callbacks,
     });
 }
+async function processTellaskFunctionRound(args) {
+    const multiAskHumanCalls = args.funcCalls.filter((call) => call.name === 'askHuman' && args.allowedSpecials.has('askHuman'));
+    const funcCallsForResolution = multiAskHumanCalls.length > 1
+        ? args.funcCalls.filter((call) => call.name !== 'askHuman')
+        : args.funcCalls;
+    const resolvedTellask = resolveTellaskFunctionCalls(funcCallsForResolution, {
+        allowedSpecials: args.allowedSpecials,
+    });
+    const validByCallId = new Map(resolvedTellask.validCalls.map((handled) => [handled.originalCall.id, handled]));
+    const invalidByCallId = new Map(resolvedTellask.invalidCalls.map((issue) => [issue.originalCall.id, issue]));
+    const orderedSpecialDispositions = [];
+    for (const originalCall of args.funcCalls) {
+        if (!isTellaskCallFunctionName(originalCall.name) ||
+            !args.allowedSpecials.has(originalCall.name)) {
+            continue;
+        }
+        if (multiAskHumanCalls.length > 1 && originalCall.name === 'askHuman') {
+            orderedSpecialDispositions.push({
+                kind: 'invalid',
+                issue: {
+                    originalCall,
+                    error: MULTIPLE_ASKHUMAN_CALLS_ERROR,
+                    rawArgumentsText: getRawArgumentsText(originalCall),
+                    contextArguments: getRawArgumentsText(originalCall),
+                },
+            });
+            continue;
+        }
+        const handled = validByCallId.get(originalCall.id);
+        if (handled) {
+            orderedSpecialDispositions.push({ kind: 'valid', handled });
+            continue;
+        }
+        const issue = invalidByCallId.get(originalCall.id);
+        if (issue) {
+            orderedSpecialDispositions.push({ kind: 'invalid', issue });
+            continue;
+        }
+        throw new Error(`kernel-driver tellask special call invariant violation: unresolved tellask disposition for '${originalCall.id}' (${originalCall.name})`);
+    }
+    const orderedValidCalls = orderedSpecialDispositions.flatMap((entry) => entry.kind === 'valid' ? [entry.handled] : []);
+    const orderedInvalidCalls = orderedSpecialDispositions.flatMap((entry) => entry.kind === 'invalid' ? [entry.issue] : []);
+    const specialCallById = new Map(orderedValidCalls.map(({ call }) => [call.callId, call]));
+    const originalCallById = new Map(args.funcCalls.map((call) => [call.id, call]));
+    const tellaskCallMessages = [];
+    const issueResults = [];
+    for (const disposition of orderedSpecialDispositions) {
+        if (disposition.kind === 'valid') {
+            const handled = disposition.handled;
+            await args.dlg.persistTellaskCall(handled.originalCall.id, handled.call.callName, getRawArgumentsText(handled.originalCall), handled.originalCall.genseq, {
+                deliveryMode: isReplyTellaskCallName(handled.call.callName)
+                    ? 'func_call_requested'
+                    : 'tellask_call_start',
+            });
+            tellaskCallMessages.push({
+                type: 'func_call_msg',
+                role: 'assistant',
+                genseq: handled.originalCall.genseq,
+                id: handled.originalCall.id,
+                name: handled.call.callName,
+                arguments: getRawArgumentsText(handled.originalCall),
+            });
+            continue;
+        }
+        const issue = disposition.issue;
+        await args.dlg.funcCallRequested(issue.originalCall.id, issue.originalCall.name, issue.contextArguments);
+        const result = formatTellaskInvalidCallResult({
+            call: issue.originalCall,
+            error: issue.error,
+        });
+        await args.dlg.persistTellaskCallResultPair({
+            id: issue.originalCall.id,
+            name: issue.originalCall.name,
+            rawArgumentsText: issue.rawArgumentsText,
+            genseq: issue.originalCall.genseq,
+            result,
+            deliveryMode: 'func_call_requested',
+        });
+        tellaskCallMessages.push({
+            type: 'func_call_msg',
+            role: 'assistant',
+            genseq: issue.originalCall.genseq,
+            id: issue.originalCall.id,
+            name: issue.originalCall.name,
+            arguments: issue.rawArgumentsText,
+        });
+        issueResults.push(result);
+    }
+    let tellaskExecution;
+    try {
+        tellaskExecution = await executeTellaskCalls({
+            dlg: args.dlg,
+            calls: orderedValidCalls.map((handled) => handled.call),
+            callbacks: args.callbacks,
+        });
+    }
+    catch (err) {
+        const errText = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+        for (const { call } of orderedValidCalls) {
+            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 persistTellaskFuncResult(args.dlg, {
+                type: 'func_result_msg',
+                id: call.callId,
+                name: call.callName,
+                content: `Special function '${call.callName}' execution failed: ${errText}`,
+                role: 'tool',
+                genseq: originalCall.genseq,
+            });
+        }
+        throw err;
+    }
+    const tellaskFuncResults = [];
+    const tellaskFuncResultByCallId = new Map();
+    const tellaskToolOutputs = [];
+    for (const output of tellaskExecution.toolOutputs) {
+        if (output.type === 'func_result_msg') {
+            const result = output;
+            tellaskFuncResultByCallId.set(result.id, result);
+            tellaskFuncResults.push(result);
+            continue;
+        }
+        if (output.type === 'tellask_result_msg') {
+            const callId = typeof output.callId === 'string' ? output.callId : '';
+            if (callId === '') {
+                tellaskToolOutputs.push(output);
+                continue;
+            }
+            const originatingCall = specialCallById.get(callId);
+            if (originatingCall) {
+                const originalCall = originalCallById.get(callId);
+                const result = {
+                    type: 'func_result_msg',
+                    role: 'tool',
+                    genseq: originalCall?.genseq ?? 1,
+                    id: callId,
+                    name: originatingCall.callName,
+                    content: output.content,
+                };
+                tellaskFuncResultByCallId.set(callId, result);
+                tellaskFuncResults.push(result);
+            }
+            continue;
+        }
+        tellaskToolOutputs.push(output);
+    }
+    for (const { call } of orderedValidCalls) {
+        if (tellaskFuncResultByCallId.has(call.callId)) {
+            continue;
+        }
+        const originalCall = originalCallById.get(call.callId);
+        if (!originalCall) {
+            throw new Error(`kernel-driver tellask call invariant violation: missing original call for '${call.callId}'`);
+        }
+        const pendingResult = buildPendingTellaskFuncResult({
+            callId: call.callId,
+            callName: call.callName,
+            genseq: originalCall.genseq,
+        });
+        tellaskFuncResultByCallId.set(call.callId, pendingResult);
+        tellaskFuncResults.push(pendingResult);
+    }
+    for (const result of tellaskFuncResults) {
+        await persistTellaskFuncResult(args.dlg, result);
+    }
+    return {
+        normalCalls: resolvedTellask.normalCalls,
+        tellaskCallMessages,
+        tellaskResults: [...issueResults, ...tellaskFuncResults],
+        toolOutputs: tellaskToolOutputs,
+        handledCallIds: orderedValidCalls.map(({ call }) => call.callId),
+        shouldStopAfterReplyTool: tellaskExecution.successfulReplyCallIds.length > 0,
+    };
+}