@ray-js/t-agent-plugin-aistream 0.2.7 → 0.2.8-beta.2

package/dist/mcp/McpServer.d.ts

@@ -0,0 +1,11 @@
+import { BaseContext, McpServerInfo, McpServerOptions, McpToolConfig, McpToolDefinition, McpToolHandler } from './types';
+export declare class McpServer<TContext extends BaseContext = BaseContext> {
+    readonly serverInfo: McpServerInfo;
+    readonly protocolVersion: string;
+    private readonly tools;
+    private readonly capabilities;
+    constructor(serverInfo: McpServerInfo, options?: McpServerOptions);
+    registerTool(name: string, config: McpToolConfig, handler: McpToolHandler<TContext>): void;
+    getToolDefinitions(): McpToolDefinition[];
+    handleRequest(payload: string, context: Omit<TContext, 'mcpReq'> & Partial<Pick<TContext, 'mcpReq'>>): Promise<string | null>;
+}

package/dist/mcp/McpServer.js

@@ -0,0 +1,162 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const _excluded = ["handler"];
+import "core-js/modules/es.json.stringify.js";
+import "core-js/modules/es.string.trim.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+function isCallToolResult(value) {
+  return !!value && Array.isArray(value.content);
+}
+function normalizeToolResult(value) {
+  if (isCallToolResult(value)) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    return {
+      content: [{
+        type: 'text',
+        text: value
+      }]
+    };
+  }
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(value == null ? {} : value)
+    }]
+  };
+}
+function createJsonRpcError(id, code, message, data) {
+  const response = {
+    jsonrpc: '2.0',
+    id,
+    error: {
+      code,
+      message
+    }
+  };
+  if (data !== undefined) {
+    response.error.data = data;
+  }
+  return JSON.stringify(response);
+}
+export class McpServer {
+  constructor(serverInfo) {
+    var _options$capabilities;
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _defineProperty(this, "tools", new Map());
+    this.serverInfo = serverInfo;
+    this.protocolVersion = options.protocolVersion || '2025-06-18';
+    this.capabilities = _objectSpread({
+      tools: _objectSpread({
+        listChanged: true
+      }, ((_options$capabilities = options.capabilities) === null || _options$capabilities === void 0 ? void 0 : _options$capabilities.tools) || {}),
+      resources: {}
+    }, options.capabilities || {});
+  }
+  registerTool(name, config, handler) {
+    this.tools.set(name, _objectSpread(_objectSpread({
+      name
+    }, config), {}, {
+      handler
+    }));
+  }
+  getToolDefinitions() {
+    return Array.from(this.tools.values()).map(_ref => {
+      let {
+          handler: _handler
+        } = _ref,
+        tool = _objectWithoutProperties(_ref, _excluded);
+      return _objectSpread(_objectSpread({}, tool), {}, {
+        inputSchema: tool.inputSchema || {
+          type: 'object',
+          properties: {}
+        }
+      });
+    });
+  }
+  async handleRequest(payload, context) {
+    let request;
+    try {
+      request = JSON.parse(payload);
+    } catch (error) {
+      return createJsonRpcError(null, -32700, 'Parse error');
+    }
+    const reqContext = _objectSpread(_objectSpread({}, context), {}, {
+      mcpReq: request
+    });
+    const {
+      id = null,
+      method,
+      params
+    } = request;
+    switch (method) {
+      case 'initialize':
+        return JSON.stringify({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            protocolVersion: this.protocolVersion,
+            capabilities: this.capabilities,
+            serverInfo: this.serverInfo
+          }
+        });
+      case 'notifications/initialized':
+        return null;
+      case 'tools/list':
+        return JSON.stringify({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            tools: this.getToolDefinitions()
+          }
+        });
+      case 'tools/call':
+        {
+          if (!params || typeof params !== 'object' || Array.isArray(params)) {
+            return createJsonRpcError(id, -32602, 'Invalid params: tools/call params must be an object');
+          }
+          const toolName = params === null || params === void 0 ? void 0 : params.name;
+          const args = (params === null || params === void 0 ? void 0 : params.arguments) || {};
+          if (typeof toolName !== 'string' || !toolName.trim()) {
+            return createJsonRpcError(id, -32602, 'Invalid params: tools/call name must be a non-empty string');
+          }
+          if (params.arguments !== undefined && (typeof params.arguments !== 'object' || params.arguments === null || Array.isArray(params.arguments))) {
+            return createJsonRpcError(id, -32602, 'Invalid params: tools/call arguments must be an object');
+          }
+          const tool = toolName ? this.tools.get(toolName) : undefined;
+          if (!tool) {
+            return createJsonRpcError(id, -32601, "Tool not found: ".concat(toolName));
+          }
+          try {
+            const result = await tool.handler(args, reqContext);
+            return JSON.stringify({
+              jsonrpc: '2.0',
+              id,
+              result: normalizeToolResult(result)
+            });
+          } catch (error) {
+            return JSON.stringify({
+              jsonrpc: '2.0',
+              id,
+              result: {
+                content: [{
+                  type: 'text',
+                  text: JSON.stringify({
+                    status: 'error',
+                    message: error instanceof Error ? error.message : String(error)
+                  })
+                }],
+                isError: true
+              }
+            });
+          }
+        }
+      default:
+        return createJsonRpcError(id, -32601, "Unknown method: ".concat(method));
+    }
+  }
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './McpServer';
+export * from './withMCP';

