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

package/dist/core/src/env/llm/invoke.test.d.ts

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

package/dist/core/src/env/llm/invoke.test.js

@@ -0,0 +1,62 @@
+import { describe, test, expect } from "bun:test";
+import { parseModelString, createInvokeConfig } from "./invoke.js";
+describe("invoke module", () => {
+    describe("parseModelString", () => {
+        test("should parse full model string with provider", () => {
+            const result = parseModelString("openai/gpt-4o");
+            expect(result.providerId).toBe("openai");
+            expect(result.modelId).toBe("gpt-4o");
+        });
+        test("should parse model string with multiple slashes", () => {
+            const result = parseModelString("openai/gpt-4o-turbo");
+            expect(result.providerId).toBe("openai");
+            expect(result.modelId).toBe("gpt-4o-turbo");
+        });
+        test("should return default provider for model-only string", () => {
+            const result = parseModelString("gpt-4o");
+            expect(result.providerId).toBe("openai");
+            expect(result.modelId).toBe("gpt-4o");
+        });
+        test("should return defaults for undefined input", () => {
+            const result = parseModelString(undefined);
+            expect(result.providerId).toBe("openai");
+            expect(result.modelId).toBe("gpt-4o");
+        });
+        test("should handle anthropic provider", () => {
+            const result = parseModelString("anthropic/claude-3-5-sonnet");
+            expect(result.providerId).toBe("anthropic");
+            expect(result.modelId).toBe("claude-3-5-sonnet");
+        });
+        test("should handle google provider", () => {
+            const result = parseModelString("google/gemini-2.0-flash");
+            expect(result.providerId).toBe("google");
+            expect(result.modelId).toBe("gemini-2.0-flash");
+        });
+        test("should handle openai-compatible provider", () => {
+            const result = parseModelString("openai-compatible/deepseek-chat");
+            expect(result.providerId).toBe("openai-compatible");
+            expect(result.modelId).toBe("deepseek-chat");
+        });
+    });
+    describe("createInvokeConfig", () => {
+        test("should create config with all fields", () => {
+            const config = createInvokeConfig("openai/gpt-4o", "sk-test", "https://api.openai.com/v1");
+            expect(config.model).toBe("openai/gpt-4o");
+            expect(config.apiKey).toBe("sk-test");
+            expect(config.baseURL).toBe("https://api.openai.com/v1");
+        });
+        test("should create config without baseURL", () => {
+            const config = createInvokeConfig("gpt-4o", "sk-test");
+            expect(config.model).toBe("gpt-4o");
+            expect(config.apiKey).toBe("sk-test");
+            expect(config.baseURL).toBeUndefined();
+        });
+        test("should handle undefined baseURL", () => {
+            const config = createInvokeConfig("gpt-4o", "sk-test", undefined);
+            expect(config.model).toBe("gpt-4o");
+            expect(config.apiKey).toBe("sk-test");
+            expect(config.baseURL).toBeUndefined();
+        });
+    });
+});
+//# sourceMappingURL=invoke.test.js.map

package/dist/core/src/env/llm/llm-config.test.d.ts

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

package/dist/core/src/env/llm/llm-config.test.js

