evolcore 0.0.26 → 0.0.27

package/dist/core/message/message-queue.js

@@ -4,6 +4,7 @@ import { logger } from '../../utils/logger.js';
 import { LogicalQueueBridge } from './logical-queue-bridge.js';
 import { normalizeCausation } from '../causation/context.js';
 import { KeyedFairMutex } from '../handoff/mutex.js';
+import { ExecutionTimeoutError, OrphanedTargetSessionError, isExecutionFailure } from '../../utils/error-utils.js';
 const DEFAULT_AGENT_NAME = '<unknown>';
 const RESTART_RESUME_CONTENT = 'evolcore 服务已重启，请继续之前未完成的任务。';
 export class MessageQueue {
@@ -52,7 +53,7 @@ export class MessageQueue {
     setInterruptCallback(callback) {
         this.interruptCallback = callback;
     }
-    triggerInterrupt(queueKey, sessionKey, baseagent, evolagentName, reason) {
+    triggerInterrupt(queueKey, sessionKey, baseagent, evolagentName, reason, timeout) {
         const existing = this.interruptBarriers.get(queueKey);
         if (existing)
             return existing;
@@ -61,7 +62,9 @@ export class MessageQueue {
         this.activeTerminalReasons.set(queueKey, reason);
         let interruption;
         try {
-            interruption = Promise.resolve(this.interruptCallback(sessionKey, baseagent, evolagentName, reason));
+            interruption = Promise.resolve(timeout
+                ? this.interruptCallback(sessionKey, baseagent, evolagentName, reason, timeout)
+                : this.interruptCallback(sessionKey, baseagent, evolagentName, reason));
         }
         catch (error) {
             interruption = Promise.reject(error);
@@ -980,7 +983,8 @@ export class MessageQueue {
                     this.persistQueuesImmediate();
                 }
                 else if (message.messageId) {
-                    void this.cancelActiveAndWait(message.messageId, message.selfAID).finally(() => {
+                    const timeout = isExecutionFailure(options?.signal?.reason) ? options.signal.reason : undefined;
+                    void this.cancelActiveAndWait(message.messageId, message.selfAID, timeout).finally(() => {
                         this.forgetProcessed(sessionKey, message);
                         settleReject(error);
                     });
@@ -1262,7 +1266,9 @@ export class MessageQueue {
         return result;
     }
     isMergeBarrier(message) {
-        return !!message.executionPermissionOverride
+        return !!message.taskRecovery
+            || !!message.asyncQuestionAnswer
+            || !!message.executionPermissionOverride
             || !!message.handoffDelivery
             || !!message.triggerMeta
             || !!message.causation?.trigger?.path.length;
@@ -1525,12 +1531,14 @@ export class MessageQueue {
         return cancellation.found;
     }
     /** Cancel an active message and wait until the runner interrupt barrier settles. */
-    async cancelActiveAndWait(messageId, selfAID) {
-        const cancellation = this.beginActiveCancellation(messageId, selfAID);
+    async cancelActiveAndWait(messageId, selfAID, cause) {
+        const cancellation = this.beginActiveCancellation(messageId, selfAID, cause);
         await cancellation.barrier;
         return cancellation.found;
     }
-    beginActiveCancellation(messageId, selfAID) {
+    beginActiveCancellation(messageId, selfAID, cause) {
+        const reason = cause instanceof ExecutionTimeoutError ? 'timeout'
+            : cause instanceof OrphanedTargetSessionError ? 'execution_error' : cause ?? 'recalled';
         for (const [queueKey, activeState] of this.activeStates.entries()) {
             if (!activeState.messageIds.has(messageId))
                 continue;
@@ -1558,18 +1566,20 @@ export class MessageQueue {
             }
             const sessionKey = this.sessionKeyFromQueueKey(queueKey);
             const agentName = this.processingAgent.get(queueKey);
-            logger.info(`[Queue] Recalled active message ${messageId}, interrupting session ${sessionKey}`);
-            this.eventBus?.publish({
-                type: 'task:interrupted',
-                sessionId: sessionKey,
-                reason: 'recalled',
-                agentName,
-                taskId: activeState?.taskId,
-                generation: activeState?.generation,
-                causation: active?.message.causation,
-            });
+            logger.info(`[Queue] Cancelled active message ${messageId}, interrupting session ${sessionKey}: ${reason}`);
+            // TimeoutController owns the failure event and outbound timeout terminal.
+            if (reason !== 'timeout' && reason !== 'execution_error')
+                this.eventBus?.publish({
+                    type: 'task:interrupted',
+                    sessionId: sessionKey,
+                    reason,
+                    agentName,
+                    taskId: activeState?.taskId,
+                    generation: activeState?.generation,
+                    causation: active?.message.causation,
+                });
             const barrier = this.interruptCallback
-                ? this.triggerInterrupt(queueKey, sessionKey, activeState.baseagent, agentName, 'recalled')
+                ? this.triggerInterrupt(queueKey, sessionKey, activeState.baseagent, agentName, reason, isExecutionFailure(cause) ? cause : undefined)
                 : Promise.resolve();
             return { found: true, barrier };
         }
@@ -1603,33 +1613,11 @@ export class MessageQueue {
         }
         let releasePromise;
         const promise = new Promise(resolve => { releasePromise = resolve; });
-        let queued = 0;
-        let active = false;
-        let dispatching = false;
-        for (const [queueKey, queue] of this.queues.entries()) {
-            if (!this.matchesSession(queueKey, sessionKey))
-                continue;
-            queued += this.queueRawMessageCount(queue);
-            if (this.processing.has(queueKey) || this.activeBatches.has(queueKey))
-                active = true;
-            if (this.processing.has(queueKey) && !this.activeBatches.has(queueKey))
-                dispatching = true;
-        }
-        for (const queueKey of this.activeBatches.keys()) {
-            if (this.matchesSession(queueKey, sessionKey))
-                active = true;
-        }
         const state = {
             promise,
             releasePromise,
             holders: 1,
-            snapshot: {
-                prequeue: this.prequeueReservations.get(sessionKey) ?? 0,
-                active,
-                queued,
-                dispatching,
-                cutoff: this.enqueueSequence,
-            },
+            snapshot: this.getSessionSnapshot(sessionKey),
         };
         this.externalLocks.set(sessionKey, state);
         let released = false;
@@ -1648,6 +1636,50 @@ export class MessageQueue {
             },
         };
     }
+    /** Live admission state, including work that arrived after an older gate. */
+    getMessageState(sessionId, messageId, selfAid) {
+        for (const [key, queue] of this.queues) {
+            if (this.matchesSession(key, sessionId) && queue.some(item => this.partsOf(item)
+                .some(part => this.partMatchesMessage(part, messageId, selfAid, key))))
+                return { state: 'queued' };
+        }
+        for (const [key, item] of this.activeBatches) {
+            if (this.matchesSession(key, sessionId) && this.partsOf(item)
+                .some(part => this.partMatchesMessage(part, messageId, selfAid, key))) {
+                return { state: 'active' };
+            }
+        }
+        return { state: 'missing' };
+    }
+    /** Live admission state, including work that arrived after an older gate. */
+    getSessionSnapshot(sessionKey) {
+        let queued = 0;
+        let active = false;
+        let dispatching = false;
+        const activeTaskIds = new Set();
+        for (const [queueKey, queue] of this.queues.entries()) {
+            if (!this.matchesSession(queueKey, sessionKey))
+                continue;
+            queued += this.queueRawMessageCount(queue);
+            if (this.processing.has(queueKey) || this.activeBatches.has(queueKey))
+                active = true;
+            if (this.processing.has(queueKey) && !this.activeBatches.has(queueKey))
+                dispatching = true;
+        }
+        for (const queueKey of this.activeBatches.keys()) {
+            if (!this.matchesSession(queueKey, sessionKey))
+                continue;
+            active = true;
+            const taskId = this.activeStates.get(queueKey)?.taskId;
+            if (taskId)
+                activeTaskIds.add(taskId);
+        }
+        return {
+            prequeue: this.prequeueReservations.get(sessionKey) ?? 0,
+            active, queued, dispatching, cutoff: this.enqueueSequence,
+            activeTaskIds: [...activeTaskIds],
+        };
+    }
     /**
      * Mark an admitted message before it enters debounce or other pre-queue
      * work. The returned release is idempotent so callers can use it both from