@opentiny/next-sdk 0.1.9 → 0.1.11

package/WebMcp.ts

@@ -16,3 +16,5 @@ export type * from '@modelcontextprotocol/sdk/shared/transport.js'
 export type * from '@modelcontextprotocol/sdk/client/sse.js'
 export type * from '@modelcontextprotocol/sdk/client/streamableHttp.js'
 export type * from '@modelcontextprotocol/sdk/server/mcp.js'
+
+export * from './transport/ExtensionPageServerTransport'

package/WebMcpClient.ts

@@ -18,11 +18,9 @@ import {
   MessageChannelClientTransport,
   sseOptions,
   streamOptions,
-  attemptConnection,
   createSseProxy,
   createStreamProxy,
-  createSocketProxy,
-  AuthClientProvider
+  createSocketProxy
 } from '@opentiny/next'
 import type {
   Result,
@@ -61,12 +59,9 @@ export interface ClientConnectOptions {
   url: string
   token?: string
   sessionId?: string
-  authProvider?: AuthClientProvider
   type?: 'channel' | 'sse' | 'stream' | 'socket'
   agent?: boolean
   onError?: (error: Error) => void
-  onUnauthorized?: (connect: () => Promise<void>) => Promise<void>
-  onReconnect?: () => Promise<void>
 }
 
 type SendRequestT = Request
@@ -117,13 +112,11 @@ export class WebMcpClient {
       return { transport: this.transport, sessionId: this.transport.sessionId as string }
     }
 
-    const { url, token, sessionId, authProvider, type, agent, onError, onUnauthorized, onReconnect } =
-      options as ClientConnectOptions
+    const { url, token, sessionId, type, agent, onError } = options as ClientConnectOptions
 
     if (agent === true) {
-      const proxyOptions: ProxyOptions = { client: this.client, url, token, sessionId, authProvider }
+      const proxyOptions: ProxyOptions = { client: this.client, url, token, sessionId }
 
-      let reconnect = false
       let response
 
       const connectProxy = async () => {
@@ -136,17 +129,6 @@ export class WebMcpClient {
 
         transport.onerror = async (error: Error) => {
           onError?.(error)
-
-          if (error.message === 'Unauthorized' && !reconnect) {
-            if (typeof onUnauthorized === 'function') {
-              await onUnauthorized(connectProxy)
-            } else {
-              reconnect = true
-              await connectProxy()
-              reconnect = false
-              await onReconnect?.()
-            }
-          }
         }
 
         response = { transport, sessionId }
@@ -165,14 +147,9 @@ export class WebMcpClient {
     }
 
     if (type === 'sse') {
-      if (authProvider) {
-        const createTransport = () => new SSEClientTransport(endpoint, { authProvider })
-        transport = await attemptConnection(this.client, authProvider.waitForOAuthCode, createTransport)
-      } else {
-        const opts = sseOptions(token, sessionId) as SSEClientTransportOptions
-        transport = new SSEClientTransport(endpoint, opts)
-        await this.client.connect(transport)
-      }
+      const opts = sseOptions(token, sessionId) as SSEClientTransportOptions
+      transport = new SSEClientTransport(endpoint, opts)
+      await this.client.connect(transport)
     }
 
     if (type === 'socket') {
@@ -182,14 +159,9 @@ export class WebMcpClient {
     }
 
     if (typeof transport === 'undefined') {
-      if (authProvider) {
-        const createTransport = () => new StreamableHTTPClientTransport(endpoint, { authProvider })
-        transport = await attemptConnection(this.client, authProvider.waitForOAuthCode, createTransport)
-      } else {
-        const opts = streamOptions(token, sessionId) as StreamableHTTPClientTransportOptions
-        transport = new StreamableHTTPClientTransport(endpoint, opts)
-        await this.client.connect(transport)
-      }
+      const opts = streamOptions(token, sessionId) as StreamableHTTPClientTransportOptions
+      transport = new StreamableHTTPClientTransport(endpoint, opts)
+      await this.client.connect(transport)
     }
 
     this.transport = transport

package/agent/AgentModelProvider.ts

@@ -7,6 +7,7 @@ import { ProviderV2 } from '@ai-sdk/provider'
 import { OpenAIProvider } from '@ai-sdk/openai'
 import { createOpenAI } from '@ai-sdk/openai'
 import { createDeepSeek } from '@ai-sdk/deepseek'
+import { ExtensionClientTransport } from '../transport/ExtensionClientTransport'
 
 export const AIProviderFactories = {
   ['openai']: createOpenAI,
@@ -15,35 +16,35 @@ export const AIProviderFactories = {
 
 type ChatMethodFn = typeof streamText | typeof generateText
 
-/** 一个通用的ai-sdk的agent封装
+/** 一个通用的ai-sdk的Agent封装
  * @summary 内部自动管理了 llm, mcpServer, ai-sdk的clients 和 tools
  * @returns 暴露了 chat, chatStream方法
  */
 export class AgentModelProvider {
   llm: ProviderV2 | OpenAIProvider
-  /**  mcpServers 允许为配置为 McpServerConfig, 或者任意的 MCPTransport
+  /**  当前mcpServers对象集合。键为服务器名称，值为 McpServerConfig 或任意的 MCPTransport
    * 参考: https://ai-sdk.dev/docs/ai-sdk-core/tools-and-tool-calling#initializing-an-mcp-client */
-  mcpServers: McpServerConfig[] = []
-  /**  ai-sdk的 mcpClient */
-  mcpClients: any[] = []
-  /** 所有的tools */
-  mcpTools: Array<Record<string, any>> = []
-  /**  需要实时过滤掉的tools name*/
+  mcpServers: Record<string, McpServerConfig> = {}
+  /** 当前ai-sdk的 mcpClient 对象集合，键为服务器名称 */
+  mcpClients: Record<string, any> = {}
+  /** 当前 mcpClients 所对应的tools，键为服务器名称 */
+  mcpTools: Record<string, Record<string, any>> = {}
+  /** 需要实时过滤掉的tools name*/
   ignoreToolnames: string[] = []
-
-  /** chat 时，自动更新 所有的tools 后的事件 */
+  /** Agent 自动更新所有的tools 后的事件 */
   onUpdatedTools: (() => void) | undefined
-  /** 内部报错时，抛出错误事件 */
+  /** Agent 内部报错时，抛出的错误事件 */
   onError: ((msg: string, err?: any) => void) | undefined
-
-  /** 缓存 ai-sdk response 中的 多轮会话 */
+  /** MCP Client 断开连接时的回调 */
+  onClientDisconnected?: (serverName: string, reason?: string) => void
+  /** 缓存 ai-sdk response 中的 多轮会话的上下文 */
   messages: any[] = []
 
   constructor({ llmConfig, mcpServers, llm }: IAgentModelProviderOption) {
-    // 1、保存 mcpServer
-    this.mcpServers = mcpServers || []
+    this.mcpServers = mcpServers || {}
+    this.mcpClients = {}
+    this.mcpTools = {}
 
-    // 2、保存 llm
     if (llm) {
       this.llm = llm
     } else if (llmConfig) {
@@ -63,13 +64,15 @@ export class AgentModelProvider {
     }
   }
 
-  /** 创建一个 ai-sdk的 mcpClient, 创建失败则返回 Null */
+  /** 创建一个 ai-sdk的 mcpClient, 创建失败则返回 null */
   private async _createOneClient(serverConfig: McpServerConfig) {
     try {
       let transport: MCPClientConfig['transport']
       // transport 一定是 streamableHttp 或者就是： ai-sdk允许的 transport
       if ('type' in serverConfig && serverConfig.type.toLocaleLowerCase() === 'streamablehttp') {
-        transport = new StreamableHTTPClientTransport(new URL(serverConfig.url))
+        transport = new StreamableHTTPClientTransport(new URL((serverConfig as { url: string }).url))
+      } else if ('type' in serverConfig && serverConfig.type === 'extension') {
+        transport = new ExtensionClientTransport(serverConfig.sessionId)
       } else {
         transport = serverConfig as MCPClientConfig['transport']
       }
@@ -77,6 +80,7 @@ export class AgentModelProvider {
       const client = await createMCPClient({ transport: transport as MCPClientConfig['transport'] })
       //@ts-ignore
       client['__transport__'] = transport
+
       return client
     } catch (error: unknown) {
       if (this.onError) {
@@ -86,41 +90,57 @@ export class AgentModelProvider {
       return null
     }
   }
-  /** 关闭一个client */
+  /** 关闭一个 mcpClient */
   private async _closeOneClient(client: any) {
-    await client['__transport__']?.terminateSession?.()
-    await client['__transport__']?.close?.()
-    await client?.close?.()
+    try {
+      await client['__transport__']?.terminateSession?.()
+      await client['__transport__']?.close?.()
+      await client?.close?.()
+    } catch (error) {}
   }
-  /** 创建 ai-sdk的 mcpClient, 失败则保存为null */
+  /** 创建所有 mcpClients */
   private async _createMpcClients() {
     // 使用 Promise.all 并行处理所有 mcpServer 项
-    this.mcpClients = await Promise.all(
-      this.mcpServers.map(async (server) => {
-        return this._createOneClient(server)
+    const serverEntries = Object.entries(this.mcpServers)
+    const clients = await Promise.all(
+      serverEntries.map(async ([serverName, server]) => {
+        const client = await this._createOneClient(server)
+        return { serverName, client }
       })
     )
+    // 将结果存储到对象中，使用 serverName 作为键
+    this.mcpClients = {}
+    clients.forEach(({ serverName, client }) => {
+      this.mcpClients[serverName] = client
+    })
   }
-  /** 创建所有 mcpClients 的 tools, 失败则保存为null */
+  /** 查询所有 mcpClients 的 tools, 失败则保存为null */
   private async _createMpcTools() {
-    this.mcpTools = await Promise.all(
-      this.mcpClients.map(async (client) => {
+    const clientEntries = Object.entries(this.mcpClients)
+    const tools = await Promise.all(
+      clientEntries.map(async ([serverName, client]) => {
         try {
-          return client ? await client?.tools?.() : null
+          const result = client ? await client?.tools?.() : 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 null
+          return { serverName, tools: null }
         }
       })
     )
+    // 将结果存储到对象中，使用 serverName 作为键
+    this.mcpTools = {}
+    tools.forEach(({ serverName, tools: toolsData }) => {
+      this.mcpTools[serverName] = toolsData
+    })
   }
   /** 关闭所有的 clients */
   async closeAll() {
     await Promise.all(
-      this.mcpClients.map(async (client) => {
+      Object.values(this.mcpClients).map(async (client) => {
         try {
           await this._closeOneClient(client)
         } catch (error: unknown) {
@@ -133,58 +153,68 @@ export class AgentModelProvider {
     )
   }
 
+  /** 创建所有的 mcpClients，并更新它们的tools */
   async initClientsAndTools() {
     await this._createMpcClients()
     await this._createMpcTools()
+    this.onUpdatedTools?.()
   }
 
-  async updateMcpServers(mcpServers: McpServerConfig[]) {
+  /** 全量更新所有的 mcpServers */
+  async updateMcpServers(mcpServers?: Record<string, McpServerConfig>) {
     await this.closeAll()
-    this.mcpServers = mcpServers
+    this.mcpServers = mcpServers || this.mcpServers
     await this.initClientsAndTools()
   }
 
-  async insertMcpServer(mcpServer: McpServerConfig) {
-    const find = this.mcpServers.find((item: any) => 'url' in item && 'url' in mcpServer && item.url === mcpServer.url)
-
-    if (!find) {
-      this.mcpServers = [...this.mcpServers, mcpServer]
-      const client = await this._createOneClient(mcpServer)
-      this.mcpClients.push(client)
-      this.mcpTools.push((await client?.tools?.()) as Record<string, any>)
-      return true
+  /** 插入一个新的mcpServer，如果已经存在则返回false */
+  async insertMcpServer(serverName: string, mcpServer: McpServerConfig) {
+    // 检查是否已存在相同名称的服务器
+    if (this.mcpServers[serverName]) {
+      return false
     }
-    return false
+
+    const client = await this._createOneClient(mcpServer)
+    this.mcpClients[serverName] = client
+    this.mcpTools[serverName] = (await client?.tools?.()) as Record<string, any>
+    this.mcpServers[serverName] = mcpServer
+    this.onUpdatedTools?.()
+
+    return true
   }
-  /** 通过引用，删除一个 mcpServers mcpClients  mcpTools ignoreToolnames  */
-  async removeMcpServer(mcpServer: McpServerConfig) {
-    const index = this.mcpServers.findIndex((server) => server === mcpServer)
+  /** 通过服务器名称删除mcpServer： mcpServers mcpClients  mcpTools ignoreToolnames  */
+  async removeMcpServer(serverName: string) {
+    if (!this.mcpServers[serverName]) {
+      return
+    }
 
-    // 移除
-    this.mcpServers.splice(index, 1)
+    // 删除 mcpServer
+    delete this.mcpServers[serverName]
 
-    // 移除
-    const delClient = this.mcpClients[index]
-    this.mcpClients.splice(index, 1)
+    // 关闭并删除 client
+    const delClient = this.mcpClients[serverName]
+    delete this.mcpClients[serverName]
     try {
       await this._closeOneClient(delClient)
     } catch (error) {}
 
-    // 移除 tools
-    const delTool = this.mcpTools[index]
-    this.mcpTools.splice(index, 1)
+    // 删除 tools 并清理 ignoreToolnames
+    const delTool = this.mcpTools[serverName]
+    delete this.mcpTools[serverName]
 
-    // 移除 ignoreToolnames
     if (delTool) {
       Object.keys(delTool).forEach((toolName) => {
         this.ignoreToolnames = this.ignoreToolnames.filter((name) => name !== toolName)
       })
     }
+
+    this.onUpdatedTools?.()
   }
 
   /** 创建临时允许调用的tools集合 */
   private _tempMergeTools(extraTool = {}) {
-    const toolsResult = this.mcpTools.reduce((acc, curr) => ({ ...acc, ...curr }), {})
+    // 将对象的值转换为数组后再 reduce
+    const toolsResult = Object.values(this.mcpTools).reduce((acc, curr) => ({ ...acc, ...curr }), {})
     Object.assign(toolsResult, extraTool)
 
     this.ignoreToolnames.forEach((name) => {
@@ -203,8 +233,6 @@ export class AgentModelProvider {
 
     await this.initClientsAndTools()
 
-    this.onUpdatedTools?.()
-
     const chatOptions = {
       // @ts-ignore  ProviderV2 是所有llm的父类， 在每一个具体的llm 类都有一个选择model的函数用法
       model: this.llm(model),

package/agent/type.ts

@@ -14,7 +14,11 @@ export interface IAgentModelProviderLlmConfig {
 }
 
 /** Mcp Server的配置对象 */
-export type McpServerConfig = { type: 'streamableHttp' | 'sse'; url: string } | { transport: MCPTransport }
+export type McpServerConfig =
+  | { type: 'streamableHttp'; url: string }
+  | { type: 'sse'; url: string }
+  | { type: 'extension'; url: string; sessionId: string }
+  | { transport: MCPTransport }
 
 /** */
 export interface IAgentModelProviderOption {
@@ -25,6 +29,6 @@ export interface IAgentModelProviderOption {
   llm?: ProviderV2
   /** 代理模型提供器的大语言配置对象, 不能与 llm 同时传入 */
   llmConfig?: IAgentModelProviderLlmConfig
-  /** Mcp Server的配置对象的集合 */
-  mcpServers?: McpServerConfig[]
+  /** Mcp Server的配置对象的集合，键为服务器名称，值为配置对象 */
+  mcpServers?: Record<string, McpServerConfig>
 }

package/agent/utils/getAISDKTools.ts

@@ -2,9 +2,9 @@ import { dynamicTool, jsonSchema, Tool, ToolCallOptions, ToolSet } from 'ai'
 import { WebMcpClient } from '../../WebMcpClient'
 
 /**
- * 快速 从官方 mcp 或 WebMcpClient 这2种client中， 抽取成 ai-sdk 所需要的 tool的对象
+ * 快速从官方 mcp 或 WebMcpClient 这2种client中读取 tools 数组，并转换成 ai-sdk 的tool的对象格式。
  * @params client  一个已连接好的 WebMcpClient
- * @returns  ai-sdk的 tool 格式的对象。
+ * @returns ai-sdk的dynamicTool对象。
  */
 export const getAISDKTools = async (client: WebMcpClient): Promise<ToolSet> => {
   const tools: Record<string, Tool> = {}