@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

package/dist/core/src/env/environment.test.js

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview BaseEnvironment Unit Tests
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { BaseEnvironment } from "./environment.js";
+describe("BaseEnvironment", () => {
+    let env;
+    beforeEach(() => {
+        env = new BaseEnvironment({ name: "test-env", version: "1.0.0" });
+    });
+    afterEach(async () => {
+        await env.stop();
+    });
+    describe("构造函数", () => {
+        it("应该使用默认配置", () => {
+            const defaultEnv = new BaseEnvironment();
+            expect(defaultEnv.name).toBe("base-environment");
+            expect(defaultEnv.version).toBe("1.0.0");
+        });
+        it("应该使用提供的配置", () => {
+            expect(env.name).toBe("test-env");
+            expect(env.version).toBe("1.0.0");
+        });
+    });
+    describe("getConfig()", () => {
+        it("应该返回正确的配置", () => {
+            const config = env.getConfig();
+            expect(config.name).toBe("test-env");
+            expect(config.version).toBe("1.0.0");
+            expect(config.enabled).toBe(true);
+        });
+    });
+    describe("组件管理", () => {
+        it("应该注册和获取组件", () => {
+            const mockComponent = {
+                name: "test-component",
+                version: "1.0.0",
+                hooks: {},
+                getStatus: () => "created",
+                getConfig: () => ({ name: "test-component", version: "1.0.0", enabled: true }),
+                init: vi.fn(),
+                start: vi.fn(),
+                stop: vi.fn(),
+            };
+            env.registerComponent(mockComponent);
+            expect(env.getComponent("test-component")).toBe(mockComponent);
+            expect(env.listComponents()).toHaveLength(1);
+        });
+        it("应该注销组件", () => {
+            const mockComponent = {
+                name: "test-component",
+                version: "1.0.0",
+                hooks: {},
+                getStatus: () => "created",
+                getConfig: () => ({ name: "test-component", version: "1.0.0", enabled: true }),
+                init: vi.fn(),
+                start: vi.fn(),
+                stop: vi.fn(),
+            };
+            env.registerComponent(mockComponent);
+            env.unregisterComponent("test-component");
+            expect(env.getComponent("test-component")).toBeUndefined();
+            expect(env.listComponents()).toHaveLength(0);
+        });
+        it("获取不存在的组件应返回 undefined", () => {
+            expect(env.getComponent("non-existent")).toBeUndefined();
+        });
+    });
+    describe("handle_query", () => {
+        it("应该抛出错误（AgentComponent 未注册）", async () => {
+            await env.init();
+            await expect(env.handle_query("hello")).rejects.toThrow("AgentComponent not found");
+        });
+    });
+    describe("handle_action", () => {
+        it("应该抛出错误（未实现）", async () => {
+            await env.init();
+            const action = { type: "test", params: {} };
+            const context = {};
+            await expect(env.handle_action(action, context)).rejects.toThrow("handle_action not implemented");
+        });
+    });
+    describe("EnvEvent 机制", () => {
+        it("应该订阅和取消订阅", () => {
+            const handler = vi.fn();
+            const unsubscribe = env.subscribe(handler);
+            // 推送事件
+            env.pushEnvEvent({
+                id: "test-id",
+                type: "test.event",
+                timestamp: Date.now(),
+                metadata: { env_name: "test" },
+                payload: {},
+            });
+            expect(handler).toHaveBeenCalledTimes(1);
+            // 取消订阅
+            unsubscribe();
+            // 再次推送事件
+            env.pushEnvEvent({
+                id: "test-id-2",
+                type: "test.event",
+                timestamp: Date.now(),
+                metadata: { env_name: "test" },
+                payload: {},
+            });
+            expect(handler).toHaveBeenCalledTimes(1); // 不应再调用
+        });
+        it("subscribeAll 应该等同于 subscribe", () => {
+            const handler = vi.fn();
+            const unsubscribe = env.subscribeAll(handler);
+            env.pushEnvEvent({ id: "1", type: "any.event", timestamp: Date.now(), metadata: {}, payload: {} });
+            env.pushEnvEvent({ id: "2", type: "another.event", timestamp: Date.now(), metadata: {}, payload: {} });
+            expect(handler).toHaveBeenCalledTimes(2);
+            unsubscribe();
+        });
+        it("应该订阅指定类型事件", () => {
+            const handler = vi.fn();
+            const unsubscribe = env.subscribeTo("specific.event", handler);
+            // 推送指定类型事件
+            env.pushEnvEvent({
+                id: "test-id",
+                type: "specific.event",
+                timestamp: Date.now(),
+                metadata: { env_name: "test" },
+                payload: {},
+            });
+            // 推送其他类型事件
+            env.pushEnvEvent({
+                id: "test-id-2",
+                type: "other.event",
+                timestamp: Date.now(),
+                metadata: { env_name: "test" },
+                payload: {},
+            });
+            expect(handler).toHaveBeenCalledTimes(1);
+            unsubscribe();
+        });
+        it("应该订阅多个类型事件", () => {
+            const handler = vi.fn();
+            const unsubscribe = env.subscribeTo(["event1", "event2"], handler);
+            env.pushEnvEvent({ id: "1", type: "event1", timestamp: Date.now(), metadata: {}, payload: {} });
+            env.pushEnvEvent({ id: "2", type: "event2", timestamp: Date.now(), metadata: {}, payload: {} });
+            env.pushEnvEvent({ id: "3", type: "event3", timestamp: Date.now(), metadata: {}, payload: {} });
+            expect(handler).toHaveBeenCalledTimes(2);
+            unsubscribe();
+        });
+        it("pushEnvEvent 应该自动填充元信息", () => {
+            const handler = vi.fn();
+            env.subscribe(handler);
+            env.pushEnvEvent({
+                type: "test.event",
+                payload: { data: "test" },
+            });
+            const event = handler.mock.calls[0][0];
+            expect(event.id).toBeDefined();
+            expect(event.timestamp).toBeDefined();
+            expect(event.metadata.env_name).toBe("test-env");
+        });
+    });
+    describe("生命周期", () => {
+        it("应该正确初始化", async () => {
+            await env.init();
+            expect(env.getStatus()).toBe("running");
+        });
+        it("应该正确启动", async () => {
+            await env.start();
+            expect(env.getStatus()).toBe("running");
+        });
+        it("重复启动不应报错", async () => {
+            await env.start();
+            await env.start();
+            expect(env.getStatus()).toBe("running");
+        });
+        it("应该正确停止", async () => {
+            await env.stop();
+            expect(env.getStatus()).toBe("stopped");
+        });
+        it("停止后应清理事件处理器", async () => {
+            const handler = vi.fn();
+            env.subscribe(handler);
+            await env.stop();
+            // 停止后推送事件应该不触发
+            env.pushEnvEvent({ id: "test", type: "test", timestamp: Date.now(), metadata: {}, payload: {} });
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=environment.test.js.map

package/dist/core/src/env/errors.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview 统一错误类型体系
+ *
+ * 提供 AgentError, ToolError, LLMError, ComponentError, ContextError 等错误类型
+ * 每个错误包含 code（错误码）和 details（额外信息）
+ */
+/**
+ * 错误码枚举
+ */
+export declare const ErrorCodes: {
+    readonly AGENT_NOT_FOUND: "AGENT_001";
+    readonly AGENT_RUN_FAILED: "AGENT_002";
+    readonly AGENT_TIMEOUT: "AGENT_003";
+    readonly AGENT_CONFIG_INVALID: "AGENT_004";
+    readonly TOOL_NOT_FOUND: "TOOL_001";
+    readonly TOOL_DISABLED: "TOOL_002";
+    readonly TOOL_EXECUTION_FAILED: "TOOL_003";
+    readonly TOOL_VALIDATION_FAILED: "TOOL_004";
+    readonly LLM_PROVIDER_NOT_FOUND: "LLM_001";
+    readonly LLM_INVOCATION_FAILED: "LLM_002";
+    readonly LLM_TIMEOUT: "LLM_003";
+    readonly LLM_CONFIG_INVALID: "LLM_004";
+    readonly COMPONENT_NOT_FOUND: "COMP_001";
+    readonly COMPONENT_INIT_FAILED: "COMP_002";
+    readonly COMPONENT_NOT_RUNNING: "COMP_003";
+    readonly CONFIG_NOT_FOUND: "CONFIG_001";
+    readonly CONFIG_INVALID: "CONFIG_002";
+    readonly CONFIG_SOURCE_ERROR: "CONFIG_003";
+    readonly CONTEXT_THRESHOLD_EXCEEDED: "CTX_001";
+    readonly CONTEXT_COMPACTION_FAILED: "CTX_002";
+    readonly MCP_INIT_FAILED: "MCP_001";
+    readonly MCP_SERVER_ERROR: "MCP_002";
+    readonly MCP_TOOL_ERROR: "MCP_003";
+};
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+/**
+ * RoyError 基类
+ */
+export declare class RoyError extends Error {
+    readonly code: ErrorCode;
+    readonly details?: unknown;
+    constructor(message: string, code: ErrorCode, details?: unknown);
+}
+/**
+ * Agent 相关错误
+ */
+export declare class AgentError extends RoyError {
+    constructor(message: string, code?: ErrorCode, details?: unknown);
+}
+/**
+ * Tool 相关错误
+ */
+export declare class ToolError extends RoyError {
+    readonly toolName?: string;
+    constructor(message: string, code?: ErrorCode, toolName?: string, details?: unknown);
+}
+/**
+ * LLM 相关错误
+ */
+export declare class LLMError extends RoyError {
+    readonly provider?: string;
+    constructor(message: string, code?: ErrorCode, provider?: string, details?: unknown);
+}
+/**
+ * Component 相关错误
+ */
+export declare class ComponentError extends RoyError {
+    readonly componentName?: string;
+    constructor(message: string, code?: ErrorCode, componentName?: string, details?: unknown);
+}
+/**
+ * Context 相关错误
+ */
+export declare class ContextError extends RoyError {
+    readonly sessionId?: string;
+    readonly usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    readonly contextWindow?: number;
+    constructor(message: string, code?: ErrorCode, sessionId?: string, usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    }, contextWindow?: number, details?: unknown);
+}
+/**
+ * 检查是否是 RoyError
+ */
+export declare function isRoyError(error: unknown): error is RoyError;
+/**
+ * 获取错误码
+ */
+export declare function getErrorCode(error: unknown): ErrorCode | undefined;
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/src/env/errors.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview 统一错误类型体系
+ *
+ * 提供 AgentError, ToolError, LLMError, ComponentError, ContextError 等错误类型
+ * 每个错误包含 code（错误码）和 details（额外信息）
+ */
+/**
+ * 错误码枚举
+ */
+export const ErrorCodes = {
+    // Agent 错误 (AGENT_xxx)
+    AGENT_NOT_FOUND: "AGENT_001",
+    AGENT_RUN_FAILED: "AGENT_002",
+    AGENT_TIMEOUT: "AGENT_003",
+    AGENT_CONFIG_INVALID: "AGENT_004",
+    // Tool 错误 (TOOL_xxx)
+    TOOL_NOT_FOUND: "TOOL_001",
+    TOOL_DISABLED: "TOOL_002",
+    TOOL_EXECUTION_FAILED: "TOOL_003",
+    TOOL_VALIDATION_FAILED: "TOOL_004",
+    // LLM 错误 (LLM_xxx)
+    LLM_PROVIDER_NOT_FOUND: "LLM_001",
+    LLM_INVOCATION_FAILED: "LLM_002",
+    LLM_TIMEOUT: "LLM_003",
+    LLM_CONFIG_INVALID: "LLM_004",
+    // Component 错误 (COMP_xxx)
+    COMPONENT_NOT_FOUND: "COMP_001",
+    COMPONENT_INIT_FAILED: "COMP_002",
+    COMPONENT_NOT_RUNNING: "COMP_003",
+    // Config 错误 (CONFIG_xxx)
+    CONFIG_NOT_FOUND: "CONFIG_001",
+    CONFIG_INVALID: "CONFIG_002",
+    CONFIG_SOURCE_ERROR: "CONFIG_003",
+    // Context 错误 (CTX_xxx)
+    CONTEXT_THRESHOLD_EXCEEDED: "CTX_001",
+    CONTEXT_COMPACTION_FAILED: "CTX_002",
+    // MCP 错误 (MCP_xxx)
+    MCP_INIT_FAILED: "MCP_001",
+    MCP_SERVER_ERROR: "MCP_002",
+    MCP_TOOL_ERROR: "MCP_003",
+};
+/**
+ * RoyError 基类
+ */
+export class RoyError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+/**
+ * Agent 相关错误
+ */
+export class AgentError extends RoyError {
+    constructor(message, code = ErrorCodes.AGENT_NOT_FOUND, details) {
+        super(message, code, details);
+    }
+}
+/**
+ * Tool 相关错误
+ */
+export class ToolError extends RoyError {
+    toolName;
+    constructor(message, code = ErrorCodes.TOOL_NOT_FOUND, toolName, details) {
+        super(message, code, details);
+        this.toolName = toolName;
+    }
+}
+/**
+ * LLM 相关错误
+ */
+export class LLMError extends RoyError {
+    provider;
+    constructor(message, code = ErrorCodes.LLM_INVOCATION_FAILED, provider, details) {
+        super(message, code, details);
+        this.provider = provider;
+    }
+}
+/**
+ * Component 相关错误
+ */
+export class ComponentError extends RoyError {
+    componentName;
+    constructor(message, code = ErrorCodes.COMPONENT_NOT_FOUND, componentName, details) {
+        super(message, code, details);
+        this.componentName = componentName;
+    }
+}
+/**
+ * Context 相关错误
+ */
+export class ContextError extends RoyError {
+    sessionId;
+    usage;
+    contextWindow;
+    constructor(message, code = ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, sessionId, usage, contextWindow, details) {
+        super(message, code, details);
+        this.sessionId = sessionId;
+        this.usage = usage;
+        this.contextWindow = contextWindow;
+    }
+}
+/**
+ * 检查是否是 RoyError
+ */
+export function isRoyError(error) {
+    return error instanceof RoyError;
+}
+/**
+ * 获取错误码
+ */
+export function getErrorCode(error) {
+    if (error instanceof RoyError) {
+        return error.code;
+    }
+    return undefined;
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/src/env/errors.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=errors.test.d.ts.map

package/dist/core/src/env/errors.test.js

@@ -0,0 +1,110 @@
+import { describe, test, expect } from "bun:test";
+import { AgentError, ToolError, LLMError, ComponentError, ContextError, ErrorCodes, isRoyError, getErrorCode } from "./errors.js";
+describe("错误类型体系", () => {
+    describe("AgentError", () => {
+        test("应该包含 code 和 details 属性", () => {
+            const error = new AgentError("Agent not found", ErrorCodes.AGENT_NOT_FOUND, { agentName: "test-agent" });
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(AgentError);
+            expect(error.name).toBe("AgentError");
+            expect(error.message).toBe("Agent not found");
+            expect(error.code).toBe("AGENT_001");
+            expect(error.details).toEqual({ agentName: "test-agent" });
+        });
+        test("应该支持不传 details", () => {
+            const error = new AgentError("Test error", ErrorCodes.AGENT_RUN_FAILED);
+            expect(error.details).toBeUndefined();
+        });
+    });
+    describe("ToolError", () => {
+        test("应该包含 code 和 toolName 属性", () => {
+            const error = new ToolError("Tool execution failed", ErrorCodes.TOOL_EXECUTION_FAILED, "readFile");
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(ToolError);
+            expect(error.name).toBe("ToolError");
+            expect(error.code).toBe("TOOL_003");
+            expect(error.toolName).toBe("readFile");
+        });
+    });
+    describe("LLMError", () => {
+        test("应该包含 code 和 provider 属性", () => {
+            const error = new LLMError("LLM invocation failed", ErrorCodes.LLM_INVOCATION_FAILED, "openai");
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(LLMError);
+            expect(error.name).toBe("LLMError");
+            expect(error.code).toBe("LLM_002");
+            expect(error.provider).toBe("openai");
+        });
+    });
+    describe("ComponentError", () => {
+        test("应该包含 code 和 componentName 属性", () => {
+            const error = new ComponentError("Component init failed", ErrorCodes.COMPONENT_INIT_FAILED, "agent");
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(ComponentError);
+            expect(error.name).toBe("ComponentError");
+            expect(error.code).toBe("COMP_002");
+            expect(error.componentName).toBe("agent");
+        });
+    });
+    describe("isRoyError", () => {
+        test("应该识别 AgentError", () => {
+            const error = new AgentError("test", ErrorCodes.AGENT_NOT_FOUND);
+            expect(isRoyError(error)).toBe(true);
+        });
+        test("应该识别 ToolError", () => {
+            const error = new ToolError("test", ErrorCodes.TOOL_NOT_FOUND, "tool");
+            expect(isRoyError(error)).toBe(true);
+        });
+        test("不应该识别普通 Error", () => {
+            const error = new Error("test");
+            expect(isRoyError(error)).toBe(false);
+        });
+    });
+    describe("getErrorCode", () => {
+        test("应该返回 RoyError 的 code", () => {
+            const error = new AgentError("test", ErrorCodes.AGENT_NOT_FOUND);
+            expect(getErrorCode(error)).toBe("AGENT_001");
+        });
+        test("应该返回 undefined 对于普通 Error", () => {
+            const error = new Error("test");
+            expect(getErrorCode(error)).toBeUndefined();
+        });
+    });
+    describe("ContextError", () => {
+        test("应该包含 code、sessionId、usage 和 contextWindow 属性", () => {
+            const usage = {
+                promptTokens: 10000,
+                completionTokens: 500,
+                totalTokens: 10500,
+            };
+            const error = new ContextError("Context threshold exceeded", ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED, "session-123", usage, 128000);
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(ContextError);
+            expect(error.name).toBe("ContextError");
+            expect(error.message).toBe("Context threshold exceeded");
+            expect(error.code).toBe("CTX_001");
+            expect(error.sessionId).toBe("session-123");
+            expect(error.usage).toEqual(usage);
+            expect(error.contextWindow).toBe(128000);
+        });
+        test("应该支持不传可选参数", () => {
+            const error = new ContextError("Context error", ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED);
+            expect(error.sessionId).toBeUndefined();
+            expect(error.usage).toBeUndefined();
+            expect(error.contextWindow).toBeUndefined();
+        });
+        test("应该使用默认错误码", () => {
+            const error = new ContextError("Context error");
+            expect(error.code).toBe("CTX_001");
+        });
+    });
+    describe("ErrorCodes - Context errors", () => {
+        test("应该包含 CONTEXT_THRESHOLD_EXCEEDED", () => {
+            expect(ErrorCodes.CONTEXT_THRESHOLD_EXCEEDED).toBe("CTX_001");
+        });
+        test("应该包含 CONTEXT_COMPACTION_FAILED", () => {
+            expect(ErrorCodes.CONTEXT_COMPACTION_FAILED).toBe("CTX_002");
+        });
+    });
+});
+//# sourceMappingURL=errors.test.js.map

package/dist/core/src/env/event-source/event-source-agent-handler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * EventSourceAgentHandler
+ *
+ * 将事件源事件转换为 Agent 输入的处理器
+ */
+import type { EventSourceEvent, EventSourceEventHandler } from "./types";
+/**
+ * EventSourceAgentHandler 配置
+ */
+export interface EventSourceAgentHandlerConfig {
+    /** 是否启用 */
+    enabled?: boolean;
+    /** 前缀（用于区分事件消息） */
+    prefix?: string;
+    /** 是否包含原始事件 */
+    includeRawEvent?: boolean;
+    /** 是否包含时间戳 */
+    includeTimestamp?: boolean;
+}
+/**
+ * EventSourceAgentHandler
+ *
+ * 将事件源事件转换为 Agent 可读的文本消息
+ */
+export declare class EventSourceAgentHandler {
+    private config;
+    constructor(config?: EventSourceAgentHandlerConfig);
+    /**
+     * 创建事件处理器
+     */
+    createHandler(): EventSourceEventHandler;
+    /**
+     * 格式化事件为 Agent 消息
+     */
+    formatEventForAgent(event: EventSourceEvent): string;
+    /**
+     * 更新配置
+     */
+    updateConfig(config: Partial<EventSourceAgentHandlerConfig>): void;
+    /**
+     * 获取配置
+     */
+    getConfig(): Readonly<Required<EventSourceAgentHandlerConfig>>;
+}
+//# sourceMappingURL=event-source-agent-handler.d.ts.map

package/dist/core/src/env/event-source/event-source-agent-handler.js

@@ -0,0 +1,80 @@
+/**
+ * EventSourceAgentHandler
+ *
+ * 将事件源事件转换为 Agent 输入的处理器
+ */
+import { createLogger } from "../log-trace/logger.js";
+const logger = createLogger("event-source-agent-handler");
+/**
+ * EventSourceAgentHandler
+ *
+ * 将事件源事件转换为 Agent 可读的文本消息
+ */
+export class EventSourceAgentHandler {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            enabled: config.enabled ?? true,
+            prefix: config.prefix ?? "[事件源]",
+            includeRawEvent: config.includeRawEvent ?? false,
+            includeTimestamp: config.includeTimestamp ?? true,
+        };
+    }
+    /**
+     * 创建事件处理器
+     */
+    createHandler() {
+        return (event) => {
+            if (!this.config.enabled) {
+                return;
+            }
+            const message = this.formatEventForAgent(event);
+            logger.debug(`[AgentHandler] Formatted event: ${message.substring(0, 100)}`);
+            // 这里返回格式化后的消息，供调用方使用
+            return message;
+        };
+    }
+    /**
+     * 格式化事件为 Agent 消息
+     */
+    formatEventForAgent(event) {
+        const parts = [];
+        // 前缀
+        parts.push(this.config.prefix);
+        // 时间戳
+        if (this.config.includeTimestamp) {
+            const time = new Date(event.timestamp).toLocaleString("zh-CN");
+            parts.push(`[${time}]`);
+        }
+        // 来源信息
+        parts.push(`来源: ${event.payload.sourceType}`);
+        // 事件类型
+        parts.push(`类型: ${event.type}`);
+        // 消息内容
+        parts.push(`内容: ${event.payload.message}`);
+        // 原始事件（可选）
+        if (this.config.includeRawEvent) {
+            const rawStr = typeof event.payload.rawEvent === "string"
+                ? event.payload.rawEvent
+                : JSON.stringify(event.payload.rawEvent);
+            parts.push(`原始数据: ${rawStr}`);
+        }
+        return parts.join(" ");
+    }
+    /**
+     * 更新配置
+     */
+    updateConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config,
+        };
+    }
+    /**
+     * 获取配置
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+//# sourceMappingURL=event-source-agent-handler.js.map

package/dist/core/src/env/event-source/event-source-agent-handler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=event-source-agent-handler.test.d.ts.map