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

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

@@ -0,0 +1,41 @@
+import type { LLMConfig, LLMProvider, ProviderConfig } from "./types";
+/**
+ * Provider 管理器
+ * 负责创建和管理 LLM Provider 实例
+ */
+export declare class ProviderManager {
+    private providers;
+    /**
+     * 从配置初始化所有 Provider
+     */
+    initialize(config: LLMConfig): Promise<void>;
+    /**
+     * 获取 Provider
+     */
+    getProvider(id: string): LLMProvider | undefined;
+    /**
+     * 列出所有 Provider
+     */
+    listProviders(): LLMProvider[];
+    /**
+     * 解析 Provider 配置中的环境变量
+     */
+    resolveProviderConfig(config: ProviderConfig): Promise<ProviderConfig>;
+    /**
+     * 解析环境变量
+     * 支持 ${VAR} 格式
+     */
+    resolveEnvVar(value: string): Promise<string>;
+    /**
+     * 创建 Provider 实例
+     * 注意：实际创建需要根据 Provider 类型调用对应的 AI SDK
+     * 这里返回占位实现，真正的 Provider 创建需要 AI SDK 依赖
+     */
+    private createProvider;
+    /**
+     * 根据类型创建实际的 Provider 实例
+     * 需要外部传入 AI SDK 的 createProvider
+     */
+    createAIProvider(id: string, config: ProviderConfig, createFn: (apiKey: string, baseURL?: string) => unknown): LLMProvider;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/core/src/env/llm/provider.js

@@ -0,0 +1,90 @@
+/**
+ * Provider 管理器
+ * 负责创建和管理 LLM Provider 实例
+ */
+export class ProviderManager {
+    providers = new Map();
+    /**
+     * 从配置初始化所有 Provider
+     */
+    async initialize(config) {
+        this.providers.clear();
+        for (const [id, providerConfig] of Object.entries(config.providers)) {
+            const resolvedConfig = await this.resolveProviderConfig(providerConfig);
+            const provider = this.createProvider(id, resolvedConfig);
+            this.providers.set(id, provider);
+        }
+    }
+    /**
+     * 获取 Provider
+     */
+    getProvider(id) {
+        return this.providers.get(id);
+    }
+    /**
+     * 列出所有 Provider
+     */
+    listProviders() {
+        return Array.from(this.providers.values());
+    }
+    /**
+     * 解析 Provider 配置中的环境变量
+     */
+    async resolveProviderConfig(config) {
+        return {
+            ...config,
+            apiKey: await this.resolveEnvVar(config.apiKey),
+            baseURL: config.baseURL ? await this.resolveEnvVar(config.baseURL) : undefined,
+        };
+    }
+    /**
+     * 解析环境变量
+     * 支持 ${VAR} 格式
+     */
+    async resolveEnvVar(value) {
+        // 检查是否包含环境变量模式
+        const envVarPattern = /\$\{([^}]+)\}/g;
+        const matches = [...value.matchAll(envVarPattern)];
+        if (matches.length === 0) {
+            return value;
+        }
+        // 替换所有环境变量
+        let result = value;
+        for (const match of matches) {
+            const varName = match[1];
+            const envValue = process.env[varName];
+            if (envValue === undefined) {
+                throw new Error(`Environment variable ${varName} is not set`);
+            }
+            result = result.replace(match[0], envValue);
+        }
+        return result;
+    }
+    /**
+     * 创建 Provider 实例
+     * 注意：实际创建需要根据 Provider 类型调用对应的 AI SDK
+     * 这里返回占位实现，真正的 Provider 创建需要 AI SDK 依赖
+     */
+    createProvider(id, config) {
+        // 实际的 Provider 创建需要 AI SDK
+        // 这里返回基本信息，实际的 provider.instance 需要由 AI SDK 创建
+        return {
+            id,
+            provider: null, // 将在实际使用时由 AI SDK 创建
+            models: config.models || [],
+        };
+    }
+    /**
+     * 根据类型创建实际的 Provider 实例
+     * 需要外部传入 AI SDK 的 createProvider
+     */
+    createAIProvider(id, config, createFn) {
+        const providerInstance = createFn(config.apiKey, config.baseURL);
+        return {
+            id,
+            provider: providerInstance,
+            models: config.models || [],
+        };
+    }
+}
+//# sourceMappingURL=provider.js.map

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

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

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

