@ai-setting/roy-agent-core 1.3.10 → 1.3.14

package/src/env/llm/provider.test.ts

@@ -1,182 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import type { LLMConfig, ProviderConfig } from "./types";
-import { ProviderManager } from "./provider";
-
-describe("ProviderManager", () => {
-  let manager: ProviderManager;
-
-  beforeEach(() => {
-    manager = new ProviderManager();
-  });
-
-  describe("initialize", () => {
-    test("should create providers from config", async () => {
-      const config: LLMConfig = {
-        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: LLMConfig = {
-        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: LLMConfig = {
-        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: LLMConfig = {
-        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: LLMConfig = {
-        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: LLMConfig = {
-        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;
-    });
-  });
-});

package/src/env/llm/provider.ts

@@ -1,108 +0,0 @@
-import type { LLMConfig, LLMProvider, ProviderConfig, ProviderType } from "./types";
-
-/**
- * Provider 管理器
- * 负责创建和管理 LLM Provider 实例
- */
-export class ProviderManager {
-  private providers = new Map<string, LLMProvider>();
-
-  /**
-   * 从配置初始化所有 Provider
-   */
-  async initialize(config: LLMConfig): Promise<void> {
-    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: string): LLMProvider | undefined {
-    return this.providers.get(id);
-  }
-
-  /**
-   * 列出所有 Provider
-   */
-  listProviders(): LLMProvider[] {
-    return Array.from(this.providers.values());
-  }
-
-  /**
-   * 解析 Provider 配置中的环境变量
-   */
-  async resolveProviderConfig(config: ProviderConfig): Promise<ProviderConfig> {
-    return {
-      ...config,
-      apiKey: await this.resolveEnvVar(config.apiKey),
-      baseURL: config.baseURL ? await this.resolveEnvVar(config.baseURL) : undefined,
-    };
-  }
-
-  /**
-   * 解析环境变量
-   * 支持 ${VAR} 格式
-   */
-  async resolveEnvVar(value: string): Promise<string> {
-    // 检查是否包含环境变量模式
-    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 依赖
-   */
-  private createProvider(id: string, config: ProviderConfig): LLMProvider {
-    // 实际的 Provider 创建需要 AI SDK
-    // 这里返回基本信息，实际的 provider.instance 需要由 AI SDK 创建
-    return {
-      id,
-      provider: null, // 将在实际使用时由 AI SDK 创建
-      models: config.models || [],
-    };
-  }
-
-  /**
-   * 根据类型创建实际的 Provider 实例
-   * 需要外部传入 AI SDK 的 createProvider
-   */
-  createAIProvider(
-    id: string,
-    config: ProviderConfig,
-    createFn: (apiKey: string, baseURL?: string) => unknown
-  ): LLMProvider {
-    const providerInstance = createFn(config.apiKey, config.baseURL);
-    return {
-      id,
-      provider: providerInstance,
-      models: config.models || [],
-    };
-  }
-}

package/src/env/llm/transform.test.ts

@@ -1,251 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { z } from "zod";
-import { LLMTransform } from "./transform";
-import type { LLMMessage, ToolInfo } from "./types";
-
-describe("LLMTransform", () => {
-  const transform = new LLMTransform();
-
-  describe("normalizeMessages", () => {
-    test("should handle basic user message", () => {
-      const input: LLMMessage[] = [
-        { role: "user", content: "Hello" },
-      ];
-
-      const result = transform.normalizeMessages(input, "openai");
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({ role: "user", content: "Hello" });
-    });
-
-    test("should handle system message", () => {
-      const input: LLMMessage[] = [
-        { role: "system", content: "You are helpful" },
-        { role: "user", content: "Hi" },
-      ];
-
-      const result = transform.normalizeMessages(input, "openai");
-      expect(result[0].role).toBe("system");
-      expect(result[0].content).toBe("You are helpful");
-    });
-
-    test("should convert tool message to assistant format for openai", () => {
-      const input: LLMMessage[] = [
-        { role: "tool", content: '{"result":"sunny"}', toolCallId: "call_1" },
-      ];
-
-      const result = transform.normalizeMessages(input, "openai");
-      // OpenAI 使用 tool role
-      expect(result[0].role).toBe("tool");
-      expect(result[0].toolCallId).toBe("call_1");
-    });
-
-    test("should handle messages with tool calls", () => {
-      const input: LLMMessage[] = [
-        {
-          role: "assistant",
-          content: "Let me search for that",
-          toolCalls: [
-            { id: "call_1", name: "search", arguments: '{"query":"weather"}' },
-          ],
-        },
-      ];
-
-      const result = transform.normalizeMessages(input, "openai");
-      expect(result[0].toolCalls).toHaveLength(1);
-      expect(result[0].toolCalls?.[0].name).toBe("search");
-    });
-
-    test("should handle multi-turn conversation", () => {
-      const input: LLMMessage[] = [
-        { role: "user", content: "What's the weather?" },
-        { role: "assistant", content: "I'll check for you" },
-        { role: "user", content: "Thanks" },
-      ];
-
-      const result = transform.normalizeMessages(input, "openai");
-      expect(result).toHaveLength(3);
-    });
-
-    test("should pass through for anthropic format", () => {
-      const input: LLMMessage[] = [
-        { role: "user", content: "Hello" },
-      ];
-
-      // Anthropic might have different requirements
-      const result = transform.normalizeMessages(input, "anthropic");
-      expect(result).toHaveLength(1);
-    });
-  });
-
-  describe("extractToolSchema", () => {
-    test("should extract basic tool schema", () => {
-      const tool: ToolInfo = {
-        name: "getWeather",
-        description: "Get weather for a location",
-        parameters: {
-          type: "object",
-          properties: {
-            location: { type: "string" },
-          },
-          required: ["location"],
-        },
-      };
-
-      const result = transform.extractToolSchema(tool);
-      expect(result.name).toBe("getWeather");
-      expect(result.description).toBe("Get weather for a location");
-    });
-
-    test("should handle tool without description", () => {
-      const tool: ToolInfo = {
-        name: "simpleTool",
-        parameters: {
-          type: "object",
-          properties: {},
-        },
-      };
-
-      const result = transform.extractToolSchema(tool);
-      expect(result.name).toBe("simpleTool");
-      expect(result.description).toBeUndefined();
-    });
-
-    test("should extract nested parameters", () => {
-      const tool: ToolInfo = {
-        name: "complexTool",
-        parameters: {
-          type: "object",
-          properties: {
-            user: {
-              type: "object",
-              properties: {
-                name: { type: "string" },
-                age: { type: "number" },
-              },
-            },
-          },
-        },
-      };
-
-      const result = transform.extractToolSchema(tool);
-      expect(result.parameters.properties).toBeDefined();
-      expect(result.parameters.properties?.user).toBeDefined();
-    });
-
-    test("should handle array parameters", () => {
-      const tool: ToolInfo = {
-        name: "batchTool",
-        parameters: {
-          type: "object",
-          properties: {
-            items: {
-              type: "array",
-              items: { type: "string" },
-            },
-          },
-        },
-      };
-
-      const result = transform.extractToolSchema(tool);
-      expect(result.parameters.properties?.items?.type).toBe("array");
-    });
-  });
-
-  describe("zodToJsonSchema", () => {
-    test("should convert zod schema to json schema", () => {
-      const zodSchema = z.object({
-        name: z.string(),
-        age: z.number(),
-      });
-
-      const result = transform.zodToJsonSchema(zodSchema);
-      expect(result.type).toBe("object");
-      expect(result.properties).toBeDefined();
-      expect(result.properties?.name).toBeDefined();
-      expect(result.properties?.age).toBeDefined();
-    });
-
-    test("should handle optional fields", () => {
-      const zodSchema = z.object({
-        name: z.string(),
-        email: z.string().optional(),
-      });
-
-      const result = transform.zodToJsonSchema(zodSchema);
-      expect(result.type).toBe("object");
-      expect(result.properties).toBeDefined();
-      expect(result.properties?.name).toBeDefined();
-      expect(result.properties?.email).toBeDefined();
-    });
-
-    test("should handle nested objects", () => {
-      const zodSchema = z.object({
-        user: z.object({
-          name: z.string(),
-          address: z.object({
-            city: z.string(),
-          }),
-        }),
-      });
-
-      const result = transform.zodToJsonSchema(zodSchema);
-      expect(result.properties?.user?.properties).toBeDefined();
-      expect(result.properties?.user?.properties?.address?.properties).toBeDefined();
-    });
-
-    test("should handle array types", () => {
-      const zodSchema = z.object({
-        tags: z.array(z.string()),
-      });
-
-      const result = transform.zodToJsonSchema(zodSchema);
-      expect(result.properties?.tags?.type).toBe("array");
-    });
-
-    test("should handle enum types", () => {
-      const zodSchema = z.object({
-        status: z.enum(["active", "inactive", "pending"]),
-      });
-
-      const result = transform.zodToJsonSchema(zodSchema);
-      expect(result.properties?.status?.enum).toEqual(["active", "inactive", "pending"]);
-    });
-  });
-
-  describe("formatToolResult", () => {
-    test("should format successful tool result", () => {
-      const result = transform.formatToolResult({
-        toolCallId: "call_1",
-        result: '{"temperature": 25}',
-      });
-      expect(result.content).toBe('{"temperature": 25}');
-    });
-
-    test("should format error tool result", () => {
-      const result = transform.formatToolResult({
-        toolCallId: "call_1",
-        result: "Error: API timeout",
-        isError: true,
-      });
-      expect(result.content).toBe("Error: API timeout");
-      expect(result.isError).toBe(true);
-    });
-  });
-
-  describe("parseToolArguments", () => {
-    test("should parse valid JSON arguments", () => {
-      const result = transform.parseToolArguments('{"query":"weather"}');
-      expect(result).toEqual({ query: "weather" });
-    });
-
-    test("should return empty object for empty string", () => {
-      const result = transform.parseToolArguments("");
-      expect(result).toEqual({});
-    });
-
-    test("should handle JSON parse errors gracefully", () => {
-      const result = transform.parseToolArguments("not valid json");
-      expect(result).toEqual({});
-    });
-  });
-});