@opentiny/next-sdk 0.1.0 → 0.1.1

package/WebMcpServer.ts

@@ -0,0 +1,440 @@
+import { MessageChannelServerTransport, createTransportPair } from '@opentiny/next'
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { z, ZodObject, ZodLiteral, ZodType, ZodOptional } from 'zod'
+import {
+  SetLevelRequestSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema,
+  ListResourcesRequestSchema,
+  RootsListChangedNotificationSchema
+} from '@modelcontextprotocol/sdk/types.js'
+import type {
+  ToolCallback,
+  RegisteredTool,
+  PromptCallback,
+  RegisteredPrompt,
+  ResourceMetadata,
+  ResourceTemplate,
+  RegisteredResource,
+  ReadResourceCallback,
+  RegisteredResourceTemplate,
+  ReadResourceTemplateCallback
+} from '@modelcontextprotocol/sdk/server/mcp.js'
+import type {
+  Result,
+  Request,
+  Notification,
+  Implementation,
+  ToolAnnotations,
+  ServerCapabilities,
+  ClientCapabilities,
+  ElicitResult,
+  ElicitRequest,
+  ListRootsRequest,
+  CreateMessageRequest,
+  LoggingMessageNotification,
+  ResourceUpdatedNotification
+} from '@modelcontextprotocol/sdk/types.js'
+import type { ZodRawShape, ZodTypeDef } from 'zod'
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
+import type { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js'
+import type {
+  RequestOptions,
+  NotificationOptions,
+  RequestHandlerExtra
+} from '@modelcontextprotocol/sdk/shared/protocol.js'
+
+type PromptArgsRawShape = {
+  [k: string]: ZodType<string, ZodTypeDef, string> | ZodOptional<ZodType<string, ZodTypeDef, string>>
+}
+
+type SendRequestT = Request
+type SendNotificationT = Notification
+type SendResultT = Result
+
+/**
+ * High-level Web MCP server that provides a simpler API for working with resources, tools, and prompts.
+ * For advanced usage (like sending notifications or setting custom request handlers), use the underlying
+ * Server instance available via the `server` property.
+ */
+export class WebMcpServer {
+  public readonly server: McpServer
+  public transport: Transport | undefined
+
+  constructor(serverInfo: Implementation, options?: ServerOptions) {
+    const info: Implementation = {
+      name: 'web-mcp-server',
+      version: '1.0.0'
+    }
+
+    const capabilities: ServerCapabilities = {
+      prompts: { listChanged: true },
+      resources: { subscribe: true, listChanged: true },
+      tools: { listChanged: true },
+      completions: {},
+      logging: {}
+    }
+
+    this.server = new McpServer(serverInfo || info, options || { capabilities })
+
+    this.server.server.oninitialized = () => {
+      this.oninitialized?.()
+    }
+
+    this.server.server.onclose = () => {
+      this.onclose?.()
+    }
+
+    this.server.server.onerror = (error: Error) => {
+      this.onerror?.(error)
+    }
+  }
+
+  /**
+   * Connects the server to a transport via the specified option.
+   */
+  async connect(options: Transport | string): Promise<Transport> {
+    if (typeof (options as Transport)['start'] === 'function') {
+      this.transport = options as Transport
+      this.transport.onclose = undefined
+      this.transport.onerror = undefined
+      this.transport.onmessage = undefined
+    } else {
+      this.transport = new MessageChannelServerTransport(options as string)
+      await (this.transport as MessageChannelServerTransport).listen()
+    }
+
+    await this.server.connect(this.transport)
+    return this.transport
+  }
+
+  /**
+   * Callback for when initialization has fully completed (i.e., the client has sent an `initialized` notification).
+   */
+  oninitialized?: () => void
+
+  /**
+   * Callback for when the connection is closed for any reason.
+   *
+   * This is invoked when close() is called as well.
+   */
+  onclose?: () => void
+
+  /**
+   * Callback for when an error occurs.
+   *
+   * Note that errors are not necessarily fatal; they are used for reporting any kind of exceptional condition out of band.
+   */
+  onerror?: (error: Error) => void
+
+  /**
+   * Closes the connection.
+   */
+  async close(): Promise<void> {
+    await this.server.close()
+  }
+
+  /**
+   * Registers a tool with a config object and callback.
+   */
+  registerTool<InputArgs extends ZodRawShape, OutputArgs extends ZodRawShape>(
+    name: string,
+    config: {
+      title?: string
+      description?: string
+      inputSchema?: InputArgs
+      outputSchema?: OutputArgs
+      annotations?: ToolAnnotations
+    },
+    cb: ToolCallback<InputArgs>
+  ): RegisteredTool {
+    return this.server.registerTool(name, config, cb)
+  }
+
+  /**
+   * Registers a prompt with a config object and callback.
+   */
+  registerPrompt<Args extends PromptArgsRawShape>(
+    name: string,
+    config: {
+      title?: string
+      description?: string
+      argsSchema?: Args
+    },
+    cb: PromptCallback<Args>
+  ): RegisteredPrompt {
+    return this.server.registerPrompt(name, config, cb)
+  }
+
+  /**
+   * Registers a resource with a config object and callback.
+   * For static resources, use a URI string. For dynamic resources, use a ResourceTemplate.
+   */
+  registerResource(
+    name: string,
+    uriOrTemplate: string,
+    config: ResourceMetadata,
+    readCallback: ReadResourceCallback
+  ): RegisteredResource
+  registerResource(
+    name: string,
+    uriOrTemplate: ResourceTemplate,
+    config: ResourceMetadata,
+    readCallback: ReadResourceTemplateCallback
+  ): RegisteredResourceTemplate
+  registerResource(
+    name: string,
+    uriOrTemplate: string | ResourceTemplate,
+    config: ResourceMetadata,
+    readCallback: ReadResourceCallback | ReadResourceTemplateCallback
+  ): RegisteredResource | RegisteredResourceTemplate {
+    if (typeof uriOrTemplate === 'string') {
+      return this.server.registerResource(name, uriOrTemplate, config, readCallback as ReadResourceCallback)
+    } else {
+      return this.server.registerResource(name, uriOrTemplate, config, readCallback as ReadResourceTemplateCallback)
+    }
+  }
+
+  /**
+   * Checks if the server is connected to a transport.
+   * @returns True if the server is connected
+   */
+  isConnected() {
+    return this.server.isConnected()
+  }
+
+  /**
+   * Sends a resource list changed event to the client, if connected.
+   */
+  sendResourceListChanged() {
+    this.server.sendResourceListChanged()
+  }
+
+  /**
+   * Sends a tool list changed event to the client, if connected.
+   */
+  sendToolListChanged() {
+    this.server.sendToolListChanged()
+  }
+
+  /**
+   * Sends a prompt list changed event to the client, if connected.
+   */
+  sendPromptListChanged() {
+    this.server.sendPromptListChanged()
+  }
+
+  /**
+   * After initialization has completed, this will be populated with the client's reported capabilities.
+   */
+  getClientCapabilities(): ClientCapabilities | undefined {
+    return this.server.server.getClientCapabilities()
+  }
+
+  /**
+   * After initialization has completed, this will be populated with information about the client's name and version.
+   */
+  getClientVersion(): Implementation | undefined {
+    return this.server.server.getClientVersion()
+  }
+
+  /**
+   * Sends a ping to the client to check if it is still connected.
+   */
+  async ping() {
+    return await this.server.server.ping()
+  }
+
+  /**
+   * Creates a LLM message to be sent to the client.
+   */
+  async createMessage(params: CreateMessageRequest['params'], options?: RequestOptions) {
+    return await this.server.server.createMessage(params, options)
+  }
+
+  /**
+   * Elicits input from the client, such as a prompt or resource.
+   */
+  async elicitInput(params: ElicitRequest['params'], options?: RequestOptions): Promise<ElicitResult> {
+    return await this.server.server.elicitInput(params, options)
+  }
+
+  /**
+   * Lists the root resources available to the client.
+   */
+  async listRoots(params?: ListRootsRequest['params'], options?: RequestOptions) {
+    return await this.server.server.listRoots(params, options)
+  }
+
+  /**
+   * Sends a logging message to the client.
+   */
+  async sendLoggingMessage(params: LoggingMessageNotification['params']) {
+    return await this.server.server.sendLoggingMessage(params)
+  }
+
+  /**
+   * Sends a resource updated notification to the client.
+   */
+  async sendResourceUpdated(params: ResourceUpdatedNotification['params']) {
+    return await this.server.server.sendResourceUpdated(params)
+  }
+
+  /**
+   * Sends a request and wait for a response.
+   *
+   * Do not use this method to emit notifications! Use notification() instead.
+   */
+  request<T extends ZodType<object>>(
+    request: SendRequestT,
+    resultSchema: T,
+    options?: RequestOptions
+  ): Promise<z.infer<T>> {
+    return this.server.server.request(request, resultSchema, options)
+  }
+
+  /**
+   * Emits a notification, which is a one-way message that does not expect a response.
+   */
+  async notification(notification: SendNotificationT, options?: NotificationOptions): Promise<void> {
+    return await this.server.server.notification(notification, options)
+  }
+
+  /**
+   * Registers a handler to invoke when this protocol object receives a request with the given method.
+   *
+   * Note that this will replace any previous request handler for the same method.
+   */
+  setRequestHandler<
+    T extends ZodObject<{
+      method: ZodLiteral<string>
+    }>
+  >(
+    requestSchema: T,
+    handler: (
+      request: z.infer<T>,
+      extra: RequestHandlerExtra<SendRequestT, SendNotificationT>
+    ) => SendResultT | Promise<SendResultT>
+  ): void {
+    this.server.server.setRequestHandler(requestSchema, handler)
+  }
+
+  /**
+   * Removes the request handler for the given method.
+   */
+  removeRequestHandler(method: string): void {
+    this.server.server.removeRequestHandler(method)
+  }
+
+  /**
+   * Registers a handler to invoke when this protocol object receives a notification with the given method.
+   *
+   * Note that this will replace any previous notification handler for the same method.
+   */
+  setNotificationHandler<
+    T extends ZodObject<{
+      method: ZodLiteral<string>
+    }>
+  >(notificationSchema: T, handler: (notification: z.infer<T>) => void | Promise<void>): void {
+    this.server.server.setNotificationHandler(notificationSchema, handler)
+  }
+
+  /**
+   * Removes the notification handler for the given method.
+   */
+  removeNotificationHandler(method: string): void {
+    this.server.server.removeNotificationHandler(method)
+  }
+
+  /**
+   * Registers a handler for the subscribe request.
+   */
+  onSubscribe(
+    handler: (
+      request: z.infer<typeof SubscribeRequestSchema>,
+      extra: RequestHandlerExtra<SendRequestT, SendNotificationT>
+    ) => SendResultT | Promise<SendResultT>
+  ): void {
+    this.server.server.setRequestHandler(SubscribeRequestSchema, handler)
+  }
+
+  /**
+   * Registers a handler for the unsubscribe request.
+   */
+  onUnsubscribe(
+    handler: (
+      request: z.infer<typeof UnsubscribeRequestSchema>,
+      extra: RequestHandlerExtra<SendRequestT, SendNotificationT>
+    ) => SendResultT | Promise<SendResultT>
+  ): void {
+    this.server.server.setRequestHandler(UnsubscribeRequestSchema, handler)
+  }
+
+  /**
+   * Registers a handler for the set log level request.
+   */
+  onSetLogLevel(
+    handler: (
+      request: z.infer<typeof SetLevelRequestSchema>,
+      extra: RequestHandlerExtra<SendRequestT, SendNotificationT>
+    ) => SendResultT | Promise<SendResultT>
+  ): void {
+    this.server.server.setRequestHandler(SetLevelRequestSchema, handler)
+  }
+
+  /**
+   * Registers a handler for the list tools request.
+   */
+  onListResources(
+    handler: (
+      request: z.infer<typeof ListResourcesRequestSchema>,
+      extra: RequestHandlerExtra<SendRequestT, SendNotificationT>
+    ) => SendResultT | Promise<SendResultT>
+  ): void {
+    this.server.server.setRequestHandler(ListResourcesRequestSchema, handler)
+  }
+
+  /**
+   * Registers a handler for the roots list changed notification.
+   */
+  onRootsListChanged(
+    handler: (notification: z.infer<typeof RootsListChangedNotificationSchema>) => void | Promise<void>
+  ): void {
+    this.server.server.setNotificationHandler(RootsListChangedNotificationSchema, handler)
+  }
+
+  /**
+   * Close the transport for window.addEventListener('pagehide')
+   */
+  async onPagehide(event: PageTransitionEvent) {
+    if (event.persisted) {
+      return
+    }
+
+    if (this.transport && typeof this.transport['close'] === 'function') {
+      await this.transport.close()
+    }
+  }
+}
+
+/**
+ * Creates a new MessageChannelServerTransport instance.
+ */
+export const createMessageChannelServerTransport = (endpoint: string, globalObject?: object) =>
+  new MessageChannelServerTransport(endpoint, globalObject)
+
+/**
+ * Creates a pair of transports for communication between a server and client using MessageChannel.
+ */
+export const createMessageChannelPairTransport = () => createTransportPair()
+
+/**
+ * Checks if the transport is a MessageChannelServerTransport.
+ */
+export const isMessageChannelServerTransport = (transport: unknown): transport is MessageChannelServerTransport =>
+  transport instanceof MessageChannelServerTransport
+
+/**
+ * Checks if the server is an instance of MCP Server.
+ */
+export const isMcpServer = (server: unknown): server is McpServer => server instanceof McpServer

package/agent/AgentModelProvider.ts

@@ -0,0 +1,88 @@
+import { streamText, stepCountIs, generateText } from 'ai'
+import type { ToolSet } from 'ai'
+import { getMcpClients, getMcpTools } from './utils'
+import type { IAgentModelProviderOption, McpServerConfig } from './type'
+import { AIProviderFactories } from './utils/aiProviderFactories'
+import { ProviderV2 } from '@ai-sdk/provider'
+import { OpenAIProvider } from '@ai-sdk/openai'
+
+export class AgentModelProvider {
+  llm: ProviderV2 | OpenAIProvider
+  mcpServers: McpServerConfig[]
+  isGetMcpClients = false
+  mcpClients: any[] = []
+
+  constructor({ llmConfig, mcpServers, llm }: IAgentModelProviderOption) {
+    // 1、保存 mcpServer
+    this.mcpServers = mcpServers || []
+
+    // 2、保存 llm
+    if (llm) {
+      this.llm = llm
+    } else if (llmConfig) {
+      let providerFn: (options: any) => ProviderV2 | OpenAIProvider
+
+      if (typeof llmConfig.providerType === 'string') {
+        providerFn = AIProviderFactories[llmConfig.providerType]
+      } else {
+        providerFn = llmConfig.providerType
+      }
+      this.llm = providerFn({
+        apiKey: llmConfig.apiKey,
+        baseURL: llmConfig.baseURL
+      })
+    } else {
+      throw new Error('Either llmConfig or llm must be provided')
+    }
+  }
+
+  async initClients() {
+    if (!this.isGetMcpClients) {
+      this.mcpClients = await getMcpClients(this.mcpServers)
+      this.isGetMcpClients = true
+    }
+  }
+  async chat({
+    model,
+    maxSteps = 5,
+    ...options
+  }: Parameters<typeof generateText>[0] & { maxSteps?: number }): Promise<any> {
+    if (!this.llm) {
+      throw new Error('LLM is not initialized')
+    }
+
+    // 每次会话需要获取最新的工具列表，因为工具是会发生变化的
+    await this.initClients()
+    const tools = await getMcpTools(this.mcpClients)
+
+    return generateText({
+      // @ts-ignore  ProviderV2 是所有llm的父类， 在每一个具体的llm 类都有一个选择model的函数用法
+      model: this.llm(model),
+      tools: tools as ToolSet,
+      stopWhen: stepCountIs(maxSteps),
+      ...options
+    })
+  }
+
+  async chatStream({
+    model,
+    maxSteps = 5,
+    ...options
+  }: Parameters<typeof streamText>[0] & { maxSteps?: number }): Promise<any> {
+    if (!this.llm) {
+      throw new Error('LLM is not initialized')
+    }
+
+    // 每次会话需要获取最新的工具列表，因为工具是会发生变化的
+    await this.initClients()
+    const tools = await getMcpTools(this.mcpClients)
+
+    return streamText({
+      // @ts-ignore 同上
+      model: this.llm(model),
+      tools: tools as ToolSet,
+      stopWhen: stepCountIs(maxSteps),
+      ...options
+    })
+  }
+}

package/agent/type.ts

@@ -0,0 +1,30 @@
+export type { experimental_MCPClient as MCPClient } from 'ai'
+import type { ProviderV2 } from '@ai-sdk/provider'
+import type { MCPTransport } from 'ai'
+
+/** 代理模型提供器的大语言配置对象 */
+export interface IAgentModelProviderLlmConfig {
+  apiKey: string
+  baseURL: string
+  /** 支持内置的常用模型，或者传入一个ai-sdk官方的Provider工厂函数
+   * @example
+   * import { createOpenAI } from '@ai-sdk/openai'
+   */
+  providerType: 'openai' | 'deepseek' | ((options: any) => ProviderV2)
+}
+
+/** Mcp Server的配置对象 */
+export type McpServerConfig = { type: 'streamableHttp' | 'sse'; url: string } | { transport: MCPTransport }
+
+/** */
+export interface IAgentModelProviderOption {
+  /** ai-sdk官方的Provider实例，不能与 llmConfig 同时传入
+   * @example
+   * import { openai } from '@ai-sdk/openai'
+   */
+  llm?: ProviderV2
+  /** 代理模型提供器的大语言配置对象, 不能与 llm 同时传入 */
+  llmConfig?: IAgentModelProviderLlmConfig
+  /** Mcp Server的配置对象的集合 */
+  mcpServers?: McpServerConfig[]
+}

package/agent/utils/aiProviderFactories.ts

@@ -0,0 +1,7 @@
+import { createOpenAI } from '@ai-sdk/openai'
+import { createDeepSeek } from '@ai-sdk/deepseek'
+
+export const AIProviderFactories = {
+  ['openai']: createOpenAI,
+  ['deepseek']: createDeepSeek
+}

package/agent/utils/index.ts

@@ -0,0 +1,44 @@
+import {
+  experimental_createMCPClient as createMCPClient,
+  ToolSet,
+  experimental_MCPClientConfig as MCPClientConfig
+} from 'ai'
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
+import { McpServerConfig, MCPClient } from '../type'
+
+/** 创建 McpClients, 其中 mcpServers 允许为配置为 McpServerConfig, 或者任意的 MCPTransport
+ * 参考: https://ai-sdk.dev/docs/ai-sdk-core/tools-and-tool-calling#initializing-an-mcp-client
+ */
+export const getMcpClients = async (mcpServers: McpServerConfig[]) => {
+  if (!mcpServers || mcpServers?.length === 0) {
+    return []
+  }
+  // 使用 Promise.all 并行处理所有 mcpServer 项
+  const allMcpClients = await Promise.all(
+    mcpServers.map(async (item: McpServerConfig) => {
+      try {
+        let transport: MCPClientConfig['transport']
+        // FIXME
+        if ('type' in item && item.type === 'streamableHttp') {
+          transport = new StreamableHTTPClientTransport(new URL(item.url))
+        } else {
+          transport = item as MCPClientConfig['transport'] // sse 或 自定义的 MCPTranport
+        }
+
+        return createMCPClient({ transport: transport as MCPClientConfig['transport'] })
+      } catch (error) {
+        console.error(`Failed to create MCP client`, item, error)
+        return []
+      }
+    })
+  )
+
+  return allMcpClients
+}
+
+/** 合并所有的Mcp Tools */
+export const getMcpTools = async (mcpClients: MCPClient[]): Promise<ToolSet> => {
+  const tools = await Promise.all(mcpClients.map((client) => client?.tools?.()))
+
+  return tools.reduce((acc, curr) => ({ ...acc, ...curr }), {})
+}

package/dist/agent/AgentModelProvider.d.ts

@@ -0,0 +1,18 @@
+import { streamText, generateText } from 'ai';
+import type { IAgentModelProviderOption, McpServerConfig } from './type';
+import { ProviderV2 } from '@ai-sdk/provider';
+import { OpenAIProvider } from '@ai-sdk/openai';
+export declare class AgentModelProvider {
+    llm: ProviderV2 | OpenAIProvider;
+    mcpServers: McpServerConfig[];
+    isGetMcpClients: boolean;
+    mcpClients: any[];
+    constructor({ llmConfig, mcpServers, llm }: IAgentModelProviderOption);
+    initClients(): Promise<void>;
+    chat({ model, maxSteps, ...options }: Parameters<typeof generateText>[0] & {
+        maxSteps?: number;
+    }): Promise<any>;
+    chatStream({ model, maxSteps, ...options }: Parameters<typeof streamText>[0] & {
+        maxSteps?: number;
+    }): Promise<any>;
+}