@@ -0,0 +1,453 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { LLMComponent } from "./llm.js";
+import { ConfigComponent } from "../../config/config-component.js";
+import * as fsSync from "fs";
+import * as path from "path";
+import * as os from "os";
+describe("LLMComponent Config Loading", () => {
+    let component;
+    let configComponent;
+    let mockEnv;
+    let tempDir;
+    beforeEach(() => {
+        component = new LLMComponent();
+        configComponent = new ConfigComponent();
+        // Create temp directory for config files
+        tempDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "llm-config-test-"));
+        // Set XDG_DATA_HOME to temp directory so ConfigComponent can find config files
+        configComponent.setXdgDataHome(tempDir);
+        // Mock environment
+        mockEnv = {
+            getComponent: vi.fn((name) => {
+                if (name === "config")
+                    return configComponent;
+                return undefined;
+            }),
+            hasComponent: vi.fn((name) => name === "config"),
+            logger: vi.fn(),
+            trace: vi.fn(),
+        };
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        // Clean up temp directory
+        try {
+            fsSync.rmSync(tempDir, { recursive: true });
+        }
+        catch { }
+    });
+    describe("LLMComponentOptions", () => {
+        test("should accept configComponent only", async () => {
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent }
+            });
+            expect(component.getStatus()).toBe("running");
+        });
+        test("should accept configPath option", async () => {
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                llm: {
+                    defaultModel: "gpt-4o"
+                }
+            }), "utf-8");
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent, configPath: "config.jsonc" }
+            });
+            expect(component.getStatus()).toBe("running");
+        });
+        test("should accept envPrefix option", async () => {
+            process.env.LLM_DEFAULT_MODEL = "claude-3";
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: { configComponent, envPrefix: "LLM" }
+            });
+            expect(component.getStatus()).toBe("running");
+            delete process.env.LLM_DEFAULT_MODEL;
+        });
+        test("should accept config option with direct object", async () => {
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    config: {
+                        defaultModel: "gpt-4o",
+                        temperature: 0.5
+                    }
+                }
+            });
+            expect(component.getStatus()).toBe("running");
+        });
+    });
+    describe("config priority: Object > Env > File", () => {
+        test("should Object config override Env config", async () => {
+            // Set environment variable (注意: EnvSource 会将 llm.defaultModel 转换为 LLM_LLM_DEFAULT_MODEL)
+            process.env.LLM_LLM_DEFAULT_MODEL = "env-model";
+            // Create file config (使用相对路径，XDG_DATA_HOME 已经设置为 tempDir)
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                llm: { defaultModel: "file-model" }
+            }), "utf-8");
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc", // 相对路径，相对于 XDG_DATA_HOME
+                    envPrefix: "LLM",
+                    config: { defaultModel: "object-model" }
+                }
+            });
+            // Object config should have highest priority
+            expect(configComponent.get("llm.defaultModel")).toBe("object-model");
+            delete process.env.LLM_LLM_DEFAULT_MODEL;
+        });
+        test("should Env config override File config", async () => {
+            // Set environment variable
+            process.env.LLM_LLM_TEMPERATURE = "0.9";
+            // Create file config
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                llm: {
+                    defaultModel: "file-model",
+                    temperature: 0.1
+                }
+            }), "utf-8");
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc",
+                    envPrefix: "LLM"
+                }
+            });
+            // Env should override file
+            expect(configComponent.get("llm.temperature")).toBe("0.9");
+            // File value should still exist for non-overridden keys
+            expect(configComponent.get("llm.defaultModel")).toBe("file-model");
+            delete process.env.LLM_LLM_TEMPERATURE;
+        });
+        test("should File config be loaded when present", async () => {
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                llm: {
+                    defaultModel: "file-model",
+                    temperature: 0.7
+                }
+            }), "utf-8");
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc"
+                }
+            });
+            expect(configComponent.get("llm.defaultModel")).toBe("file-model");
+            expect(configComponent.get("llm.temperature")).toBe(0.7);
+        });
+        test("should Env config work without File config", async () => {
+            process.env.LLM_LLM_DEFAULT_MODEL = "env-model";
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    envPrefix: "LLM"
+                }
+            });
+            expect(configComponent.get("llm.defaultModel")).toBe("env-model");
+            delete process.env.LLM_LLM_DEFAULT_MODEL;
+        });
+        test("should Object config work without Env and File config", async () => {
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    config: { defaultModel: "object-model" }
+                }
+            });
+            expect(configComponent.get("llm.defaultModel")).toBe("object-model");
+        });
+        test("should nested Object config be flattened correctly", async () => {
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    config: {
+                        providers: {
+                            openai: {
+                                apiKey: "test-key",
+                                baseURL: "https://api.openai.com"
+                            }
+                        }
+                    }
+                }
+            });
+            expect(configComponent.get("llm.providers.openai.apiKey")).toBe("test-key");
+            expect(configComponent.get("llm.providers.openai.baseURL")).toBe("https://api.openai.com");
+        });
+    });
+    describe("configPath optional", () => {
+        test("should not throw error when configPath file does not exist", async () => {
+            const nonExistentPath = path.join(tempDir, "non-existent.jsonc");
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: nonExistentPath
+                }
+            });
+            expect(component.getStatus()).toBe("running");
+        });
+    });
+    describe("config loading order", () => {
+        test("should load File first, then Env, then Object", async () => {
+            // Set environment variable
+            process.env.LLM_LLM_MAX_TOKENS = "2000";
+            // Create file config
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                llm: {
+                    defaultModel: "file-model",
+                    maxTokens: 1000
+                }
+            }), "utf-8");
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc",
+                    envPrefix: "LLM",
+                    config: {
+                        temperature: 0.9,
+                        topP: 0.95
+                    }
+                }
+            });
+            // Object config (highest priority)
+            expect(configComponent.get("llm.temperature")).toBe(0.9);
+            expect(configComponent.get("llm.topP")).toBe(0.95);
+            // Env config (medium priority) - overrides file
+            expect(configComponent.get("llm.maxTokens")).toBe("2000");
+            // File config (lowest priority) - base values
+            expect(configComponent.get("llm.defaultModel")).toBe("file-model");
+            delete process.env.LLM_LLM_MAX_TOKENS;
+        });
+    });
+    describe("nested config - providers", () => {
+        test("should load nested providers config from File", async () => {
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                llm: {
+                    providers: {
+                        openai: {
+                            apiKey: "sk-test-openai",
+                            baseURL: "https://api.openai.com/v1"
+                        },
+                        anthropic: {
+                            apiKey: "sk-ant-test"
+                        }
+                    }
+                }
+            }), "utf-8");
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc"
+                }
+            });
+            expect(configComponent.get("llm.providers.openai.apiKey")).toBe("sk-test-openai");
+            expect(configComponent.get("llm.providers.openai.baseURL")).toBe("https://api.openai.com/v1");
+            expect(configComponent.get("llm.providers.anthropic.apiKey")).toBe("sk-ant-test");
+        });
+        test("should load nested providers config from Object", async () => {
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    config: {
+                        providers: {
+                            openai: {
+                                apiKey: "object-openai-key",
+                                baseURL: "https://custom.openai.com/v1"
+                            }
+                        }
+                    }
+                }
+            });
+            expect(configComponent.get("llm.providers.openai.apiKey")).toBe("object-openai-key");
+            expect(configComponent.get("llm.providers.openai.baseURL")).toBe("https://custom.openai.com/v1");
+        });
+        test("should load nested providers from config object (flat key)", async () => {
+            // 直接设置嵌套路径（扁平格式）
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    config: {
+                        "providers.openai.apiKey": "flat-nested-key",
+                        "providers.openai.baseURL": "https://flat.example.com"
+                    }
+                }
+            });
+            expect(configComponent.get("llm.providers.openai.apiKey")).toBe("flat-nested-key");
+            expect(configComponent.get("llm.providers.openai.baseURL")).toBe("https://flat.example.com");
+        });
+    });
+    describe("camelCase to snake_case conversion", () => {
+        test("should convert camelCase keys to SNAKE_CASE env vars", async () => {
+            // defaultModel -> DEFAULT_MODEL
+            // topP -> TOP_P
+            process.env.LLM_LLM_DEFAULT_MODEL = "claude-model";
+            process.env.LLM_LLM_TOP_P = "0.8";
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    envPrefix: "LLM"
+                }
+            });
+            expect(configComponent.get("llm.defaultModel")).toBe("claude-model");
+            expect(configComponent.get("llm.topP")).toBe("0.8");
+            delete process.env.LLM_LLM_DEFAULT_MODEL;
+            delete process.env.LLM_LLM_TOP_P;
+        });
+        test("should handle custom envPrefix", async () => {
+            // 自定义前缀（注意：MY_APP_ 会变成 MY_APP_LLM_DEFAULT_MODEL）
+            process.env.MY_APP_LLM_DEFAULT_MODEL = "custom-model";
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    envPrefix: "MY_APP"
+                }
+            });
+            expect(configComponent.get("llm.defaultModel")).toBe("custom-model");
+            delete process.env.MY_APP_LLM_DEFAULT_MODEL;
+        });
+        test("should load env vars with underscore prefix", async () => {
+            // 测试 LLM_DEFAULT_MODEL 被转换为 llm.default.model
+            // 注意：由于驼峰命名限制，DEFAULT_MODEL 会变成 default.model 而非 defaultModel
+            process.env.LLM_DEFAULT_MODEL = "underscore-model";
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    envPrefix: "LLM"
+                }
+            });
+            // LLM_DEFAULT_MODEL -> llm.default.model (下划线转点号)
+            expect(configComponent.get("llm.default.model")).toBe("underscore-model");
+            delete process.env.LLM_DEFAULT_MODEL;
+        });
+    });
+    describe("edge cases", () => {
+        test("should handle missing config file gracefully", async () => {
+            // 不创建配置文件，直接使用默认前缀
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "non-existent-config.jsonc"
+                }
+            });
+            expect(component.getStatus()).toBe("running");
+        });
+        test("should handle empty env vars gracefully", async () => {
+            process.env.LLM_LLM_DEFAULT_MODEL = "";
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    envPrefix: "LLM"
+                }
+            });
+            // 空字符串是有效值
+            expect(configComponent.get("llm.defaultModel")).toBe("");
+            delete process.env.LLM_LLM_DEFAULT_MODEL;
+        });
+        test("should load all basic keys from File", async () => {
+            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
+                llm: {
+                    defaultModel: "gpt-4-turbo",
+                    defaultProvider: "anthropic",
+                    temperature: 0.3,
+                    maxTokens: 8192,
+                    topP: 0.9,
+                    stream: true
+                }
+            }), "utf-8");
+            await component.init({
+                name: "llm",
+                version: "1.0.0",
+                enabled: true,
+                env: mockEnv,
+                options: {
+                    configComponent,
+                    configPath: "config.jsonc"
+                }
+            });
+            expect(configComponent.get("llm.defaultModel")).toBe("gpt-4-turbo");
+            expect(configComponent.get("llm.defaultProvider")).toBe("anthropic");
+            expect(configComponent.get("llm.temperature")).toBe(0.3);
+            expect(configComponent.get("llm.maxTokens")).toBe(8192);
+            expect(configComponent.get("llm.topP")).toBe(0.9);
+            expect(configComponent.get("llm.stream")).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=llm-config.test.js.map

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

