@ai-setting/roy-agent-core 1.0.0

package/src/env/llm/invoke.ts

@@ -0,0 +1,1039 @@
+/**
+ * @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,
+  };
+}