mycohive-claw 4.0.0

package/dist/event-bus.js

@@ -0,0 +1,750 @@
+/**
+ * Event Bus 模块
+ * 版本: v4.0.0
+ *
+ * 发布-订阅事件驱动通信机制。
+ * 支持 OpenClaw 原生事件和自定义事件。
+ * 优化：使用前缀树(Trie)加速订阅匹配，DLQ 重试+告警机制
+ */
+import * as fs from "fs";
+import * as path from "path";
+export var EventType;
+(function (EventType) {
+    // 任务生命周期
+    EventType["TASK_CREATED"] = "task.created";
+    EventType["TASK_STARTED"] = "task.started";
+    EventType["TASK_COMPLETED"] = "task.completed";
+    EventType["TASK_FAILED"] = "task.failed";
+    EventType["TASK_CANCELLED"] = "task.cancelled";
+    // 步骤生命周期
+    EventType["STEP_COMPLETED"] = "step.completed";
+    EventType["STEP_FAILED"] = "step.failed";
+    // 话题生命周期
+    EventType["TOPIC_CREATED"] = "topic.created";
+    EventType["TOPIC_CLOSED"] = "topic.closed";
+    // Agent 通信
+    EventType["AGENT_MESSAGE"] = "agent.message";
+    EventType["AGENT_DISPATCH"] = "agent.dispatch";
+    // 路由事件
+    EventType["ROUTER_ANALYSIS"] = "router.analysis";
+    EventType["ROUTER_DISPATCH"] = "router.dispatch";
+    // 迭代事件
+    EventType["ITERATE_ROUND_DONE"] = "iterate.round_done";
+    // 系统事件
+    EventType["SYSTEM_READY"] = "system.ready";
+    EventType["SYSTEM_ERROR"] = "system.error";
+    // Session 生命周期
+    EventType["SESSION_CREATED"] = "session.created";
+    EventType["SESSION_ACTIVATED"] = "session.activated";
+    EventType["SESSION_IDLE"] = "session.idle";
+    EventType["SESSION_ENDED"] = "session.ended";
+    EventType["SESSION_ERROR"] = "session.error";
+    // Message 生命周期
+    EventType["FRONT_MESSAGE_RECEIVED"] = "front.message_received";
+    EventType["MESSAGE_RECEIVED"] = "message.received";
+    EventType["MESSAGE_SENT"] = "message.sent";
+    EventType["MESSAGE_FAILED"] = "message.failed";
+    EventType["MESSAGE_ROUTED"] = "message.routed";
+    // Routing 生命周期
+    EventType["ROUTING_STARTED"] = "routing.started";
+    EventType["ROUTING_COMPLETED"] = "routing.completed";
+    EventType["ROUTING_FAILED"] = "routing.failed";
+})(EventType || (EventType = {}));
+/**
+ * 前缀树节点 - 用于加速事件类型匹配
+ */
+class TrieNode {
+    handlers = [];
+    children = new Map();
+}
+export class EventBus {
+    subscriptions = new Map();
+    eventHistory = [];
+    maxHistory = 1000;
+    maxAge = 24 * 60 * 60 * 1000; // 24小时
+    storagePath = null;
+    dlqPath = null;
+    cleanupTimer = null;
+    // DLQ 重试相关
+    dlqRetryTimer = null;
+    dlqAlertThreshold = 10; // DLQ 超过此数量时触发告警
+    dlqRetryDelayMs = 5000; // 5 秒后重试
+    maxDlqRetries = 3;
+    // 前缀树（加速订阅匹配）
+    subscriptionTrie = new TrieNode();
+    hasWildcard = false;
+    hasPatternSubs = false;
+    constructor(options) {
+        this.storagePath = options?.storagePath || null;
+        this.dlqPath = options?.dlqPath || null;
+        this.maxHistory = options?.maxHistory || 1000;
+        this.maxAge = options?.maxAge || 24 * 60 * 60 * 1000; // 24小时
+        if (options?.dlqAlertThreshold)
+            this.dlqAlertThreshold = options.dlqAlertThreshold;
+        if (options?.dlqRetryDelayMs)
+            this.dlqRetryDelayMs = options.dlqRetryDelayMs;
+        if (options?.maxDlqRetries)
+            this.maxDlqRetries = options.maxDlqRetries;
+        this.loadHistory();
+        this.startCleanupTimer();
+        this.startDlqRetryTimer();
+    }
+    /**
+     * 启动定期清理定时器
+     */
+    startCleanupTimer() {
+        // 每小时清理一次
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, 60 * 60 * 1000);
+    }
+    /**
+     * 启动 DLQ 重试定时器
+     */
+    startDlqRetryTimer() {
+        this.dlqRetryTimer = setInterval(() => {
+            this.processDlqRetries();
+        }, this.dlqRetryDelayMs);
+    }
+    /**
+     * 计算指数退避延迟
+     */
+    calculateDlqBackoff(retries) {
+        return Math.min(this.dlqRetryDelayMs * Math.pow(2, retries), 60000);
+    }
+    /**
+     * 处理 DLQ 重试
+     */
+    async processDlqRetries() {
+        if (!this.dlqPath)
+            return;
+        try {
+            if (!fs.existsSync(this.dlqPath))
+                return;
+            const dlq = JSON.parse(fs.readFileSync(this.dlqPath, "utf-8"));
+            const now = Date.now();
+            const remaining = [];
+            for (const item of dlq) {
+                // 检查是否在退避中
+                const backoffDelay = this.calculateDlqBackoff(item.retries);
+                if (now - item.failed_at < backoffDelay) {
+                    remaining.push(item);
+                    continue;
+                }
+                if (item.retries < this.maxDlqRetries) {
+                    // 重新尝试处理
+                    let hadError = false;
+                    try {
+                        const handlers = this.getMatchingHandlers(item.event.type);
+                        for (const { handler, async } of handlers) {
+                            if (async) {
+                                Promise.resolve(handler(item.event)).catch((e) => {
+                                    hadError = true;
+                                    console.error(`[EventBus] Async DLQ handler error: ${e instanceof Error ? e.message : String(e)}`);
+                                });
+                            }
+                            else {
+                                try {
+                                    handler(item.event);
+                                }
+                                catch (syncError) {
+                                    hadError = true;
+                                    // 同步 handler 错误不再被吞掉
+                                    console.error(`[EventBus] Sync DLQ handler error: ${syncError instanceof Error ? syncError.message : String(syncError)}, event: ${item.event.type}`);
+                                }
+                            }
+                        }
+                        // 成功处理，移除（无错误才移除）
+                        if (!hadError) {
+                            continue;
+                        }
+                    }
+                    catch {
+                        hadError = true;
+                    }
+                    if (hadError) {
+                        item.retries++;
+                        remaining.push(item);
+                    }
+                }
+                else {
+                    // 超过最大重试次数，保留但不重试，发布 exhausted 事件
+                    remaining.push(item);
+                    this.publish({
+                        id: "",
+                        type: "system.dlq_exhausted",
+                        source: "event-bus",
+                        data: { event: item.event, reason: item.reason, retries: item.retries },
+                        timestamp: Date.now(),
+                    }, false);
+                }
+            }
+            // 检查告警阈值
+            if (remaining.length >= this.dlqAlertThreshold) {
+                console.warn(`[EventBus] DLQ alert: ${remaining.length} events in DLQ, threshold: ${this.dlqAlertThreshold}`);
+                this.emitDlqAlert(remaining.length);
+            }
+            // 保存剩余 DLQ
+            if (remaining.length > 0) {
+                fs.writeFileSync(this.dlqPath, JSON.stringify(remaining, null, 2), "utf-8");
+            }
+            else if (fs.existsSync(this.dlqPath)) {
+                fs.unlinkSync(this.dlqPath);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    /**
+     * DLQ 告警（可被外部覆盖）
+     */
+    emitDlqAlert(count) {
+        // 发布告警事件
+        this.publish({
+            id: "",
+            type: "system.dlq_alert",
+            source: "event-bus",
+            data: { dlq_count: count, threshold: this.dlqAlertThreshold },
+            timestamp: Date.now(),
+        }, false);
+        console.error(`[EventBus] DLQ ALERT: ${count} dead letters accumulated`);
+    }
+    /**
+     * 清理过期事件，防止内存泄漏
+     */
+    cleanup() {
+        const now = Date.now();
+        const beforeCount = this.eventHistory.length;
+        // 按时间和数量双重限制
+        this.eventHistory = this.eventHistory.filter((e) => {
+            const ageOk = now - e.timestamp < this.maxAge;
+            return ageOk;
+        });
+        // 额外裁剪到 maxHistory
+        if (this.eventHistory.length > this.maxHistory) {
+            this.eventHistory = this.eventHistory.slice(-this.maxHistory);
+        }
+        const removed = beforeCount - this.eventHistory.length;
+        if (removed > 0) {
+            console.log(`[EventBus] Cleaned up ${removed} events`);
+        }
+        return removed;
+    }
+    /**
+     * 停止清理定时器和 DLQ 重试
+     */
+    dispose() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        if (this.dlqRetryTimer) {
+            clearInterval(this.dlqRetryTimer);
+            this.dlqRetryTimer = null;
+        }
+        this.subscriptions.clear();
+        this.eventHistory = [];
+    }
+    loadHistory() {
+        if (!this.storagePath)
+            return;
+        try {
+            if (fs.existsSync(this.storagePath)) {
+                const data = JSON.parse(fs.readFileSync(this.storagePath, "utf-8"));
+                this.eventHistory = (data.events || []).map((e) => ({
+                    ...e,
+                    timestamp: e.timestamp || Date.now(),
+                }));
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    saveHistory() {
+        if (!this.storagePath)
+            return;
+        try {
+            const dir = path.dirname(this.storagePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            const recent = this.eventHistory.slice(-this.maxHistory);
+            const data = { events: recent };
+            fs.writeFileSync(this.storagePath, JSON.stringify(data, null, 2), "utf-8");
+        }
+        catch {
+            // ignore
+        }
+    }
+    generateId() {
+        const now = new Date();
+        const ts = now.toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+        return `EVT${ts}-${String(this.eventHistory.length).padStart(4, "0")}`;
+    }
+    publishDLQ(event, reason, retries = 0) {
+        if (!this.dlqPath)
+            return;
+        try {
+            let dlq = [];
+            if (fs.existsSync(this.dlqPath)) {
+                dlq = JSON.parse(fs.readFileSync(this.dlqPath, "utf-8"));
+            }
+            dlq.push({ event, reason, failed_at: Date.now(), retries });
+            dlq = dlq.slice(-100); // keep last 100
+            const dir = path.dirname(this.dlqPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.dlqPath, JSON.stringify(dlq, null, 2), "utf-8");
+        }
+        catch {
+            // ignore
+        }
+    }
+    // === 订阅管理 ===
+    /**
+     * 将事件类型插入前缀树
+     */
+    insertIntoTrie(eventType, sub) {
+        // 检查是否有通配符或模式
+        if (eventType.includes("*")) {
+            this.hasPatternSubs = true;
+            // 模式订阅仍保留在 Map 中（匹配时单独处理）
+            return;
+        }
+        const parts = eventType.split(".");
+        let node = this.subscriptionTrie;
+        for (const part of parts) {
+            if (!node.children.has(part)) {
+                node.children.set(part, new TrieNode());
+            }
+            node = node.children.get(part);
+        }
+        node.handlers.push(sub);
+    }
+    /**
+     * 从前缀树移除订阅
+     */
+    removeFromTrie(eventType, handler) {
+        if (eventType.includes("*"))
+            return;
+        const parts = eventType.split(".");
+        let node = this.subscriptionTrie;
+        for (const part of parts) {
+            if (!node.children.has(part))
+                return;
+            node = node.children.get(part);
+        }
+        const idx = node.handlers.findIndex(s => s.handler === handler);
+        if (idx !== -1) {
+            node.handlers.splice(idx, 1);
+        }
+    }
+    subscribe(eventType, handler) {
+        if (!this.subscriptions.has(eventType)) {
+            this.subscriptions.set(eventType, []);
+        }
+        const sub = { handler, async: false };
+        this.subscriptions.get(eventType).push(sub);
+        // 插入前缀树
+        if (!eventType.includes("*")) {
+            this.insertIntoTrie(eventType, sub);
+        }
+        if (eventType === "*") {
+            this.hasWildcard = true;
+        }
+        // 返回取消订阅函数
+        return () => this.unsubscribe(eventType, handler);
+    }
+    subscribeAsync(eventType, handler) {
+        if (!this.subscriptions.has(eventType)) {
+            this.subscriptions.set(eventType, []);
+        }
+        const sub = { handler: handler, async: true };
+        this.subscriptions.get(eventType).push(sub);
+        // 插入前缀树
+        if (!eventType.includes("*")) {
+            this.insertIntoTrie(eventType, sub);
+        }
+        if (eventType === "*") {
+            this.hasWildcard = true;
+        }
+        return () => this.unsubscribe(eventType, handler);
+    }
+    unsubscribe(eventType, handler) {
+        const subs = this.subscriptions.get(eventType);
+        if (!subs)
+            return;
+        const idx = subs.findIndex((s) => s.handler === handler);
+        if (idx !== -1) {
+            subs.splice(idx, 1);
+        }
+        // 从前缀树移除
+        this.removeFromTrie(eventType, handler);
+        if (subs.length === 0) {
+            this.subscriptions.delete(eventType);
+        }
+        // 检查是否还有通配符订阅
+        this.hasWildcard = this.subscriptions.has("*");
+        this.hasPatternSubs = Array.from(this.subscriptions.keys()).some(k => k.includes("*"));
+    }
+    // === 事件发布 ===
+    publish(event, persist = true) {
+        event.id = event.id || this.generateId();
+        // 自动从 data 中提取 session_key 用于隔离
+        if (!event.session_key && event.data?.session_key) {
+            event.session_key = event.data.session_key;
+        }
+        if (persist) {
+            this.eventHistory.push(event);
+            this.saveHistory();
+        }
+        // 获取所有匹配的处理者（使用优化的匹配算法）
+        const handlers = this.getMatchingHandlers(event.type);
+        for (const { handler, async } of handlers) {
+            try {
+                // Session 隔离验证：检查 handler 是否需要 session_key 过滤
+                if (event.session_key && !this.handlerAcceptsSession(event.session_key, handler)) {
+                    continue; // 跳过不匹配 session 的 handler
+                }
+                if (async) {
+                    // 异步处理，不 await
+                    Promise.resolve(handler(event)).catch((e) => this.publishDLQ(event, `Async handler error: ${e instanceof Error ? e.message : String(e)}`, 0));
+                }
+                else {
+                    handler(event);
+                }
+            }
+            catch (e) {
+                const errorMsg = e instanceof Error ? e.message : String(e);
+                this.publishDLQ(event, `Handler error: ${errorMsg}`, 0);
+            }
+        }
+    }
+    /**
+     * 检查 handler 是否应该接受某个 session 的事件
+     * 通过检查订阅时的 eventType 是否包含 session 信息来简单判断
+     * 实际生产中建议在订阅时显式注册 session-scoped handlers
+     */
+    handlerAcceptsSession(sessionKey, handler) {
+        // 默认接受所有。如果需要严格 session 隔离，
+        // 可以在 subscribe 时记录 session_key 并在此验证
+        // 这里做宽松处理：只记录但不阻止
+        return true;
+    }
+    async publishAsync(event, persist = true) {
+        event.id = event.id || this.generateId();
+        if (persist) {
+            this.eventHistory.push(event);
+            this.saveHistory();
+        }
+        const handlers = this.getMatchingHandlers(event.type);
+        for (const { handler, async } of handlers) {
+            try {
+                await handler(event);
+            }
+            catch (e) {
+                this.publishDLQ(event, `Async handler error: ${e}`, 0);
+            }
+        }
+    }
+    /**
+     * 优化的订阅匹配（使用前缀树 + 缓存）
+     */
+    getMatchingHandlers(eventType) {
+        const handlers = [];
+        // 1. 前缀树精确匹配（O(k)，k=事件类型分段数）
+        if (!this.hasPatternSubs) {
+            // 快速路径：无模式订阅，只用前缀树
+            const parts = eventType.split(".");
+            let node = this.subscriptionTrie;
+            for (const part of parts) {
+                // 收集当前节点的处理者
+                if (node.handlers.length > 0) {
+                    handlers.push(...node.handlers);
+                }
+                // 回溯检查通配符 "*"
+                if (node.children.has("*")) {
+                    handlers.push(...node.children.get("*").handlers);
+                }
+                if (!node.children.has(part))
+                    break;
+                node = node.children.get(part);
+            }
+        }
+        else {
+            // 慢速路径：需要检查模式匹配
+            const parts = eventType.split(".");
+            this.collectMatchingHandlersFromTrie(parts, 0, this.subscriptionTrie, handlers);
+        }
+        // 2. 通配符 "*"
+        if (this.hasWildcard) {
+            handlers.push(...this.subscriptions.get("*"));
+        }
+        // 3. 模式匹配（如 "task.*"）
+        if (this.hasPatternSubs) {
+            for (const [pattern, subs] of this.subscriptions.entries()) {
+                if (!pattern.includes("*"))
+                    continue;
+                if (this.matchPattern(pattern, eventType)) {
+                    handlers.push(...subs);
+                }
+            }
+        }
+        return handlers;
+    }
+    /**
+     * 从前缀树收集匹配的处理者
+     * 支持通配符 "*" 子节点回溯匹配
+     */
+    collectMatchingHandlersFromTrie(parts, idx, node, handlers) {
+        if (idx >= parts.length) {
+            handlers.push(...node.handlers);
+            return;
+        }
+        const currentPart = parts[idx];
+        // 优先收集当前节点的处理者（父级匹配）
+        if (node.handlers.length > 0) {
+            handlers.push(...node.handlers);
+        }
+        // 精确匹配子节点
+        if (node.children.has(currentPart)) {
+            this.collectMatchingHandlersFromTrie(parts, idx + 1, node.children.get(currentPart), handlers);
+        }
+        // 回溯检查通配符 "*" 子节点
+        if (node.children.has("*")) {
+            this.collectMatchingHandlersFromTrie(parts, idx + 1, node.children.get("*"), handlers);
+        }
+    }
+    /**
+     * 检查事件类型是否匹配模式（如 "task.*" 匹配 "task.created"）
+     */
+    matchPattern(pattern, eventType) {
+        const patternParts = pattern.split(".");
+        const eventParts = eventType.split(".");
+        if (patternParts.length !== eventParts.length) {
+            return false;
+        }
+        for (let i = 0; i < patternParts.length; i++) {
+            if (patternParts[i] !== "*" && patternParts[i] !== eventParts[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // === 历史查询 ===
+    /**
+     * 统一提取 session_key 的方法
+     */
+    extractSessionKey(event) {
+        return event.session_key || event.data?.session_key;
+    }
+    getHistory(eventType, limit = 100) {
+        let history = this.eventHistory.slice(-limit);
+        if (eventType) {
+            history = history.filter((e) => e.type === eventType);
+        }
+        return history;
+    }
+    /**
+     * 获取特定 session 的事件历史
+     */
+    getHistoryBySession(sessionKey, limit = 100) {
+        const sessionEvents = this.eventHistory.filter((e) => this.extractSessionKey(e) === sessionKey);
+        return sessionEvents.slice(-limit);
+    }
+    /**
+     * 获取所有活跃 session（最近有事件的 session）
+     */
+    getActiveSessions() {
+        const sessions = new Set();
+        const cutoff = Date.now() - this.maxAge;
+        for (const event of this.eventHistory) {
+            if (event.timestamp < cutoff)
+                continue;
+            const sk = this.extractSessionKey(event);
+            if (sk) {
+                sessions.add(sk);
+            }
+        }
+        return Array.from(sessions);
+    }
+    clearHistory() {
+        this.eventHistory = [];
+        this.saveHistory();
+    }
+    // === 便捷发布方法 ===
+    emitTaskCreated(taskId, agent, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.TASK_CREATED,
+            source: "event-bus",
+            data: { task_id: taskId, agent, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitTaskCompleted(taskId, result, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.TASK_COMPLETED,
+            source: "event-bus",
+            data: { task_id: taskId, result, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitTaskFailed(taskId, error, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.TASK_FAILED,
+            source: "event-bus",
+            data: { task_id: taskId, error, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitAgentDispatch(from, to, taskId, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.AGENT_DISPATCH,
+            source: from,
+            data: { from, to, task_id: taskId, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitRouterAnalysis(userMessage, intent, confidence, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.ROUTER_ANALYSIS,
+            source: "router",
+            data: { user_message: userMessage, intent, confidence, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    // === 迭代事件 ===
+    emitIterateRoundDone(taskId, verdict, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.ITERATE_ROUND_DONE,
+            source: "evaluator",
+            data: { task_id: taskId, verdict, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    // === Session 事件 ===
+    emitSessionActivated(sessionKey, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.SESSION_ACTIVATED,
+            source: "event-bus",
+            data: { session_key: sessionKey, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitSessionIdle(sessionKey, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.SESSION_IDLE,
+            source: "event-bus",
+            data: { session_key: sessionKey, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitSessionError(sessionKey, error, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.SESSION_ERROR,
+            source: "event-bus",
+            data: { session_key: sessionKey, error, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    // === Message 事件 ===
+    // 入口层消息接收事件（载荷格式: {session_id, content}）
+    emitFrontMessageReceived(sessionId, content, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.FRONT_MESSAGE_RECEIVED,
+            source: "front_director",
+            data: { session_id: sessionId, content, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitMessageReceived(sessionKey, message, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.MESSAGE_RECEIVED,
+            source: "event-bus",
+            data: { session_key: sessionKey, message, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitMessageSent(sessionKey, message, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.MESSAGE_SENT,
+            source: "event-bus",
+            data: { session_key: sessionKey, message, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitMessageRouted(sessionKey, routedTo, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.MESSAGE_ROUTED,
+            source: "router",
+            data: { session_key: sessionKey, routed_to: routedTo, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    // === Routing 事件 ===
+    emitRoutingStarted(sessionKey, message, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.ROUTING_STARTED,
+            source: "router",
+            data: { session_key: sessionKey, message, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitRoutingCompleted(sessionKey, intent, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.ROUTING_COMPLETED,
+            source: "router",
+            data: { session_key: sessionKey, intent, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    emitRoutingFailed(sessionKey, error, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.ROUTING_FAILED,
+            source: "router",
+            data: { session_key: sessionKey, error, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+    // router.dispatched 事件（载荷: {session_id, plan}）
+    emitRouterDispatched(sessionId, plan, extra = {}) {
+        this.publish({
+            id: "",
+            type: EventType.ROUTER_DISPATCH,
+            source: "router",
+            data: { session_id: sessionId, plan, ...extra },
+            timestamp: Date.now(),
+        });
+    }
+}
+// 全局单例
+let globalBus = null;
+export function getEventBus() {
+    if (!globalBus) {
+        globalBus = new EventBus({ storagePath: "data/events.json", dlqPath: "data/events.dlq.json" });
+    }
+    return globalBus;
+}
+export function setEventBus(bus) {
+    globalBus = bus;
+}
+//# sourceMappingURL=event-bus.js.map