@@ -0,0 +1,152 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { ProviderManager } from "./provider.js";
+describe("ProviderManager", () => {
+    let manager;
+    beforeEach(() => {
+        manager = new ProviderManager();
+    });
+    describe("initialize", () => {
+        test("should create providers from config", async () => {
+            const config = {
+                providers: {
+                    openai: {
+                        provider: "openai",
+                        apiKey: "sk-test-key",
+                        baseURL: "https://api.openai.com/v1",
+                        models: ["gpt-4", "gpt-4-turbo"],
+                    },
+                },
+                defaultProvider: "openai",
+                defaultModel: "gpt-4",
+            };
+            await manager.initialize(config);
+            const provider = manager.getProvider("openai");
+            expect(provider).toBeDefined();
+            expect(provider?.id).toBe("openai");
+        });
+        test("should create multiple providers", async () => {
+            const config = {
+                providers: {
+                    openai: {
+                        provider: "openai",
+                        apiKey: "sk-test-openai",
+                    },
+                    anthropic: {
+                        provider: "anthropic",
+                        apiKey: "sk-ant-test",
+                    },
+                },
+                defaultProvider: "openai",
+                defaultModel: "gpt-4",
+            };
+            await manager.initialize(config);
+            const providers = manager.listProviders();
+            expect(providers).toHaveLength(2);
+            expect(providers.map((p) => p.id).sort()).toEqual(["anthropic", "openai"]);
+        });
+        test("should resolve environment variables", async () => {
+            // Set environment variable
+            process.env.TEST_OPENAI_KEY = "sk-env-test-key";
+            const config = {
+                providers: {
+                    openai: {
+                        provider: "openai",
+                        apiKey: "${TEST_OPENAI_KEY}",
+                    },
+                },
+                defaultProvider: "openai",
+                defaultModel: "gpt-4",
+            };
+            await manager.initialize(config);
+            const provider = manager.getProvider("openai");
+            expect(provider).toBeDefined();
+            // Clean up
+            delete process.env.TEST_OPENAI_KEY;
+        });
+        test("should throw error for missing required env var", async () => {
+            const config = {
+                providers: {
+                    openai: {
+                        provider: "openai",
+                        apiKey: "${MISSING_VAR_12345}",
+                    },
+                },
+                defaultProvider: "openai",
+                defaultModel: "gpt-4",
+            };
+            await expect(manager.initialize(config)).rejects.toThrow();
+        });
+    });
+    describe("getProvider", () => {
+        test("should return undefined for non-existent provider", () => {
+            const provider = manager.getProvider("non-existent");
+            expect(provider).toBeUndefined();
+        });
+        test("should return provider after initialization", async () => {
+            const config = {
+                providers: {
+                    openai: {
+                        provider: "openai",
+                        apiKey: "sk-test",
+                        models: ["gpt-4"],
+                    },
+                },
+                defaultProvider: "openai",
+                defaultModel: "gpt-4",
+            };
+            await manager.initialize(config);
+            const provider = manager.getProvider("openai");
+            expect(provider).toBeDefined();
+            expect(provider?.id).toBe("openai");
+            expect(provider?.models).toContain("gpt-4");
+        });
+    });
+    describe("listProviders", () => {
+        test("should return empty array before initialization", () => {
+            const providers = manager.listProviders();
+            expect(providers).toEqual([]);
+        });
+        test("should return all providers after initialization", async () => {
+            const config = {
+                providers: {
+                    openai: { provider: "openai", apiKey: "sk-openai" },
+                    anthropic: { provider: "anthropic", apiKey: "sk-ant" },
+                    google: { provider: "google", apiKey: "sk-google" },
+                },
+                defaultProvider: "openai",
+                defaultModel: "gpt-4",
+            };
+            await manager.initialize(config);
+            const providers = manager.listProviders();
+            expect(providers).toHaveLength(3);
+        });
+    });
+    describe("resolveEnvVar", () => {
+        test("should resolve simple environment variable", async () => {
+            process.env.TEST_VAR = "test-value";
+            const result = await manager.resolveEnvVar("${TEST_VAR}");
+            expect(result).toBe("test-value");
+            delete process.env.TEST_VAR;
+        });
+        test("should return original string if no env var pattern", async () => {
+            const result = await manager.resolveEnvVar("plain-string");
+            expect(result).toBe("plain-string");
+        });
+        test("should handle nested braces", async () => {
+            process.env.OUTER_INNER = "nested-value";
+            const result = await manager.resolveEnvVar("${OUTER_INNER}");
+            expect(result).toBe("nested-value");
+            delete process.env.OUTER_INNER;
+        });
+        test("should throw error for missing environment variable", async () => {
+            await expect(manager.resolveEnvVar("${DEFINITELY_NOT_A_REAL_VAR_123}")).rejects.toThrow();
+        });
+        test("should handle mixed content with env var", async () => {
+            process.env.API_KEY = "secret-key";
+            const result = await manager.resolveEnvVar("Bearer ${API_KEY}");
+            expect(result).toBe("Bearer secret-key");
+            delete process.env.API_KEY;
+        });
+    });
+});
+//# sourceMappingURL=provider.test.js.map

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

