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

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

@@ -1,755 +0,0 @@
-/**
- * @fileoverview LLM invocation with AI SDK integration.
- *
- * This module provides LLM invocation using AI SDK for better provider support.
- * Stream events are published via Environment.pushEnvEvent().
- */
-import { randomUUID } from "crypto";
-import { streamText, jsonSchema } from "ai";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { createLogger } from "../log-trace/logger.js";
-// 创建 llm:invoke 模块日志器
-const logger = createLogger("llm:invoke");
-/**
- * AI SDK 最大重试次数
- * AI SDK 内部使用指数退避策略（默认 2s → 4s → 8s）
- */
-const MAX_RETRIES = 3;
-/**
- * LLM 默认超时时间（毫秒）
- */
-const DEFAULT_TIMEOUT = 60000;
-/**
- * 超时错误
- */
-export class TimeoutError extends Error {
-    timeout;
-    constructor(message, timeout) {
-        super(message);
-        this.timeout = timeout;
-        this.name = "TimeoutError";
-    }
-}
-/**
- * 带超时的 Promise 包装器
- *
- * @param promise 要执行的 Promise
- * @param timeoutMs 超时时间（毫秒）
- * @param message 自定义错误消息
- * @returns Promise 结果
- * @throws TimeoutError 当超时时
- */
-export async function withTimeout(promise, timeoutMs = DEFAULT_TIMEOUT, message) {
-    const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-            reject(new TimeoutError(message || `LLM invocation timeout after ${timeoutMs}ms`, timeoutMs));
-        }, timeoutMs);
-    });
-    return Promise.race([promise, timeoutPromise]);
-}
-/**
- * 解析模型字符串
- * 格式: "providerId/modelId"
- */
-export function parseModelString(model) {
-    if (!model) {
-        return { providerId: "openai", modelId: "gpt-4o" };
-    }
-    const parts = model.split("/");
-    if (parts.length >= 2) {
-        return { providerId: parts[0], modelId: parts.slice(1).join("/") };
-    }
-    return { providerId: "openai", modelId: model };
-}
-/**
- * 从 Usage 信息提取标准格式
- */
-function extractUsageInfo(usage) {
-    if (!usage)
-        return undefined;
-    // 标准格式: inputTokens/outputTokens 是对象，包含 total 属性（AI SDK LanguageModelV3Usage）
-    if (usage.inputTokens && typeof usage.inputTokens === "object") {
-        return {
-            promptTokens: usage.inputTokens.total ?? 0,
-            completionTokens: usage.outputTokens?.total ?? 0,
-            totalTokens: usage.totalTokens ?? 0,
-        };
-    }
-    // 旧格式: 直接 number 属性
-    if (typeof usage.promptTokens === "number") {
-        return {
-            promptTokens: usage.promptTokens,
-            completionTokens: usage.completionTokens ?? 0,
-            totalTokens: usage.totalTokens ?? 0,
-        };
-    }
-    // MiniMax 格式: 使用 tokenDetails
-    if (usage.inputTokenDetails || usage.outputTokenDetails) {
-        return {
-            promptTokens: usage.inputTokenDetails?.tokens ?? 0,
-            completionTokens: usage.outputTokenDetails?.tokens ?? 0,
-            totalTokens: usage.totalTokens ?? 0,
-        };
-    }
-    // MiniMax 流式格式: 只有 total_tokens
-    if (usage.raw && typeof usage.raw.total_tokens === "number") {
-        return {
-            promptTokens: 0,
-            completionTokens: 0,
-            totalTokens: usage.raw.total_tokens,
-        };
-    }
-    return undefined;
-}
-/**
- * 将 LLMMessage 转换为 AI SDK 格式
- */
-function convertToSDKMessages(messages) {
-    return messages.map((msg) => {
-        // 处理 assistant 消息中的 toolCalls
-        if (msg.role === "assistant" && msg.toolCalls && msg.toolCalls.length > 0) {
-            // AI SDK v6 期望 toolCalls 在 content 数组中作为 tool-call part
-            // 注意：使用 input: unknown 而不是 arguments: string
-            const toolCallParts = msg.toolCalls.map((tc) => {
-                // 解析 arguments 为对象
-                let input = {};
-                if (tc.function?.arguments) {
-                    if (typeof tc.function.arguments === "string") {
-                        try {
-                            input = JSON.parse(tc.function.arguments);
-                        }
-                        catch {
-                            input = tc.function.arguments;
-                        }
-                    }
-                    else {
-                        input = tc.function.arguments;
-                    }
-                }
-                else if (tc.arguments) {
-                    if (typeof tc.arguments === "string") {
-                        try {
-                            input = JSON.parse(tc.arguments);
-                        }
-                        catch {
-                            input = tc.arguments;
-                        }
-                    }
-                    else {
-                        input = tc.arguments;
-                    }
-                }
-                return {
-                    type: "tool-call",
-                    toolCallId: tc.id,
-                    toolName: tc.function?.name || tc.name || "unknown",
-                    input,
-                };
-            });
-            return {
-                role: "assistant",
-                content: toolCallParts,
-            };
-        }
-        // 验证 tool 消息格式
-        if (msg.role === "tool") {
-            if (!msg.toolCallId) {
-                logger.warn("Tool message missing toolCallId", { msg });
-            }
-            // AI SDK v6 要求 tool 消息的 output 格式为 { type: 'text', value: string }
-            // 处理 content 可能是数组的情况（AI SDK v6 格式）
-            let outputValue = "";
-            const content = msg.content;
-            if (typeof content === "string") {
-                outputValue = content;
-            }
-            else if (Array.isArray(content)) {
-                // 如果是数组，可能是 [{ type: 'tool-result', output: '...' }]
-                const toolResultPart = content.find((p) => p?.type === "tool-result");
-                if (toolResultPart) {
-                    outputValue = typeof toolResultPart.output === "string"
-                        ? toolResultPart.output
-                        : JSON.stringify(toolResultPart.output);
-                }
-                else {
-                    // 尝试提取任何文本内容
-                    outputValue = JSON.stringify(content);
-                }
-            }
-            else {
-                outputValue = JSON.stringify(content);
-            }
-            const converted = {
-                role: "tool",
-                content: [{
-                        type: "tool-result",
-                        toolCallId: msg.toolCallId || "unknown",
-                        toolName: msg.name || "unknown",
-                        output: {
-                            type: "text",
-                            value: outputValue,
-                        },
-                    }],
-            };
-            return converted;
-        }
-        return msg;
-    });
-}
-/**
- * 将 ToolInfo 转换为 AI SDK ToolSet 格式
- */
-function convertToolsToSDK(tools) {
-    const result = {};
-    for (const tool of tools) {
-        const jsonSchemaObj = extractToolSchema(tool.parameters);
-        result[tool.name] = {
-            description: tool.description || "",
-            inputSchema: jsonSchema(jsonSchemaObj),
-        };
-    }
-    return result;
-}
-/**
- * 从 Zod 类型提取 JSON Schema
- */
-function extractToolSchema(parameters) {
-    // 如果是 Zod 类型
-    if (parameters && typeof parameters === "object" && "_def" in parameters) {
-        const zodSchema = parameters;
-        const schema = zodToJsonSchema(zodSchema, "zod");
-        if ("$ref" in schema && schema.definitions) {
-            const def = schema.definitions.zod;
-            if (def && def.type === "object" && def.properties) {
-                return {
-                    type: "object",
-                    properties: def.properties,
-                    required: def.required,
-                    additionalProperties: true,
-                };
-            }
-        }
-        return schema;
-    }
-    // 如果已经是 JSON Schema 格式
-    return parameters;
-}
-/**
- * 生成 Provider 选项
- */
-function generateProviderOptions(providerType, options) {
-    const result = {
-        providerOptions: {},
-    };
-    if (options.temperature !== undefined) {
-        result.temperature = options.temperature;
-    }
-    if (options.maxTokens !== undefined) {
-        result.maxTokens = options.maxTokens;
-    }
-    // Provider 特定配置
-    switch (providerType) {
-        case "anthropic":
-            // Anthropic 不支持 temperature，使用 top_p
-            break;
-        case "openai-compatible":
-            // OpenAI 兼容格式支持 includeUsage
-            result.providerOptions.includeUsage = true;
-            break;
-    }
-    return result;
-}
-/**
- * 创建 Env 事件发布函数
- * @param env Environment 实例
- * @param context 上下文信息
- * @returns 发布函数
- */
-function createEnvEventEmitter(env, context) {
-    if (!env) {
-        return null;
-    }
-    return (event) => {
-        try {
-            env.pushEnvEvent({
-                id: randomUUID(),
-                type: `llm.${event.type}`,
-                timestamp: Date.now(),
-                metadata: {
-                    source: "llm.invoke",
-                    sessionId: context?.sessionId,
-                    messageId: context?.messageId,
-                },
-                payload: event,
-            });
-        }
-        catch (err) {
-            logger.warn("Failed to push env event", { error: String(err), eventType: event.type });
-        }
-    };
-}
-/**
- * 处理文本中的 thinking 标签
- */
-function processThinkingFromText(textDelta, config) {
-    if (!config.enabled || !textDelta) {
-        return { cleanedText: textDelta };
-    }
-    const tags = config.tags || ["thinking", "think"];
-    let remainingText = textDelta;
-    let extractedThinking = "";
-    for (const tag of tags) {
-        let openTag;
-        let closeTag;
-        // 特殊处理 "think" -> 映射到标准的 <think>/</think>
-        if (tag === "think") {
-            openTag = "<think>";
-            closeTag = "</think>";
-        }
-        else {
-            openTag = `<${tag}>`;
-            closeTag = `</${tag}>`;
-        }
-        // 匹配所有 thinking 标签
-        const regex = new RegExp(`${openTag}([\\s\\S]*?)${closeTag}`, "gi");
-        let match;
-        while ((match = regex.exec(remainingText)) !== null) {
-            const content = match[1];
-            extractedThinking += content;
-            // 从输出中移除 thinking 标签
-            if (config.removeFromOutput !== false) {
-                remainingText = remainingText.replaceAll(match[0], "");
-            }
-        }
-    }
-    return {
-        cleanedText: remainingText,
-        thinkingContent: extractedThinking || undefined,
-    };
-}
-/**
- * 处理流式 thinking 标签
- * 在检测到 opening/closing 标签时立即触发推理事件
- */
-function processThinkingStream(textDelta, config, state) {
-    if (!config.enabled || !textDelta) {
-        return {
-            cleanedText: textDelta,
-            isThinkingTagOpen: state.isOpen,
-            currentThinkingContent: state.content,
-            reasoningEvents: [],
-        };
-    }
-    const tags = config.tags || ["thinking"];
-    let remainingText = textDelta;
-    const reasoningEvents = [];
-    let isOpen = state.isOpen;
-    let currentContent = state.content;
-    for (const tag of tags) {
-        const openTag = `<${tag}>`;
-        const closeTag = `</${tag}>`;
-        let text = remainingText;
-        let result = "";
-        const openIndex = text.toLowerCase().indexOf(openTag.toLowerCase());
-        const closeIndex = text.toLowerCase().indexOf(closeTag.toLowerCase());
-        if (openIndex !== -1 && (closeIndex === -1 || openIndex < closeIndex)) {
-            // 先找到 opening 标签
-            const beforeOpen = text.substring(0, openIndex);
-            const afterOpen = text.substring(openIndex + openTag.length);
-            if (!isOpen) {
-                isOpen = true;
-                currentContent = "";
-                reasoningEvents.push("");
-            }
-            result += beforeOpen;
-            const innerCloseIndex = afterOpen.toLowerCase().indexOf(closeTag.toLowerCase());
-            if (innerCloseIndex !== -1) {
-                // 同一 delta 中有 opening 和 closing
-                const thinkingContent = afterOpen.substring(0, innerCloseIndex);
-                const afterClose = afterOpen.substring(innerCloseIndex + closeTag.length);
-                currentContent += thinkingContent;
-                reasoningEvents.push(currentContent);
-                isOpen = false;
-                currentContent = "";
-                result += afterClose;
-            }
-            else {
-                // 只有 opening 标签
-                currentContent += afterOpen;
-                reasoningEvents.push(currentContent);
-                result += "";
-            }
-            remainingText = result;
-        }
-        else if (closeIndex !== -1) {
-            // 先找到 closing 标签
-            const beforeClose = text.substring(0, closeIndex);
-            const afterClose = text.substring(closeIndex + closeTag.length);
-            if (isOpen) {
-                currentContent += beforeClose;
-                reasoningEvents.push(currentContent);
-                isOpen = false;
-                currentContent = "";
-                result = afterClose;
-            }
-            else {
-                result = text;
-            }
-            remainingText = result;
-        }
-    }
-    return {
-        cleanedText: remainingText,
-        isThinkingTagOpen: isOpen,
-        currentThinkingContent: currentContent,
-        reasoningEvents,
-    };
-}
-/**
- * 核心 LLM 调用函数
- * 使用 AI SDK 的 streamText
- *
- * 流式事件通过 env.pushEnvEvent() 发布
- *
- * @param config - Invoke 配置
- * @param options - LLM 选项
- * @param ctx - Tool Context
- * @returns ToolResult
- */
-export async function invoke(config, options, ctx) {
-    try {
-        // 0. 创建 Env 事件发布器
-        const emitToEnv = createEnvEventEmitter(options.env, options.context);
-        // 1. 解析模型字符串
-        const { providerId, modelId } = parseModelString(options.model || config.model);
-        // 2. 获取 Provider 实例
-        // 注意：实际使用需要 ProviderManager 已初始化
-        // 这里简化处理，直接创建 SDK Provider
-        const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
-        if (!provider) {
-            throw new Error(`Failed to create provider for ${providerId}`);
-        }
-        // 3. 转换消息为 AI SDK 格式
-        const messages = convertToSDKMessages(options.messages);
-        // DEBUG: 记录转换后消息中的 toolCallId 匹配情况
-        const toolCallIds = new Set();
-        const assistantToolCalls = [];
-        const toolResultIds = [];
-        for (const msg of messages) {
-            if (msg.role === "assistant") {
-                // 检查 assistant 消息中的 toolCalls
-                const assistantContent = Array.isArray(msg.content) ? msg.content : [];
-                for (const part of assistantContent) {
-                    if (part && typeof part === "object" && part.type === "tool-call") {
-                        const tc = part.toolCall || part;
-                        assistantToolCalls.push({ id: tc.id, name: tc.name || (tc.function && tc.function.name) });
-                        toolCallIds.add(tc.id);
-                    }
-                }
-            }
-            if (msg.role === "tool") {
-                const toolContent = Array.isArray(msg.content) ? msg.content : [];
-                for (const part of toolContent) {
-                    if (part && typeof part === "object" && part.type === "tool-result") {
-                        toolResultIds.push(part.toolCallId);
-                    }
-                }
-            }
-        }
-        // 检查 toolCallId 匹配
-        const missingToolResults = assistantToolCalls.filter(tc => !toolResultIds.includes(tc.id));
-        const orphanedToolResults = toolResultIds.filter(id => !toolCallIds.has(id));
-        if (assistantToolCalls.length > 0 || toolResultIds.length > 0) {
-            logger.debug("[invoke] ToolCallId matching analysis:", {
-                assistantToolCalls,
-                toolResultIds,
-                missingToolResults: missingToolResults.length > 0 ? missingToolResults : "none",
-                orphanedToolResults: orphanedToolResults.length > 0 ? orphanedToolResults : "none",
-            });
-        }
-        // 4. 转换工具
-        const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
-        // 5. 生成 Provider 选项
-        const providerOptions = generateProviderOptions(providerId, {
-            temperature: options.temperature,
-            maxTokens: options.maxTokens,
-        });
-        // 6. 发布开始事件
-        const model = `${providerId}/${modelId}`;
-        if (emitToEnv) {
-            emitToEnv({ type: "start", metadata: { model } });
-        }
-        // 7. 调用 AI SDK streamText
-        const streamTextOptions = {
-            model: provider.languageModel(modelId),
-            messages,
-            tools,
-            temperature: providerOptions.temperature,
-            maxTokens: providerOptions.maxTokens,
-            abortSignal: ctx.abort,
-            maxRetries: MAX_RETRIES,
-            streamOptions: {
-                includeUsage: true,
-            },
-        };
-        const result = await streamText(streamTextOptions);
-        // 8. 处理流
-        let fullContent = "";
-        let reasoningContent = "";
-        const toolCalls = [];
-        let usageInfo;
-        // 流式推理状态
-        let isThinkingTagOpen = false;
-        let currentThinkingContent = "";
-        for await (const part of result.fullStream) {
-            const streamPart = part;
-            switch (streamPart.type) {
-                case "text-delta":
-                    const textDelta = streamPart.text;
-                    // 检查是否有 thinkingInText 配置（从 config.options 中获取）
-                    const thinkingConfig = config.options?.thinkingInText;
-                    if (thinkingConfig?.enabled) {
-                        const thinkingResult = processThinkingStream(textDelta, thinkingConfig, {
-                            isOpen: isThinkingTagOpen,
-                            content: currentThinkingContent,
-                        });
-                        isThinkingTagOpen = thinkingResult.isThinkingTagOpen;
-                        currentThinkingContent = thinkingResult.currentThinkingContent;
-                        fullContent += thinkingResult.cleanedText;
-                        for (const reasoningDelta of thinkingResult.reasoningEvents) {
-                            reasoningContent = reasoningDelta;
-                            if (emitToEnv) {
-                                emitToEnv({ type: "reasoning", content: reasoningContent });
-                            }
-                        }
-                        if (emitToEnv) {
-                            emitToEnv({ type: "text", content: fullContent, delta: thinkingResult.cleanedText });
-                        }
-                    }
-                    else {
-                        fullContent += textDelta;
-                        if (emitToEnv) {
-                            emitToEnv({ type: "text", content: fullContent, delta: textDelta });
-                        }
-                    }
-                    break;
-                case "reasoning-delta":
-                    const reasoningDelta = streamPart.text;
-                    reasoningContent += reasoningDelta;
-                    if (emitToEnv) {
-                        emitToEnv({ type: "reasoning", content: reasoningContent });
-                    }
-                    break;
-                case "tool-call":
-                    const toolInput = streamPart.input;
-                    const toolCallId = streamPart.toolCallId;
-                    const toolName = streamPart.toolName;
-                    toolCalls.push({
-                        id: toolCallId,
-                        name: toolName,
-                        args: toolInput,
-                    });
-                    if (emitToEnv) {
-                        emitToEnv({
-                            type: "tool_call",
-                            toolCall: {
-                                id: toolCallId,
-                                name: toolName,
-                                arguments: JSON.stringify(toolInput),
-                            },
-                        });
-                    }
-                    break;
-                case "finish-step":
-                    const stepUsage = extractUsageInfo(streamPart.usage);
-                    if (stepUsage) {
-                        usageInfo = stepUsage;
-                    }
-                    break;
-                case "error":
-                    throw streamPart.error;
-                case "finish":
-                    usageInfo = extractUsageInfo(streamPart.totalUsage);
-                    if (!usageInfo && streamPart.usage) {
-                        usageInfo = extractUsageInfo(streamPart.usage);
-                    }
-                    break;
-            }
-        }
-        // 9. 发布完成事件
-        if (emitToEnv) {
-            emitToEnv({
-                type: "completed",
-                content: fullContent,
-                metadata: {
-                    model,
-                    usage: usageInfo,
-                },
-            });
-        }
-        // 10. 返回结果
-        if (toolCalls.length > 0) {
-            // 有工具调用时，返回第一个工具调用的结果
-            const firstToolCall = toolCalls[0];
-            return {
-                toolCallId: firstToolCall.id,
-                result: JSON.stringify({
-                    content: fullContent,
-                    reasoning: reasoningContent || undefined,
-                    tool_calls: toolCalls.map((tc) => ({
-                        id: tc.id,
-                        function: {
-                            name: tc.name,
-                            arguments: JSON.stringify(tc.args),
-                        },
-                    })),
-                }),
-            };
-        }
-        // 无工具调用时，返回内容
-        return {
-            toolCallId: "invoke-" + Date.now(),
-            result: JSON.stringify({
-                content: fullContent,
-                reasoning: reasoningContent || undefined,
-                usage: usageInfo,
-                model,
-            }),
-        };
-    }
-    catch (error) {
-        logger.error("Error during invocation", {
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
-        });
-        return {
-            toolCallId: "error-" + Date.now(),
-            result: error instanceof Error ? error.message : String(error),
-            isError: true,
-        };
-    }
-}
-/**
- * 创建 Provider 实例
- * 根据 providerId 创建对应的 AI SDK Provider
- */
-function createProviderInstance(providerId, apiKey, baseURL) {
-    try {
-        // OpenAI
-        if (providerId === "openai") {
-            const openai = createOpenAI({
-                apiKey,
-                baseURL,
-            });
-            return openai;
-        }
-        // Anthropic
-        if (providerId === "anthropic") {
-            const anthropic = createAnthropic({
-                apiKey,
-            });
-            return anthropic;
-        }
-        // Google
-        if (providerId === "google") {
-            const google = createGoogleGenerativeAI({
-                apiKey,
-            });
-            return google;
-        }
-        // 默认: 使用 OpenAI 兼容格式（支持 minimax、deepseek 等）
-        const defaultProvider = createOpenAICompatible({
-            name: providerId,
-            apiKey,
-            baseURL: baseURL || "",
-            includeUsage: true, // Enable usage in stream responses for MiniMax etc.
-        });
-        return defaultProvider;
-    }
-    catch (error) {
-        logger.error(`Failed to create provider ${providerId}`, { error: String(error) });
-        return null;
-    }
-}
-/**
- * 非流式 LLM 调用
- *
- * 使用 AI SDK 的 generateText API，返回完整响应
- */
-export async function invokeNonStream(config, options, ctx) {
-    // 解析模型字符串
-    const { providerId, modelId } = parseModelString(options.model || config.model);
-    // 获取 Provider 实例
-    const provider = createProviderInstance(providerId, config.apiKey, config.baseURL);
-    if (!provider) {
-        throw new Error(`Failed to create provider for ${providerId}`);
-    }
-    // 转换消息和工具
-    const messages = convertToSDKMessages(options.messages);
-    const tools = options.tools && options.tools.length > 0 ? convertToolsToSDK(options.tools) : undefined;
-    // 生成 Provider 选项
-    const providerOptions = generateProviderOptions(providerId, {
-        temperature: options.temperature,
-        maxTokens: options.maxTokens,
-    });
-    // 使用 generateText API（非流式）
-    const { generateText } = await import("ai");
-    const genTextFn = generateText;
-    const result = await genTextFn({
-        model: provider.languageModel(modelId),
-        messages,
-        tools,
-        temperature: providerOptions.temperature,
-        maxTokens: providerOptions.maxTokens,
-        abortSignal: ctx.abort,
-    });
-    // 计算 usage
-    const usage = result.usage;
-    const usageInfo = usage ? {
-        promptTokens: usage.promptTokens ?? 0,
-        completionTokens: usage.completionTokens ?? 0,
-        totalTokens: usage.totalTokens ?? 0,
-    } : undefined;
-    // 发布完成事件（如果有 env）
-    if (options.env) {
-        options.env.pushEnvEvent({
-            id: randomUUID(),
-            type: "llm.completed",
-            timestamp: Date.now(),
-            metadata: {
-                source: "llm.invokeNonStream",
-                sessionId: options.context?.sessionId,
-                messageId: options.context?.messageId,
-            },
-            payload: {
-                type: "completed",
-                content: result.text,
-                metadata: {
-                    model: `${providerId}/${modelId}`,
-                    usage: usageInfo,
-                },
-            },
-        });
-    }
-    return {
-        content: result.text,
-        finishReason: result.finishReason === "stop" ? "stop" : "tool-calls",
-        model: `${providerId}/${modelId}`,
-        usage: usageInfo,
-    };
-}
-/**
- * 创建 LLM 配置
- */
-export function createInvokeConfig(model, apiKey, baseURL) {
-    return {
-        model,
-        apiKey,
-        baseURL,
-    };
-}
-//# sourceMappingURL=invoke.js.map