@opentiny/next-sdk 0.1.15 → 0.2.1

package/agent/AgentModelProvider.ts

@@ -1,5 +1,8 @@
 import { streamText, stepCountIs, generateText, StreamTextResult } from 'ai'
-import { experimental_MCPClientConfig as MCPClientConfig, experimental_createMCPClient as createMCPClient } from 'ai'
+import {
+  experimental_MCPClientConfig as MCPClientConfig,
+  experimental_createMCPClient as createMCPClient
+} from '@ai-sdk/mcp'
 import type { ToolSet } from 'ai'
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
 import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
@@ -12,6 +15,8 @@ import { ExtensionClientTransport } from '../transport/ExtensionClientTransport'
 import { MessageChannelTransport } from '@opentiny/next'
 import { WebMcpClient } from '../WebMcpClient'
 import { getAISDKTools } from './utils/getAISDKTools'
+import { generateReActToolsPrompt } from './utils/generateReActPrompt'
+import { parseReActAction } from './utils/parseReActAction'
 
 export const AIProviderFactories = {
   ['openai']: createOpenAI,
@@ -43,6 +48,8 @@ export class AgentModelProvider {
   onClientDisconnected?: (serverName: string, reason?: string) => void
   /** 缓存 ai-sdk response 中的 多轮会话的上下文 */
   messages: any[] = []
+  /** 是否使用 ReAct 模式（通过提示词而非 function calling 进行工具调用） */
+  useReActMode: boolean = false
 
   constructor({ llmConfig, mcpServers }: IAgentModelProviderOption) {
     if (!llmConfig) {
@@ -70,6 +77,9 @@ export class AgentModelProvider {
     } else {
       throw new Error('Either llmConfig.llm or llmConfig.providerType must be provided')
     }
+
+    // 读取 ReAct 模式配置
+    this.useReActMode = (llmConfig as any).useReActMode ?? false
   }
 
   /** 创建一个 ai-sdk的 mcpClient, 创建失败则返回 null */
@@ -81,6 +91,8 @@ export class AgentModelProvider {
         transport = new StreamableHTTPClientTransport(new URL((serverConfig as { url: string }).url))
       } else if ('type' in serverConfig && serverConfig.type === 'extension') {
         transport = new ExtensionClientTransport(serverConfig.sessionId)
+      } else if ('transport' in serverConfig) {
+        transport = serverConfig.transport
       } else {
         transport = serverConfig as MCPClientConfig['transport']
       }
@@ -100,6 +112,7 @@ export class AgentModelProvider {
           { name: 'mcp-web-client', version: '1.0.0' },
           { capabilities: { roots: { listChanged: true }, sampling: {}, elicitation: {} } }
         )
+        // @ts-ignore transport 已经在前面的条件分支中转换为 Transport 实例，类型系统无法正确推断
         await client.connect(transport)
 
         //@ts-ignore
@@ -120,7 +133,8 @@ export class AgentModelProvider {
     try {
       const transport = client['__transport__']
 
-      // 如果是 InMemoryTransport，不关闭传输层 因为它是配对的，关闭一端会影响另一端（服务端）
+      // 如果是 InMemoryTransport 或 MessageChannelTransport，不关闭传输层
+      // 因为它们是配对的，关闭一端会影响另一端（服务端）
       if (
         (transport && transport instanceof InMemoryTransport) ||
         (transport && transport instanceof MessageChannelTransport)
@@ -284,10 +298,489 @@ export class AgentModelProvider {
     return toolsResult
   }
 
+  /** 生成 ReAct 模式的系统提示词（包含工具描述） */
+  private _generateReActSystemPrompt(tools: ToolSet, modelName: string, baseSystemPrompt?: string): string {
+    // 统一使用 XML 格式的 ReAct 提示词（所有 ReAct 模式都使用相同格式）
+    const toolsPrompt = generateReActToolsPrompt(tools)
+
+    if (baseSystemPrompt) {
+      return `${baseSystemPrompt}${toolsPrompt}`
+    }
+    return `你是一个智能助手，可以通过调用工具来完成任务。\n${toolsPrompt}`
+  }
+
+  /** 执行 ReAct 模式下的工具调用 */
+  private async _executeReActToolCall(
+    toolName: string,
+    args: any,
+    tools: ToolSet
+  ): Promise<{ success: boolean; result?: any; error?: string }> {
+    const tool = tools[toolName]
+    if (!tool) {
+      return { success: false, error: `工具 ${toolName} 不存在` }
+    }
+
+    try {
+      const toolInfo = tool as any
+      const executeFn = toolInfo.execute || toolInfo.call
+      if (typeof executeFn !== 'function') {
+        return { success: false, error: `工具 ${toolName} 没有可执行的函数` }
+      }
+
+      const result = await executeFn(args, {})
+      return { success: true, result }
+    } catch (error: any) {
+      const errorMsg = error?.message || String(error) || '工具执行失败'
+      return { success: false, error: errorMsg }
+    }
+  }
+
+  /** ReAct 模式的对话实现 */
+  private async _chatReAct(
+    chatMethod: ChatMethodFn,
+    { model, maxSteps = 5, ...options }: Parameters<typeof generateText>[0] & { maxSteps?: number; message?: string }
+  ): Promise<any> {
+    if (!this.llm) {
+      throw new Error('LLM is not initialized')
+    }
+
+    await this.initClientsAndTools()
+
+    // 合并所有可用工具
+    const allTools = this._tempMergeTools(options.tools) as ToolSet
+    const toolNames = Object.keys(allTools)
+
+    // 如果没有工具，回退到普通模式
+    if (toolNames.length === 0) {
+      return this._chat(chatMethod, { model, maxSteps, ...options })
+    }
+
+    // 准备消息历史
+    let currentMessages: any[] = []
+    if (options.message && !options.messages) {
+      currentMessages.push({ role: 'user', content: options.message })
+    } else if (options.messages) {
+      currentMessages = [...options.messages]
+    } else {
+      currentMessages = [...this.messages]
+    }
+
+    // 确保 model 是字符串类型（ReAct 模式下 model 应该是模型名称字符串）
+    const modelName = typeof model === 'string' ? model : (model as any)?.modelId || 'default-model'
+
+    // 生成包含工具描述的系统提示词
+    const systemPrompt = this._generateReActSystemPrompt(allTools, modelName, options.system as string)
+
+    const systemMessage = { role: 'system', content: systemPrompt }
+
+    // 确保第一条消息是系统提示词
+    const messagesWithSystem =
+      currentMessages[0]?.role === 'system' ? currentMessages : [systemMessage, ...currentMessages]
+
+    // 判断是否为流式输出
+    const isStream = chatMethod === streamText
+
+    if (isStream) {
+      // 流式输出模式：创建一个包装的流
+      return this._chatReActStream(messagesWithSystem, allTools, modelName, maxSteps, options)
+    } else {
+      // 非流式输出模式：循环对话直到完成
+      return this._chatReActNonStream(messagesWithSystem, allTools, modelName, maxSteps, options)
+    }
+  }
+
+  /**
+   * 检查消息内容是否包含图片
+   * @param content 消息内容
+   * @returns 是否包含图片
+   */
+  private _messageHasImage(content: any): boolean {
+    if (!content) return false
+
+    // 如果 content 是数组，检查是否有 image 类型的项
+    if (Array.isArray(content)) {
+      return content.some((item) => item && item.type === 'image')
+    }
+
+    return false
+  }
+
+  /**
+   * 从消息中移除图片，但保留文本内容
+   * @param message 原始消息
+   * @returns 移除图片后的消息（如果只有图片没有文本，返回 null）
+   */
+  private _removeImageFromMessage(message: any): any | null {
+    if (!message || !message.content) {
+      return null
+    }
+
+    // 如果 content 不是数组，直接返回（没有图片）
+    if (!Array.isArray(message.content)) {
+      return message
+    }
+
+    // 过滤掉图片类型的内容，保留文本
+    const textContent = message.content.filter((item: any) => item && item.type !== 'image')
+
+    // 如果过滤后没有内容，返回 null
+    if (textContent.length === 0) {
+      return null
+    }
+
+    // 返回只包含文本的消息副本
+    return {
+      ...message,
+      content: textContent
+    }
+  }
+
+  /**
+   * 构建用于模型调用的消息列表（magentic-ui 风格）
+   * 策略：保留所有文本消息，仅限制图片数量（类似 magentic-ui 的 maybe_remove_old_screenshots）
+   *
+   * @param systemMessage 系统提示词
+   * @param allMessages 所有消息历史（包括初始消息和后续对话）
+   * @param maxImages 最多保留的图片数量（默认3张）
+   * @returns 构建好的消息列表
+   */
+  private _buildMessagesForModel(systemMessage: any | null, allMessages: any[], maxImages: number = 3): any[] {
+    const messages: any[] = []
+
+    // 1. 添加系统提示词
+    if (systemMessage) {
+      messages.push(systemMessage)
+    }
+
+    // 2. 保留所有文本消息，但限制图片数量
+    // 从后往前遍历，优先保留最新的图片
+    let imageCount = 0
+    const processedMessages: any[] = []
+
+    for (let i = allMessages.length - 1; i >= 0; i--) {
+      const msg = allMessages[i]
+
+      // 检查消息是否包含图片
+      const hasImage = this._messageHasImage(msg.content)
+
+      if (hasImage) {
+        if (imageCount < maxImages) {
+          // 图片数量未超限，保留完整消息
+          processedMessages.unshift(msg)
+          imageCount++
+        } else {
+          // 图片数量超限，移除图片但保留文本（如果有）
+          const textOnly = this._removeImageFromMessage(msg)
+          if (textOnly) {
+            processedMessages.unshift(textOnly)
+          }
+        }
+      } else {
+        // 非图片消息：全部保留
+        processedMessages.unshift(msg)
+      }
+    }
+
+    messages.push(...processedMessages)
+
+    return messages
+  }
+
+  /** ReAct 模式非流式对话 */
+  private async _chatReActNonStream(
+    messages: any[],
+    tools: ToolSet,
+    model: string,
+    maxSteps: number,
+    options: any
+  ): Promise<any> {
+    // 保存完整的消息历史（用于最终返回和传递给模型）
+    let fullMessageHistory = [...messages]
+    // 提取系统提示词（第一条消息）
+    const systemMessage = messages[0]?.role === 'system' ? messages[0] : null
+    // 提取所有非系统消息
+    const allUserMessages = systemMessage ? messages.slice(1) : messages
+
+    let stepCount = 0
+    // 配置：最多保留的图片数量（默认3张，类似 magentic-ui）
+    const maxImages = (options as any).maxImages ?? 3
+
+    while (stepCount < maxSteps) {
+      stepCount++
+
+      // 构建用于模型调用的消息列表（magentic-ui 风格：保留所有文本，限制图片）
+      const messagesForModel = this._buildMessagesForModel(systemMessage, allUserMessages, maxImages)
+
+      // 调用 LLM（ReAct 模式下不传递 tools，因为工具调用通过提示词实现）
+      // 参考 magentic-ui：保留所有文本历史（上下文完整），仅限制图片数量（优化 token）
+      const { tools: _, ...restOptions } = options
+      const result = await generateText({
+        // @ts-ignore ProviderV2 是所有llm的父类，在每一个具体的llm类都有一个选择model的函数用法
+        model: this.llm(model),
+        messages: messagesForModel,
+        ...restOptions
+      })
+
+      const assistantMessage = result.text
+      // 添加到所有消息和完整历史
+      const assistantMsg = { role: 'assistant', content: assistantMessage }
+      allUserMessages.push(assistantMsg)
+      fullMessageHistory.push(assistantMsg)
+
+      // 解析工具调用
+      const action = parseReActAction(assistantMessage, tools)
+
+      if (!action) {
+        // 没有工具调用，返回最终结果
+        this.messages = fullMessageHistory
+        return {
+          text: assistantMessage,
+          response: { messages: fullMessageHistory }
+        }
+      }
+
+      // 执行工具调用
+      const toolResult = await this._executeReActToolCall(action.toolName, action.arguments, tools)
+
+      // 统一使用 XML 格式的 Observation
+      const resultString = toolResult.success ? JSON.stringify(toolResult.result) : `工具执行失败 - ${toolResult.error}`
+      const observation = `<tool_response>\n${resultString}\n</tool_response>`
+
+      // 添加到所有消息和完整历史
+      const observationMessage = {
+        role: 'user',
+        content: observation
+      }
+      allUserMessages.push(observationMessage)
+      fullMessageHistory.push(observationMessage)
+    }
+
+    // 达到最大步数，返回最后一条消息
+    this.messages = fullMessageHistory
+    const lastMessage = fullMessageHistory[fullMessageHistory.length - 2]?.content || ''
+    return {
+      text: lastMessage,
+      response: { messages: fullMessageHistory }
+    }
+  }
+
+  /** ReAct 模式流式对话 */
+  private _chatReActStream(messages: any[], tools: ToolSet, model: string, maxSteps: number, options: any): any {
+    // 保存 this 引用，以便在异步生成器中使用
+    const self = this
+    // @ts-ignore ProviderV2 是所有llm的父类，在每一个具体的llm类都有一个选择model的函数用法
+    const llmModel = this.llm(model)
+
+    // 创建一个 Promise 来跟踪流完成状态，用于触发 onFinish
+    let streamCompleteResolver: (value: any) => void
+    let streamCompleteRejecter: (error: any) => void
+    const streamCompletePromise = new Promise((resolve, reject) => {
+      streamCompleteResolver = resolve
+      streamCompleteRejecter = reject
+    })
+
+    // 创建一个异步生成器来模拟流式输出
+    const stream = new ReadableStream({
+      async start(controller) {
+        // 保存完整的消息历史（用于最终返回和传递给模型）
+        let fullMessageHistory = [...messages]
+        // 提取系统提示词（第一条消息）
+        const systemMessage = messages[0]?.role === 'system' ? messages[0] : null
+        // 提取所有非系统消息
+        const allUserMessages = systemMessage ? messages.slice(1) : [...messages]
+
+        let stepCount = 0
+        let accumulatedText = ''
+        // 配置：最多保留的图片数量（默认3张，类似 magentic-ui）
+        const maxImages = (options as any).maxImages ?? 3
+
+        try {
+          while (stepCount < maxSteps) {
+            stepCount++
+
+            // 构建用于模型调用的消息列表（magentic-ui 风格：保留所有文本，限制图片）
+            const messagesForModel = self._buildMessagesForModel(systemMessage, allUserMessages, maxImages)
+
+            // 移除 tools 选项，ReAct 模式下不传递 tools
+            const { tools: _, ...restOptions } = options
+
+            // 删除影响多轮对话的配置
+            delete restOptions.system
+            delete restOptions.onFinish
+            const result = await streamText({
+              ...restOptions,
+              model: llmModel,
+              messages: messagesForModel
+            })
+
+            // 收集流式输出
+            let assistantText = ''
+            for await (const part of result.fullStream) {
+              if (part.type === 'text-delta') {
+                assistantText += part.text || ''
+                // 转发文本增量
+                controller.enqueue({
+                  type: 'text-delta',
+                  text: part.text
+                })
+              } else if (part.type === 'text-start') {
+                controller.enqueue({ type: 'text-start' })
+              } else if (part.type === 'text-end') {
+                // 暂时不关闭，等待检查是否有工具调用
+              } else {
+                // 转发其他类型的事件
+                controller.enqueue(part)
+              }
+            }
+
+            accumulatedText += assistantText
+            // 添加到所有消息和完整历史
+            const assistantMsg = { role: 'assistant', content: accumulatedText }
+            allUserMessages.push(assistantMsg)
+            fullMessageHistory.push(assistantMsg)
+
+            // 解析工具调用
+            const action = parseReActAction(accumulatedText, tools)
+
+            if (!action) {
+              // 没有工具调用，结束流
+              controller.enqueue({ type: 'text-end' })
+              controller.close()
+              self.messages = fullMessageHistory
+              // 触发 onFinish 回调
+              streamCompleteResolver({ messages: fullMessageHistory })
+              return
+            }
+
+            // 特殊处理: computer 工具的 terminate 操作
+            if (action.toolName === 'computer' && action.arguments?.action === 'terminate') {
+              // 视为对话结束
+              controller.enqueue({ type: 'text-end' })
+              controller.close()
+              self.messages = fullMessageHistory
+              streamCompleteResolver({ messages: fullMessageHistory })
+              return
+            }
+
+            // 发送工具调用开始事件（符合 tiny-robot 格式）
+            const toolCallId = `react-${Date.now()}`
+            controller.enqueue({
+              type: 'tool-input-start',
+              id: toolCallId,
+              toolName: action.toolName
+            })
+
+            // 发送工具调用参数（显示调用中状态）
+            const argsString = JSON.stringify(action.arguments, null, 2)
+            controller.enqueue({
+              type: 'tool-input-delta',
+              id: toolCallId,
+              delta: argsString
+            })
+
+            // 执行工具调用
+            const toolResult = await self._executeReActToolCall(action.toolName, action.arguments, tools)
+
+            // 如果结果包含 screenshot，先提取出来，避免 JSON stringify 导致过大
+            let screenshot = undefined
+            let resultData = toolResult.result
+            if (
+              toolResult.success &&
+              toolResult.result &&
+              typeof toolResult.result === 'object' &&
+              toolResult.result.screenshot
+            ) {
+              screenshot = toolResult.result.screenshot
+              const { screenshot: _, ...rest } = toolResult.result
+              resultData = rest
+            }
+
+            // 构造 Observation 文本（统一使用 XML 格式）
+            let observationText = ''
+
+            if (toolResult.success) {
+              // 尝试从 resultData 中提取纯文本信息
+              if (
+                resultData &&
+                Array.isArray(resultData.content) &&
+                resultData.content.length > 0 &&
+                resultData.content[0].text
+              ) {
+                observationText = resultData.content[0].text
+              } else {
+                observationText = JSON.stringify(resultData)
+              }
+            } else {
+              observationText = `工具执行失败 - ${toolResult.error}`
+            }
+
+            // 统一使用 XML 格式的 Observation，如果有截图，添加验证提示
+            let finalObservation = `<tool_response>\n${observationText}\n</tool_response>`
+
+            if (screenshot) {
+              finalObservation += `\n请检查截图以确认操作是否成功。如果成功，请继续下一步；如果失败，请重试。`
+            }
+
+            // 发送工具结果（符合 tiny-robot 格式，给 UI 展示用的，不包含 base64 防止卡顿）
+            controller.enqueue({
+              type: 'tool-result',
+              toolCallId: toolCallId,
+              result: finalObservation
+            })
+
+            // 添加工具结果到消息历史（ReAct 模式下，工具结果作为 user 消息添加）
+            const observationMessage = screenshot
+              ? {
+                  role: 'user',
+                  content: [
+                    { type: 'text', text: finalObservation },
+                    { type: 'image', image: screenshot }
+                  ]
+                }
+              : {
+                  role: 'user',
+                  content: finalObservation
+                }
+
+            // 添加到所有消息和完整历史
+            allUserMessages.push(observationMessage)
+            fullMessageHistory.push(observationMessage)
+
+            // 重置累积文本，准备下一轮
+            accumulatedText = ''
+          }
+
+          // 达到最大步数
+          controller.enqueue({ type: 'text-end' })
+          controller.close()
+          self.messages = fullMessageHistory
+          // 触发 onFinish 回调
+          streamCompleteResolver({ messages: fullMessageHistory })
+        } catch (error: any) {
+          controller.error(error)
+          streamCompleteRejecter(error)
+        }
+      }
+    })
+
+    // 返回一个类似 streamText 的结果对象
+    // response Promise 需要在流结束时 resolve，这样才能触发 onFinish 回调
+    return {
+      fullStream: stream,
+      response: streamCompletePromise
+    }
+  }
+
   private async _chat(
     chatMethod: ChatMethodFn,
     { model, maxSteps = 5, ...options }: Parameters<typeof generateText>[0] & { maxSteps?: number; message?: string }
   ): Promise<any> {
+    // 如果启用 ReAct 模式，使用 ReAct 实现
+    if (this.useReActMode) {
+      return this._chatReAct(chatMethod, { model, maxSteps, ...options })
+    }
+
+    // 否则使用原有的 function calling 模式
     if (!this.llm) {
       throw new Error('LLM is not initialized')
     }

package/agent/type.ts

@@ -1,6 +1,8 @@
-export type { experimental_MCPClient as MCPClient } from 'ai'
 import type { ProviderV2 } from '@ai-sdk/provider'
-import type { MCPTransport } from 'ai'
+import type { experimental_MCPClientConfig as MCPClientConfig } from '@ai-sdk/mcp'
+
+// 从 MCPClientConfig 中提取 transport 类型
+export type MCPTransport = MCPClientConfig['transport']
 
 type ProviderFactory = 'openai' | 'deepseek' | ((options: any) => ProviderV2)
 
@@ -13,6 +15,8 @@ type LlmFactoryConfig = {
   providerType: ProviderFactory
   /** 互斥：当使用 providerType 分支时不允许传入 llm */
   llm?: never
+  /** 是否使用 ReAct 模式（通过提示词而非 function calling 进行工具调用），默认为 false */
+  useReActMode?: boolean
 }
 
 type LlmInstanceConfig = {
@@ -22,6 +26,8 @@ type LlmInstanceConfig = {
   apiKey?: never
   baseURL?: never
   providerType?: never
+  /** 是否使用 ReAct 模式（通过提示词而非 function calling 进行工具调用），默认为 false */
+  useReActMode?: boolean
 }
 
 /** 代理模型提供器的大语言配置对象, 通过 XOR 表达二选一 */
@@ -32,7 +38,7 @@ export type McpServerConfig =
   | { type: 'streamableHttp'; url: string; useAISdkClient?: boolean }
   | { type: 'sse'; url: string; useAISdkClient?: boolean }
   | { type: 'extension'; url: string; sessionId: string; useAISdkClient?: boolean }
-  | { transport: MCPTransport; useAISdkClient?: boolean }
+  | { type: 'local'; transport: MCPTransport; useAISdkClient?: boolean }
 
 /** */
 export interface IAgentModelProviderOption {

package/agent/utils/generateReActPrompt.ts

@@ -0,0 +1,55 @@
+import type { ToolSet } from 'ai'
+
+/**
+ * 生成 ReAct 模式的工具描述提示词（统一使用 XML 格式）
+ * 将工具集合转换为 ReAct 格式的文本描述，用于添加到系统提示词中
+ * @param tools - 工具集合对象
+ * @returns 格式化的工具描述字符串
+ */
+export function generateReActToolsPrompt(tools: ToolSet): string {
+  const toolEntries = Object.entries(tools)
+
+  // 如果没有工具，返回空字符串
+  if (toolEntries.length === 0) {
+    return ''
+  }
+
+  let prompt = '\n\n# 工具调用\n\n'
+  prompt += '你可以根据需要调用以下工具：\n\n'
+  prompt += '<tools>\n'
+
+  // 遍历所有工具，生成工具描述
+  toolEntries.forEach(([toolName, tool]) => {
+    const toolInfo = tool as any
+    const description = toolInfo.description || '无描述'
+    const schema = toolInfo.parameters || toolInfo.inputSchema || {}
+
+    // 构造类似 OpenAI function 的格式但放在 XML 中
+    const toolJson = {
+      name: toolName,
+      description: description,
+      parameters: schema
+    }
+    prompt += `${JSON.stringify(toolJson, null, 2)}\n`
+  })
+
+  prompt += '</tools>\n\n'
+  prompt += '## 工具调用格式\n\n'
+  prompt += '要调用工具，请使用以下 XML 格式：\n'
+  prompt += 'Thought: [你的思考过程]\n'
+  prompt += '<tool_call>{"name": "toolName", "arguments": {"arg1": "value1"}}</tool_call>\n\n'
+  prompt += '工具执行后，你将收到 <tool_response> 格式的结果。你可以继续思考或调用其他工具。\n\n'
+  prompt += '## 使用示例\n\n'
+  prompt += '如果用户要求"获取今天的日期"，你可以这样调用工具：\n'
+  prompt += 'Thought: 用户想要获取今天的日期，我需要调用日期相关的工具。\n'
+  prompt += '<tool_call>{"name": "get-today", "arguments": {}}</tool_call>\n\n'
+  prompt += '然后等待工具返回结果（Observation），再根据结果给出最终答案。\n\n'
+  prompt += '## 任务完成\n\n'
+  prompt += '当任务完成或无法继续时，直接给出最终答案即可。\n\n'
+  prompt += '**重要提示**：\n'
+  prompt += '- 必须严格按照 XML 格式调用工具\n'
+  prompt += '- arguments 必须是有效的 JSON 格式\n'
+  prompt += '- 如果不需要调用工具，直接给出最终答案即可\n'
+
+  return prompt
+}

package/agent/utils/parseReActAction.ts

@@ -0,0 +1,34 @@
+import type { ToolSet } from 'ai'
+
+/**
+ * 解析 ReAct 格式的工具调用
+ * 从模型输出文本中提取工具名称和参数
+ * 现在统一使用 XML 格式（<call> 标签），同时保留对其他格式的兼容性支持
+ * @param text - 模型输出的文本
+ * @param availableTools - 可用的工具集合，用于验证工具名称
+ * @returns 解析出的工具调用信息，如果未找到则返回 null
+ */
+export function parseReActAction(text: string, availableTools: ToolSet): { toolName: string; arguments: any } | null {
+  if (!text || typeof text !== 'string') {
+    return null
+  }
+
+  // XML 格式 <tool_call>
+  const toolCallMatchLegacy = text.match(/<tool_call>([\s\S]*?)<\/tool_call>/i)
+  if (toolCallMatchLegacy) {
+    try {
+      const jsonContent = toolCallMatchLegacy[1].trim()
+      const parsed = JSON.parse(jsonContent)
+      const toolName = parsed.name || parsed.action || parsed.tool
+      const args = parsed.arguments || parsed.args || parsed.input || {}
+
+      if (toolName && availableTools[toolName]) {
+        return { toolName, arguments: args }
+      }
+    } catch {
+      // 解析失败，继续尝试其他方法
+    }
+  }
+
+  return null
+}