@@ -0,0 +1,164 @@
+import { BaseComponent, type ComponentConfig } from "../component";
+import { type LLMConfig, type LLMInvokeRequest, type LLMInvokeResult, type ModelLimits } from "./types";
+import type { ConfigComponent } from "../../config/config-component";
+import { ContextError } from "../errors";
+/**
+ * LLMComponent 配置（通过 options.config 传递）
+ *
+ * 配置加载顺序（优先级从低到高）：
+ * 1. File - 配置文件（通过 configPath 指定）
+ * 2. Env - 环境变量（通过 envPrefix 配置前缀）
+ * 3. Object - 直接传入的 config 对象（最高优先级）
+ *
+ * 环境变量转换规则：
+ * - 驼峰命名会被转换为下划线分隔的大写形式
+ * - 例如: "llm.defaultModel" + prefix "LLM" -> "LLM_LLM_DEFAULT_MODEL"
+ */
+export interface LLMComponentOptions {
+    /** ConfigComponent 实例（必填） */
+    configComponent: ConfigComponent;
+    /** 配置文件相对路径（可选，基于 XDG_DATA_HOME） */
+    configPath?: string;
+    /** 环境变量前缀（可选，默认 "LLM"） */
+    envPrefix?: string;
+    /** 直接传入的配置对象（可选，优先级最高） */
+    config?: Partial<LLMConfig>;
+}
+/**
+ * LLMComponent
+ * 管理 LLM 调用，使用 AI SDK 进行实际调用
+ *
+ * 配置通过 ConfigComponent 实时获取，支持配置热更新
+ *
+ * @example
+ * // 通过 ConfigComponent 加载配置
+ * const configComponent = new ConfigComponent();
+ * configComponent.setXdgDataHome(__dirname);
+ *
+ * const llmComponent = new LLMComponent();
+ * await llmComponent.init({
+ *   env,  // Environment 实例（必填）
+ *   options: {
+ *     configComponent,  // ConfigComponent 实例
+ *     configPath: "config.jsonc"  // 配置文件路径
+ *   }
+ * });
+ *
+ * // 配置更新后，下次调用会自动获取最新配置
+ * configComponent.set("llm.temperature", 0.5);
+ */
+export declare class LLMComponent extends BaseComponent {
+    readonly name = "llm";
+    readonly version = "2.0.0";
+    private configComponent?;
+    /** 配置变更 watcher 清理函数 */
+    private configWatcher?;
+    constructor();
+    /**
+     * 初始化组件
+     *
+     * 配置加载优先级（从高到低）：
+     * 1. Object - 直接传入的 config 对象
+     * 2. Env - 环境变量（通过 envPrefix 配置前缀）
+     * 3. File - 配置文件（通过 configPath 指定）
+     */
+    init(config: ComponentConfig): Promise<void>;
+    /**
+     * 注册配置到 ConfigComponent
+     *
+     * 配置加载顺序（优先级从低到高）：
+     * 1. FileSource - 从配置文件加载（最低）
+     * 2. EnvSource - 从环境变量加载（中等）
+     * 3. MemorySource - 直接配置对象（最高）
+     */
+    private registerConfig;
+    /**
+     * 将配置对象展平为点号路径
+     *
+     * @example
+     * flattenConfig({ providers: { openai: { apiKey: "xxx" } } })
+     * -> { "llm.providers.openai.apiKey": "xxx" }
+     */
+    private flattenConfig;
+    /**
+     * 注册配置热更新监听
+     */
+    private registerConfigWatcher;
+    /**
+     * 处理配置变更（支持热更新）
+     */
+    protected onConfigChange(event: {
+        key: string;
+        oldValue?: unknown;
+        newValue?: unknown;
+    }): void;
+    /**
+     * 启动组件
+     */
+    onStart(): Promise<void>;
+    /**
+     * 停止组件
+     */
+    onStop(): Promise<void>;
+    /**
+     * 从配置源获取配置值
+     * 优先从 ConfigComponent 获取（支持热更新），否则返回默认值
+     */
+    private getLLMConfig;
+    /**
+     * 解析请求，构建调用上下文（invoke 和 invokeStream 共享）
+     */
+    private resolveRequest;
+    /**
+     * 调用 LLM
+     *
+     * 流式事件通过 env.pushEnvEvent() 发布
+     */
+    invoke(request: LLMInvokeRequest): Promise<LLMInvokeResult>;
+    /**
+     * 获取 Provider API Key
+     */
+    private getApiKey;
+    /**
+     * 获取 Provider
+     */
+    getProvider(id: string): import("./types").ProviderConfig;
+    /**
+     * 列出所有 Provider
+     */
+    listProviders(): string[];
+    /**
+     * 获取模型的限制配置
+     *
+     * @param providerId - Provider ID
+     * @param modelId - 模型 ID（可选，默认使用 provider 的 defaultModel）
+     * @returns 模型限制配置，如果没有配置则返回 undefined
+     */
+    getModelLimits(providerId: string, modelId?: string): ModelLimits | undefined;
+    /**
+     * 获取上下文窗口阈值配置
+     *
+     * @param providerId - Provider ID
+     * @param modelId - 模型 ID
+     * @returns 包含 contextWindow 和 thresholdRatio 的对象
+     */
+    getContextThresholdConfig(providerId: string, modelId?: string): {
+        contextWindow: number;
+        thresholdRatio: number;
+    };
+    /**
+     * 检测上下文阈值是否超过
+     *
+     * @param usage - LLM 使用量信息
+     * @param providerId - Provider ID
+     * @param modelId - 模型 ID
+     * @param sessionId - Session ID（用于错误信息）
+     * @returns 如果超过阈值，返回 ContextError；否则返回 undefined
+     */
+    checkContextThreshold(usage: {
+        totalTokens: number;
+        promptTokens?: number;
+        completionTokens?: number;
+    } | undefined, providerId: string, modelId: string | undefined, sessionId?: string): ContextError | undefined;
+}
+//# sourceMappingURL=llm.d.ts.map