@ai-setting/roy-agent-core 1.3.9 → 1.3.11

package/src/env/llm/invoke.ts

@@ -1,1039 +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, type ModelMessage, type ToolSet, 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 { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import type { ToolInfo, ToolResult, LLMOutput, LLMMessage, UsageInfo } from "./types";
-import type { Environment } from "../interface";
-import { createLogger } from "../log-trace/logger";
-
-// 创建 llm:invoke 模块日志器
-const logger = createLogger("llm:invoke");
-
-// LanguageModel type alias for type checking
-type AISDKLanguageModel = Parameters<ReturnType<typeof createOpenAI>["languageModel"]>[0];
-
-/**
- * GenerateText Options
- * 
- * 定义 generateText 函数的参数类型，用于类型安全调用
- */
-interface GenerateTextOptions {
-  model: AISDKLanguageModel;
-  messages: ModelMessage[];
-  tools?: ToolSet;
-  temperature?: number;
-  maxTokens?: number;
-  abortSignal?: AbortSignal;
-  [key: string]: unknown;
-}
-
-/**
- * GenerateText Result
- * 
- * 定义 generateText 返回的结果类型
- */
-interface GenerateTextResult {
-  text: string;
-  finishReason: string;
-  usage: {
-    promptTokens?: number;
-    completionTokens?: number;
-    totalTokens?: number;
-  };
-  [key: string]: unknown;
-}
-
-/**
- * Invoke LLM 配置
- */
-export interface InvokeConfig {
-  /** 模型标识符（格式: providerId/modelId） */
-  model: string;
-  /** Base URL */
-  baseURL?: string;
-  /** API Key */
-  apiKey: string;
-  /** 额外选项 */
-  options?: {
-    thinkingInText?: {
-      enabled?: boolean;
-      tags?: string[];
-    };
-  };
-}
-
-/**
- * LLM 选项
- */
-export interface InvokeOptions {
-  /** 消息列表 */
-  messages: LLMMessage[];
-  /** 工具列表 */
-  tools?: ToolInfo[];
-  /** 模型标识符（可选） */
-  model?: string;
-  /** 温度参数 */
-  temperature?: number;
-  /** 最大 Token 数 */
-  maxTokens?: number;
-  /** Environment 实例（用于发布流式事件，可选） */
-  env?: Environment;
-  /** 上下文信息（用于事件元数据） */
-  context?: {
-    /** Session ID */
-    sessionId?: string;
-    /** Message ID */
-    messageId?: string;
-  };
-}
-
-/**
- * LLM Tool Context - Context for tool calls during LLM invocation
- */
-export interface LLMToolContext {
-  /** Abort Signal */
-  abort?: AbortSignal | undefined;
-  /** 额外上下文 */
-  context?: Record<string, unknown>;
-}
-
-/**
- * Usage 信息（AI SDK 格式）
- * 参考: LanguageModelV3Usage from @ai-sdk/provider
- */
-interface AISDKUsage {
-  // 标准格式: inputTokens/outputTokens 是对象，包含 total 等属性
-  inputTokens?: {
-    total?: number;
-    noCache?: number;
-    cacheRead?: number;
-    cacheWrite?: number;
-    [key: string]: unknown;
-  };
-  outputTokens?: {
-    total?: number;
-    [key: string]: unknown;
-  };
-  totalTokens?: number;
-  // 兼容旧格式: 直接 number
-  promptTokens?: number;
-  completionTokens?: number;
-  inputTokenDetails?: {
-    tokens?: number;
-    [key: string]: unknown;
-  };
-  outputTokenDetails?: {
-    tokens?: number;
-    [key: string]: unknown;
-  };
-  raw?: {
-    total_tokens?: number;
-    prompt_tokens?: number;
-    completion_tokens?: number;
-  };
-}
-
-/**
- * Usage 信息转换
- */
-export interface ConvertedUsageInfo {
-  /** Prompt Token 数 */
-  promptTokens: number;
-  /** Completion Token 数 */
-  completionTokens: number;
-  /** 总 Token 数 */
-  totalTokens: number;
-}
-
-/**
- * AI SDK 最大重试次数
- * AI SDK 内部使用指数退避策略（默认 2s → 4s → 8s）
- */
-const MAX_RETRIES = 3;
-
-/**
- * LLM 默认超时时间（毫秒）
- */
-const DEFAULT_TIMEOUT = 60000;
-
-/**
- * 超时错误
- */
-export class TimeoutError extends Error {
-  constructor(message: string, public readonly timeout: number) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-}
-
-/**
- * 带超时的 Promise 包装器
- * 
- * @param promise 要执行的 Promise
- * @param timeoutMs 超时时间（毫秒）
- * @param message 自定义错误消息
- * @returns Promise 结果
- * @throws TimeoutError 当超时时
- */
-export async function withTimeout<T>(
-  promise: Promise<T>,
-  timeoutMs: number = DEFAULT_TIMEOUT,
-  message?: string
-): Promise<T> {
-  const timeoutPromise = new Promise<never>((_, 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?: string): { providerId: string; modelId: string } {
-  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: AISDKUsage | undefined): ConvertedUsageInfo | undefined {
-  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: LLMMessage[]): ModelMessage[] {
-  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: unknown = {};
-        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 as any).arguments) {
-          if (typeof (tc as any).arguments === "string") {
-            try {
-              input = JSON.parse((tc as any).arguments);
-            } catch {
-              input = (tc as any).arguments;
-            }
-          } else {
-            input = (tc as any).arguments;
-          }
-        }
-        
-        return {
-          type: "tool-call" as const,
-          toolCallId: tc.id,
-          toolName: tc.function?.name || tc.name || "unknown",
-          input,
-        };
-      });
-      
-      return {
-        role: "assistant" as const,
-        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 as string | unknown[];
-      if (typeof content === "string") {
-        outputValue = content;
-      } else if (Array.isArray(content)) {
-        // 如果是数组，可能是 [{ type: 'tool-result', output: '...' }]
-        const toolResultPart = (content as any[]).find((p: any) => 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: ModelMessage = {
-        role: "tool" as const,
-        content: [{
-          type: "tool-result" as const,
-          toolCallId: msg.toolCallId || "unknown",
-          toolName: msg.name || "unknown",
-          output: {
-            type: "text" as const,
-            value: outputValue,
-          },
-        }],
-      };
-      
-      return converted;
-    }
-    return msg as unknown as ModelMessage;
-  });
-}
-
-/**
- * 将 ToolInfo 转换为 AI SDK ToolSet 格式
- */
-function convertToolsToSDK(tools: ToolInfo[]): ToolSet {
-  const result: ToolSet = {};
-
-  for (const tool of tools) {
-    const jsonSchemaObj = extractToolSchema(tool.parameters);
-    (result as Record<string, unknown>)[tool.name] = {
-      description: tool.description || "",
-      inputSchema: jsonSchema(jsonSchemaObj),
-    };
-  }
-
-  return result;
-}
-
-/**
- * 从 Zod 类型提取 JSON Schema
- */
-function extractToolSchema(parameters: Record<string, unknown>): Record<string, unknown> {
-  // 如果是 Zod 类型
-  if (parameters && typeof parameters === "object" && "_def" in (parameters as { _def?: unknown })) {
-    const zodSchema = parameters as unknown as z.ZodType;
-    const schema: Record<string, unknown> = zodToJsonSchema(zodSchema, "zod") as Record<string, unknown>;
-    if ("$ref" in schema && schema.definitions) {
-      const def = (schema.definitions as Record<string, unknown>).zod as Record<string, unknown> | undefined;
-      if (def && def.type === "object" && def.properties) {
-        return {
-          type: "object",
-          properties: def.properties,
-          required: def.required,
-          additionalProperties: true,
-        };
-      }
-    }
-    return schema as Record<string, unknown>;
-  }
-
-  // 如果已经是 JSON Schema 格式
-  return parameters as Record<string, unknown>;
-}
-
-/**
- * 生成 Provider 选项
- */
-function generateProviderOptions(
-  providerType: string,
-  options: {
-    temperature?: number;
-    maxTokens?: number;
-  }
-): {
-  temperature?: number;
-  maxTokens?: number;
-  providerOptions: Record<string, unknown>;
-} {
-  const result: {
-    temperature?: number;
-    maxTokens?: number;
-    providerOptions: Record<string, unknown>;
-  } = {
-    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?: Environment, context?: InvokeOptions["context"]) {
-  if (!env) {
-    return null;
-  }
-
-  return (event: { type: string; [key: string]: unknown }) => {
-    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: string,
-  config: {
-    enabled?: boolean;
-    tags?: string[];
-    removeFromOutput?: boolean;
-  }
-): { cleanedText: string; thinkingContent?: string } {
-  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: string;
-    let closeTag: string;
-
-    // 特殊处理 "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: string,
-  config: {
-    enabled?: boolean;
-    tags?: string[];
-    removeFromOutput?: boolean;
-  },
-  state: {
-    isOpen: boolean;
-    content: string;
-  }
-): {
-  cleanedText: string;
-  isThinkingTagOpen: boolean;
-  currentThinkingContent: string;
-  reasoningEvents: string[];
-} {
-  if (!config.enabled || !textDelta) {
-    return {
-      cleanedText: textDelta,
-      isThinkingTagOpen: state.isOpen,
-      currentThinkingContent: state.content,
-      reasoningEvents: [],
-    };
-  }
-
-  const tags = config.tags || ["thinking"];
-  let remainingText = textDelta;
-  const reasoningEvents: string[] = [];
-  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: InvokeConfig,
-  options: InvokeOptions,
-  ctx: LLMToolContext
-): Promise<ToolResult> {
-  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<string>();
-    const assistantToolCalls: { id: string; name?: string }[] = [];
-    const toolResultIds: string[] = [];
-    
-    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 as any).type === "tool-call") {
-            const tc = (part as any).toolCall || (part as any);
-            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 as any).type === "tool-result") {
-            toolResultIds.push((part as any).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) as Parameters<typeof streamText>[0]["model"],
-      messages,
-      tools,
-      temperature: providerOptions.temperature,
-      maxTokens: providerOptions.maxTokens,
-      abortSignal: ctx.abort,
-      maxRetries: MAX_RETRIES,
-      streamOptions: {
-        includeUsage: true,
-      },
-    };
-
-    const result = await streamText(streamTextOptions as Parameters<typeof streamText>[0]);
-
-    // 8. 处理流
-    let fullContent = "";
-    let reasoningContent = "";
-    const toolCalls: Array<{ id: string; name: string; args: Record<string, unknown> }> = [];
-    let usageInfo: ConvertedUsageInfo | undefined;
-
-    // 流式推理状态
-    let isThinkingTagOpen = false;
-    let currentThinkingContent = "";
-
-    for await (const part of result.fullStream) {
-      const streamPart = part as Record<string, unknown>;
-
-      switch (streamPart.type) {
-        case "text-delta":
-          const textDelta = streamPart.text as string;
-
-          // 检查是否有 thinkingInText 配置（从 config.options 中获取）
-          const thinkingConfig = (config.options as { thinkingInText?: { enabled?: boolean; tags?: string[] } } | undefined)?.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 as string;
-          reasoningContent += reasoningDelta;
-          if (emitToEnv) {
-            emitToEnv({ type: "reasoning", content: reasoningContent });
-          }
-          break;
-
-        case "tool-call":
-          const toolInput = streamPart.input as Record<string, unknown>;
-          const toolCallId = streamPart.toolCallId as string;
-          const toolName = streamPart.toolName as string;
-          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 as AISDKUsage);
-          if (stepUsage) {
-            usageInfo = stepUsage;
-          }
-          break;
-
-        case "error":
-          throw streamPart.error;
-
-        case "finish":
-          usageInfo = extractUsageInfo(streamPart.totalUsage as AISDKUsage);
-          if (!usageInfo && streamPart.usage) {
-            usageInfo = extractUsageInfo(streamPart.usage as AISDKUsage);
-          }
-          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: string,
-  apiKey: string,
-  baseURL?: string
-): any {
-  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: InvokeConfig,
-  options: InvokeOptions,
-  ctx: LLMToolContext
-): Promise<LLMOutput> {
-  // 解析模型字符串
-  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 as unknown as (options: GenerateTextOptions) => Promise<GenerateTextResult>;
-  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: UsageInfo | undefined = usage ? {
-    promptTokens: (usage as Record<string, unknown>).promptTokens as number ?? 0,
-    completionTokens: (usage as Record<string, unknown>).completionTokens as number ?? 0,
-    totalTokens: (usage as Record<string, unknown>).totalTokens as number ?? 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: string,
-  apiKey: string,
-  baseURL?: string
-): InvokeConfig {
-  return {
-    model,
-    apiKey,
-    baseURL,
-  };
-}