dominds 1.25.6 → 1.25.7

package/dist/dialog-display-state.js

@@ -103,6 +103,16 @@ function q4hSuspensionDisplayState(hasQ4H) {
     }
     return undefined;
 }
+function pendingReplyObligationDisplayState(activeReplyObligation) {
+    if (activeReplyObligation === undefined) {
+        return undefined;
+    }
+    return {
+        kind: 'stopped',
+        reason: { kind: 'pending_reply_obligation' },
+        continueEnabled: true,
+    };
+}
 async function resolveSideDialogFinalResponseClosure(args) {
     if (!args.latest) {
         return { kind: 'no_final_response' };
@@ -111,26 +121,50 @@ async function resolveSideDialogFinalResponseClosure(args) {
     if (!finalResponseAnchor) {
         return { kind: 'no_final_response' };
     }
+    const finalResponseCallId = finalResponseAnchor.callId.trim();
     const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(args.dialogId, 'running');
     if (activeReplyObligation === undefined) {
         return {
             kind: 'closed_without_active_reply_obligation',
-            callId: finalResponseAnchor.callId,
+            callId: finalResponseCallId,
         };
     }
-    if (activeReplyObligation.targetCallId === finalResponseAnchor.callId) {
+    if (activeReplyObligation.targetCallId.trim() === finalResponseCallId) {
         return {
             kind: 'closed_with_matching_reply_obligation',
-            callId: finalResponseAnchor.callId,
+            callId: finalResponseCallId,
             activeReplyObligation,
         };
     }
     return {
         kind: 'blocked_by_different_reply_obligation',
-        callId: finalResponseAnchor.callId,
+        callId: finalResponseCallId,
         activeReplyObligation,
     };
 }
+async function clearMatchingFinalResponseReplyObligation(dialogId, closure) {
+    if (closure.kind !== 'closed_with_matching_reply_obligation') {
+        return false;
+    }
+    await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(dialogId, undefined, 'running');
+    return true;
+}
+async function settleFinalResponseClosureForIdleProjection(dialogId, closure) {
+    switch (closure.kind) {
+        case 'no_final_response':
+        case 'blocked_by_different_reply_obligation':
+            return false;
+        case 'closed_without_active_reply_obligation':
+            return true;
+        case 'closed_with_matching_reply_obligation':
+            await clearMatchingFinalResponseReplyObligation(dialogId, closure);
+            return true;
+        default: {
+            const _exhaustive = closure;
+            throw new Error(`Unhandled final response closure kind: ${String(_exhaustive)}`);
+        }
+    }
+}
 function classifyRunControlBucket(state) {
     if (!state)
         return 'none';
@@ -372,6 +406,7 @@ async function setDialogDisplayState(dialogId, displayState, status = 'running')
         });
         return;
     }
+    let nextDisplayState = displayState;
     let previousDisplayState;
     let previousExecutionMarker;
     // "dead" is irreversible. Once a dialog is marked dead, do not allow overwriting it with
@@ -397,24 +432,53 @@ async function setDialogDisplayState(dialogId, displayState, status = 'running')
             }
             return;
         }
+        if (status === 'running' && displayState.kind === 'idle_waiting_user') {
+            const finalResponseClosure = await resolveSideDialogFinalResponseClosure({
+                dialogId,
+                latest,
+            });
+            const finalResponseClosedForIdle = await settleFinalResponseClosureForIdleProjection(dialogId, finalResponseClosure);
+            if (!finalResponseClosedForIdle) {
+                const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, status);
+                const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+                if (pendingReplyObligation) {
+                    nextDisplayState = pendingReplyObligation;
+                    log.warn('Redirecting idle displayState to pending reply obligation projection', undefined, {
+                        dialogId: dialogId.valueOf(),
+                        rootId: dialogId.rootId,
+                        selfId: dialogId.selfId,
+                        status,
+                        targetCallId: activeReplyObligation?.targetCallId ?? null,
+                        targetDialogId: activeReplyObligation?.targetDialogId.valueOf() ?? null,
+                        previousDisplayState: latest?.displayState ?? null,
+                        previousExecutionMarker: latest?.executionMarker ?? null,
+                        sideDialogFinalResponseCallId: latest?.sideDialogFinalResponse?.callId ?? null,
+                    });
+                }
+            }
+        }
     }
     catch (err) {
         log.warn('Failed to check existing displayState before setDialogDisplayState', err, {
             dialogId: dialogId.valueOf(),
             status,
+            intendedDisplayState: displayState,
         });
+        if (status === 'running' && displayState.kind === 'idle_waiting_user') {
+            return;
+        }
     }
