dominds 0.7.0 → 0.7.2

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

@@ -71,6 +71,93 @@ async function emitUserMarkdown(dlg, content) {
 function resolveModelInfo(providerCfg, model) {
     return providerCfg.models[model];
 }
+function resolveModelContextLimitTokens(modelInfo) {
+    if (modelInfo &&
+        typeof modelInfo.context_length === 'number' &&
+        Number.isFinite(modelInfo.context_length)) {
+        const n = Math.floor(modelInfo.context_length);
+        return n > 0 ? n : null;
+    }
+    if (modelInfo &&
+        typeof modelInfo.input_length === 'number' &&
+        Number.isFinite(modelInfo.input_length)) {
+        const n = Math.floor(modelInfo.input_length);
+        return n > 0 ? n : null;
+    }
+    return null;
+}
+function resolveEffectiveOptimalMaxTokens(args) {
+    const configuredOptimal = args.modelInfo &&
+        typeof args.modelInfo.optimal_max_tokens === 'number' &&
+        Number.isFinite(args.modelInfo.optimal_max_tokens)
+        ? Math.floor(args.modelInfo.optimal_max_tokens)
+        : undefined;
+    const optimalMaxTokensConfigured = configuredOptimal !== undefined && configuredOptimal > 0 ? configuredOptimal : undefined;
+    const configuredCritical = args.modelInfo &&
+        typeof args.modelInfo.critical_max_tokens === 'number' &&
+        Number.isFinite(args.modelInfo.critical_max_tokens)
+        ? Math.floor(args.modelInfo.critical_max_tokens)
+        : undefined;
+    const criticalMaxTokensConfigured = configuredCritical !== undefined && configuredCritical > 0 ? configuredCritical : undefined;
+    const defaultOptimal = 100000;
+    const effectiveOptimalMaxTokens = optimalMaxTokensConfigured !== undefined ? optimalMaxTokensConfigured : defaultOptimal;
+    const defaultCritical = Math.max(1, Math.floor(args.modelContextLimitTokens * 0.9));
+    const effectiveCriticalMaxTokens = criticalMaxTokensConfigured !== undefined ? criticalMaxTokensConfigured : defaultCritical;
+    return {
+        effectiveOptimalMaxTokens,
+        optimalMaxTokensConfigured,
+        effectiveCriticalMaxTokens,
+        criticalMaxTokensConfigured,
+    };
+}
+function computeContextHealthSnapshot(args) {
+    const modelInfo = args.providerCfg.models[args.model];
+    const modelContextWindowText = modelInfo && typeof modelInfo.context_window === 'string'
+        ? modelInfo.context_window
+        : undefined;
+    const modelContextLimitTokens = resolveModelContextLimitTokens(modelInfo);
+    if (modelContextLimitTokens === null) {
+        return { kind: 'unavailable', reason: 'model_limit_unavailable', modelContextWindowText };
+    }
+    const { effectiveOptimalMaxTokens, optimalMaxTokensConfigured, effectiveCriticalMaxTokens, criticalMaxTokensConfigured, } = resolveEffectiveOptimalMaxTokens({
+        modelInfo,
+        modelContextLimitTokens,
+    });
+    if (args.usage.kind !== 'available') {
+        return {
+            kind: 'unavailable',
+            reason: 'usage_unavailable',
+            modelContextWindowText,
+            modelContextLimitTokens,
+            effectiveOptimalMaxTokens,
+            optimalMaxTokensConfigured,
+            effectiveCriticalMaxTokens,
+            criticalMaxTokensConfigured,
+        };
+    }
+    const hardUtil = args.usage.promptTokens / modelContextLimitTokens;
+    const optimalUtil = args.usage.promptTokens / effectiveOptimalMaxTokens;
+    const level = args.usage.promptTokens > effectiveCriticalMaxTokens
+        ? 'critical'
+        : args.usage.promptTokens > effectiveOptimalMaxTokens
+            ? 'caution'
+            : 'healthy';
+    return {
+        kind: 'available',
+        promptTokens: args.usage.promptTokens,
+        completionTokens: args.usage.completionTokens,
+        totalTokens: args.usage.totalTokens,
+        modelContextWindowText,
+        modelContextLimitTokens,
+        effectiveOptimalMaxTokens,
+        optimalMaxTokensConfigured,
+        effectiveCriticalMaxTokens,
+        criticalMaxTokensConfigured,
+        hardUtil,
+        optimalUtil,
+        level,
+    };
+}
 async function buildProviderContext(args) {
     const provider = args.agent.provider ?? args.team.memberDefaults.provider;
     const model = args.agent.model ?? args.team.memberDefaults.model;
@@ -372,6 +459,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
             const funcTools = projected.tools;
             let suspendForHuman = false;
             let llmGenModelForGen = model;
+            let contextHealthForGen;
             await dlg.notifyGeneratingStart();
             try {
                 const currentPrompt = pendingPrompt;
@@ -553,6 +641,12 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                         nonStreamResult.llmGenModel.trim() !== '') {
                         llmGenModelForGen = nonStreamResult.llmGenModel.trim();
                     }
+                    contextHealthForGen = computeContextHealthSnapshot({
+                        providerCfg,
+                        model,
+                        usage: nonStreamResult.usage,
+                    });
+                    dlg.setLastContextHealth(contextHealthForGen);
                     const nonStreamMsgs = nonStreamResult.messages;
                     const assistantMsgs = nonStreamMsgs.filter((m) => m.type === 'saying_msg' || m.type === 'thinking_msg');
                     const collectedAssistantCalls = [];
@@ -802,6 +896,12 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                     streamResult.llmGenModel.trim() !== '') {
                     llmGenModelForGen = streamResult.llmGenModel.trim();
                 }
+                contextHealthForGen = computeContextHealthSnapshot({
+                    providerCfg,
+                    model,
+                    usage: streamResult.usage,
+                });
+                dlg.setLastContextHealth(contextHealthForGen);
                 const collectedCalls = parser.getCollectedCalls();
                 const policyViolation = (0, policy_1.resolveDriverV2PolicyViolationKind)({
                     policy,
@@ -887,7 +987,7 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
                 }
             }
             finally {
-                await dlg.notifyGeneratingFinish(undefined, llmGenModelForGen);
+                await dlg.notifyGeneratingFinish(contextHealthForGen, llmGenModelForGen);
             }
         }
         finalRunState = await (0, dialog_run_state_1.computeIdleRunState)(dlg);

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

