@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

package/dist/coder-harness/src/plugins/plugin-hook-adapter.test.js

@@ -1,312 +0,0 @@
-/**
- * @fileoverview PluginHookAdapter 测试
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { HookManager } from "@ai-setting/roy-agent-core";
-// Mock Plugin types (used inline in tests)
-// Mock HookManager for testing
-class MockHookManager extends HookManager {
-    getHookCount(hookPoint) {
-        return this.hooks?.get(hookPoint)?.length ?? 0;
-    }
-    getHooks(hookPoint) {
-        return this.hooks?.get(hookPoint) ?? [];
-    }
-    hasHook(hookPoint, name) {
-        const hooks = this.hooks?.get(hookPoint);
-        return hooks?.some((h) => h.name === name) ?? false;
-    }
-}
-// Import after mocks are set up
-import { PluginHookAdapter, createPluginHookAdapter } from "./plugin-hook-adapter.js";
-describe("PluginHookAdapter", () => {
-    let mockHookManager;
-    let adapter;
-    beforeEach(() => {
-        mockHookManager = new MockHookManager();
-        adapter = new PluginHookAdapter(mockHookManager);
-    });
-    describe("实例创建", () => {
-        it("should create adapter with component", () => {
-            expect(adapter).toBeDefined();
-            expect(adapter).toBeInstanceOf(PluginHookAdapter);
-        });
-        it("should have empty registered plugins initially", () => {
-            expect(adapter.getRegisteredPlugins()).toEqual([]);
-        });
-        it("should report no plugins as registered", () => {
-            expect(adapter.isPluginRegistered("LSPPlugin")).toBe(false);
-            expect(adapter.isPluginRegistered("CodeCheckPlugin")).toBe(false);
-            expect(adapter.isPluginRegistered("ReminderPlugin")).toBe(false);
-        });
-    });
-    describe("createPluginHookAdapter 工厂函数", () => {
-        it("should create adapter with config and auto-register LSP and CodeCheck plugins", async () => {
-            const config = {
-                enableLSP: true,
-                enableCodeCheck: true,
-                enableReminder: true, // ReminderPlugin 通过 agent:before.llm hook，不是 tool:after.execute
-            };
-            const configuredAdapter = createPluginHookAdapter(mockHookManager, config);
-            expect(configuredAdapter).toBeDefined();
-            expect(configuredAdapter).toBeInstanceOf(PluginHookAdapter);
-            // LSPPlugin 和 CodeCheckPlugin 会被自动注册到 tool:after.execute
-            expect(configuredAdapter.isPluginRegistered("LSPPlugin")).toBe(true);
-            expect(configuredAdapter.isPluginRegistered("CodeCheckPlugin")).toBe(true);
-            // 注意：ReminderPlugin 使用不同的 hook 点，不通过此 adapter 注册
-        });
-        it("should only register plugins that support onAfterTool hook", async () => {
-            const config = {
-                enableLSP: true,
-                enableReminder: true,
-            };
-            // 应该只注册 LSPPlugin，不抛出 ReminderPlugin 错误
-            expect(() => {
-                createPluginHookAdapter(mockHookManager, config);
-            }).not.toThrow();
-        });
-    });
-    describe("单个 Plugin 注册", () => {
-        it("should register LSPPlugin and create hook", async () => {
-            const mockLSPPlugin = {
-                name: "LSPPlugin",
-                priority: 80,
-                description: "LSP-based code intelligence",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            adapter.registerLSPPlugin(mockLSPPlugin);
-            expect(adapter.isPluginRegistered("LSPPlugin")).toBe(true);
-            expect(mockHookManager.hasHook("tool:after.execute", "LSPPlugin")).toBe(true);
-            expect(mockHookManager.getHookCount("tool:after.execute")).toBe(1);
-        });
-        it("should register CodeCheckPlugin and create hook", async () => {
-            const mockCodeCheckPlugin = {
-                name: "CodeCheckPlugin",
-                priority: 90,
-                description: "Code checking plugin",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            adapter.registerCodeCheckPlugin(mockCodeCheckPlugin);
-            expect(adapter.isPluginRegistered("CodeCheckPlugin")).toBe(true);
-            expect(mockHookManager.hasHook("tool:after.execute", "CodeCheckPlugin")).toBe(true);
-        });
-        it("should register ReminderPlugin and create hook", async () => {
-            const mockReminderPlugin = {
-                name: "ReminderPlugin",
-                priority: 100,
-                description: "Reminder plugin",
-                execute: vi.fn().mockResolvedValue({ continue: true }),
-            };
-            adapter.registerReminderPlugin(mockReminderPlugin);
-            expect(adapter.isPluginRegistered("ReminderPlugin")).toBe(true);
-            // ReminderPlugin uses agent:before.llm hook point
-            expect(mockHookManager.hasHook("agent:before.llm", "ReminderPlugin")).toBe(true);
-        });
-        it("should use plugin priority when registering hook", async () => {
-            const mockPlugin = {
-                name: "CustomPlugin",
-                priority: 50,
-                description: "Custom plugin",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            adapter.registerLSPPlugin(mockPlugin);
-            const hooks = mockHookManager.getHooks("tool:after.execute");
-            const customHook = hooks.find((h) => h.name === "CustomPlugin");
-            expect(customHook?.priority).toBe(50);
-        });
-        it("should use default priority when plugin doesn't specify one", async () => {
-            const mockPlugin = {
-                name: "NoPriorityPlugin",
-                description: "Plugin without priority",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            adapter.registerLSPPlugin(mockPlugin);
-            const hooks = mockHookManager.getHooks("tool:after.execute");
-            const pluginHook = hooks.find((h) => h.name === "NoPriorityPlugin");
-            expect(pluginHook?.priority).toBe(PluginHookAdapter.PRIORITY.LSP_PLUGIN);
-        });
-    });
-    describe("重复注册不重复", () => {
-        it("should not register the same plugin twice", async () => {
-            const mockPlugin = {
-                name: "LSPPlugin",
-                priority: 80,
-                description: "LSP-based code linting",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            // 第一次注册
-            adapter.registerLSPPlugin(mockPlugin);
-            expect(mockHookManager.getHookCount("tool:after.execute")).toBe(1);
-            // 第二次注册（应该跳过）
-            adapter.registerLSPPlugin(mockPlugin);
-            expect(mockHookManager.getHookCount("tool:after.execute")).toBe(1);
-            // 验证只有 1 个 Hook
-            expect(mockHookManager.getHooks("tool:after.execute").filter((h) => h.name === "LSPPlugin").length).toBe(1);
-        });
-        it("should warn when trying to register duplicate plugin", async () => {
-            const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-            const mockPlugin = {
-                name: "LSPPlugin",
-                priority: 80,
-                description: "LSP-based code linting",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            adapter.registerLSPPlugin(mockPlugin);
-            adapter.registerLSPPlugin(mockPlugin);
-            expect(warnSpy).toHaveBeenCalledWith("PluginHookAdapter: LSPPlugin is already registered, skipping.");
-            warnSpy.mockRestore();
-        });
-    });
-    describe("dispose", () => {
-        it("should remove all registered hooks on dispose", async () => {
-            const mockLSPPlugin = {
-                name: "LSPPlugin",
-                priority: 80,
-                description: "LSP-based code intelligence",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            const mockCodeCheckPlugin = {
-                name: "CodeCheckPlugin",
-                priority: 90,
-                description: "Code checking plugin",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            adapter.registerLSPPlugin(mockLSPPlugin);
-            adapter.registerCodeCheckPlugin(mockCodeCheckPlugin);
-            expect(mockHookManager.getHookCount("tool:after.execute")).toBe(2);
-            await adapter.dispose();
-            expect(mockHookManager.getHookCount("tool:after.execute")).toBe(0);
-        });
-        it("should clear registered plugins list after dispose", async () => {
-            const mockPlugin = {
-                name: "LSPPlugin",
-                priority: 80,
-                description: "LSP-based code linting",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            adapter.registerLSPPlugin(mockPlugin);
-            expect(adapter.getRegisteredPlugins()).toContain("LSPPlugin");
-            await adapter.dispose();
-            expect(adapter.getRegisteredPlugins()).toEqual([]);
-        });
-        it("should handle dispose when no plugins registered", async () => {
-            const disposePromise = adapter.dispose();
-            await expect(disposePromise).resolves.toBeUndefined();
-        });
-        it("should allow re-registration after dispose", async () => {
-            const mockPlugin = {
-                name: "LSPPlugin",
-                priority: 80,
-                description: "LSP-based code linting",
-                onAfterTool: vi.fn().mockResolvedValue(undefined),
-            };
-            adapter.registerLSPPlugin(mockPlugin);
-            await adapter.dispose();
-            // 重新创建 adapter 来重置状态
-            const reAdapter = new PluginHookAdapter(mockHookManager);
-            reAdapter.registerLSPPlugin(mockPlugin);
-            expect(reAdapter.isPluginRegistered("LSPPlugin")).toBe(true);
-            expect(mockHookManager.getHookCount("tool:after.execute")).toBe(1);
-        });
-    });
-    describe("Hook 执行", () => {
-        it("should execute plugin onAfterTool when hook is called", async () => {
-            const onAfterToolMock = vi.fn().mockResolvedValue(undefined);
-            const mockPlugin = {
-                name: "LSPPlugin",
-                priority: 80,
-                description: "LSP-based code intelligence",
-                onAfterTool: onAfterToolMock,
-            };
-            adapter.registerLSPPlugin(mockPlugin);
-            // 获取注册的 Hook
-            const hooks = mockHookManager.getHooks("tool:after.execute");
-            const hook = hooks.find((h) => h.name === "LSPPlugin");
-            // 模拟执行 Hook
-            const mockContext = {
-                component: { name: "test", version: "1.0.0" },
-                data: {
-                    toolName: "write_file",
-                    args: { path: "/test/file.ts" },
-                    result: { success: true },
-                },
-                metadata: {},
-                phase: "after",
-                hookPoint: "tool:after.execute",
-            };
-            await hook.execute(mockContext);
-            expect(onAfterToolMock).toHaveBeenCalledWith(mockContext);
-        });
-    });
-    describe("AfterToolHookData 类型", () => {
-        it("should support proper AfterToolHookData structure", () => {
-            const hookData = {
-                toolName: "write_file",
-                args: { path: "/test/file.ts", content: "test content" },
-                result: {
-                    success: true,
-                    output: "File written successfully",
-                    metadata: {
-                        lineCount: 1,
-                    },
-                },
-            };
-            expect(hookData.toolName).toBe("write_file");
-            expect(hookData.result.success).toBe(true);
-            expect(hookData.result.metadata?.lineCount).toBe(1);
-        });
-        it("should support failure result structure", () => {
-            const hookData = {
-                toolName: "write_file",
-                args: { path: "/test/file.ts" },
-                result: {
-                    success: false,
-                    error: "Permission denied",
-                    metadata: {
-                        code: "EACCES",
-                    },
-                },
-            };
-            expect(hookData.result.success).toBe(false);
-            expect(hookData.result.error).toBe("Permission denied");
-        });
-    });
-    describe("BuiltInPluginsConfig 类型", () => {
-        it("should support all configuration options", () => {
-            const config = {
-                enableLSP: true,
-                enableCodeCheck: true,
-                enableReminder: true,
-                lspConfig: { enabled: true, idleTimeout: 30000 },
-                codeCheckConfig: { enabled: true, ignorePatterns: ["*.min.js"] },
-                reminderConfig: { messageTemplate: "已达到 {maxIterations} 次限制" },
-            };
-            expect(config.enableLSP).toBe(true);
-            expect(config.enableCodeCheck).toBe(true);
-            expect(config.enableReminder).toBe(true);
-            expect(config.lspConfig?.idleTimeout).toBe(30000);
-        });
-        it("should allow partial configuration", () => {
-            const config = {
-                enableLSP: true,
-            };
-            expect(config.enableLSP).toBe(true);
-            expect(config.enableCodeCheck).toBeUndefined();
-            expect(config.enableReminder).toBeUndefined();
-        });
-        it("should support alias compatibility (lspEnabled)", () => {
-            // 注意：lspEnabled 是输入别名，在内部 registerBuiltInPlugins 方法中会被解析
-            // BuiltInPluginsConfig 类型定义同时支持两种命名风格
-            const config = {
-                lspEnabled: true,
-                reminderEnabled: true,
-            };
-            // 类型定义中 lspEnabled 和 reminderEnabled 是可选的输入属性
-            expect(config.lspEnabled).toBe(true);
-            expect(config.reminderEnabled).toBe(true);
-            // enableLSP 和 enableReminder 也可以使用（另一种命名风格）
-            expect(config.enableLSP).toBeUndefined(); // 未设置为 undefined
-        });
-    });
-});
-//# sourceMappingURL=plugin-hook-adapter.test.js.map

package/dist/coder-harness/src/plugins/reminder-plugin.d.ts

@@ -1,69 +0,0 @@
-/**
- * @fileoverview ReminderPlugin - 最大迭代次数提醒插件
- *
- * 在 Agent 的 ReAct 循环中，当达到最大迭代次数时，
- * 通过 before.llm hook 注入 user message 提醒 LLM 不要继续调用工具，
- * 直接基于已有信息给用户一个总结。
- *
- * 避免因达到最大迭代次数而无疾而终的情况。
- */
-import type { HookContext as AgentHookContext } from "@ai-setting/roy-agent-core";
-import type { HookResult } from "@ai-setting/roy-agent-core";
-/**
- * ReminderPlugin 配置
- */
-export interface ReminderPluginConfig {
-    /** 自定义提醒消息模板（可选） */
-    messageTemplate?: string;
-}
-/**
- * ReminderPlugin
- *
- * 利用 Agent 的 before.llm hook，在最后一次 LLM 调用前注入提醒消息。
- *
- * 工作原理：
- * - 监听 agent:before.llm hook
- * - 检查当前迭代次数是否达到最大迭代次数
- * - 如果是最后一次调用，注入 user message 提醒 LLM 直接总结
- *
- * @example
- * ```typescript
- * // 注册到 Agent
- * agentComponent.registerPlugin("my-agent", new ReminderPlugin());
- *
- * // 或使用自定义消息模板
- * agentComponent.registerPlugin("my-agent", new ReminderPlugin({
- *   messageTemplate: "已达到 {maxIterations} 次限制，请总结当前进度"
- * }));
- * ```
- */
-export declare class ReminderPlugin {
-    readonly name = "ReminderPlugin";
-    readonly version = "1.0.0";
-    readonly description = "\u5728\u6700\u540E\u4E00\u6B21 LLM \u8C03\u7528\u524D\u6CE8\u5165\u63D0\u9192\uFF0C\u907F\u514D\u8FBE\u5230\u6700\u5927\u8FED\u4EE3\u6B21\u6570\u800C\u65E0\u75BE\u800C\u7EC8";
-    /**
-     * 优先级：较高，确保在其他 before.llm hooks 之后执行
-     * 这样可以确保提醒消息在最后注入
-     */
-    readonly priority = 100;
-    private messageTemplate;
-    constructor(config?: ReminderPluginConfig);
-    /**
-     * 获取 Hook 点配置
-     */
-    get hooks(): {
-        point: "agent:before.llm";
-        priority: number;
-    }[];
-    /**
-     * 执行 Hook
-     *
-     * 检查是否是最后一次 LLM 调用，如果是则注入提醒消息。
-     */
-    execute(ctx: AgentHookContext): Promise<HookResult>;
-}
-/**
- * 创建 ReminderPlugin 实例的工厂函数
- */
-export declare function createReminderPlugin(config?: ReminderPluginConfig): ReminderPlugin;
-//# sourceMappingURL=reminder-plugin.d.ts.map