-    const nextExecutionMarker = displayState.kind === 'stopped'
-        ? { kind: 'interrupted', reason: displayState.reason }
-        : displayState.kind === 'dead'
-            ? { kind: 'dead', reason: displayState.reason }
+    const nextExecutionMarker = nextDisplayState.kind === 'stopped'
+        ? { kind: 'interrupted', reason: nextDisplayState.reason }
+        : nextDisplayState.kind === 'dead'
+            ? { kind: 'dead', reason: nextDisplayState.reason }
             : previousExecutionMarker?.kind === 'interrupted'
                 ? undefined
                 : previousExecutionMarker;
     try {
         await persistence_1.DialogPersistence.mutateDialogLatest(dialogId, () => ({
             kind: 'patch',
-            patch: { displayState, executionMarker: nextExecutionMarker },
+            patch: { displayState: nextDisplayState, executionMarker: nextExecutionMarker },
         }), status);
     }
     catch (err) {
@@ -424,11 +488,12 @@ async function setDialogDisplayState(dialogId, displayState, status = 'running')
             selfId: dialogId.selfId,
             status,
             intendedDisplayState: displayState,
+            persistedDisplayState: nextDisplayState,
         });
     }
     const typed = evt_registry_1.dialogEventRegistry.createTypedEvent(dialogId, {
         type: 'dlg_display_state_evt',
-        displayState,
+        displayState: nextDisplayState,
     });
     if (broadcastToClients) {
         broadcastToClients(typed);
@@ -487,10 +552,14 @@ async function computeIdleDisplayState(dlg) {
         dialogId: dlg.id,
         latest,
     });
