evolclaw 2.8.1 → 2.8.2

package/dist/core/evolagent.js

@@ -1,3 +1,94 @@
+import fs from 'fs';
+import path from 'path';
+import { logger } from '../utils/logger.js';
+import { validateDefaultChannelRef } from '../config.js';
+const VALID_BASEAGENTS = new Set(['claude', 'codex', 'gemini', 'hermes']);
+const VALID_CHANNEL_TYPES = new Set(['feishu', 'aun', 'wechat', 'wecom', 'dingtalk', 'qqbot']);
+const VALID_CHATMODES = new Set(['interactive', 'proactive']);
+export function validateEvolAgentConfig(raw) {
+    const errors = [];
+    if (!raw || typeof raw !== 'object') {
+        return { valid: false, errors: ['config must be an object'] };
+    }
+    if (typeof raw.name !== 'string' || raw.name.trim() === '') {
+        errors.push('name is required and must be a non-empty string');
+    }
+    if (raw.enabled !== undefined && typeof raw.enabled !== 'boolean') {
+        errors.push('enabled must be a boolean if present');
+    }
+    if (!raw.agents || typeof raw.agents !== 'object') {
+        errors.push('agents must be an object with exactly one baseagent block');
+    }
+    else {
+        const keys = Object.keys(raw.agents).filter(k => VALID_BASEAGENTS.has(k));
+        const unknownKeys = Object.keys(raw.agents).filter(k => !VALID_BASEAGENTS.has(k));
+        if (unknownKeys.length > 0) {
+            errors.push(`agents contains unknown baseagent keys: ${unknownKeys.join(', ')}`);
+        }
+        if (keys.length === 0) {
+            errors.push('agents must contain exactly one of: claude | codex | gemini | hermes');
+        }
+        else if (keys.length > 1) {
+            errors.push(`agents must contain exactly one baseagent (single baseagent only), got: ${keys.join(', ')}`);
+        }
+    }
+    if (!raw.channels || typeof raw.channels !== 'object') {
+        errors.push('channels is required');
+    }
+    else {
+        const channelKeys = Object.keys(raw.channels).filter(k => k !== 'defaultChannel');
+        if (channelKeys.length === 0) {
+            errors.push('channels must contain at least one channel type');
+        }
+        for (const key of channelKeys) {
+            if (!VALID_CHANNEL_TYPES.has(key)) {
+                errors.push(`unknown channel type: ${key}`);
+            }
+        }
+        // defaultChannel reference validation (same rules as evolclaw.json)
+        let totalInstances = 0;
+        for (const key of channelKeys) {
+            const block = raw.channels[key];
+            const insts = Array.isArray(block) ? block : (block ? [block] : []);
+            totalInstances += insts.length;
+        }
+        const dc = raw.channels.defaultChannel;
+        if (dc) {
+            const err = validateDefaultChannelRef(dc, raw.channels);
+            if (err)
+                errors.push(err);
+        }
+        else if (totalInstances > 1) {
+            errors.push('channels.defaultChannel is required when multiple channel instances are configured (use "type" or "type/instanceName")');
+        }
+    }
+    if (!raw.projects || typeof raw.projects !== 'object') {
+        errors.push('projects is required');
+    }
+    else {
+        const p = raw.projects.defaultPath;
+        if (typeof p !== 'string' || p === '') {
+            errors.push('projects.defaultPath is required');
+        }
+        else if (!path.isAbsolute(p)) {
+            errors.push(`projects.defaultPath must be absolute, got: ${p}`);
+        }
+    }
+    if (raw.chatmode !== undefined) {
+        if (typeof raw.chatmode !== 'object' || raw.chatmode === null) {
+            errors.push('chatmode must be an object if present');
+        }
+        else {
+            for (const key of ['private', 'group']) {
+                const val = raw.chatmode[key];
+                if (val !== undefined && !VALID_CHATMODES.has(val)) {
+                    errors.push(`chatmode.${key} must be 'interactive' or 'proactive'`);
+                }
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
 export class EvolAgent {
     name;
     configPath;
@@ -28,6 +119,22 @@ export class EvolAgent {
     get projectPath() {
         return this.config.projects.defaultPath;
     }
+    /**
+     * Compute the effective channel-instance name (used as registry key, session.channel, etc).
+     *
+     * - DefaultAgent: rawName ?? type  (preserves backward-compat with evolclaw.json)
+     * - EvolAgent:
+     *   - rawName present → `${agent.name}-${type}-${rawName}`
+     *   - rawName absent  → `${agent.name}-${type}`
+     *
+     * The agent-name prefix avoids collisions with DefaultAgent channels, e.g.
+     * test-bot's aun → "test-bot-aun" instead of "aun".
+     */
+    effectiveChannelName(type, rawName) {
+        if (this.isDefault)
+            return rawName ?? type;
+        return rawName ? `${this.name}-${type}-${rawName}` : `${this.name}-${type}`;
+    }
     channelInstanceNames() {
         const names = [];
         for (const [type, raw] of Object.entries(this.config.channels || {})) {
@@ -35,11 +142,153 @@ export class EvolAgent {
             for (const inst of instances) {
                 if (!inst || typeof inst !== 'object')
                     continue;
-                names.push(inst.name ?? type);
+                names.push(this.effectiveChannelName(type, inst.name));
             }
         }
         return names;
     }
+    /**
+     * Locate a channel-instance config block within this agent's config by
+     * matching the effective channel name (with agent prefix for EvolAgents).
+     * Returns the raw mutable instance object, or `null` if not found.
+     */
+    findChannelInstance(channelName) {
+        const channels = this.config.channels || {};
+        for (const [type, raw] of Object.entries(channels)) {
+            if (type === 'defaultChannel')
+                continue;
+            const instances = Array.isArray(raw) ? raw : [raw];
+            for (const inst of instances) {
+                if (!inst || typeof inst !== 'object')
+                    continue;
+                const effName = this.effectiveChannelName(type, inst.name);
+                if (effName === channelName)
+                    return inst;
+            }
+        }
+        return null;
+    }
+    /** Get owner of a specific channel instance owned by this agent. */
+    getOwner(channelName) {
+        const inst = this.findChannelInstance(channelName);
+        return inst?.owner;
+    }
+    /** True when `userId` is the owner of `channelName`. */
+    isOwner(channelName, userId) {
+        return this.getOwner(channelName) === userId;
+    }
+    /**
+     * True when `userId` is admin (or owner) of `channelName`.
+     * Owner implicitly has admin rights.
+     */
+    isAdmin(channelName, userId) {
+        if (this.isOwner(channelName, userId))
+            return true;
+        const inst = this.findChannelInstance(channelName);
+        const admins = inst?.admins || [];
+        return admins.includes(userId);
+    }
+    /**
+     * Set owner for a channel instance and persist to agent.json.
+     * Throws when called on DefaultAgent (no configPath) — callers must use
+     * the global config setter for default channels.
+     */
+    setOwner(channelName, userId) {
+        const inst = this.findChannelInstance(channelName);
+        if (!inst) {
+            logger.warn(`[EvolAgent] setOwner: channel "${channelName}" not found in agent "${this.name}"`);
+            return;
+        }
+        inst.owner = userId;
+        this.persist();
+    }
+    /** Get showActivities mode for a channel instance owned by this agent. */
+    getShowActivities(channelName) {
+        const inst = this.findChannelInstance(channelName);
+        return inst?.showActivities ?? 'all';
+    }
+    /**
+     * Set showActivities for a channel instance and persist to agent.json.
+     * Throws when called on DefaultAgent — callers must use the global setter.
+     */
+    setShowActivities(channelName, mode) {
+        const inst = this.findChannelInstance(channelName);
+        if (!inst) {
+            logger.warn(`[EvolAgent] setShowActivities: channel "${channelName}" not found in agent "${this.name}"`);
+            return;
+        }
+        inst.showActivities = mode;
+        this.persist();
+    }
+    /**
+     * Set this agent's baseagent.model and persist to agent.json.
+     * Refuses for DefaultAgent. Writes to config.agents[baseagent].model.
+     */
+    setBaseagentModel(value) {
+        const ba = this.baseagent;
+        if (!this.config.agents[ba])
+            this.config.agents[ba] = {};
+        if (value === undefined) {
+            delete this.config.agents[ba].model;
+        }
+        else {
+            this.config.agents[ba].model = value;
+        }
+        this.persist();
+    }
+    /**
+     * Get the agent's project list (defaults to a single entry derived from
+     * projects.defaultPath when projects.list is empty/absent).
+     */
+    getProjects() {
+        const list = this.config.projects?.list;
+        if (list && Object.keys(list).length > 0)
+            return { ...list };
+        const dp = this.config.projects?.defaultPath;
+        if (dp)
+            return { [path.basename(dp)]: dp };
+        return {};
+    }
+    /**
+     * Add (or update) a named project in this agent's projects.list and persist.
+     * Throws for DefaultAgent (caller should write to evolclaw.json instead).
+     */
+    addProject(name, projectPath) {
+        if (!this.config.projects)
+            this.config.projects = { defaultPath: projectPath, list: {} };
+        if (!this.config.projects.list)
+            this.config.projects.list = {};
+        this.config.projects.list[name] = projectPath;
+        this.persist();
+    }
+    /**
+     * Set this agent's baseagent.effort and persist to agent.json.
+     * For codex, the field is named `reasoning` (alias). Refuses for DefaultAgent.
+     */
+    setBaseagentEffort(value) {
+        const ba = this.baseagent;
+        if (!this.config.agents[ba])
+            this.config.agents[ba] = {};
+        const fieldName = ba === 'codex' ? 'reasoning' : 'effort';
+        if (value === undefined) {
+            delete this.config.agents[ba][fieldName];
+        }
+        else {
+            this.config.agents[ba][fieldName] = value;
+        }
+        this.persist();
+    }
+    /**
+     * Persist the in-memory config back to the agent.json file.
+     * Refuses for DefaultAgent: it is built from evolclaw.json and has no
+     * dedicated file — callers must route writes through the global config.
+     */
+    persist() {
+        if (!this.configPath) {
+            throw new Error('Cannot persist DefaultAgent config; use global config setters');
+        }
+        fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2) + '\n', 'utf-8');
+    }
     getContext(channelName, chatType, globalChatmode) {
         const chatMode = this.resolveChatMode(chatType, globalChatmode);
         return {

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

@@ -16,6 +16,7 @@ export class MessageBridge {
     eventBus;
     debouncers = new Map();
     defaultDebounce;
+    agentRegistry;
     constructor(config, sessionManager, processor, messageQueue, cmdHandler, eventBus) {
         this.config = config;
         this.sessionManager = sessionManager;
@@ -25,6 +26,10 @@ export class MessageBridge {
         this.eventBus = eventBus;
         this.defaultDebounce = config.debounce ?? 2;
     }
+    /** Inject EvolAgentRegistry so owner lookups/writes route to agent.json for agent-owned channels. */
+    setAgentRegistry(registry) {
+        this.agentRegistry = registry;
+    }
     getDebouncer(channelName, channelType) {
         let d = this.debouncers.get(channelName);
         if (!d) {
@@ -88,7 +93,13 @@ export class MessageBridge {
                     if (msg.peerName)
                         metadata.peerName = msg.peerName;
                 }
-                const session = await this.sessionManager.getOrCreateSession(channelName, msg.channelId, this.config.projects?.defaultPath || process.cwd(), msg.threadId, Object.keys(metadata).length ? metadata : undefined, undefined, msg.peerId, chatType);
+                // Resolve effective project path: agent's projectPath when channel is agent-owned,
+                // otherwise fall back to global config.projects.defaultPath
+                const owningAgent = this.agentRegistry?.resolveByChannel(channelName);
+                const effectiveProjectPath = (owningAgent && !owningAgent.isDefault)
+                    ? owningAgent.projectPath
+                    : (this.config.projects?.defaultPath || process.cwd());
+                const session = await this.sessionManager.getOrCreateSession(channelName, msg.channelId, effectiveProjectPath, msg.threadId, Object.keys(metadata).length ? metadata : undefined, undefined, msg.peerId, chatType);
                 // 4. 消息前缀（由 policy 决定）
                 const channelInfo = this.processor.getChannelInfo?.(channelName);
                 if (channelInfo?.policy) {
@@ -114,9 +125,11 @@ export class MessageBridge {
                 if (fullMessage.messageId)
                     adapter?.acknowledge?.(fullMessage.messageId).catch(() => { });
                 const isInterrupt = chatType !== 'group';
+                const enqueueAgentName = (owningAgent && !owningAgent.isDefault) ? owningAgent.name : '[default]';
                 const doEnqueue = async (m) => {
                     return this.messageQueue.enqueue(session.id, m, session.projectPath, {
                         interruptible: isInterrupt,
+                        agentName: enqueueAgentName,
                     });
                 };
                 if (isInterrupt) {
@@ -192,12 +205,19 @@ export class MessageBridge {
     }
     /** 首次交互自动绑定 owner */
     async autoBindOwner(channel, userId) {
+        // Registry-first: route owner queries/writes to the agent that owns this channel.
+        // Falls back to evolclaw.json for default-agent channels.
         const { getOwner, setOwner } = await import('../../config.js');
-        const currentOwner = getOwner(this.config, channel);
+        const currentOwner = this.agentRegistry?.getOwner?.(channel) ?? getOwner(this.config, channel);
         // currentOwner === undefined means either no owner set, or instance not found
         // In both cases, try to set — setOwner is a no-op for unknown instances
         if (currentOwner === undefined) {
-            setOwner(this.config, channel, userId);
+            if (this.agentRegistry?.setChannelOwner) {
+                this.agentRegistry.setChannelOwner(channel, userId);
+            }
+            else {
+                setOwner(this.config, channel, userId);
+            }
             logger.info(`[Owner] Auto-bound ${channel} owner: ${userId}`);
             this.eventBus.publish({ type: 'channel:owner-bound', channel, userId });
         }

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

@@ -11,7 +11,7 @@ import { summarizeToolInput } from '../permission.js';
 import { DEFAULT_PERMISSION_MODE } from '../../types.js';
 import { getOwner } from '../../config.js';
 import { getPackageRoot, resolveRoot } from '../../paths.js';
-import { renderPromptSection } from '../../prompts/templates.js';
+import { renderPromptSection } from '../../agents/templates.js';
 /**
  * 统一消息处理器
  * 负责处理来自不同渠道的消息，协调事件流处理
@@ -77,6 +77,19 @@ export class MessageProcessor {
     setMessageQueue(queue) {
         this.messageQueue = queue;
     }
+    agentRegistry;
+    setAgentRegistry(registry) {
+        this.agentRegistry = registry;
+    }
+    getAgentContext(channelName, chatType) {
+        if (!this.agentRegistry)
+            return null;
+        const agent = this.agentRegistry.resolveByChannel(channelName);
+        if (!agent)
+            return null;
+        const globalCm = this.config.chatmode;
+        return agent.getContext(channelName, chatType, globalCm);
+    }
     /**
      * 注册渠道适配器
      */
@@ -157,6 +170,11 @@ export class MessageProcessor {
         const streamKey = session.id;
         const chatType = message.chatType || 'private';
         const identityRole = session.identity?.role || 'anonymous';
+        // Resolve agent context from registry (Phase 2 foundation)
+        const agentContext = this.getAgentContext(channelKey, chatType);
+        if (agentContext) {
+            logger.debug(`[MessageProcessor] Agent context resolved: ${agentContext.name} (${agentContext.baseagent})`);
+        }
         // 按 session.agentId 选择 agent 后端
         const agent = this.getAgent(session.agentId);
         const monitorEnabled = this.config.idleMonitor?.enabled !== false;
@@ -270,6 +288,8 @@ export class MessageProcessor {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelKey = session.metadata?.channelName || message.channel;
         const channelInfo = this.resolveChannelInfo(channelKey);
+        // Per-method agent name for stats bucketing (agent.name or '[default]')
+        const agentNameForStats = this.agentRegistry?.resolveByChannel(channelKey)?.name ?? '[default]';
         if (!channelInfo) {
             logger.error(`[MessageProcessor] Unknown channel: ${channelKey}`);
             return;
@@ -312,6 +332,7 @@ export class MessageProcessor {
                 channel: message.channel,
                 channelId: message.channelId,
                 content: message.content,
+                agentName: agentNameForStats,
                 timestamp: Date.now()
             });
             const imageInfo = message.images && message.images.length > 0 ? ` [${message.images.length} image(s)]` : '';
@@ -584,7 +605,7 @@ export class MessageProcessor {
                     if (isCrossChannel) {
                         const targetAdapterName = targetInfo.adapter.channelName;
                         const targetChannelType = targetInfo.options?.channelType || targetAdapterName;
-                        const ownerPeerId = getOwner(this.config, targetAdapterName);
+                        const ownerPeerId = this.agentRegistry?.getOwner?.(targetAdapterName) ?? getOwner(this.config, targetAdapterName);
                         targetChannelId = ownerPeerId ? (this.sessionManager.getOwnerChatId(targetChannelType, ownerPeerId) ?? '') : '';
                         if (!targetChannelId) {
                             await adapter.sendText(message.channelId, `\u274c 未找到 ${targetLabel} 的私聊会话，请先在该通道发送一条消息`, taskReplyContext());
@@ -642,6 +663,12 @@ export class MessageProcessor {
             // 清除处理中状态
             this.sessionManager.clearProcessing(session.id);
             logger.info(`[MessageProcessor] session ${session.id} processing cleared task=${taskId}`);
+            // 更新 EvolAgent.lastActivity
+            if (this.agentRegistry) {
+                const owningAgent = this.agentRegistry.resolveByChannel(channelKey);
+                if (owningAgent)
+                    owningAgent.lastActivity = Date.now();
+            }
             // 注意：不在此处清除 interruptedSessions，由下一条消息的 prompt 包装逻辑消费
             const interruptReason = this.interruptedSessions.get(session.id);
             if (streamResult.isError) {
@@ -655,6 +682,7 @@ export class MessageProcessor {
                     sessionId: session.id,
                     error: errorSummary,
                     errorType,
+                    agentName: agentNameForStats,
                     terminalReason: streamResult.terminalReason
                 });
                 // 系统级 subtype 仍累计错误计数，供 /status 诊断使用
@@ -687,6 +715,7 @@ export class MessageProcessor {
                     terminalReason: streamResult.terminalReason,
                     finalText: streamResult.lastReplyText || undefined,
                     durationMs: Date.now() - startTime,
+                    agentName: agentNameForStats,
                     timestamp: Date.now()
                 });
                 // 记录处理完成
@@ -749,7 +778,8 @@ export class MessageProcessor {
                 type: 'message:error',
                 sessionId: session.id,
                 error: errorMsg,
-                errorType
+                errorType,
+                agentName: agentNameForStats,
             });
             // 记录处理失败
             logger.message({
@@ -822,6 +852,8 @@ export class MessageProcessor {
      * SDK 事件 → AgentEvent 的转换在 AgentRunner.transformStream() 中完成。
      */
     async processEventStream(stream, session, flusher, resetTimer, shouldSuppress, thoughtEmitter) {
+        // Per-session agent name for stats bucketing
+        const agentNameForStats = this.agentRegistry?.resolveByChannel(session.metadata?.channelName || session.channel)?.name ?? '[default]';
         let hasReceivedText = false;
         let hasErrorResult = false; // 是否已有 tool_result/error 事件输出过错误
         let completeResult = { isError: false, lastReplyText: '', fullText: '', hasReceivedText: false };
@@ -942,6 +974,7 @@ export class MessageProcessor {
                             toolName: event.name,
                             isError: event.isError,
                             content: event.result,
+                            agentName: agentNameForStats,
                             timestamp: Date.now()
                         });
                         if (event.isError && !shouldSuppress()) {
@@ -1027,6 +1060,7 @@ export class MessageProcessor {
                         channelId: session.channelId,
                         finalText: lastReplyText || event.result || undefined,
                         durationMs: event.durationMs,
+                        agentName: agentNameForStats,
                         timestamp: Date.now()
                     });
                 }
@@ -1045,7 +1079,8 @@ export class MessageProcessor {
                         type: 'message:error',
                         sessionId: session.id,
                         error: event.errors?.join('; ') || '\u672a\u77e5\u9519\u8bef',
-                        errorType: bgErrorType
+                        errorType: bgErrorType,
+                        agentName: agentNameForStats,
                     });
                 }
             }

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

@@ -1,8 +1,10 @@
 import path from 'path';
 import { logger } from '../../utils/logger.js';
+const DEFAULT_AGENT_NAME = '[default]';
 export class MessageQueue {
     queues = new Map();
     processing = new Set();
+    processingAgent = new Map(); // queueKey → agentName（处理中项目的 agent）
     externalLocks = new Map();
     handler;
     currentSessionKey;
@@ -77,18 +79,24 @@ export class MessageQueue {
             return Promise.resolve();
         }
         const queueKey = this.getQueueKey(sessionKey, projectPath);
-        logger.debug(`[Queue] Enqueuing message for ${queueKey}`);
+        const agentName = options?.agentName || DEFAULT_AGENT_NAME;
+        logger.debug(`[Queue] Enqueuing message for ${queueKey} (agent=${agentName})`);
         return new Promise((resolve, reject) => {
             if (!this.queues.has(queueKey)) {
                 this.queues.set(queueKey, []);
             }
-            this.queues.get(queueKey).push({ message, projectPath, resolve, reject });
+            this.queues.get(queueKey).push({ message, projectPath, agentName, resolve, reject });
             // 根据 interruptible 选项决定是否触发中断
             if (this.processing.has(queueKey)) {
                 if (options?.interruptible !== false) {
                     // 单聊：保留中断行为
                     logger.debug(`[Queue] ${queueKey} is processing, triggering interrupt`);
-                    this.eventBus?.publish({ type: 'message:interrupted', sessionId: sessionKey, reason: 'new_message' });
+                    this.eventBus?.publish({
+                        type: 'message:interrupted',
+                        sessionId: sessionKey,
+                        reason: 'new_message',
+                        agentName: this.processingAgent.get(queueKey),
+                    });
                     if (this.interruptCallback) {
                         this.interruptCallback(sessionKey, this.currentAgentId).catch(() => { });
                     }
@@ -118,6 +126,7 @@ export class MessageQueue {
             if (!queue || queue.length === 0) {
                 logger.debug(`[Queue] Queue ${queueKey} is empty, stopping`);
                 this.processing.delete(queueKey);
+                this.processingAgent.delete(queueKey);
                 this.currentSessionKey = undefined;
                 this.currentProjectPath = undefined;
                 this.activeMessageIds.clear();
@@ -129,6 +138,7 @@ export class MessageQueue {
             this.currentSessionKey = queueKey;
             this.currentProjectPath = merged.projectPath;
             this.currentAgentId = merged.message.agentId;
+            this.processingAgent.set(queueKey, merged.agentName);
             // 记录正在执行的 messageId（用于撤回中断）
             this.activeMessageIds.clear();
             for (const item of items) {
@@ -203,6 +213,7 @@ export class MessageQueue {
         return {
             message: merged,
             projectPath: last.projectPath,
+            agentName: last.agentName,
             resolve: () => { }, // 由调用方管理
             reject: () => { },
         };
@@ -226,6 +237,20 @@ export class MessageQueue {
         }
         return false;
     }
+    /**
+     * 检查指定 channel 下是否有任何 session 在处理。
+     * queueKey 格式为 `${sessionKey}::${projectPath}`，其中 sessionKey
+     * 形如 `${channelName}-${channelId}-${ts}`，因此匹配 `${channelName}-` 前缀。
+     */
+    isChannelProcessing(channelName) {
+        const prefix = `${channelName}-`;
+        for (const key of this.processing.keys()) {
+            if (key.startsWith(prefix) || key.startsWith(`${channelName}::`)) {
+                return true;
+            }
+        }
+        return false;
+    }
     cancel(messageId) {
         for (const queue of this.queues.values()) {
             const idx = queue.findIndex(q => q.message.messageId === messageId);
@@ -250,7 +275,12 @@ export class MessageQueue {
         // 从 queueKey 提取 sessionKey
         const sessionKey = this.currentSessionKey.split('::')[0];
         logger.info(`[Queue] Recalled active message ${messageId}, interrupting session ${sessionKey}`);
-        this.eventBus?.publish({ type: 'message:interrupted', sessionId: sessionKey, reason: 'recalled' });
+        this.eventBus?.publish({
+            type: 'message:interrupted',
+            sessionId: sessionKey,
+            reason: 'recalled',
+            agentName: this.processingAgent.get(this.currentSessionKey),
+        });
         if (this.interruptCallback) {
             this.interruptCallback(sessionKey, this.currentAgentId).catch(() => { });
         }
@@ -293,4 +323,29 @@ export class MessageQueue {
     getGlobalProcessingCount() {
         return this.processing.size;
     }
+    /**
+     * 获取指定 agent 的待处理消息数量。
+     * agent 维度按 enqueue 时传入的 agentName 计数。
+     */
+    getQueueLengthByAgent(agentName) {
+        let total = 0;
+        for (const queue of this.queues.values()) {
+            for (const item of queue) {
+                if ((item.agentName || DEFAULT_AGENT_NAME) === agentName)
+                    total++;
+            }
+        }
+        return total;
+    }
+    /**
+     * 获取指定 agent 的处理中队列数量。
+     */
+    getProcessingCountByAgent(agentName) {
+        let total = 0;
+        for (const a of this.processingAgent.values()) {
+            if ((a || DEFAULT_AGENT_NAME) === agentName)
+                total++;
+        }
+        return total;
+    }
 }