@@ -0,0 +1,58 @@
+import type { LLMMessage, ToolInfo, ToolResult } from "./types";
+/**
+ * LLM 消息转换工具
+ */
+export declare class LLMTransform {
+    /**
+     * 标准化消息格式
+     * 根据不同 Provider 调整消息格式
+     */
+    normalizeMessages(messages: LLMMessage[], providerType: string): LLMMessage[];
+    /**
+     * 标准化为 OpenAI 格式
+     */
+    private normalizeForOpenAI;
+    /**
+     * 标准化为 Anthropic 格式
+     */
+    private normalizeForAnthropic;
+    /**
+     * 从 ToolInfo 提取 JSON Schema
+     */
+    extractToolSchema(tool: ToolInfo): {
+        name: string;
+        description?: string;
+        parameters: Record<string, unknown>;
+    };
+    /**
+     * 将 Zod Schema 转换为 JSON Schema
+     * 兼容 Zod v3 和 v4
+     */
+    zodToJsonSchema(schema: any): Record<string, unknown>;
+    /**
+     * 提取 Zod Schema 的结构
+     * 兼容 Zod v3 和 v4
+     *
+     * Zod v3: schema._def.typeName === "ZodObject"
+     * Zod v4: schema._def.type === "object"
+     */
+    private extractZodSchema;
+    /**
+     * 格式化工具结果
+     */
+    formatToolResult(result: ToolResult): {
+        role: "tool";
+        tool_call_id: string;
+        content: string;
+        isError?: boolean;
+    };
+    /**
+     * 解析工具参数
+     */
+    parseToolArguments(args: string): Record<string, unknown>;
+    /**
+     * 序列化工具参数为 JSON 字符串
+     */
+    serializeToolArguments(args: Record<string, unknown>): string;
+}
+//# sourceMappingURL=transform.d.ts.map

package/dist/core/src/env/llm/transform.js

