dominds 1.4.2 → 1.5.2

package/dist/llm/driver-v2-ref-only/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DRIVER_V2_IMPLEMENTATION_STATE = void 0;
+exports.driveDialogStream = driveDialogStream;
+exports.emitSayingEvents = emitSayingEvents;
+exports.supplyResponseToSupdialog = supplyResponseToSupdialog;
+exports.runBackendDriver = runBackendDriver;
+exports.restoreDialogHierarchy = restoreDialogHierarchy;
+const orchestrator_1 = require("./orchestrator");
+const restore_dialog_hierarchy_1 = require("./restore-dialog-hierarchy");
+exports.DRIVER_V2_IMPLEMENTATION_STATE = 'active';
+async function driveDialogStream(...args) {
+    return await (0, orchestrator_1.driveDialogStream)(...args);
+}
+async function emitSayingEvents(...args) {
+    return await (0, orchestrator_1.emitSayingEvents)(...args);
+}
+async function supplyResponseToSupdialog(...args) {
+    return await (0, orchestrator_1.supplyResponseToSupdialog)(...args);
+}
+function runBackendDriver() {
+    return (0, orchestrator_1.runBackendDriver)();
+}
+async function restoreDialogHierarchy(...args) {
+    return await (0, restore_dialog_hierarchy_1.restoreDialogHierarchy)(...args);
+}

