@ai-setting/roy-agent-core 1.0.0

package/src/env/llm/invoke-threshold-check.test.ts

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview Test for skipThresholdCheck feature
+ *
+ * TDD: 测试 LLMInvokeRequest 的 skipThresholdCheck 参数
+ * 
+ * 验证:
+ * 1. LLMInvokeRequest 类型支持 skipThresholdCheck 参数
+ * 2. SummaryAgent 调用时传入 skipThresholdCheck: true
+ */
+
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { SummaryAgent } from "../agent/summary-agent";
+import type { LLMComponent } from "./llm";
+import type { PromptComponent } from "../prompt/prompt-component";
+
+describe("skipThresholdCheck feature", () => {
+  describe("LLMInvokeRequest type", () => {
+    test("should support skipThresholdCheck parameter", () => {
+      // This test verifies the type exists - if TypeScript compiles, this passes
+      // We import the actual types to verify they compile correctly
+      const mockRequest = {
+        messages: [{ role: "user" as const, content: "test" }],
+        skipThresholdCheck: true
+      };
+      
+      // Type check - if this compiles, the type is correct
+      expect(mockRequest.skipThresholdCheck).toBe(true);
+    });
+
+    test("should allow skipThresholdCheck to be undefined (optional)", () => {
+      const mockRequest = {
+        messages: [{ role: "user" as const, content: "test" }]
+        // skipThresholdCheck not specified
+      };
+      
+      // Should compile without skipThresholdCheck
+      expect(mockRequest.messages).toHaveLength(1);
+    });
+  });
+
+  describe("SummaryAgent", () => {
+    test("should pass skipThresholdCheck to LLM invoke", async () => {
+      // Create mock LLMComponent that tracks the invoke call
+      const mockInvoke = vi.fn().mockResolvedValue({
+        output: {
+          content: JSON.stringify({
+            title: "Test",
+            processKeyPoints: ["Point 1"],
+            currentState: "State",
+            nextSteps: ["Step 1"],
+            userIntents: ["Intent 1"]
+          }),
+          finishReason: "stop"
+        },
+        providerId: "openai",
+        model: "gpt-4o",
+        latencyMs: 100
+      });
+
+      const mockLLMComponent = {
+        invoke: mockInvoke
+      } as unknown as LLMComponent;
+
+      // Create mock PromptComponent
+      const mockPromptComponent = {
+        render: vi.fn().mockResolvedValue("mocked prompt")
+      } as unknown as PromptComponent;
+
+      // Create SummaryAgent
+      const summaryAgent = new SummaryAgent(mockPromptComponent, mockLLMComponent);
+
+      // Run summary agent with array messages
+      await summaryAgent.run({
+        messages: [
+          { role: "user", content: "test message 1" },
+          { role: "assistant", content: "response 1" }
+        ],
+        userContext: "test context",
+        outputFormat: "json"
+      });
+
+      // Verify invoke was called with skipThresholdCheck: true
+      expect(mockInvoke).toHaveBeenCalled();
+      const invokeCall = mockInvoke.mock.calls[0][0];
+      expect(invokeCall.skipThresholdCheck).toBe(true);
+    });
+  });
+});

package/src/env/llm/invoke-timeout.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, expect } from "bun:test";
+import { withTimeout, TimeoutError } from "./invoke";
+
+describe("LLM 超时控制", () => {
+  
+  describe("withTimeout", () => {
+    test("应该正常完成不超时的操作", async () => {
+      const result = await withTimeout(
+        Promise.resolve("success"),
+        1000
+      );
+      
+      expect(result).toBe("success");
+    });
+    
+    test("应该在超时时抛出 TimeoutError", async () => {
+      await expect(
+        withTimeout(
+          new Promise<string>((resolve) => setTimeout(() => resolve("done"), 500)),
+          100 // 100ms 超时，但操作需要 500ms
+        )
+      ).rejects.toThrow("LLM invocation timeout after 100ms");
+    });
+    
+    test("应该支持自定义错误消息", async () => {
+      await expect(
+        withTimeout(
+          new Promise<string>((resolve) => setTimeout(() => resolve("done"), 500)),
+          100,
+          "Custom timeout message"
+        )
+      ).rejects.toThrow("Custom timeout message");
+    });
+    
+    test("应该支持取消超时", async () => {
+      const result = await withTimeout(
+        new Promise<string>((resolve) => setTimeout(() => resolve("done"), 50)),
+        1000 // 1000ms 超时，操作只需要 50ms
+      );
+      
+      expect(result).toBe("done");
+    });
+  });
+  
+  describe("TimeoutError", () => {
+    test("应该有正确的名称和消息", () => {
+      const error = new TimeoutError("test message", 100);
+      
+      expect(error.name).toBe("TimeoutError");
+      expect(error.message).toBe("test message");
+      expect(error.timeout).toBe(100);
+    });
+  });
+});

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

@@ -0,0 +1,71 @@
+import { describe, test, expect } from "bun:test";
+import { parseModelString, createInvokeConfig } from "./invoke";
+
+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();
+    });
+  });
+});