evolcore 0.0.25 → 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;
@@ -1275,6 +1281,8 @@ export class MessageQueue {
             return false;
         if (first.projectPath !== next.projectPath || first.agentName !== next.agentName)
             return false;
+        // Results from the same parent handoff are still mergeable. Their
+        // resultRefs are retained and consumed individually after one turn.
         const a = first.message.handoffDelivery?.originAuthorization;
         const b = next.message.handoffDelivery?.originAuthorization;
         if (!a || !b)
@@ -1323,6 +1331,10 @@ export class MessageQueue {
         let hasMessagesAfterRestartResume = false;
         const originHandoffIds = [];
         const seenOriginHandoffIds = new Set();
+        const originResultIds = [];
+        const seenOriginResultIds = new Set();
+        const originResultRefs = [];
+        const seenOriginResultRefs = new Set();
         const allOriginHandoffs = items.every(item => this.isOriginHandoff(item.message));
         for (const item of items) {
             const m = item.message;
@@ -1347,6 +1359,24 @@ export class MessageQueue {
                         originHandoffIds.push(id);
                     }
                 }
+                const refs = m.handoffDelivery.resultRefs?.length
+                    ? m.handoffDelivery.resultRefs
+                    : (m.handoffDelivery.resultIds?.length
+                        ? m.handoffDelivery.resultIds.map(resultId => ({ handoffId: m.handoffDelivery.handoffId, resultId }))
+                        : (m.handoffDelivery.resultId
+                            ? [{ handoffId: m.handoffDelivery.handoffId, resultId: m.handoffDelivery.resultId }]
+                            : []));
+                for (const ref of refs) {
+                    const refKey = `${ref.handoffId}\u0000${ref.resultId}`;
+                    if (!seenOriginResultRefs.has(refKey)) {
+                        seenOriginResultRefs.add(refKey);
+                        originResultRefs.push(ref);
+                    }
+                    if (!seenOriginResultIds.has(ref.resultId)) {
+                        seenOriginResultIds.add(ref.resultId);
+                        originResultIds.push(ref.resultId);
+                    }
+                }
             }
             for (const id of [...(m.sourceMessageIds ?? []), ...(m.messageId ? [m.messageId] : [])]) {
                 if (!seenSourceMessageIds.has(id)) {
@@ -1418,6 +1448,8 @@ export class MessageQueue {
                     ...last.message.handoffDelivery,
                     handoffId: originHandoffIds[0],
                     handoffIds: originHandoffIds,
+                    ...(originResultIds.length > 0 ? { resultIds: originResultIds } : {}),
+                    ...(originResultRefs.length > 0 ? { resultRefs: originResultRefs } : {}),
                 }
                 : last.message.handoffDelivery,
         };
@@ -1499,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;
@@ -1532,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 };
         }
@@ -1577,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;
@@ -1622,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

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

@@ -101,6 +101,7 @@ export function deliveryTargetFromSession(session) {
 export function replyContextFromSession(session, context) {
     return {
         ...(session.metadata?.replyContext ?? {}),
+        ...(session.threadId ? { threadId: session.threadId } : {}),
         ...(context ?? {}),
         // Session chatType/groupId is the persisted routing authority. The nested
         // reply context can outlive a route correction, so only an explicit