dominds 1.8.2 → 1.8.4

package/dist/llm/driver-v2/supdialog-response.js

@@ -1,400 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.supplyResponseToSupdialogV2 = supplyResponseToSupdialogV2;
-exports.supplySubdialogResponseToSpecificCallerIfPendingV2 = supplySubdialogResponseToSpecificCallerIfPendingV2;
-exports.supplySubdialogResponseToAssignedCallerIfPendingV2 = supplySubdialogResponseToAssignedCallerIfPendingV2;
-const dialog_1 = require("../../dialog");
-const dialog_global_registry_1 = require("../../dialog-global-registry");
-const dialog_instance_registry_1 = require("../../dialog-instance-registry");
-const log_1 = require("../../log");
-const persistence_1 = require("../../persistence");
-const time_1 = require("../../shared/utils/time");
-const pending_tellask_reminder_1 = require("../../tools/pending-tellask-reminder");
-const subdialog_txn_1 = require("./subdialog-txn");
-async function syncPendingTellaskReminderBestEffort(dlg, where) {
-    try {
-        const changed = await (0, pending_tellask_reminder_1.syncPendingTellaskReminderState)(dlg);
-        if (!changed)
-            return;
-        await dlg.processReminderUpdates();
-    }
-    catch (err) {
-        log_1.log.warn('Failed to sync pending tellask reminder', undefined, {
-            where,
-            dialogId: dlg.id.selfId,
-            rootId: dlg.id.rootId,
-            error: err instanceof Error ? err.message : String(err),
-        });
-    }
-}
-function buildFbrRelayPayload(subdialog, finalResponseText) {
-    const language = subdialog.getLastUserLanguageCode();
-    const isZh = language === 'zh';
-    const roundSayingMsgs = subdialog.msgs
-        .filter((msg) => msg.type === 'saying_msg')
-        .map((msg) => msg.content)
-        .filter((content) => content.trim() !== '')
-        .map((content, idx) => ({
-        idx,
-        content,
-    }));
-    if (roundSayingMsgs.length <= 1) {
-        return `${finalResponseText}\n\n${buildFbrDistillPrompt(language)}`;
-    }
-    const roundsText = roundSayingMsgs
-        .map((entry) => `### ${isZh ? `FBR 第 ${entry.idx + 1} 轮` : `FBR Round ${entry.idx + 1}`}\n${entry.content}`)
-        .join('\n\n');
-    const allRoundPayload = isZh
-        ? `## FBR 全量回帖（按轮次）\n\n${roundsText}`
-        : `## FBR Full Conclusions (by round)\n\n${roundsText}`;
-    return `${allRoundPayload}\n\n${buildFbrDistillPrompt(language)}`;
-}
-function buildFbrDistillPrompt(language) {
-    if (language === 'zh') {
-        return `## 提示上游：收到全量回帖后请提炼\n\n以上为该次 FBR 的全量结论，包含全部轮次。上游请在收到这条全量回帖后进行综合提炼（distill），形成可执行项与决策后立即执行；若需要人类澄清/授权/决策，立即发起 \`askHuman\`。`;
-    }
-    return `## Upstream Distill Note\n\nThe text above is the full FBR output for this run, containing all rounds. After receiving this full reply, distill the full set and execute immediately once actionable decisions are formed; if human clarification/authorization/decision is required, issue \`askHuman\` immediately.`;
-}
-async function resolveOwnerDialogBySelfId(subdialog, ownerDialogId) {
-    const rootDialog = subdialog.rootDialog;
-    if (!(await ensureDialogFreshOrDiscard(rootDialog, 'resolveOwnerDialogBySelfId:root'))) {
-        return undefined;
-    }
-    if (ownerDialogId === rootDialog.id.selfId) {
-        return rootDialog;
-    }
-    const existing = rootDialog.lookupDialog(ownerDialogId);
-    if (existing) {
-        if (!(await ensureDialogFreshOrDiscard(existing, 'resolveOwnerDialogBySelfId:lookup'))) {
-            return undefined;
-        }
-        return existing;
-    }
-    const restored = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, new dialog_1.DialogID(ownerDialogId, rootDialog.id.rootId), rootDialog.status);
-    if (!restored) {
-        return undefined;
-    }
-    if (!(await ensureDialogFreshOrDiscard(restored, 'resolveOwnerDialogBySelfId:restore'))) {
-        return undefined;
-    }
-    return restored;
-}
-async function ensureDialogFreshOrDiscard(dialog, where) {
-    try {
-        const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(dialog.id, dialog.status);
-        if (metadata) {
-            return true;
-        }
-    }
-    catch (err) {
-        log_1.log.warn('driver-v2 failed to verify dialog freshness against persisted status', undefined, {
-            where,
-            rootId: dialog.id.rootId,
-            selfId: dialog.id.selfId,
-            status: dialog.status,
-            error: err instanceof Error ? err.message : String(err),
-        });
-    }
-    log_1.log.warn('driver-v2 discarding stale dialog object due to status/path mismatch', undefined, {
-        where,
-        rootId: dialog.id.rootId,
-        selfId: dialog.id.selfId,
-        status: dialog.status,
-    });
-    if (dialog instanceof dialog_1.RootDialog) {
-        dialog_global_registry_1.globalDialogRegistry.unregister(dialog.id.rootId);
-    }
-    return false;
-}
-async function resolveLatestAssignmentAnchorRef(args) {
-    const normalizedCallId = args.callId.trim();
-    if (normalizedCallId === '') {
-        return undefined;
-    }
-    const latest = await persistence_1.DialogPersistence.loadDialogLatest(args.calleeDialogId, args.status);
-    if (!latest) {
-        return undefined;
-    }
-    const maxCourse = Math.floor(latest.currentCourse);
-    for (let course = maxCourse; course >= 1; course -= 1) {
-        const courseEvents = await persistence_1.DialogPersistence.loadCourseEvents(args.calleeDialogId, course, args.status);
-        for (let i = courseEvents.length - 1; i >= 0; i -= 1) {
-            const event = courseEvents[i];
-            if (event.type !== 'teammate_call_anchor_record') {
-                continue;
-            }
-            if (event.anchorRole !== 'assignment') {
-                continue;
-            }
-            if (event.callId.trim() !== normalizedCallId) {
-                continue;
-            }
-            if (!Number.isFinite(event.genseq) || event.genseq <= 0) {
-                continue;
-            }
-            return { course, genseq: Math.floor(event.genseq) };
-        }
-    }
-    return undefined;
-}
-async function supplyResponseToSupdialogV2(args) {
-    const { parentDialog, subdialogId, responseText, callType, callId, status = 'completed', calleeResponseRef, scheduleDrive, subdialog: maybeSubdialog, } = args;
-    try {
-        const result = await (0, subdialog_txn_1.withSubdialogTxnLock)(parentDialog.id, async () => {
-            const pendingSubdialogs = await persistence_1.DialogPersistence.loadPendingSubdialogs(parentDialog.id, parentDialog.status);
-            let pendingRecord;
-            const filteredPending = [];
-            for (const pending of pendingSubdialogs) {
-                if (pending.subdialogId === subdialogId.selfId) {
-                    pendingRecord = pending;
-                }
-                else {
-                    filteredPending.push(pending);
-                }
-            }
-            let responderId = subdialogId.rootId;
-            let responderAgentId;
-            let callName = 'tellaskSessionless';
-            let mentionList;
-            let tellaskContent = responseText;
-            let originMemberId;
-            try {
-                const metadata = await persistence_1.DialogPersistence.loadDialogMetadata(subdialogId, parentDialog.status);
-                if (metadata && metadata.assignmentFromSup) {
-                    originMemberId = metadata.assignmentFromSup.originMemberId;
-                    if (!pendingRecord) {
-                        callName = metadata.assignmentFromSup.callName;
-                        mentionList = metadata.assignmentFromSup.mentionList;
-                        tellaskContent = metadata.assignmentFromSup.tellaskContent;
-                    }
-                }
-                if (!pendingRecord && metadata && typeof metadata.agentId === 'string') {
-                    if (metadata.agentId.trim() !== '') {
-                        responderId = metadata.agentId;
-                        responderAgentId = metadata.agentId;
-                    }
-                }
-            }
-            catch (err) {
-                log_1.log.warn('Failed to load subdialog metadata for response record', undefined, {
-                    parentId: parentDialog.id.selfId,
-                    subdialogId: subdialogId.selfId,
-                    error: err,
-                });
-            }
-            if (!originMemberId) {
-                originMemberId = parentDialog.agentId;
-            }
-            if (pendingRecord) {
-                callName = pendingRecord.callName;
-                responderId = pendingRecord.targetAgentId;
-                responderAgentId = pendingRecord.targetAgentId;
-                mentionList = pendingRecord.mentionList;
-                tellaskContent = pendingRecord.tellaskContent;
-            }
-            if ((callName === 'tellask' || callName === 'tellaskSessionless') &&
-                (!Array.isArray(mentionList) || mentionList.length < 1)) {
-                mentionList = [`@${responderId}`];
-            }
-            await persistence_1.DialogPersistence.savePendingSubdialogs(parentDialog.id, filteredPending, parentDialog.status);
-            const hasQ4H = await parentDialog.hasPendingQ4H();
-            const shouldRevive = !hasQ4H && filteredPending.length === 0;
-            if (shouldRevive && parentDialog instanceof dialog_1.RootDialog) {
-                await persistence_1.DialogPersistence.setNeedsDrive(parentDialog.id, true, parentDialog.status);
-            }
-            return {
-                responderId,
-                responderAgentId,
-                callName,
-                mentionList,
-                tellaskContent,
-                originMemberId,
-                callId: pendingRecord?.callId,
-                callingCourse: pendingRecord &&
-                    typeof pendingRecord.callingCourse === 'number' &&
-                    Number.isFinite(pendingRecord.callingCourse) &&
-                    pendingRecord.callingCourse > 0
-                    ? Math.floor(pendingRecord.callingCourse)
-                    : undefined,
-                shouldRevive,
-            };
-        });
-        const normalizedCallId = typeof callId === 'string' ? callId.trim() : '';
-        const fallbackCallId = typeof result.callId === 'string' ? result.callId.trim() : '';
-        const resolvedCallId = normalizedCallId !== '' ? normalizedCallId : fallbackCallId;
-        const rootForLookup = parentDialog instanceof dialog_1.RootDialog
-            ? parentDialog
-            : parentDialog instanceof dialog_1.SubDialog
-                ? parentDialog.rootDialog
-                : undefined;
-        const resolvedSubdialog = maybeSubdialog ?? rootForLookup?.lookupDialog(subdialogId.selfId);
-        const shouldReportFbrUpstream = callType === 'C' &&
-            result.callName === 'freshBootsReasoning' &&
-            resolvedSubdialog !== undefined;
-        const upstreamResponseText = shouldReportFbrUpstream
-            ? buildFbrRelayPayload(resolvedSubdialog, responseText)
-            : responseText;
-        if (resolvedCallId !== '' && calleeResponseRef) {
-            const assignmentRef = await resolveLatestAssignmentAnchorRef({
-                calleeDialogId: subdialogId,
-                callId: resolvedCallId,
-                status: parentDialog.status,
-            });
-            if (!assignmentRef) {
-                log_1.log.error('Missing assignment anchor for teammate response anchor', undefined, {
-                    parentId: parentDialog.id.selfId,
-                    subdialogId: subdialogId.selfId,
-                    callId: resolvedCallId,
-                    responseCourse: calleeResponseRef.course,
-                    responseGenseq: calleeResponseRef.genseq,
-                });
-            }
-            const anchorRecord = {
-                ts: (0, time_1.formatUnifiedTimestamp)(new Date()),
-                type: 'teammate_call_anchor_record',
-                anchorRole: 'response',
-                callId: resolvedCallId,
-                genseq: calleeResponseRef.genseq,
-                assignmentCourse: assignmentRef?.course,
-                assignmentGenseq: assignmentRef?.genseq,
-                callerDialogId: parentDialog.id.selfId,
-                callerCourse: result.callingCourse,
-            };
-            await persistence_1.DialogPersistence.appendEvent(subdialogId, calleeResponseRef.course, anchorRecord, parentDialog.status);
-        }
-        await syncPendingTellaskReminderBestEffort(parentDialog, 'driver-v2:supplyResponseToSupdialog');
-        await parentDialog.receiveTeammateResponse(result.responderId, result.callName, result.mentionList, result.tellaskContent, status, subdialogId, {
-            response: upstreamResponseText,
-            agentId: result.responderAgentId ?? result.responderId,
-            callId: resolvedCallId,
-            originMemberId: result.originMemberId ?? parentDialog.agentId,
-            calleeCourse: calleeResponseRef?.course,
-            calleeGenseq: calleeResponseRef?.genseq,
-        });
-        // Keep in-memory dialog context in sync with live teammate-response events immediately.
-        // v2 context assembly now relies on dialog msgs + persisted teammate_response_record only.
-        const immediateMirror = {
-            type: 'tellask_result_msg',
-            role: 'tool',
-            responderId: result.responderId,
-            mentionList: result.mentionList,
-            tellaskContent: result.tellaskContent,
-            status,
-            callId: resolvedCallId,
-            content: upstreamResponseText,
-        };
-        await parentDialog.addChatMessages(immediateMirror);
-        if (result.shouldRevive) {
-            const isRoot = parentDialog instanceof dialog_1.RootDialog;
-            const hasRegistryEntry = isRoot
-                ? dialog_global_registry_1.globalDialogRegistry.get(parentDialog.id.rootId) !== undefined
-                : false;
-            log_1.log.debug(`All Type ${callType} subdialogs complete, parent ${parentDialog.id.selfId} scheduling auto-revive`, undefined, {
-                rootId: parentDialog.id.rootId,
-                selfId: parentDialog.id.selfId,
-                via: isRoot && hasRegistryEntry ? 'backend_loop_trigger' : 'direct_schedule_drive',
-                isRoot,
-                hasRegistryEntry,
-            });
-            if (isRoot) {
-                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(parentDialog.id.rootId, {
-                    source: 'driver_v2_supply_response',
-                    reason: `all_pending_subdialogs_resolved:type_${callType}`,
-                });
-            }
-            // Root dialogs should normally be resumed by backend loop drive-trigger.
-            // Direct schedule is kept only as fallback for non-root callers or when registry
-            // entry is not available yet (e.g., transient bootstrap windows).
-            if (!isRoot || !hasRegistryEntry) {
-                scheduleDrive(parentDialog, {
-                    waitInQue: true,
-                    driveOptions: { suppressDiligencePush: parentDialog.disableDiligencePush },
-                });
-            }
-        }
-    }
-    catch (error) {
-        log_1.log.error('driver-v2 failed to supply subdialog response', error, {
-            parentId: parentDialog.id.selfId,
-            subdialogId: subdialogId.selfId,
-        });
-        throw error;
-    }
-}
-async function supplySubdialogResponseToSpecificCallerIfPendingV2(args) {
-    const { subdialog, responseText, responseGenseq, target, scheduleDrive } = args;
-    const assignment = subdialog.assignmentFromSup;
-    if (!assignment) {
-        return false;
-    }
-    const ownerDialog = await resolveOwnerDialogBySelfId(subdialog, target.ownerDialogId);
-    if (!ownerDialog) {
-        return false;
-    }
-    if (!(await ensureDialogFreshOrDiscard(ownerDialog, 'supplySubdialogResponseToSpecificCallerIfPendingV2:owner'))) {
-        return false;
-    }
-    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(ownerDialog.id, ownerDialog.status);
-    const pendingRecord = pending.find((p) => p.subdialogId === subdialog.id.selfId);
-    if (!pendingRecord) {
-        return false;
-    }
-    if (pendingRecord.callType !== target.callType) {
-        log_1.log.warn('Reply target callType does not match pending callType; skipping stale reply target', undefined, {
-            rootId: subdialog.rootDialog.id.rootId,
-            subdialogId: subdialog.id.selfId,
-            ownerDialogId: ownerDialog.id.selfId,
-            targetCallType: target.callType,
-            pendingCallType: pendingRecord.callType,
-        });
-        return false;
-    }
-    await supplyResponseToSupdialogV2({
-        parentDialog: ownerDialog,
-        subdialogId: subdialog.id,
-        responseText,
-        subdialog,
-        callType: pendingRecord.callType,
-        callId: target.callId,
-        status: 'completed',
-        calleeResponseRef: { course: subdialog.currentCourse, genseq: responseGenseq },
-        scheduleDrive,
-    });
-    return true;
-}
-async function supplySubdialogResponseToAssignedCallerIfPendingV2(args) {
-    const { subdialog, responseText, responseGenseq, scheduleDrive } = args;
-    const assignment = subdialog.assignmentFromSup;
-    if (!assignment) {
-        return false;
-    }
-    const callerDialog = await resolveOwnerDialogBySelfId(subdialog, assignment.callerDialogId);
-    if (!callerDialog) {
-        log_1.log.warn('Missing caller dialog for subdialog response supply', undefined, {
-            rootId: subdialog.rootDialog.id.rootId,
-            subdialogId: subdialog.id.selfId,
-            callerDialogId: assignment.callerDialogId,
-        });
-        return false;
-    }
-    if (!(await ensureDialogFreshOrDiscard(callerDialog, 'supplySubdialogResponseToAssignedCallerIfPendingV2:caller'))) {
-        return false;
-    }
-    const pending = await persistence_1.DialogPersistence.loadPendingSubdialogs(callerDialog.id, callerDialog.status);
-    const pendingRecord = pending.find((p) => p.subdialogId === subdialog.id.selfId);
-    if (!pendingRecord) {
-        return false;
-    }
-    await supplyResponseToSupdialogV2({
-        parentDialog: callerDialog,
-        subdialogId: subdialog.id,
-        responseText,
-        subdialog,
-        callType: pendingRecord.callType,
-        callId: assignment.callId,
-        status: 'completed',
-        calleeResponseRef: { course: subdialog.currentCourse, genseq: responseGenseq },
-        scheduleDrive,
-    });
-    return true;
-}