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

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

@@ -1,41 +0,0 @@
-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

@@ -1,90 +0,0 @@
-/**
- * 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

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

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

@@ -1,152 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,254 +0,0 @@
-/**
- * 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

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