package/dist/mcp/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './McpServer';
+export * from './withMCP';

package/dist/mcp/types.d.ts

@@ -0,0 +1,114 @@
+import { AbortSignalObject } from '@ray-js/t-agent';
+export type JsonRpcId = string | number | null;
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type JsonSchemaTypeName = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+export interface JsonSchema {
+    type?: JsonSchemaTypeName | JsonSchemaTypeName[];
+    title?: string;
+    description?: string;
+    default?: JsonValue;
+    examples?: JsonValue[];
+    enum?: JsonValue[];
+    const?: JsonValue;
+    format?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema | JsonSchema[];
+    prefixItems?: JsonSchema[];
+    additionalProperties?: boolean | JsonSchema;
+    oneOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    minProperties?: number;
+    maxProperties?: number;
+    $defs?: Record<string, JsonSchema>;
+    definitions?: Record<string, JsonSchema>;
+    $ref?: string;
+}
+export interface JsonRpcRequest<TMethod extends string = string, TParams = any> {
+    jsonrpc: '2.0';
+    id?: JsonRpcId;
+    method: TMethod;
+    params?: TParams;
+}
+export interface JsonRpcResponse<TResult = any> {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    result?: TResult;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+}
+export interface BaseContext {
+    sessionId?: string;
+    mcpReq: JsonRpcRequest;
+    signal?: AbortSignalObject;
+    [key: string]: any;
+}
+export interface McpServerInfo {
+    name: string;
+    version: string;
+}
+export interface McpServerOptions {
+    protocolVersion?: string;
+    capabilities?: {
+        tools?: {
+            listChanged?: boolean;
+        };
+        resources?: Record<string, any>;
+        [key: string]: any;
+    };
+}
+export interface McpToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface McpToolConfig {
+    title?: string;
+    description?: string;
+    inputSchema?: JsonSchema;
+    annotations?: McpToolAnnotations;
+}
+export interface McpTextContent {
+    type: 'text';
+    text: string;
+}
+export interface McpImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
+export type McpContent = McpTextContent | McpImageContent;
+export interface CallToolResult {
+    content: McpContent[];
+    isError?: boolean;
+    structuredContent?: Record<string, any>;
+    [key: string]: any;
+}
+export type McpToolHandler<TContext extends BaseContext = BaseContext> = (args: Record<string, any>, context: TContext) => Promise<CallToolResult | Record<string, any> | string | void> | CallToolResult | Record<string, any> | string | void;
+export interface McpToolDefinition extends McpToolConfig {
+    name: string;
+}
+export interface McpTool<TContext extends BaseContext = BaseContext> extends McpToolDefinition {
+    handler: McpToolHandler<TContext>;
+}

package/dist/mcp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/withMCP.d.ts

@@ -0,0 +1,15 @@
+import { ChatAgent, GetChatPluginHandler } from '@ray-js/t-agent';
+import { AIStreamPlugin } from '../withAIStream';
+import { SessionEventBody } from '../AIStreamTypes';
+import { McpServer } from './McpServer';
+import { BaseContext } from './types';
+export interface WithMCPOptions<TContext extends BaseContext = BaseContext> {
+    createServer: (agent: ChatAgent<AIStreamPlugin>) => McpServer<TContext>;
+    createContext?: (event: SessionEventBody, agent: ChatAgent<AIStreamPlugin>) => Omit<TContext, 'mcpReq' | 'sessionId' | 'signal'>;
+}
+export type MCPPlugin = GetChatPluginHandler<typeof withMCP>;
+export declare function withMCP<TContext extends BaseContext = BaseContext>(options: WithMCPOptions<TContext>): (_agent: ChatAgent) => {
+    mcp: {
+        getServer: () => McpServer<TContext>;
+    };
+};

