@opentiny/next-sdk 0.1.14 → 0.1.15-beta.2

package/agent/AgentModelProvider.ts

@@ -1,5 +1,8 @@
 import { streamText, stepCountIs, generateText, StreamTextResult } from 'ai'
-import { experimental_MCPClientConfig as MCPClientConfig } 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 */
@@ -85,16 +95,29 @@ export class AgentModelProvider {
         transport = serverConfig as MCPClientConfig['transport']
       }
 
-      const client = new WebMcpClient(
-        { name: 'mcp-web-client', version: '1.0.0' },
-        { capabilities: { roots: { listChanged: true }, sampling: {}, elicitation: {} } }
-      )
-      await client.connect(transport)
-
-      //@ts-ignore
-      client['__transport__'] = transport
+      // 根据 useAISdkClient 配置决定使用哪种 client 创建方式
+      const useAISdkClient = serverConfig.useAISdkClient ?? false
 
-      return client
+      if (useAISdkClient) {
+        // 使用 ai-sdk 的 createMCPClient
+        const client = await createMCPClient({ transport: transport as MCPClientConfig['transport'] })
+        //@ts-ignore
+        client['__transport__'] = transport
+        return client
+      } else {
+        // 使用 WebMcpClient
+        const client = new WebMcpClient(
+          { name: 'mcp-web-client', version: '1.0.0' },
+          { capabilities: { roots: { listChanged: true }, sampling: {}, elicitation: {} } }
+        )
+        // @ts-ignore transport 已经在前面的条件分支中转换为 Transport 实例，类型系统无法正确推断
+        await client.connect(transport)
+
+        //@ts-ignore
+        client['__transport__'] = transport
+
+        return client
+      }
     } catch (error: unknown) {
       if (this.onError) {
         this.onError((error as Error)?.message || `Failed to create MCP client`, error)
@@ -108,7 +131,8 @@ export class AgentModelProvider {
     try {
       const transport = client['__transport__']
 
-      // 如果是 InMemoryTransport，不关闭传输层 因为它是配对的，关闭一端会影响另一端（服务端）
+      // 如果是 InMemoryTransport 或 MessageChannelTransport，不关闭传输层
+      // 因为它们是配对的，关闭一端会影响另一端（服务端）
       if (
         (transport && transport instanceof InMemoryTransport) ||
         (transport && transport instanceof MessageChannelTransport)
@@ -116,6 +140,11 @@ export class AgentModelProvider {
         return
       }
 
+      // 因为它们是基于 Chrome 扩展的消息传递机制，关闭会影响服务端的连接
+      if (transport && transport instanceof ExtensionClientTransport) {
+        return
+      }
+
       // 其他类型的传输正常关闭
       await transport?.terminateSession?.()
       await transport?.close?.()
@@ -138,21 +167,37 @@ export class AgentModelProvider {
       this.mcpClients[serverName] = client
     })
   }
+  /** 兼容两种 client 类型的 tools 获取方法 */
+  private async _getClientTools(client: any, serverName: string): Promise<ToolSet | null> {
+    if (!client) {
+      return null
+    }
+
+    try {
+      // 判断是否为 ai-sdk 的 client（有 tools 方法）
+      if (typeof client.tools === 'function') {
+        // ai-sdk 的 client，直接调用 tools() 方法
+        return await client.tools()
+      } else {
+        // WebMcpClient，使用 getAISDKTools 函数
+        return await getAISDKTools(client)
+      }
+    } catch (error: unknown) {
+      if (this.onError) {
+        this.onError((error as Error)?.message || `Failed to query tools for ${serverName}`, error)
+      }
+      console.error(`Failed to query tools for ${serverName}`, error)
+      return null
+    }
+  }
+
   /** 查询所有 mcpClients 的 tools, 失败则保存为null */
   private async _createMpcTools() {
     const clientEntries = Object.entries(this.mcpClients)
     const tools = await Promise.all(
       clientEntries.map(async ([serverName, client]) => {
-        try {
-          const result = client ? await getAISDKTools(client) : null
-          return { serverName, tools: result }
-        } catch (error: unknown) {
-          if (this.onError) {
-            this.onError((error as Error)?.message || `Failed to query tools`, error)
-          }
-          console.error(`Failed to query tools`, error)
-          return { serverName, tools: null }
-        }
+        const result = await this._getClientTools(client, serverName)
+        return { serverName, tools: result }
       })
     )
     // 将结果存储到对象中，使用 serverName 作为键
@@ -206,7 +251,8 @@ export class AgentModelProvider {
       return null
     }
     this.mcpClients[serverName] = client
-    const tools = await getAISDKTools(client)
+    // 使用兼容的工具获取方法
+    const tools = await this._getClientTools(client, serverName)
     // 工具列表可能为 null，统一兜底为空对象，确保类型安全
     this.mcpTools[serverName] = tools && typeof tools === 'object' ? (tools as Record<string, any>) : {}
     this.mcpServers[serverName] = mcpServer
@@ -255,10 +301,488 @@ 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,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 表达二选一 */
@@ -29,10 +35,10 @@ export type IAgentModelProviderLlmConfig = LlmFactoryConfig | LlmInstanceConfig
 
 /** Mcp Server的配置对象 */
 export type McpServerConfig =
-  | { type: 'streamableHttp'; url: string }
-  | { type: 'sse'; url: string }
-  | { type: 'extension'; url: string; sessionId: string }
-  | { transport: MCPTransport }
+  | { type: 'streamableHttp'; url: string; useAISdkClient?: boolean }
+  | { type: 'sse'; url: string; useAISdkClient?: boolean }
+  | { type: 'extension'; url: string; sessionId: string; useAISdkClient?: boolean }
+  | { transport: MCPTransport; useAISdkClient?: boolean }
 
 /** */
 export interface IAgentModelProviderOption {