package/dist/coder-harness/src/plugins/reminder-plugin.js

@@ -1,92 +0,0 @@
-/**
- * @fileoverview ReminderPlugin - 最大迭代次数提醒插件
- *
- * 在 Agent 的 ReAct 循环中，当达到最大迭代次数时，
- * 通过 before.llm hook 注入 user message 提醒 LLM 不要继续调用工具，
- * 直接基于已有信息给用户一个总结。
- *
- * 避免因达到最大迭代次数而无疾而终的情况。
- */
-/**
- * 内置提醒消息模板
- */
-const DEFAULT_REMINDER_MESSAGE = `你已经达到了最大 react 次数限制（{maxIterations}次）。
-
-请不要再调用任何工具，利用目前已有的信息，给用户一个简洁明了的总结，包括：
-1. 目前的进展
-2. 已完成的工作
-3. 遇到的问题（如有）
-4. 下一步建议（如有）`;
-/**
- * ReminderPlugin
- *
- * 利用 Agent 的 before.llm hook，在最后一次 LLM 调用前注入提醒消息。
- *
- * 工作原理：
- * - 监听 agent:before.llm hook
- * - 检查当前迭代次数是否达到最大迭代次数
- * - 如果是最后一次调用，注入 user message 提醒 LLM 直接总结
- *
- * @example
- * ```typescript
- * // 注册到 Agent
- * agentComponent.registerPlugin("my-agent", new ReminderPlugin());
- *
- * // 或使用自定义消息模板
- * agentComponent.registerPlugin("my-agent", new ReminderPlugin({
- *   messageTemplate: "已达到 {maxIterations} 次限制，请总结当前进度"
- * }));
- * ```
- */
-export class ReminderPlugin {
-    name = "ReminderPlugin";
-    version = "1.0.0";
-    description = "在最后一次 LLM 调用前注入提醒，避免达到最大迭代次数而无疾而终";
-    /**
-     * 优先级：较高，确保在其他 before.llm hooks 之后执行
-     * 这样可以确保提醒消息在最后注入
-     */
-    priority = 100;
-    messageTemplate;
-    constructor(config) {
-        this.messageTemplate = config?.messageTemplate ?? DEFAULT_REMINDER_MESSAGE;
-    }
-    /**
-     * 获取 Hook 点配置
-     */
-    get hooks() {
-        return [
-            { point: "agent:before.llm", priority: this.priority },
-        ];
-    }
-    /**
-     * 执行 Hook
-     *
-     * 检查是否是最后一次 LLM 调用，如果是则注入提醒消息。
-     */
-    async execute(ctx) {
-        // 检查是否是最后一次 LLM 调用
-        // 注意：这里的 iteration 是从 1 开始的，当 iteration === maxIterations 时是最后一次调用
-        const isLastIteration = ctx.iteration >= ctx.maxIterations;
-        if (!isLastIteration) {
-            // 不是最后一次，不需要注入提醒
-            return { stopped: false, results: [] };
-        }
-        // 构建提醒消息
-        const reminderContent = this.messageTemplate.replace(/\{maxIterations\}/g, String(ctx.maxIterations));
-        // 注入 user message
-        // 注意：这会修改 ctx.messages，AI SDK 会将其作为用户输入发送给 LLM
-        ctx.messages.push({
-            role: "user",
-            content: reminderContent,
-        });
-        return { stopped: false, results: [] };
-    }
-}
-/**
- * 创建 ReminderPlugin 实例的工厂函数
- */
-export function createReminderPlugin(config) {
-    return new ReminderPlugin(config);
-}
-//# sourceMappingURL=reminder-plugin.js.map

