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

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

@@ -0,0 +1,67 @@
+import { z } from "zod";
+// ============================================================================
+// Config Schema
+// ============================================================================
+/**
+ * ProviderCapabilities Zod Schema
+ */
+export const ProviderCapabilitiesSchema = z.object({
+    reasoning: z.boolean().optional(),
+    toolcall: z.boolean().optional(),
+    interleaved: z.object({
+        field: z.string(),
+    }).optional(),
+    thinkingInText: z.object({
+        enabled: z.boolean().optional(),
+        tags: z.array(z.string()).optional(),
+        removeFromOutput: z.boolean().optional(),
+    }).optional(),
+});
+/**
+ * ModelLimits Zod Schema
+ */
+export const ModelLimitsSchema = z.object({
+    contextWindow: z.number().int().positive(),
+    compactionThreshold: z.number().min(0).max(1).optional(),
+    maxOutputTokens: z.number().int().positive().optional(),
+});
+/**
+ * ProviderConfig Zod Schema
+ */
+export const ProviderConfigSchema = z.object({
+    provider: z.string(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    apiKey: z.string(),
+    baseURL: z.string().optional(),
+    models: z.array(z.string()).optional(),
+    defaultModel: z.string().optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().int().positive().optional(),
+    capabilities: ProviderCapabilitiesSchema.optional(),
+    limits: z.record(z.string(), ModelLimitsSchema).optional(),
+    providerOptions: z.record(z.unknown()).optional(),
+    options: z.record(z.unknown()).optional(),
+});
+/**
+ * LLMDefaultConfig Zod Schema
+ */
+export const LLMDefaultConfigSchema = z.object({
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().int().positive().optional(),
+});
+/**
+ * LLMConfig Zod Schema
+ */
+export const LLMConfigSchema = z.object({
+    default: LLMDefaultConfigSchema.optional(),
+    defaultModel: z.string().optional(),
+    providers: z.record(z.string(), ProviderConfigSchema),
+    defaultProvider: z.string(),
+    temperature: z.number().min(0).max(2).default(0.7),
+    maxTokens: z.number().int().positive().optional(),
+    topP: z.number().min(0).max(1).optional(),
+    stream: z.boolean().default(true),
+    options: z.record(z.unknown()).optional(),
+});
+//# sourceMappingURL=types.js.map

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

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

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

@@ -0,0 +1,520 @@
+import { describe, test, expect } from "bun:test";
+import { LLMConfigSchema } from "./types.js";
+describe("LLMConfigSchema", () => {
+    test("should validate valid config with required fields", () => {
+        const config = {
+            providers: {
+                openai: {
+                    provider: "openai",
+                    apiKey: "sk-test",
+                    baseURL: "https://api.openai.com/v1",
+                    models: ["gpt-4", "gpt-4-turbo"],
+                },
+            },
+            defaultProvider: "openai",
+            defaultModel: "gpt-4",
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.defaultProvider).toBe("openai");
+            expect(result.data.defaultModel).toBe("gpt-4");
+        }
+    });
+    test("should validate config with optional fields", () => {
+        const config = {
+            providers: {
+                openai: {
+                    provider: "openai",
+                    apiKey: "sk-test",
+                },
+            },
+            defaultProvider: "openai",
+            defaultModel: "gpt-4",
+            temperature: 0.7,
+            maxTokens: 4096,
+            topP: 0.9,
+            stream: true,
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.temperature).toBe(0.7);
+            expect(result.data.maxTokens).toBe(4096);
+        }
+    });
+    test("should fail validation for missing providers", () => {
+        const config = {
+            defaultProvider: "openai",
+            defaultModel: "gpt-4",
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(false);
+    });
+    test("should fail validation for missing defaultProvider", () => {
+        const config = {
+            providers: {
+                openai: {
+                    provider: "openai",
+                    apiKey: "sk-test",
+                },
+            },
+            defaultModel: "gpt-4",
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(false);
+    });
+    test("should apply default values", () => {
+        const config = {
+            providers: {
+                openai: {
+                    provider: "openai",
+                    apiKey: "sk-test",
+                },
+            },
+            defaultProvider: "openai",
+            defaultModel: "gpt-4",
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.stream).toBe(true); // default: true
+            expect(result.data.temperature).toBe(0.7); // default: 0.7
+        }
+    });
+});
+describe("LLMMessage type", () => {
+    test("should accept user message", () => {
+        const msg = {
+            role: "user",
+            content: "Hello, world!",
+        };
+        expect(msg.role).toBe("user");
+        expect(msg.content).toBe("Hello, world!");
+    });
+    test("should accept assistant message with content", () => {
+        const msg = {
+            role: "assistant",
+            content: "Hello!",
+        };
+        expect(msg.role).toBe("assistant");
+    });
+    test("should accept assistant message with tool calls", () => {
+        const msg = {
+            role: "assistant",
+            content: "Let me search for that.",
+            toolCalls: [
+                {
+                    id: "call_1",
+                    name: "search",
+                    arguments: '{"query":"weather"}',
+                },
+            ],
+        };
+        expect(msg.toolCalls).toHaveLength(1);
+        expect(msg.toolCalls?.[0].name).toBe("search");
+    });
+    test("should accept system message", () => {
+        const msg = {
+            role: "system",
+            content: "You are a helpful assistant.",
+        };
+        expect(msg.role).toBe("system");
+    });
+    test("should accept tool message", () => {
+        const msg = {
+            role: "tool",
+            content: "The weather is sunny.",
+            toolCallId: "call_1",
+        };
+        expect(msg.role).toBe("tool");
+        expect(msg.toolCallId).toBe("call_1");
+    });
+});
+describe("LLMOutput type", () => {
+    test("should accept output with content", () => {
+        const output = {
+            content: "The answer is 42.",
+            finishReason: "stop",
+        };
+        expect(output.content).toBe("The answer is 42.");
+        expect(output.finishReason).toBe("stop");
+    });
+    test("should accept output with tool calls", () => {
+        const output = {
+            content: "Let me get that information.",
+            finishReason: "tool-calls",
+            toolCalls: [
+                {
+                    id: "call_1",
+                    name: "search",
+                    arguments: '{"query":"weather"}',
+                },
+            ],
+        };
+        expect(output.toolCalls).toHaveLength(1);
+    });
+    test("should accept output with usage info", () => {
+        const output = {
+            content: "Hello!",
+            finishReason: "stop",
+            usage: {
+                promptTokens: 10,
+                completionTokens: 5,
+                totalTokens: 15,
+            },
+        };
+        expect(output.usage?.promptTokens).toBe(10);
+        expect(output.usage?.completionTokens).toBe(5);
+    });
+});
+describe("ToolCall type", () => {
+    test("should accept valid tool call", () => {
+        const toolCall = {
+            id: "call_abc123",
+            name: "getWeather",
+            arguments: '{"location":"Beijing","unit":"celsius"}',
+        };
+        expect(toolCall.id).toBe("call_abc123");
+        expect(toolCall.name).toBe("getWeather");
+        expect(toolCall.arguments).toBe('{"location":"Beijing","unit":"celsius"}');
+    });
+});
+describe("ToolResult type", () => {
+    test("should accept tool result", () => {
+        const result = {
+            toolCallId: "call_abc123",
+            result: "Sunny, 25°C",
+        };
+        expect(result.toolCallId).toBe("call_abc123");
+        expect(result.result).toBe("Sunny, 25°C");
+    });
+    test("should accept tool result with error", () => {
+        const result = {
+            toolCallId: "call_abc123",
+            result: "Error: API rate limited",
+            isError: true,
+        };
+        expect(result.isError).toBe(true);
+    });
+});
+describe("UsageInfo type", () => {
+    test("should accept usage info", () => {
+        const usage = {
+            promptTokens: 100,
+            completionTokens: 50,
+            totalTokens: 150,
+        };
+        expect(usage.promptTokens).toBe(100);
+        expect(usage.completionTokens).toBe(50);
+        expect(usage.totalTokens).toBe(150);
+    });
+});
+describe("ProviderCapabilitiesSchema", () => {
+    test("should validate empty capabilities", () => {
+        const { ProviderCapabilitiesSchema } = require("./types");
+        const result = ProviderCapabilitiesSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    test("should validate capabilities with reasoning", () => {
+        const { ProviderCapabilitiesSchema } = require("./types");
+        const result = ProviderCapabilitiesSchema.safeParse({
+            reasoning: true,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.reasoning).toBe(true);
+        }
+    });
+    test("should validate capabilities with toolcall", () => {
+        const { ProviderCapabilitiesSchema } = require("./types");
+        const result = ProviderCapabilitiesSchema.safeParse({
+            toolcall: true,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.toolcall).toBe(true);
+        }
+    });
+    test("should validate capabilities with thinkingInText", () => {
+        const { ProviderCapabilitiesSchema } = require("./types");
+        const result = ProviderCapabilitiesSchema.safeParse({
+            thinkingInText: {
+                enabled: true,
+                tags: ["<think>", "</think>"],
+                removeFromOutput: true,
+            },
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.thinkingInText?.enabled).toBe(true);
+            expect(result.data.thinkingInText?.tags).toEqual(["<think>", "</think>"]);
+        }
+    });
+    test("should validate capabilities with interleaved", () => {
+        const { ProviderCapabilitiesSchema } = require("./types");
+        const result = ProviderCapabilitiesSchema.safeParse({
+            interleaved: {
+                field: "thinking",
+            },
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.interleaved?.field).toBe("thinking");
+        }
+    });
+    test("should validate full capabilities", () => {
+        const { ProviderCapabilitiesSchema } = require("./types");
+        const result = ProviderCapabilitiesSchema.safeParse({
+            reasoning: true,
+            toolcall: true,
+            interleaved: { field: "thinking" },
+            thinkingInText: {
+                enabled: true,
+                tags: ["<think>"],
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe("ModelLimitsSchema", () => {
+    test("should validate valid limits", () => {
+        const { ModelLimitsSchema } = require("./types");
+        const result = ModelLimitsSchema.safeParse({
+            contextWindow: 128000,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.contextWindow).toBe(128000);
+        }
+    });
+    test("should validate limits with optional fields", () => {
+        const { ModelLimitsSchema } = require("./types");
+        const result = ModelLimitsSchema.safeParse({
+            contextWindow: 128000,
+            compactionThreshold: 0.8,
+            maxOutputTokens: 4096,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.compactionThreshold).toBe(0.8);
+            expect(result.data.maxOutputTokens).toBe(4096);
+        }
+    });
+    test("should fail for missing contextWindow", () => {
+        const { ModelLimitsSchema } = require("./types");
+        const result = ModelLimitsSchema.safeParse({});
+        expect(result.success).toBe(false);
+    });
+    test("should fail for negative contextWindow", () => {
+        const { ModelLimitsSchema } = require("./types");
+        const result = ModelLimitsSchema.safeParse({
+            contextWindow: -1000,
+        });
+        expect(result.success).toBe(false);
+    });
+    test("should fail for compactionThreshold out of range", () => {
+        const { ModelLimitsSchema } = require("./types");
+        const result = ModelLimitsSchema.safeParse({
+            contextWindow: 128000,
+            compactionThreshold: 1.5,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe("ProviderConfigSchema", () => {
+    test("should validate minimal provider config", () => {
+        const { ProviderConfigSchema } = require("./types");
+        const result = ProviderConfigSchema.safeParse({
+            provider: "openai",
+            apiKey: "sk-test",
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.provider).toBe("openai");
+            expect(result.data.apiKey).toBe("sk-test");
+        }
+    });
+    test("should validate full provider config", () => {
+        const { ProviderConfigSchema } = require("./types");
+        const result = ProviderConfigSchema.safeParse({
+            provider: "openai",
+            name: "OpenAI Provider",
+            description: "OpenAI API provider",
+            apiKey: "sk-test",
+            baseURL: "https://api.openai.com/v1",
+            models: ["gpt-4o", "gpt-4o-mini"],
+            defaultModel: "gpt-4o",
+            temperature: 0.7,
+            maxTokens: 4096,
+            capabilities: {
+                reasoning: true,
+                toolcall: true,
+            },
+            limits: {
+                "gpt-4o": {
+                    contextWindow: 128000,
+                    maxOutputTokens: 4096,
+                },
+            },
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.models).toHaveLength(2);
+            expect(result.data.capabilities?.reasoning).toBe(true);
+        }
+    });
+    test("should fail for missing apiKey", () => {
+        const { ProviderConfigSchema } = require("./types");
+        const result = ProviderConfigSchema.safeParse({
+            provider: "openai",
+        });
+        expect(result.success).toBe(false);
+    });
+    test("should validate with providerOptions", () => {
+        const { ProviderConfigSchema } = require("./types");
+        const result = ProviderConfigSchema.safeParse({
+            provider: "openai",
+            apiKey: "sk-test",
+            providerOptions: {
+                __dangerous__: {
+                    allowBrowser: true,
+                },
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe("LLMDefaultConfigSchema", () => {
+    test("should validate empty default config", () => {
+        const { LLMDefaultConfigSchema } = require("./types");
+        const result = LLMDefaultConfigSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    test("should validate with temperature", () => {
+        const { LLMDefaultConfigSchema } = require("./types");
+        const result = LLMDefaultConfigSchema.safeParse({
+            temperature: 0.5,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.temperature).toBe(0.5);
+        }
+    });
+    test("should validate with maxTokens", () => {
+        const { LLMDefaultConfigSchema } = require("./types");
+        const result = LLMDefaultConfigSchema.safeParse({
+            maxTokens: 2048,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.maxTokens).toBe(2048);
+        }
+    });
+    test("should fail for temperature out of range", () => {
+        const { LLMDefaultConfigSchema } = require("./types");
+        const result = LLMDefaultConfigSchema.safeParse({
+            temperature: 3.0,
+        });
+        expect(result.success).toBe(false);
+    });
+    test("should fail for negative maxTokens", () => {
+        const { LLMDefaultConfigSchema } = require("./types");
+        const result = LLMDefaultConfigSchema.safeParse({
+            maxTokens: -100,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe("LLMConfigSchema full validation", () => {
+    test("should validate minimal config", () => {
+        const config = {
+            providers: {
+                openai: {
+                    provider: "openai",
+                    apiKey: "sk-test",
+                },
+            },
+            defaultProvider: "openai",
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.defaultProvider).toBe("openai");
+            expect(result.data.stream).toBe(true); // default
+            expect(result.data.temperature).toBe(0.7); // default
+        }
+    });
+    test("should validate config with multiple providers", () => {
+        const config = {
+            providers: {
+                openai: {
+                    provider: "openai",
+                    apiKey: "sk-openai",
+                },
+                anthropic: {
+                    provider: "anthropic",
+                    apiKey: "sk-antropic",
+                },
+                google: {
+                    provider: "google",
+                    apiKey: "sk-google",
+                    baseURL: "https://generativelanguage.googleapis.com",
+                },
+            },
+            defaultProvider: "openai",
+            defaultModel: "gpt-4o",
+            temperature: 0.8,
+            stream: false,
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(Object.keys(result.data.providers)).toHaveLength(3);
+        }
+    });
+    test("should validate config with default section", () => {
+        const config = {
+            providers: {
+                openai: {
+                    provider: "openai",
+                    apiKey: "sk-test",
+                },
+            },
+            defaultProvider: "openai",
+            default: {
+                temperature: 0.5,
+                maxTokens: 2048,
+            },
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.default?.temperature).toBe(0.5);
+        }
+    });
+    test("should allow empty providers (config can be extended later)", () => {
+        const config = {
+            providers: {},
+            defaultProvider: "openai",
+        };
+        // Empty providers is valid - config can be extended later
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(true);
+    });
+    test("should fail for topP out of range", () => {
+        const config = {
+            providers: {
+                openai: {
+                    provider: "openai",
+                    apiKey: "sk-test",
+                },
+            },
+            defaultProvider: "openai",
+            topP: 1.5,
+        };
+        const result = LLMConfigSchema.safeParse(config);
+        expect(result.success).toBe(false);
+    });
+});
+//# sourceMappingURL=types.test.js.map

package/dist/core/src/env/log-trace/decorator-otel.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview @Traced 装饰器 OTel 集成测试
+ *
+ * 使用 OpenTelemetry 方式测试装饰器功能
+ */
+export {};
+//# sourceMappingURL=decorator-otel.test.d.ts.map