package/dist/mcp/withMCP.js

@@ -0,0 +1,98 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { EventType } from '../AIStreamTypes';
+import AbortController from '../utils/abort';
+import { deepmerge } from '@ray-js/t-agent';
+import logger from '../utils/logger';
+export function withMCP(options) {
+  return _agent => {
+    if (!_agent.plugins.aiStream) {
+      throw new Error('withMCP must be used after withAIStream');
+    }
+    const agent = _agent;
+    const {
+      createServer,
+      createContext
+    } = options;
+    const {
+      onAgentDispose
+    } = agent;
+    const {
+      onUserDataRead,
+      onSessionEventReceived,
+      sendEvent
+    } = agent.plugins.aiStream;
+    const pendingMap = new Map();
+    let server = null;
+    const ensureServer = () => {
+      if (!server) {
+        server = createServer(agent);
+      }
+      return server;
+    };
+    onUserDataRead(async (_type, _data, result) => {
+      if (_type !== 'create-session') {
+        return;
+      }
+      const activeServer = ensureServer();
+      result.userData = deepmerge(result.userData, {
+        sessionAttributes: {
+          deviceMcp: {
+            mcpVersion: activeServer.protocolVersion,
+            mcpTools: activeServer.getToolDefinitions(),
+            supportCustomMCP: true
+          }
+        }
+      });
+    });
+    onAgentDispose(() => {
+      pendingMap.forEach(controller => controller.abort(new Error('Agent disposed')));
+      pendingMap.clear();
+      server = null;
+    });
+    onSessionEventReceived(async event => {
+      if (event.eventType !== EventType.MCP_CMD || !event.payload) {
+        return;
+      }
+      const abortController = new AbortController();
+      pendingMap.set(event.eventId, abortController);
+      try {
+        const activeServer = ensureServer();
+        const extraContext = createContext ? createContext(event, agent) : {};
+        logger.debug('withMCP receive event', {
+          sessionId: event.sessionId,
+          eventId: event.eventId,
+          payload: event.payload
+        });
+        const response = await activeServer.handleRequest(event.payload, _objectSpread(_objectSpread({}, extraContext), {}, {
+          sessionId: event.sessionId,
+          signal: abortController.signal,
+          eventBody: event
+        }));
+        if (!response || abortController.signal.aborted) {
+          return;
+        }
+        logger.debug('withMCP send response', {
+          sessionId: event.sessionId,
+          eventId: event.eventId,
+          payload: response
+        });
+        await sendEvent({
+          sessionId: event.sessionId,
+          eventId: event.eventId,
+          eventType: EventType.MCP_CMD,
+          payload: response
+        });
+      } finally {
+        pendingMap.delete(event.eventId);
+      }
+    });
+    return {
+      mcp: {
+        getServer: ensureServer
+      }
+    };
+  };
+}

package/dist/polyfill.js

@@ -1,4 +1,5 @@
 import "core-js/modules/web.queue-microtask.js";
