evolcore 0.0.31 → 0.0.33

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

@@ -21,6 +21,20 @@ export class MessageQueue {
     interruptBarriers = new Map();
     interruptFailures = new Map();
     activeTerminalReasons = new Map();
+    /**
+     * 允许「未提交输入」回队的 key（仅新消息到达触发的中断）。
+     * 与 activeTerminalReasons 分开：后者还承载 stop/timeout/priority 抢占等
+     * 语义，那些场景绝不能复活旧输入。
+     */
+    requeueableInterrupts = new Set();
+    /**
+     * queueKey → 触发本次 new_message 中断的消息。
+     *
+     * 回队前用它把「打断消息」从 pending 中排除：只有当队列里没有其它等待项时
+     * 才回队。否则重放旧输入会插到那些等待项（如被 defer 的群聊消息）前面，
+     * 打乱既有调度顺序。
+     */
+    interruptingMessages = new Map();
     eventBus;
     recentMessageIds = new Set();
     DEDUP_WINDOW = 60_000; // 1 分钟窗口
@@ -108,6 +122,19 @@ export class MessageQueue {
                 }
             }
         });
+        subscribe.call(eventBus, 'input_accepted', event => {
+            if (!('inputId' in event) || !event.inputId)
+                return;
+            const inputEvent = event;
+            // inputId 格式为 sessionId 或 sessionId:xxx，取第一段匹配
+            const sessionId = inputEvent.inputId.split(':')[0];
+            for (const [queueKey, state] of this.activeStates) {
+                if (this.matchesSession(queueKey, sessionId)) {
+                    state.inputSubmitted = true;
+                    logger.debug(`[MessageQueue] input_accepted for ${queueKey}, taskId=${state.taskId}, generation=${state.generation}`);
+                }
+            }
+        });
         subscribe.call(eventBus, 'task:completed', event => {
             if ('sessionId' in event && event.sessionId)
                 this.markActiveTerminal(event.sessionId, 'completed');
@@ -124,6 +151,37 @@ export class MessageQueue {
                 this.activeTerminalReasons.set(queueKey, reason);
         }
     }
+    /**
+     * 显式允许/禁止该 key 的 active 批次在中断后回队。
+     *
+     * 只有「新消息到达触发的中断」才置 true：那种场景下旧输入尚未提交给模型，
+     * 用户也确实期望两条一起被看到。stop / 优先级抢占 / 超时等一律不允许复活。
+     */
+    markRequeueable(queueKey, requeueable) {
+        if (requeueable)
+            this.requeueableInterrupts.add(queueKey);
+        else
+            this.requeueableInterrupts.delete(queueKey);
+    }
+    /**
+     * 标记 active 批次的输入已真正提交给模型（runner 发出 input_accepted 后调用）。
+     *
+     * 这是 pre-submit 回队的关键判据：只有「未提交」的 active 才能在 new_message
+     * 中断后安全放回队列；已提交的批次若回队，会在 provider session 里产生重复用户轮次。
+     */
+    markInputSubmitted(sessionId, taskId) {
+        for (const [queueKey, state] of this.activeStates) {
+            if (!this.matchesSession(queueKey, sessionId))
+                continue;
+            // 同一 session 可能有多个 queueKey（不同 agent/project），taskId 用来精确定位。
+            if (taskId !== undefined && state.taskId !== undefined && state.taskId !== taskId)
+                continue;
+            state.inputSubmitted = true;
+            state.submittedMessageIds = Array.from(state.messageIds);
+            logger.debug(`[Queue] input submitted: key=${queueKey} task=${taskId ?? '<none>'} ids=${state.submittedMessageIds.join(',')}`);
+            return;
+        }
+    }
     /**
      * 注册一次性消息拦截器：下一条来自 sessionKey 的消息不入队、不触发 interrupt，
      * 直接传给 handler。用于 AskUserQuestion 的"手动输入"场景。
@@ -1082,7 +1140,12 @@ export class MessageQueue {
                     activeState?.peerId === message.peerId &&
                     !this.hasOtherPeerQueued(queueKey, message.peerId);
                 if (interruptSingle || interruptGroupSamePeer) {
-                    logger.debug(`[Queue] ${queueKey} is processing, triggering interrupt (samePeer=${interruptGroupSamePeer})`);
+                    const inputSubmitted = activeState?.inputSubmitted ?? false;
+                    logger.info(`[Queue] new_message interrupt: key=${queueKey} samePeer=${interruptGroupSamePeer} taskId=${activeState?.taskId ?? '<none>'} generation=${activeState?.generation ?? '<none>'} inputSubmitted=${inputSubmitted} activeMsg=${Array.from(activeState?.messageIds ?? []).join(',')}`);
+                    // 新消息到达才允许 pre-submit 回队：旧输入尚未提交给模型，
+                    // 且用户期望它与刚到的消息一起被看到。
+                    this.markRequeueable(queueKey, true);
+                    this.interruptingMessages.set(queueKey, message);
                     this.eventBus?.publish({
                         type: 'task:interrupted',
                         sessionId: sessionKey,
@@ -1218,7 +1281,7 @@ export class MessageQueue {
             this.activeBatches.set(queueKey, activeItem);
             this.processingStartTime.set(queueKey, Date.now());
             this.persistQueuesImmediate();
-            logger.info(`[Queue] processing batch: key=${queueKey} items=${rawItems.length} pending=${queue.length} rawPending=${this.queueRawMessageCount(queue)} batchRole=${merged.message.batchRole ?? '<mixed>'} peer=${activeState.peerId ?? '<multi>'} msg=${merged.message.messageId ?? '<none>'}`);
+            logger.info(`[Queue] processing batch: key=${queueKey} items=${rawItems.length} pending=${queue.length} rawPending=${this.queueRawMessageCount(queue)} batchRole=${merged.message.batchRole ?? '<mixed>'} peer=${activeState.peerId ?? '<multi>'} msg=${merged.message.messageId ?? '<none>'} sourceIds=${Array.from(activeMessageIds).join(',')}`);
             try {
                 await this.handler(merged.message);
                 logger.debug(`[Queue] Message processed successfully`);
@@ -1230,10 +1293,17 @@ export class MessageQueue {
             }
             finally {
                 if (!this.shuttingDown) {
+                    const terminalReason = this.activeTerminalReasons.get(queueKey);
+                    const disposition = this.disposeInterruptedBatch(queueKey, activeState, rawParts, merged.message.causation);
+                    if (disposition !== 'none') {
+                        logger.info(`[Queue] batch disposition: key=${queueKey} reason=${terminalReason ?? '<completed>'} disposition=${disposition}`);
+                    }
                     this.activeBatches.delete(queueKey);
                     this.processingStartTime.delete(queueKey);
                     this.activeStates.delete(queueKey);
                     this.activeTerminalReasons.delete(queueKey);
+                    this.requeueableInterrupts.delete(queueKey);
+                    this.interruptingMessages.delete(queueKey);
                     this.persistQueuesImmediate();
                 }
             }
@@ -1244,6 +1314,63 @@ export class MessageQueue {
             }
         }
     }
+    /**
+     * 决定被中断的 active 批次的下落。
+     *
+     * 只有同时满足两个条件才回队：
+     *  1) 该 key 被显式标记为「新消息到达」（markRequeueable），而不是 stop/超时/优先级抢占；
+     *  2) 该批次的输入尚未提交给模型（未收到 input_accepted / 未产出输出）。
+     *
+     * 已提交的批次若回队，会在 provider session 里产生重复用户轮次；
+     * stop/timeout/recalled 是用户或系统的明确意图，绝不复活；
+     * daemon_restart 由启动恢复流程处理，这里不重复入队。
+     *
+     * 回队到物理队首并保留原始 messageId/receivedAt，下一次 dequeueGreedy 会把它
+     * 与期间到达的 pending 消息一起合并，等价于「未提交的旧输入 + 新输入」同批提交。
+     */
+    disposeInterruptedBatch(queueKey, activeState, rawParts, causation) {
+        if (!this.requeueableInterrupts.has(queueKey))
+            return 'none';
+        if (!this.interruptCallback
+            || this.activeTerminalReasons.get(queueKey) !== 'new_message')
+            return 'none';
+        if (rawParts.length === 0)
+            return 'none';
+        // 已提交：不能重放，交由 provider/session 侧的既有用户轮次保证上下文完整。
+        if (activeState.inputSubmitted)
+            return 'input_already_submitted';
+        const queue = this.queues.get(queueKey);
+        if (!queue) {
+            logger.warn(`[Queue] pre-submit requeue skipped: queue gone key=${queueKey}`);
+            return 'none';
+        }
+        const requeued = rawParts.map(part => this.itemFromPart(part));
+        // 只有当队列里除打断消息外没有其它等待项时才回队。
+        // 若已有其它 pending（例如被 defer 的群聊消息），说明旧输入本可在当前轮
+        // 处理完毕，回队会插入一个与它们无关的额外轮次并打乱既有调度顺序；
+        // 那种情况下保持原有中断行为。
+        const interrupting = this.interruptingMessages.get(queueKey);
+        const pendingWithoutInterrupt = interrupting
+            ? queue.filter(item => item.message.messageId !== interrupting.messageId)
+            : queue;
+        if (pendingWithoutInterrupt.length > 0) {
+            logger.info(`[Queue] pre-submit requeue skipped: key=${queueKey} other pending=${pendingWithoutInterrupt.length}`);
+            return 'none';
+        }
+        queue.unshift(...requeued);
+        // 按物理顺序重建逻辑队列，避免把旧输入追加到新消息之后，导致 FIFO
+        // 在下一次 reorderPhysical 时颠倒回队消息与打断消息的顺序。
+        // 与 enqueue 路径保持同一条件，避免把 owner-inject/interrupt 消息写进逻辑队列。
+        this.logicalQueue.clear(queueKey);
+        for (const item of queue) {
+            if (item.message.source !== 'owner-inject' && item.message.attentionPolicy !== 'interrupt') {
+                this.logicalQueue.enqueue(queueKey, item.message);
+            }
+        }
+        logger.info(`[Queue] requeued pre-submit batch: key=${queueKey} ids=${requeued
+            .flatMap(item => this.messageIdsFor(item)).join(',')} causation=${causation?.traceId ?? '<none>'}`);
+        return 'requeued_pre_submit';
+    }
     /**
      * 贪心弹出队首可合并消息。
      * 群聊入队携带 role，此时取出当前所有群聊 pending 并按时间线合并；
@@ -1337,7 +1464,8 @@ export class MessageQueue {
             && a.channelKey === b.channelKey
             && a.channelType === b.channelType
             && a.chatType === b.chatType
-            && a.peerKey === b.peerKey;
+            && a.peerKey === b.peerKey
+            && a.approvalInteractionPolicy === b.approvalInteractionPolicy;
     }
     firstTimestamp(item) {
         const parts = this.partsOf(item);

package/dist/core/message/peer-mode.js

@@ -14,8 +14,11 @@ export function resolveChatMode(params) {
         configured = undefined;
     }
     const kind = normalizePeerType(params.peerType);
+    // 运行时硬约束（非配置项）：system/service 始终 interactive；agent 始终 proactive
     if (kind === 'system' || kind === 'service')
         return 'interactive';
+    if (kind === 'agent')
+        return 'proactive';
     const field = chatmodeFieldForPeer(params.chatType, params.peerType);
     const decision = resolveRuntimeStringField({
         selfAid: params.self,
@@ -70,9 +73,11 @@ export function isSystemOrServicePeer(peerType) {
  */
 export function resolveChatModeForPeer(params) {
     const kind = normalizePeerType(params.peerType);
-    // 运行时硬约束（非配置项）：system/service 对端始终同步交互
+    // 运行时硬约束（非配置项）：system/service 对端始终同步交互；agent 对端始终主动响应
     if (kind === 'system' || kind === 'service')
         return 'interactive';
+    if (kind === 'agent')
+        return 'proactive';
     // 合并后的场景表 → 出厂默认表
     const field = chatmodeFieldForPeer(params.chatType, params.peerType);
     return params.configured?.[field] ?? chatmodeFactoryDefaults()[field];