@ai-setting/roy-agent-core 1.0.0

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

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

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

@@ -0,0 +1,251 @@
+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({});
+    });
+  });
+});