package/dist/llm/driver-v2-ref-only/orchestrator.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driveDialogStream = driveDialogStream;
+exports.emitSayingEvents = emitSayingEvents;
+exports.supplyResponseToSupdialog = supplyResponseToSupdialog;
+exports.runBackendDriver = runBackendDriver;
+const dialog_global_registry_1 = require("../../dialog-global-registry");
+const log_1 = require("../../log");
+const persistence_1 = require("../../persistence");
+const round_1 = require("./round");
+const saying_events_1 = require("./saying-events");
+const supdialog_response_1 = require("./supdialog-response");
+const types_1 = require("./types");
+async function driveDialogStream(...driveArgs) {
+    const runtime = (0, types_1.createDriverV2RuntimeState)();
+    return await (0, round_1.executeDriveRound)({
+        runtime,
+        driveArgs,
+        scheduleDrive: (dialog, options) => {
+            void driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
+        },
+        driveDialog: async (dialog, options) => {
+            await driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
+        },
+    });
+}
+async function emitSayingEvents(...args) {
+    const [dlg, content] = args;
+    return await (0, saying_events_1.emitSayingEvents)(dlg, content);
+}
+async function supplyResponseToSupdialog(...args) {
+    const [parentDialog, subdialogId, responseText, callType, callId, status, calleeResponseRef] = args;
+    return await (0, supdialog_response_1.supplyResponseToSupdialogV2)({
+        parentDialog,
+        subdialogId,
+        responseText,
+        callType,
+        callId,
+        status,
+        calleeResponseRef,
+        scheduleDrive: (dialog, options) => {
+            void driveDialogStream(dialog, options.humanPrompt, options.waitInQue, options.driveOptions);
+        },
+    });
+}
+function formatDriveTriggerForLog(trigger) {
+    return {
+        action: trigger.action,
+        rootId: trigger.rootId,
+        entryFound: trigger.entryFound,
+        previousNeedsDrive: trigger.previousNeedsDrive,
+        nextNeedsDrive: trigger.nextNeedsDrive,
+        source: trigger.source,
+        reason: trigger.reason,
+        emittedAtMs: trigger.emittedAtMs,
+    };
+}
+async function driveQueuedDialogsOnce() {
+    const dialogsToDrive = dialog_global_registry_1.globalDialogRegistry.getDialogsNeedingDrive();
+    for (const rootDialog of dialogsToDrive) {
+        try {
+            const latest = await persistence_1.DialogPersistence.loadDialogLatest(rootDialog.id, 'running');
+            const runStateKind = latest?.runState?.kind;
+            if (runStateKind === 'interrupted' || runStateKind === 'proceeding_stop_requested') {
+                dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId, {
+                    source: 'driver_v2_backend_loop',
+                    reason: `run_state_blocked:${runStateKind}`,
+                });
+                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+                continue;
+            }
+            if (!(await rootDialog.canDrive())) {
+                continue;
+            }
+            await driveDialogStream(rootDialog, undefined, true);
+            const status = await rootDialog.getSuspensionStatus();
+            const shouldStayQueued = rootDialog.hasUpNext() || !status.canDrive;
+            if (shouldStayQueued) {
+                dialog_global_registry_1.globalDialogRegistry.markNeedsDrive(rootDialog.id.rootId, {
+                    source: 'driver_v2_backend_loop',
+                    reason: rootDialog.hasUpNext() ? 'post_drive_upnext_pending' : 'post_drive_suspended',
+                });
+                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, true, rootDialog.status);
+            }
+            else {
+                dialog_global_registry_1.globalDialogRegistry.markNotNeedingDrive(rootDialog.id.rootId, {
+                    source: 'driver_v2_backend_loop',
+                    reason: 'post_drive_idle',
+                });
+                await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+            }
+            const lastTrigger = dialog_global_registry_1.globalDialogRegistry.getLastDriveTrigger(rootDialog.id.rootId);
+            const lastTriggerAgeMs = lastTrigger !== undefined ? Math.max(0, Date.now() - lastTrigger.emittedAtMs) : undefined;
+            if (status.subdialogs) {
+                log_1.log.debug(`Dialog ${rootDialog.id.rootId} suspended, waiting for subdialogs`, undefined, {
+                    rootId: rootDialog.id.rootId,
+                    waitingQ4H: status.q4h,
+                    waitingSubdialogs: status.subdialogs,
+                    hasQueuedUpNext: rootDialog.hasUpNext(),
+                    lastDriveTrigger: lastTrigger
+                        ? {
+                            action: lastTrigger.action,
+                            source: lastTrigger.source,
+                            reason: lastTrigger.reason,
+                            emittedAtMs: lastTrigger.emittedAtMs,
+                            ageMs: lastTriggerAgeMs,
+                            entryFound: lastTrigger.entryFound,
+                            previousNeedsDrive: lastTrigger.previousNeedsDrive,
+                            nextNeedsDrive: lastTrigger.nextNeedsDrive,
+                        }
+                        : null,
+                });
+            }
+            if (status.q4h) {
+                log_1.log.debug(`Dialog ${rootDialog.id.rootId} awaiting Q4H answer`, undefined, {
+                    rootId: rootDialog.id.rootId,
+                    waitingQ4H: status.q4h,
+                    waitingSubdialogs: status.subdialogs,
+                    hasQueuedUpNext: rootDialog.hasUpNext(),
+                    lastDriveTrigger: lastTrigger
+                        ? {
+                            action: lastTrigger.action,
+                            source: lastTrigger.source,
+                            reason: lastTrigger.reason,
+                            emittedAtMs: lastTrigger.emittedAtMs,
+                            ageMs: lastTriggerAgeMs,
+                            entryFound: lastTrigger.entryFound,
+                            previousNeedsDrive: lastTrigger.previousNeedsDrive,
+                            nextNeedsDrive: lastTrigger.nextNeedsDrive,
+                        }
+                        : null,
+                });
+            }
+        }
+        catch (err) {
+            log_1.log.error(`Error driving dialog ${rootDialog.id.rootId}:`, err, undefined, {
+                dialogId: rootDialog.id.rootId,
+            });
+        }
+    }
+}
+function runBackendDriver() {
+    return (async () => {
+        while (true) {
+            try {
+                await driveQueuedDialogsOnce();
+                const trigger = await dialog_global_registry_1.globalDialogRegistry.waitForDriveTrigger();
+                log_1.log.debug('Backend driver woke from drive trigger event', undefined, {
+                    trigger: formatDriveTriggerForLog(trigger),
+                });
+            }
+            catch (loopErr) {
+                log_1.log.error('Error in backend driver loop:', loopErr);
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+    })();
+}

package/dist/llm/driver-v2-ref-only/policy.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDriverV2Policy = buildDriverV2Policy;
+exports.validateDriverV2PolicyInvariants = validateDriverV2PolicyInvariants;
+exports.resolveDriverV2PolicyViolationKind = resolveDriverV2PolicyViolationKind;
+const dialog_1 = require("../../dialog");
+const system_prompt_parts_1 = require("../../minds/system-prompt-parts");
+function isToollessFbrSelfSubdialog(dlg) {
+    if (!(dlg instanceof dialog_1.SubDialog))
+        return false;
+    return dlg.assignmentFromSup.callName === 'freshBootsReasoning';
+}
+function mergeModelParams(base, overlay) {
+    if (!base && !overlay)
+        return undefined;
+    if (!base)
+        return overlay;
+    if (!overlay)
+        return base;
+    return {
+        max_tokens: overlay.max_tokens ?? base.max_tokens,
+        codex: { ...(base.codex ?? {}), ...(overlay.codex ?? {}) },
+        openai: { ...(base.openai ?? {}), ...(overlay.openai ?? {}) },
+        anthropic: { ...(base.anthropic ?? {}), ...(overlay.anthropic ?? {}) },
+    };
+}
+function buildFbrSystemPrompt(language) {
+    const prefix = language === 'zh'
+        ? [
+            '# 扪心自问（FBR）支线对话',
+            '',
+            '- 你正在处理一次由 `freshBootsReasoning` 函数触发的 FBR 支线对话。',
+            '- 诉请正文是主要任务上下文；不要假设能访问上游对话历史。',
+            '- 若使用可恢复会话，你可以使用本支线对话自身的 tellaskSession 历史作为显式上下文。',
+            '- 若诉请正文缺少关键上下文，请在输出中列出缺失信息与阻塞原因。',
+            '- 当前 FBR 为技术性禁函数工具模式：不得发起任何函数调用（包括 tellaskBack / tellask / tellaskSessionless / askHuman）。',
+        ].join('\n')
+        : [
+            '# Fresh Boots Reasoning (FBR) sideline dialog',
+            '',
+            '- This is an FBR sideline dialog triggered via the `freshBootsReasoning` function.',
+            '- The tellask body is the primary task context; do not assume access to upstream dialog history.',
+            '- If this is a resumable session, you may use this sideline dialog’s own tellaskSession history as explicit context.',
+            '- If the tellask body is missing critical context, list what is missing and why it blocks reasoning.',
+            '- This FBR turn is in technical no-function mode: do not emit any function call (including tellaskBack / tellask / tellaskSessionless / askHuman).',
+        ].join('\n');
+    return prefix.trim();
+}
+function buildDriverV2Policy(args) {
+    const { dlg, agent, systemPrompt, agentTools, language } = args;
+    if (!isToollessFbrSelfSubdialog(dlg)) {
+        return {
+            mode: 'default',
+            effectiveAgent: agent,
+            effectiveSystemPrompt: systemPrompt,
+            effectiveAgentTools: agentTools,
+            prependedContextMessages: [],
+            tellaskPolicy: 'allow_any',
+            allowFunctionCalls: true,
+        };
+    }
+    const effectiveAgent = Object.assign(Object.create(agent), {
+        model_params: mergeModelParams(agent.model_params, agent.fbr_model_params),
+    });
+    return {
+        mode: 'fbr_toolless',
+        effectiveAgent,
+        effectiveSystemPrompt: buildFbrSystemPrompt(language),
+        effectiveAgentTools: [],
+        prependedContextMessages: [
+            {
+                type: 'environment_msg',
+                role: 'user',
+                content: (0, system_prompt_parts_1.buildNoToolsNotice)(language),
+            },
+        ],
+        tellaskPolicy: 'deny_all',
+        allowFunctionCalls: false,
+    };
+}
+function validateDriverV2PolicyInvariants(policy, language) {
+    if (policy.mode !== 'fbr_toolless') {
+        return { ok: true };
+    }
+    if (policy.effectiveAgentTools.length > 0) {
+        return { ok: false, detail: 'FBR effectiveAgentTools must be empty.' };
+    }
+    if (policy.allowFunctionCalls) {
+        return { ok: false, detail: 'FBR allowFunctionCalls must be false.' };
+    }
+    if (policy.tellaskPolicy !== 'deny_all') {
+        return { ok: false, detail: 'FBR tellaskPolicy must be deny_all.' };
+    }
+    const expectedNoToolsNotice = (0, system_prompt_parts_1.buildNoToolsNotice)(language);
+    if (policy.prependedContextMessages.length !== 1) {
+        return { ok: false, detail: 'FBR must prepend exactly one no-tools notice message.' };
+    }
+    const [notice] = policy.prependedContextMessages;
+    if (!notice ||
+        notice.type !== 'environment_msg' ||
+        notice.role !== 'user' ||
+        notice.content !== expectedNoToolsNotice) {
+        return {
+            ok: false,
+            detail: 'FBR prepended notice must exactly match buildNoToolsNotice(language).',
+        };
+    }
+    return { ok: true };
+}
+function hasTellaskPolicyViolation(policy, tellaskCallCount) {
+    if (policy.tellaskPolicy === 'allow_any') {
+        return false;
+    }
+    return tellaskCallCount > 0;
+}
+function resolveDriverV2PolicyViolationKind(args) {
+    const tellaskViolation = hasTellaskPolicyViolation(args.policy, args.tellaskCallCount);
+    const toolViolation = !args.policy.allowFunctionCalls && args.functionCallCount > 0;
+    if (tellaskViolation && toolViolation) {
+        return 'tellask_and_tool';
+    }
+    if (tellaskViolation) {
+        return 'tellask';
+    }
+    if (toolViolation) {
+        return 'tool';
+    }
+    return null;
+}

package/dist/llm/driver-v2-ref-only/restore-dialog-hierarchy.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreDialogHierarchy = restoreDialogHierarchy;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+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");
+async function restoreDialogHierarchy(rootDialogId, status = 'running') {
+    try {
+        const rootDialogIdent = new dialog_1.DialogID(rootDialogId);
+        const rootMeta = await persistence_1.DialogPersistence.loadRootDialogMetadata(rootDialogIdent, status);
+        if (rootMeta?.supdialogId) {
+            throw new Error(`Expected root dialog ${rootDialogId} but found subdialog metadata with supdialogId: ${rootMeta.supdialogId}`);
+        }
+        const rootDialog = await (0, dialog_instance_registry_1.getOrRestoreRootDialog)(rootDialogId, status);
+        if (!rootDialog) {
+            throw new Error(`Failed to restore dialog hierarchy for ${rootDialogId} from status ${status}`);
+        }
+        dialog_global_registry_1.globalDialogRegistry.register(rootDialog);
+        const subdialogs = new Map();
+        const rootPath = persistence_1.DialogPersistence.getRootDialogPath(rootDialogIdent, status);
+        const subdialogsPath = path_1.default.join(rootPath, 'subdialogs');
+        let allSubdialogIds = [];
+        try {
+            const entries = await fs_1.default.promises.readdir(subdialogsPath, { withFileTypes: true });
+            allSubdialogIds = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        }
+        catch (err) {
+            const code = typeof err === 'object' && err !== null && 'code' in err
+                ? err.code
+                : undefined;
+            if (code !== 'ENOENT') {
+                log_1.log.warn(`Failed to read subdialogs directory: ${subdialogsPath}, returning empty array`, err);
+            }
+            allSubdialogIds = [];
+        }
+        for (const subdialogId of allSubdialogIds) {
+            const restoredSubdialogId = new dialog_1.DialogID(subdialogId, rootDialog.id.rootId);
+            const dialog = await (0, dialog_instance_registry_1.ensureDialogLoaded)(rootDialog, restoredSubdialogId, status);
+            if (dialog && dialog.id.selfId !== dialog.id.rootId) {
+                subdialogs.set(subdialogId, dialog);
+            }
+        }
+        let totalMessages = rootDialog.msgs.length;
+        let totalCourses = rootDialog.currentCourse;
+        for (const dialog of subdialogs.values()) {
+            totalMessages += dialog.msgs.length;
+            if (dialog.currentCourse > totalCourses) {
+                totalCourses = dialog.currentCourse;
+            }
+        }
+        const summary = {
+            totalMessages,
+            totalCourses,
+            completionStatus: 'incomplete',
+        };
+        return {
+            rootDialog,
+            subdialogs,
+            summary,
+        };
+    }
+    catch (error) {
+        log_1.log.error(`Failed to restore dialog hierarchy for ${rootDialogId}:`, error);
+        throw error;
+    }
+}