package/dist/coder-harness/src/plugins/reminder-plugin.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * @fileoverview ReminderPlugin 单元测试
- */
-export {};
-//# sourceMappingURL=reminder-plugin.test.d.ts.map

package/dist/coder-harness/src/plugins/reminder-plugin.test.js

@@ -1,132 +0,0 @@
-/**
- * @fileoverview ReminderPlugin 单元测试
- */
-import { describe, it, expect, beforeEach } from "bun:test";
-import { ReminderPlugin } from "./reminder-plugin.js";
-// Mock ModelMessage
-const createMockMessage = (role, content) => ({
-    role,
-    content,
-});
-describe("ReminderPlugin", () => {
-    let plugin;
-    beforeEach(() => {
-        plugin = new ReminderPlugin();
-    });
-    describe("execute", () => {
-        it("当 iteration < maxIterations 时，不注入提醒", async () => {
-            const ctx = {
-                agent: { name: "test-agent", config: { name: "test-agent" } },
-                iteration: 99,
-                maxIterations: 200,
-                messages: [createMockMessage("user", "Hello")],
-                tools: [],
-                systemPrompt: "You are a helpful assistant.",
-                context: {},
-            };
-            const result = await plugin.execute(ctx);
-            expect(result).toEqual({ stopped: false, results: [] });
-            expect(ctx.messages.length).toBe(1); // 只有原始消息，没有注入
-        });
-        it("当 iteration === maxIterations 时，注入 user message", async () => {
-            const ctx = {
-                agent: { name: "test-agent", config: { name: "test-agent" } },
-                iteration: 200,
-                maxIterations: 200,
-                messages: [createMockMessage("user", "Hello")],
-                tools: [],
-                systemPrompt: "You are a helpful assistant.",
-                context: {},
-            };
-            const result = await plugin.execute(ctx);
-            expect(result).toEqual({ stopped: false, results: [] });
-            expect(ctx.messages.length).toBe(2); // 原始消息 + 提醒消息
-            expect(ctx.messages[1].role).toBe("user");
-            expect(ctx.messages[1].content).toContain("200");
-        });
-        it("提醒消息包含 maxIterations 占位符", async () => {
-            const ctx = {
-                agent: { name: "test-agent", config: { name: "test-agent" } },
-                iteration: 50,
-                maxIterations: 50,
-                messages: [],
-                tools: [],
-                systemPrompt: "You are a helpful assistant.",
-                context: {},
-            };
-            await plugin.execute(ctx);
-            expect(ctx.messages.length).toBe(1);
-            expect(ctx.messages[0].content).toContain("50次");
-        });
-        it("返回 stopped: false，不中断执行", async () => {
-            const ctx = {
-                agent: { name: "test-agent", config: { name: "test-agent" } },
-                iteration: 200,
-                maxIterations: 200,
-                messages: [],
-                tools: [],
-                systemPrompt: "You are a helpful assistant.",
-                context: {},
-            };
-            const result = await plugin.execute(ctx);
-            expect(result.stopped).toBe(false);
-        });
-        it("提醒消息包含要求总结的内容", async () => {
-            const ctx = {
-                agent: { name: "test-agent", config: { name: "test-agent" } },
-                iteration: 100,
-                maxIterations: 100,
-                messages: [],
-                tools: [],
-                systemPrompt: "You are a helpful assistant.",
-                context: {},
-            };
-            await plugin.execute(ctx);
-            expect(ctx.messages.length).toBe(1);
-            const content = ctx.messages[0].content;
-            expect(content).toContain("不要再调用任何工具");
-            expect(content).toContain("总结");
-        });
-    });
-    describe("自定义消息模板", () => {
-        it("支持自定义消息模板", async () => {
-            const customPlugin = new ReminderPlugin({
-                messageTemplate: "Custom: {maxIterations} iterations reached!",
-            });
-            const ctx = {
-                agent: { name: "test-agent", config: { name: "test-agent" } },
-                iteration: 100,
-                maxIterations: 100,
-                messages: [],
-                tools: [],
-                systemPrompt: "You are a helpful assistant.",
-                context: {},
-            };
-            await customPlugin.execute(ctx);
-            expect(ctx.messages.length).toBe(1);
-            expect(ctx.messages[0].content).toBe("Custom: 100 iterations reached!");
-        });
-    });
-    describe("hooks", () => {
-        it("定义了 agent:before.llm hook", () => {
-            const hooks = plugin.hooks;
-            expect(hooks.length).toBe(1);
-            expect(hooks[0].point).toBe("agent:before.llm");
-        });
-        it("设置了优先级", () => {
-            const hooks = plugin.hooks;
-            expect(hooks[0].priority).toBe(100);
-        });
-    });
-    describe("元信息", () => {
-        it("有正确的 name 和 version", () => {
-            expect(plugin.name).toBe("ReminderPlugin");
-            expect(plugin.version).toBe("1.0.0");
-        });
-        it("有描述", () => {
-            expect(plugin.description).toBeDefined();
-            expect(plugin.description).toContain("最后一次 LLM 调用前注入提醒");
-        });
-    });
-});
-//# sourceMappingURL=reminder-plugin.test.js.map