@@ -0,0 +1,254 @@
+/**
+ * LLM 消息转换工具
+ */
+export class LLMTransform {
+    /**
+     * 标准化消息格式
+     * 根据不同 Provider 调整消息格式
+     */
+    normalizeMessages(messages, providerType) {
+        return messages.map((msg) => {
+            // 根据 Provider 类型进行转换
+            switch (providerType) {
+                case "anthropic":
+                    return this.normalizeForAnthropic(msg);
+                case "openai":
+                case "openai-compatible":
+                default:
+                    return this.normalizeForOpenAI(msg);
+            }
+        });
+    }
+    /**
+     * 标准化为 OpenAI 格式
+     */
+    normalizeForOpenAI(msg) {
+        return {
+            role: msg.role,
+            content: msg.content,
+            toolCalls: msg.toolCalls,
+            toolCallId: msg.toolCallId,
+        };
+    }
+    /**
+     * 标准化为 Anthropic 格式
+     */
+    normalizeForAnthropic(msg) {
+        // Anthropic 使用不同的 tool 消息格式
+        if (msg.role === "tool") {
+            return {
+                role: "user", // Anthropic 使用 user role 传递 tool 结果
+                content: msg.content,
+                toolCallId: msg.toolCallId,
+            };
+        }
+        return msg;
+    }
+    /**
+     * 从 ToolInfo 提取 JSON Schema
+     */
+    extractToolSchema(tool) {
+        return {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        };
+    }
+    /**
+     * 将 Zod Schema 转换为 JSON Schema
+     * 兼容 Zod v3 和 v4
+     */
+    zodToJsonSchema(schema) {
+        return this.extractZodSchema(schema);
+    }
+    /**
+     * 提取 Zod Schema 的结构
+     * 兼容 Zod v3 和 v4
+     *
+     * Zod v3: schema._def.typeName === "ZodObject"
+     * Zod v4: schema._def.type === "object"
+     */
+    extractZodSchema(schema) {
+        // Zod v4 使用不同的内部结构
+        // schema._def 包含类型的定义
+        const def = schema._def;
+        if (!def)
+            return {};
+        // 获取类型标识符
+        // Zod v3: def.typeName === "ZodObject", "ZodString", etc.
+        // Zod v4: def.type === "object", "string", etc.
+        const typeName = def.typeName || "";
+        const type = def.type || "";
+        // 判断是 Zod v3 还是 v4
+        const isV3 = typeName.startsWith("Zod");
+        const isV4 = !isV3 && type !== "";
+        // 处理 ZodObject (z.object())
+        // Zod v3: def.typeName === "ZodObject", def.shape 是函数
+        // Zod v4: def.type === "object", def.shape 是对象
+        if ((isV3 && typeName === "ZodObject") || (isV4 && type === "object")) {
+            // 获取 shape - Zod v3 是函数，Zod v4 是对象
+            let shape;
+            if (isV3) {
+                // Zod v3: shape() 返回实际的对象
+                const shapeFn = def.shape;
+                shape = shapeFn ? shapeFn() : undefined;
+            }
+            else {
+                // Zod v4: shape 直接是对象
+                shape = def.shape;
+            }
+            const properties = {};
+            const required = [];
+            if (shape) {
+                for (const [key, value] of Object.entries(shape)) {
+                    // 递归处理内部类型
+                    properties[key] = this.extractZodSchema(value);
+                    // 检查是否为可选字段
+                    // Zod v3: 使用 isOptional() 方法
+                    // Zod v4: 使用 _def.defaultValue !== undefined
+                    let isOptional = false;
+                    if (isV3) {
+                        const zodType = value;
+                        isOptional = typeof zodType.isOptional === 'function' ? zodType.isOptional() : false;
+                    }
+                    else {
+                        // Zod v4: 检查 _def.defaultValue
+                        const innerDef = value._def;
+                        isOptional = innerDef?.defaultValue !== undefined;
+                    }
+                    if (!isOptional) {
+                        required.push(key);
+                    }
+                }
+            }
+            return {
+                type: "object",
+                properties,
+                ...(required.length > 0 ? { required } : {}),
+            };
+        }
+        // 处理 ZodEnum (z.enum())
+        // Zod v3: def.typeName === "ZodEnum", def.values 是数组
+        // Zod v4: def.type === "enum", def.entries 是 { value: value } 对象
+        if ((isV3 && typeName === "ZodEnum") || (isV4 && type === "enum")) {
+            // Zod v3: values 是数组
+            const zodV3Enum = def;
+            // Zod v4: entries 是对象
+            const zodV4Enum = def;
+            const values = zodV3Enum.values || Object.values(zodV4Enum.entries || {});
+            return {
+                enum: values,
+            };
+        }
+        // 处理 ZodNativeEnum (z.nativeEnum())
+        if (isV3 && typeName === "ZodNativeEnum") {
+            const enumDef = def;
+            const values = Object.values(enumDef.values || {});
+            return {
+                enum: values,
+            };
+        }
+        // 处理基本类型
+        // Zod v3: typeName === "ZodString", etc.
+        // Zod v4: type === "string", etc.
+        if ((isV3 && typeName === "ZodString") || (isV4 && type === "string")) {
+            return { type: "string" };
+        }
+        if ((isV3 && (typeName === "ZodNumber" || typeName === "ZodBigInt")) || (isV4 && (type === "number" || type === "bigint"))) {
+            return { type: "number" };
+        }
+        if ((isV3 && typeName === "ZodBoolean") || (isV4 && type === "boolean")) {
+            return { type: "boolean" };
+        }
+        // 处理 ZodArray (z.array())
+        // Zod v3: def.type === ZodType (items)
+        // Zod v4: def.type === "array", def.shape 包含 items
+        if ((isV3 && typeName === "ZodArray") || (isV4 && type === "array")) {
+            // Zod v3: def.type 是 items 类型
+            if (isV3) {
+                const itemsType = def.type;
+                if (itemsType) {
+                    return {
+                        type: "array",
+                        items: this.extractZodSchema(itemsType),
+                    };
+                }
+            }
+            // Zod v4: items 在 shape 属性中
+            const shape = def.shape;
+            if (shape) {
+                const itemKey = Object.keys(shape)[0];
+                const items = this.extractZodSchema(shape[itemKey]);
+                return {
+                    type: "array",
+                    items,
+                };
+            }
+            return {
+                type: "array",
+                items: {},
+            };
+        }
+        // 处理 ZodOptional (z.optional())
+        // Zod v3: def.innerType 是内部类型
+        // Zod v4: def.type === "optional", def.shape 包含 innerType
+        if ((isV3 && typeName === "ZodOptional") || (isV4 && type === "optional")) {
+            // Zod v3: innerType 是内部类型
+            if (isV3) {
+                const innerType = def.innerType;
+                if (innerType) {
+                    return this.extractZodSchema(innerType);
+                }
+            }
+            // Zod v4: shape 包含 innerType
+            const shape = def.shape;
+            if (shape) {
+                const innerKey = Object.keys(shape).find(k => k !== "undefinedType"); // Zod v4 的可选字段使用 undefinedType
+                if (innerKey) {
+                    return this.extractZodSchema(shape[innerKey]);
+                }
+            }
+            return {};
+        }
+        // 处理 ZodNullable (z.nullable())
+        if (isV3 && typeName === "ZodNullable") {
+            const innerType = def.innerType;
+            if (innerType) {
+                return this.extractZodSchema(innerType);
+            }
+        }
+        return {};
+    }
+    /**
+     * 格式化工具结果
+     */
+    formatToolResult(result) {
+        return {
+            role: "tool",
+            tool_call_id: result.toolCallId,
+            content: result.result,
+            ...(result.isError ? { isError: true } : {}),
+        };
+    }
+    /**
+     * 解析工具参数
+     */
+    parseToolArguments(args) {
+        if (!args || args.trim() === "") {
+            return {};
+        }
+        try {
+            return JSON.parse(args);
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * 序列化工具参数为 JSON 字符串
+     */
+    serializeToolArguments(args) {
+        return JSON.stringify(args);
+    }
+}
+//# sourceMappingURL=transform.js.map

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

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