@opentiny/next-sdk 0.1.15-beta.1 → 0.1.15

package/agent/AgentModelProvider.ts

@@ -1,8 +1,5 @@
 import { streamText, stepCountIs, generateText, StreamTextResult } from 'ai'
-import {
-  experimental_MCPClientConfig as MCPClientConfig,
-  experimental_createMCPClient as createMCPClient
-} from '@ai-sdk/mcp'
+import { experimental_MCPClientConfig as MCPClientConfig, experimental_createMCPClient as createMCPClient } from 'ai'
 import type { ToolSet } from 'ai'
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
 import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
@@ -15,8 +12,6 @@ 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,
@@ -48,8 +43,6 @@ 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) {
@@ -77,9 +70,6 @@ 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 */
@@ -110,7 +100,6 @@ 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
@@ -295,488 +284,10 @@ 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
-            // 调用流式 LLM
-            // 参考 magentic-ui：保留所有文本历史（上下文完整），仅限制图片数量（优化 token）
-            delete restOptions.system
-            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,8 +1,6 @@
+export type { experimental_MCPClient as MCPClient } from 'ai'
 import type { ProviderV2 } from '@ai-sdk/provider'
-import type { experimental_MCPClientConfig as MCPClientConfig } from '@ai-sdk/mcp'
-
-// 从 MCPClientConfig 中提取 transport 类型
-export type MCPTransport = MCPClientConfig['transport']
+import type { MCPTransport } from 'ai'
 
 type ProviderFactory = 'openai' | 'deepseek' | ((options: any) => ProviderV2)
 
@@ -15,8 +13,6 @@ type LlmFactoryConfig = {
   providerType: ProviderFactory
   /** 互斥：当使用 providerType 分支时不允许传入 llm */
   llm?: never
-  /** 是否使用 ReAct 模式（通过提示词而非 function calling 进行工具调用），默认为 false */
-  useReActMode?: boolean
 }
 
 type LlmInstanceConfig = {
@@ -26,8 +22,6 @@ type LlmInstanceConfig = {
   apiKey?: never
   baseURL?: never
   providerType?: never
-  /** 是否使用 ReAct 模式（通过提示词而非 function calling 进行工具调用），默认为 false */
-  useReActMode?: boolean
 }
 
 /** 代理模型提供器的大语言配置对象, 通过 XOR 表达二选一 */