@@ -49,6 +49,13 @@ function runBackendDriver() {
                 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);
+                            await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+                            continue;
+                        }
                         if (!(await rootDialog.canDrive())) {
                             continue;
                         }

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

@@ -6,11 +6,65 @@ const dialog_run_state_1 = require("../../dialog-run-state");
 const log_1 = require("../../log");
 const load_1 = require("../../minds/load");
 const persistence_1 = require("../../persistence");
+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 context_health_1 = require("./context-health");
 const core_1 = require("./core");
 const policy_1 = require("./policy");
 const supdialog_response_1 = require("./supdialog-response");
+const defaultCriticalCountdownGenerations = 5;
+const contextHealthRoundStateByDialogKey = new Map();
+function getContextHealthRoundState(dialog) {
+    const key = dialog.id.key();
+    const existing = contextHealthRoundStateByDialogKey.get(key);
+    if (existing) {
+        return existing;
+    }
+    const created = {};
+    contextHealthRoundStateByDialogKey.set(key, created);
+    return created;
+}
+function resetContextHealthRoundState(dialog) {
+    contextHealthRoundStateByDialogKey.delete(dialog.id.key());
+}
+function resolveCriticalCountdownRemaining(dialog, snapshot) {
+    if (!snapshot || snapshot.kind !== 'available') {
+        resetContextHealthRoundState(dialog);
+        return defaultCriticalCountdownGenerations;
+    }
+    if (snapshot.level !== 'critical') {
+        if (snapshot.level === 'healthy') {
+            resetContextHealthRoundState(dialog);
+            return defaultCriticalCountdownGenerations;
+        }
+        const state = getContextHealthRoundState(dialog);
+        state.lastSeenLevel = snapshot.level;
+        state.criticalCountdownRemaining = undefined;
+        return defaultCriticalCountdownGenerations;
+    }
+    const state = getContextHealthRoundState(dialog);
+    if (state.lastSeenLevel !== 'critical' ||
+        typeof state.criticalCountdownRemaining !== 'number' ||
+        !Number.isFinite(state.criticalCountdownRemaining)) {
+        state.lastSeenLevel = 'critical';
+        state.criticalCountdownRemaining = defaultCriticalCountdownGenerations;
+    }
+    const remaining = Math.floor(state.criticalCountdownRemaining);
+    return remaining > 0 ? remaining : 0;
+}
+function consumeCriticalCountdown(dialog) {
+    const state = getContextHealthRoundState(dialog);
+    const currentRaw = typeof state.criticalCountdownRemaining === 'number' &&
+        Number.isFinite(state.criticalCountdownRemaining)
+        ? Math.floor(state.criticalCountdownRemaining)
+        : defaultCriticalCountdownGenerations;
+    const current = currentRaw > 0 ? currentRaw : 0;
+    const next = Math.max(0, current - 1);
+    state.lastSeenLevel = 'critical';
+    state.criticalCountdownRemaining = next;
+    return next;
+}
 function resolveEffectivePrompt(dialog, humanPrompt) {
     if (humanPrompt) {
         return humanPrompt;
@@ -39,6 +93,7 @@ async function executeDriveRound(args) {
     let followUp;
     let driveResult;
     let subdialogReplyTarget;
+    const allowResumeFromInterrupted = driveOptions?.allowResumeFromInterrupted === true || humanPrompt?.origin === 'user';
     try {
         // Prime active-run registration right after acquiring dialog lock so user stop can
         // reliably interrupt queued auto-revive drives during preflight.
@@ -53,6 +108,23 @@ async function executeDriveRound(args) {
                 latest.runState.kind === 'dead') {
                 return;
             }
+            if (latest && latest.runState && latest.runState.kind === 'proceeding_stop_requested') {
+                log_1.log.info('driver-v2 skip drive while stop request is still being processed', undefined, {
+                    dialogId: dialog.id.valueOf(),
+                    reason: latest.runState.reason,
+                });
+                return;
+            }
+            if (latest &&
+                latest.runState &&
+                latest.runState.kind === 'interrupted' &&
+                !allowResumeFromInterrupted) {
+                log_1.log.info('driver-v2 skip drive for interrupted dialog without explicit resume/user prompt', undefined, {
+                    dialogId: dialog.id.valueOf(),
+                    reason: latest.runState.reason,
+                });
+                return;
+            }
         }
         catch (err) {
             log_1.log.warn('driver-v2 failed to check runState before drive; proceeding best-effort', err, {
@@ -71,18 +143,56 @@ async function executeDriveRound(args) {
         if (!validation.ok) {
             throw new Error(`driver-v2 policy invariant violation: ${validation.detail}`);
         }
+        const snapshot = dialog.getLastContextHealth();
+        const hasQueuedUpNext = dialog.hasUpNext();
+        const criticalCountdownRemaining = resolveCriticalCountdownRemaining(dialog, snapshot);
         const healthDecision = (0, context_health_1.decideDriverV2ContextHealth)({
-            snapshot: dialog.getLastContextHealth(),
-            hadUserPromptThisGen: args.driveArgs[1] !== undefined,
-            criticalCountdownRemaining: 1,
+            snapshot,
+            hadUserPromptThisGen: humanPrompt !== undefined,
+            criticalCountdownRemaining,
         });
         if (healthDecision.kind === 'suspend') {
             return;
         }
+        let healthPrompt;
+        if (healthDecision.kind === 'continue') {
+            if (healthDecision.reason === 'critical_force_new_course') {
+                const language = (0, runtime_language_1.getWorkLanguage)();
+                const newCoursePrompt = language === 'zh'
+                    ? '系统因上下文已告急（critical）而自动开启新一程对话，请继续推进任务。'
+                    : 'System auto-started a new dialog course because context health is critical. Please continue the task.';
+                await dialog.startNewCourse(newCoursePrompt);
+                dialog.setLastContextHealth({ kind: 'unavailable', reason: 'usage_unavailable' });
+                resetContextHealthRoundState(dialog);
+            }
+            else if (!hasQueuedUpNext) {
+                const language = (0, runtime_language_1.getWorkLanguage)();
+                const guideText = healthDecision.reason === 'caution_soft_remediation'
+                    ? (0, driver_messages_1.formatUserFacingContextHealthV3RemediationGuide)(language, {
+                        kind: 'caution',
+                        mode: 'soft',
+                    })
+                    : (0, driver_messages_1.formatUserFacingContextHealthV3RemediationGuide)(language, {
+                        kind: 'critical',
+                        mode: 'countdown',
+                        promptsRemainingAfterThis: consumeCriticalCountdown(dialog),
+                        promptsTotal: defaultCriticalCountdownGenerations,
+                    });
+                healthPrompt = {
+                    content: guideText,
+                    msgId: (0, id_1.generateShortId)(),
+                    grammar: 'markdown',
+                    userLanguageCode: language,
+                };
+            }
+        }
         args.runtime.driveCount += 1;
         args.runtime.totalGenIterations += 1;
         args.runtime.usedLegacyDriveCore = false;
-        const effectivePrompt = resolveEffectivePrompt(dialog, humanPrompt);
+        const promptForCore = healthDecision.kind === 'continue' && healthDecision.reason === 'critical_force_new_course'
+            ? undefined
+            : (healthPrompt ?? humanPrompt);
+        const effectivePrompt = resolveEffectivePrompt(dialog, promptForCore);
         subdialogReplyTarget = effectivePrompt?.subdialogReplyTarget;
         if (effectivePrompt && effectivePrompt.userLanguageCode) {
             dialog.setLastUserLanguageCode(effectivePrompt.userLanguageCode);

package/dist/llm/driver-v2/tellask-bridge.js

@@ -193,6 +193,33 @@ async function updateSubdialogAssignment(subdialog, assignment) {
     subdialog.assignmentFromSup = assignment;
     await persistence_1.DialogPersistence.updateSubdialogAssignment(subdialog.id, assignment);
 }
+async function lookupLiveRegisteredSubdialog(rootDialog, agentId, tellaskSession) {
+    const existing = rootDialog.lookupSubdialog(agentId, tellaskSession);
+    if (!existing) {
+        return undefined;
+    }
+    const existingSession = existing.tellaskSession;
+    if (!existingSession) {
+        throw new Error(`Type B registry invariant violation: lookupSubdialog returned entry without tellaskSession (root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()})`);
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(existing.id, rootDialog.status);
+    const runState = latest?.runState;
+    if (!runState || runState.kind !== 'dead') {
+        return existing;
+    }
+    const removed = rootDialog.unregisterSubdialog(existing.agentId, existingSession);
+    if (!removed) {
+        throw new Error(`Failed to unregister dead registered subdialog: root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()} session=${existingSession}`);
+    }
+    await rootDialog.saveSubdialogRegistry();
+    log_1.log.info('Pruned dead registered subdialog from Type B registry', undefined, {
+        rootId: rootDialog.id.rootId,
+        subdialogId: existing.id.selfId,
+        agentId: existing.agentId,
+        tellaskSession: existingSession,
+    });
+    return undefined;
+}
 function extractLastAssistantResponse(messages, defaultMessage) {
     let responseText = '';
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -662,7 +689,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                             callId,
                             collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                         };
-                        const existing = rootDialog.lookupSubdialog(parseResult.agentId, derivedSession);
+                        const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, derivedSession);
                         if (existing) {
                             try {
                                 await updateSubdialogAssignment(existing, assignment);
@@ -902,7 +929,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 };
                 const pendingOwner = callerDialog;
                 const result = await (0, subdialog_txn_1.withSubdialogTxnLock)(rootDialog.id, async () => {
-                    const existing = rootDialog.lookupSubdialog(parseResult.agentId, parseResult.tellaskSession);
+                    const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, parseResult.tellaskSession);
                     if (existing) {
                         try {
                             await updateSubdialogAssignment(existing, assignment);

package/dist/llm/driver.js

@@ -915,6 +915,7 @@ async function driveDialogStream(dlg, humanPrompt, waitInQue = false, driveOptio
     if (!waitInQue && dlg.isLocked()) {
         throw new Error(`Dialog busy driven, see how it proceeded and try again.`);
     }
+    const allowResumeFromInterrupted = driveOptions?.allowResumeFromInterrupted === true || humanPrompt?.origin === 'user';
     const release = await dlg.acquire();
     let followUp;
     let driveResult;
@@ -930,6 +931,23 @@ async function driveDialogStream(dlg, humanPrompt, waitInQue = false, driveOptio
                 latest.runState.kind === 'dead') {
                 return;
             }
+            if (latest && latest.runState && latest.runState.kind === 'proceeding_stop_requested') {
+                log_1.log.info('Skip drive while stop request is still being processed', undefined, {
+                    dialogId: dlg.id.valueOf(),
+                    reason: latest.runState.reason,
+                });
+                return;
+            }
+            if (latest &&
+                latest.runState &&
+                latest.runState.kind === 'interrupted' &&
+                !allowResumeFromInterrupted) {
+                log_1.log.info('Skip drive for interrupted dialog without explicit resume/user prompt', undefined, {
+                    dialogId: dlg.id.valueOf(),
+                    reason: latest.runState.reason,
+                });
+                return;
+            }
         }
         catch (err) {
             log_1.log.warn('Failed to check runState before drive; proceeding best-effort', err, {
@@ -991,6 +1009,13 @@ async function runBackendDriver() {
             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);
+                        await persistence_1.DialogPersistence.setNeedsDrive(rootDialog.id, false, rootDialog.status);
+                        continue;
+                    }
                     if (!(await rootDialog.canDrive())) {
                         continue;
                     }
@@ -2757,6 +2782,33 @@ async function updateSubdialogAssignment(subdialog, assignment) {
     subdialog.assignmentFromSup = assignment;
     await persistence_1.DialogPersistence.updateSubdialogAssignment(subdialog.id, assignment);
 }
+async function lookupLiveRegisteredSubdialog(rootDialog, agentId, tellaskSession) {
+    const existing = rootDialog.lookupSubdialog(agentId, tellaskSession);
+    if (!existing) {
+        return undefined;
+    }
+    const existingSession = existing.tellaskSession;
+    if (!existingSession) {
+        throw new Error(`Type B registry invariant violation: lookupSubdialog returned entry without tellaskSession (root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()})`);
+    }
+    const latest = await persistence_1.DialogPersistence.loadDialogLatest(existing.id, rootDialog.status);
+    const runState = latest?.runState;
+    if (!runState || runState.kind !== 'dead') {
+        return existing;
+    }
+    const removed = rootDialog.unregisterSubdialog(existing.agentId, existingSession);
+    if (!removed) {
+        throw new Error(`Failed to unregister dead registered subdialog: root=${rootDialog.id.valueOf()} sub=${existing.id.valueOf()} session=${existingSession}`);
+    }
+    await rootDialog.saveSubdialogRegistry();
+    log_1.log.info('Pruned dead registered subdialog from Type B registry', undefined, {
+        rootId: rootDialog.id.rootId,
+        subdialogId: existing.id.selfId,
+        agentId: existing.agentId,
+        tellaskSession: existingSession,
+    });
+    return undefined;
+}
 let agentPrimingModulePromise = null;
 async function scheduleInheritedAgentPrimingForSubdialog(callerDialog, subdialog) {
     const rootDialog = callerDialog instanceof dialog_1.RootDialog
@@ -3550,7 +3602,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                             callId,
                             collectiveTargets: options?.collectiveTargets ?? [parseResult.agentId],
                         };
-                        const existing = rootDialog.lookupSubdialog(parseResult.agentId, derivedSession);
+                        const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, derivedSession);
                         if (existing) {
                             try {
                                 await updateSubdialogAssignment(existing, assignment);
@@ -3822,7 +3874,7 @@ async function executeTellaskCall(dlg, agent, firstMention, tellaskHead, body, c
                 };
                 const pendingOwner = callerDialog;
                 const result = await withSuspensionStateLock(rootDialog.id, async () => {
-                    const existing = rootDialog.lookupSubdialog(parseResult.agentId, parseResult.tellaskSession);
+                    const existing = await lookupLiveRegisteredSubdialog(rootDialog, parseResult.agentId, parseResult.tellaskSession);
                     if (existing) {
                         try {
                             await updateSubdialogAssignment(existing, assignment);

package/dist/persistence.js

@@ -941,9 +941,26 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
     }
     async loadSubdialogRegistry(rootDialog, status) {
         const entries = await DialogPersistence.loadSubdialogRegistry(rootDialog.id, status);
+        const shouldPruneDead = status === 'running';
+        let prunedDeadRegistryEntries = false;
         for (const entry of entries) {
             if (!entry.tellaskSession)
                 continue;
+            if (shouldPruneDead) {
+                const latest = await DialogPersistence.loadDialogLatest(entry.subdialogId, status);
+                const runState = latest?.runState;
+                if (runState && runState.kind === 'dead') {
+                    prunedDeadRegistryEntries = true;
+                    rootDialog.unregisterSubdialog(entry.agentId, entry.tellaskSession);
+                    log_1.log.info('Skip dead subdialog while loading Type B registry', undefined, {
+                        rootId: rootDialog.id.rootId,
+                        subdialogId: entry.subdialogId.selfId,
+                        agentId: entry.agentId,
+                        tellaskSession: entry.tellaskSession,
+                    });
+                    continue;
+                }
+            }
             const existing = rootDialog.lookupDialog(entry.subdialogId.selfId);
             if (existing) {
                 if (existing instanceof dialog_1.SubDialog && existing.tellaskSession) {
@@ -965,6 +982,9 @@ class DiskFileDialogStore extends dialog_1.DialogStore {
             });
             rootDialog.registerSubdialog(subdialog);
         }
+        if (prunedDeadRegistryEntries) {
+            await rootDialog.saveSubdialogRegistry();
+        }
     }
     /**
      * Clear Questions for Human state in storage