+/* istanbul ignore file */
 // @ts-ignore
 globalThis.queueMicrotask = callback => {
   Promise.resolve().then(callback).catch(err => {

package/dist/utils/AIStream.d.ts

@@ -1,4 +1,4 @@
-import { AIStreamAudioFile, AIStreamUserData, Attribute, BizTag, ConnectClientType, ConnectState, FileFormat, VideoCameraType } from '../AIStreamTypes';
+import { AIStreamAudioFile, AIStreamUserData, Attribute, BizTag, ConnectClientType, ConnectState, FileFormat, SessionEventBody, VideoCameraType } from '../AIStreamTypes';
 import { AIStreamDataEntry, AIStreamObserverPool } from './observer';
 import { AbortSignalObject } from '@ray-js/t-agent';
 import { AIStreamError } from './errors';
@@ -49,6 +49,14 @@ interface AIStreamEventOptions {
     userData?: Attribute[];
     userDataJson?: string;
 }
+export type AIStreamSessionEventOptions = {
+    /** 会话 id */
+    sessionId: string;
+    /** 事件 id */
+    eventId: string;
+    /** 扩展属性 */
+    payload?: string;
+};
 export declare class AIStreamSession {
     private connection;
     private pool;
@@ -62,15 +70,20 @@ export declare class AIStreamSession {
     private promise;
     tokenExtParamsResolvable: import("./object").Resolvable<{
         [key: string]: any;
-        chatId?: string | undefined;
+        chatId?: string;
     }>;
+    private listeners;
     constructor(connection: AIStreamConnection, pool: AIStreamObserverPool, options: AIStreamSessionOptions);
     ensureSession(): Promise<void>;
+    _onSessionEvent: (entry: AIStreamDataEntry) => void;
     _onStateChanged: (entry: AIStreamDataEntry) => void;
     startEvent(options?: AIStreamEventOptions): Promise<AIStreamEvent>;
     private onDataEntry;
     private cleanupEvent;
     cleanup(): void;
+    on(name: 'sessionEvent', callback: (body: SessionEventBody) => void): void;
+    off(name: 'sessionEvent', callback: (body: SessionEventBody) => void): void;
+    private emit;
     close(): Promise<void>;
 }
 type AIStreamEventWriteChunk = {

package/dist/utils/AIStream.js

@@ -23,6 +23,7 @@ export class AIStreamClient {
     let connection = this.cached.get(key);
     if (!connection) {
       connection = new AIStreamConnection(this.pool, options);
+      this.cached.set(key, connection);
     }
     return connection;
   }
@@ -47,13 +48,18 @@ export class AIStreamConnection {
           // 断开事件触发时只做清理，因为连接已经关掉了
           this.cleanup();
         }
-      }
-      if (entry.type === 'sessionState') {
+      } else if (entry.type === 'sessionState') {
         this.activeSessions.forEach(session => {
           if (session.sessionId && session.sessionId === entry.body.sessionId) {
             session._onStateChanged(entry);
           }
         });
+      } else if (entry.type === 'sessionEvent') {
+        this.activeSessions.forEach(session => {
+          if (session.sessionId && session.sessionId === entry.body.sessionId) {
+            session._onSessionEvent(entry);
+          }
+        });
       }
     });
     this.pool = pool;
@@ -68,7 +74,8 @@ export class AIStreamConnection {
         this.observer = new AIStreamObserver(this.onStateChanged, this.pool);
         this.observer.observe({
           connectionState: true,
-          sessionState: true
+          sessionState: true,
+          sessionEvent: true
         });
       }
     };
@@ -164,6 +171,15 @@ export class AIStreamSession {
     _defineProperty(this, "disposed", false);
     _defineProperty(this, "promise", null);
     _defineProperty(this, "tokenExtParamsResolvable", createResolvable());
+    _defineProperty(this, "listeners", {
+      sessionEvent: new Set()
+    });
+    _defineProperty(this, "_onSessionEvent", entry => {
+      if (entry.type !== 'sessionEvent') {
+        return;
+      }
+      this.emit(entry);
+    });
     _defineProperty(this, "_onStateChanged", entry => {
       var _this$activeEvent;
       (_this$activeEvent = this.activeEvent) === null || _this$activeEvent === void 0 || _this$activeEvent.emit('data', entry);
@@ -272,7 +288,7 @@ export class AIStreamSession {
         }));
         if (err) {
           finErr = err;
-          if (err.code === AIStreamAppErrorCode.RECONNECT) {
+          if (err.originalCode === AIStreamAppErrorCode.RECONNECT) {
             // 200 毫秒后再试
             await new Promise(resolve => {
               setTimeout(resolve, 200);
@@ -385,6 +401,21 @@ export class AIStreamSession {
     this.sendDataChannels = [];
     this.revDataChannels = [];
   }
+  on(name, callback) {
+    if (name === 'sessionEvent') {
+      this.listeners.sessionEvent.add(callback);
+    }
+  }
+  off(name, callback) {
+    if (name === 'sessionEvent') {
+      this.listeners.sessionEvent.delete(callback);
+    }
+  }
+  emit(data) {
+    if (data.type === 'sessionEvent') {
+      this.listeners.sessionEvent.forEach(cb => cb(data.body));
+    }
+  }
 
   // 会话关闭清理
   async close() {
@@ -392,6 +423,7 @@ export class AIStreamSession {
     this.disposed = true;
     await this.connection.closeSession(this);
     this.cleanup();
+    this.listeners.sessionEvent.clear();
   }
 }
 export class AIStreamEvent {