-    if (finalResponseClosure.kind === 'closed_without_active_reply_obligation' ||
-        finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
+    if (await settleFinalResponseClosureForIdleProjection(dlg.id, finalResponseClosure)) {
         return { kind: 'idle_waiting_user' };
     }
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dlg.id, dlg.status);
+    const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+    if (pendingReplyObligation) {
+        return pendingReplyObligation;
+    }
     return { kind: 'idle_waiting_user' };
 }
 async function computeIdleDisplayStateFromPersistence(dialogId) {
@@ -525,10 +594,14 @@ async function computeIdleDisplayStateFromPersistence(dialogId) {
         return q4hSuspension;
     }
     const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
-    if (finalResponseClosure.kind === 'closed_without_active_reply_obligation' ||
-        finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
+    if (await settleFinalResponseClosureForIdleProjection(dialogId, finalResponseClosure)) {
         return { kind: 'idle_waiting_user' };
     }
+    const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
+    const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+    if (pendingReplyObligation) {
+        return pendingReplyObligation;
+    }
     return { kind: 'idle_waiting_user' };
 }
 async function healStaleSideDialogRunControlAfterFinalResponse(args) {
@@ -549,19 +622,12 @@ async function healStaleSideDialogRunControlAfterFinalResponse(args) {
         dialogId: args.dialogId,
         latest: args.latest,
     });
-    switch (finalResponseClosure.kind) {
-        case 'no_final_response':
-        case 'blocked_by_different_reply_obligation':
-            return args.latest;
-        case 'closed_without_active_reply_obligation':
-            break;
-        case 'closed_with_matching_reply_obligation':
-            await persistence_1.DialogPersistence.setActiveTellaskReplyObligation(args.dialogId, undefined, 'running');
-            break;
-        default: {
-            const _exhaustive = finalResponseClosure;
-            throw new Error(`Unhandled final response closure kind: ${String(_exhaustive)}`);
-        }
+    if (finalResponseClosure.kind !== 'closed_without_active_reply_obligation' &&
+        finalResponseClosure.kind !== 'closed_with_matching_reply_obligation') {
+        return args.latest;
+    }
+    if (!(await settleFinalResponseClosureForIdleProjection(args.dialogId, finalResponseClosure))) {
+        return args.latest;
     }
     const clearedReplyObligation = finalResponseClosure.kind === 'closed_with_matching_reply_obligation';
     log.warn('Healing stale sideDialog run-control flags after final response anchor', undefined, {
@@ -643,10 +709,14 @@ async function refreshRunControlProjectionFromPersistenceFacts(dialogId, trigger
             return q4hSuspension;
         }
         const finalResponseClosure = await resolveSideDialogFinalResponseClosure({ dialogId, latest });
-        if (finalResponseClosure.kind === 'closed_without_active_reply_obligation' ||
-            finalResponseClosure.kind === 'closed_with_matching_reply_obligation') {
+        if (await settleFinalResponseClosureForIdleProjection(dialogId, finalResponseClosure)) {
             return { kind: 'idle_waiting_user' };
         }
+        const activeReplyObligation = await persistence_1.DialogPersistence.loadActiveTellaskReplyObligation(dialogId, 'running');
+        const pendingReplyObligation = pendingReplyObligationDisplayState(activeReplyObligation);
+        if (pendingReplyObligation) {
+            return pendingReplyObligation;
+        }
         if (latest.executionMarker?.kind === 'interrupted' &&
             latest.executionMarker.reason.kind !== 'pending_reply_obligation') {
             return {

package/dist/dialog-fork.js

@@ -272,6 +272,14 @@ function countFunctionCalls(events) {
     return count;
 }
 function computeRootForkDisplayState(args) {
+    const topFrame = args.askerStack?.askerStack[args.askerStack.askerStack.length - 1];
+    if (topFrame?.tellaskReplyObligation !== undefined) {
+        return {
+            kind: 'stopped',
+            reason: { kind: 'pending_reply_obligation' },
+            continueEnabled: true,
+        };
+    }
     if (args.action.kind === 'draft_user_text') {
         return { kind: 'idle_waiting_user' };
     }
@@ -281,6 +289,17 @@ function computeRootForkDisplayState(args) {
     }
     return { kind: 'stopped', reason: { kind: 'fork_continue_ready' }, continueEnabled: true };
 }
+function computeSideDialogForkDisplayState(askerStack) {
+    const topFrame = askerStack?.askerStack[askerStack.askerStack.length - 1];
+    if (topFrame?.tellaskReplyObligation !== undefined) {
+        return {
+            kind: 'stopped',
+            reason: { kind: 'pending_reply_obligation' },
+            continueEnabled: true,
+        };
+    }
+    return { kind: 'idle_waiting_user' };
+}
 async function copyArtifactsIfPresent(sourceId, targetId, sourceStatus) {
     const sourceDir = node_path_1.default.join(persistence_1.DialogPersistence.getDialogEventsPath(sourceId, sourceStatus), 'artifacts');
     const targetDir = node_path_1.default.join(persistence_1.DialogPersistence.getDialogEventsPath(targetId, 'running'), 'artifacts');
@@ -535,32 +554,14 @@ async function persistForkPlan(args) {
     if (sourceAskerStack.askerStack.length > 0) {
         await persistence_1.DialogPersistence.saveDialogAskerStack(plan.targetId, rewriteSideDialogAskerStackStateForFork(sourceAskerStack, plan.sourceId.rootId, plan.targetId.rootId), 'running');
     }
-    for (const course of plan.retainedCourses) {
-        for (const event of course.events) {
-            await persistence_1.DialogPersistence.appendEvent(plan.targetId, course.course, rewriteRecordForFork(event, plan.targetId.rootId), 'running');
-        }
-    }
-    await appendForkBaselineState(plan, args.baselineRecordsByParentSelfId.get(plan.targetId.selfId) ?? []);
-    await persistence_1.DialogPersistence._saveReminderState(plan.targetId, [...plan.reminders], 'running');
-    await persistence_1.DialogPersistence._saveQuestions4HumanState(plan.targetId, [...plan.questions], 'running');
-    for (const record of plan.activeCalleeDispatches) {
-        await persistence_1.DialogPersistence.appendActiveCalleeDispatch(plan.targetId, record, undefined, 'running');
-    }
-    await persistence_1.DialogPersistence.saveSideDialogRegistry(plan.targetId, plan.registryEntries.map((entry) => ({
-        key: entry.key,
-        sideDialogId: new dialog_1.DialogID(entry.sideDialogId, plan.targetId.rootId),
-        agentId: entry.agentId,
-        sessionSlug: entry.sessionSlug,
-    })), 'running');
-    await persistence_1.DialogPersistence.saveSideDialogResponses(plan.targetId, [...plan.sideDialogResponses], undefined, 'running');
-    await copyArtifactsIfPresent(plan.sourceId, plan.targetId, args.sourceStatus);
     const currentCourseEvents = plan.retainedCourses.find((item) => item.course === plan.currentCourse)?.events ?? [];
     const displayState = plan.targetId.selfId === plan.targetId.rootId
         ? computeRootForkDisplayState({
             action: args.action,
             questions: plan.questions,
+            askerStack: sourceAskerStack,
         })
-        : { kind: 'idle_waiting_user' };
+        : computeSideDialogForkDisplayState(sourceAskerStack);
     await persistence_1.DialogPersistence.mutateDialogLatest(plan.targetId, () => ({
         kind: 'replace',
         next: {
@@ -581,6 +582,38 @@ async function persistForkPlan(args) {
                 : undefined,
         },
     }));
+    for (const course of plan.retainedCourses) {
+        for (const event of course.events) {
+            await persistence_1.DialogPersistence.appendEvent(plan.targetId, course.course, rewriteRecordForFork(event, plan.targetId.rootId), 'running');
+        }
+    }
+    await appendForkBaselineState(plan, args.baselineRecordsByParentSelfId.get(plan.targetId.selfId) ?? []);
+    await persistence_1.DialogPersistence._saveReminderState(plan.targetId, [...plan.reminders], 'running');
+    await persistence_1.DialogPersistence._saveQuestions4HumanState(plan.targetId, [...plan.questions], 'running');
+    for (const record of plan.activeCalleeDispatches) {
+        await persistence_1.DialogPersistence.appendActiveCalleeDispatch(plan.targetId, record, undefined, 'running');
+    }
+    await persistence_1.DialogPersistence.saveSideDialogRegistry(plan.targetId, plan.registryEntries.map((entry) => ({
+        key: entry.key,
+        sideDialogId: new dialog_1.DialogID(entry.sideDialogId, plan.targetId.rootId),
+        agentId: entry.agentId,
+        sessionSlug: entry.sessionSlug,
+    })), 'running');
+    await persistence_1.DialogPersistence.saveSideDialogResponses(plan.targetId, [...plan.sideDialogResponses], undefined, 'running');
+    await copyArtifactsIfPresent(plan.sourceId, plan.targetId, args.sourceStatus);
+    await persistence_1.DialogPersistence.mutateDialogLatest(plan.targetId, (previous) => ({
+        kind: 'patch',
+        patch: {
+            currentCourse: plan.currentCourse,
+            messageCount: countMessages(currentCourseEvents),
+            functionCallCount: countFunctionCalls(currentCourseEvents),
+            sideDialogCount: plan.childCount,
+            displayState,
+            executionMarker: displayState.kind === 'stopped'
+                ? { kind: 'interrupted', reason: displayState.reason }
+                : previous.executionMarker,
+        },
+    }));
 }
 async function forkMainDialogTreeAtGeneration(args) {
     const sourceRootId = args.sourceRootId.trim();