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

package/dist/utils/defaultMock.js

@@ -4,10 +4,11 @@ import "core-js/modules/es.json.stringify.js";
 import "core-js/modules/es.regexp.exec.js";
 import "core-js/modules/esnext.iterator.constructor.js";
 import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.find.js";
 import "core-js/modules/esnext.iterator.map.js";
 import "core-js/modules/web.dom-collections.iterator.js";
 import { mock } from './mock';
-import { EmitterEvent, generateId } from '@ray-js/t-agent';
+import { EmitterEvent, generateId, safeParseJSON } from '@ray-js/t-agent';
 import { AIStreamAppErrorCode, AIStreamServerErrorCode, BizCode, ConnectState, EventType, NetworkType, ReceivedTextPacketEof, ReceivedTextPacketType, SessionState, StreamFlag } from '../AIStreamTypes';
 import AbortController from './abort';
 import { tryCatch } from './misc';
@@ -17,6 +18,9 @@ function splitString(input) {
 }
 mock.data.set('sessionMap', new Map());
 mock.data.set('tokenMap', new Map());
+mock.data.set('mcpRequestId', 1);
+mock.data.set('sentEvents', []);
+mock.data.set('mcpAutoHandshake', true);
 const getSession = (sessionId, eventId) => {
   const connection = getCurrentConnection();
   if (!connection) {
@@ -131,6 +135,46 @@ const dispatch = (type, detail) => {
     detail
   }));
 };
+const scheduleMcpHandshake = session => {
+  var _userData$sessionAttr;
+  if (!mock.data.get('mcpAutoHandshake')) {
+    return;
+  }
+  const userData = safeParseJSON(session.userDataJson || '');
+  if (!(userData !== null && userData !== void 0 && (_userData$sessionAttr = userData.sessionAttributes) !== null && _userData$sessionAttr !== void 0 && _userData$sessionAttr.deviceMcp)) {
+    return;
+  }
+  setTimeout(() => {
+    if (session.closed) {
+      return;
+    }
+    dispatch('onEventReceived', {
+      sessionId: session.sessionId,
+      eventId: generateId(),
+      eventType: EventType.MCP_CMD,
+      payload: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {}
+      })
+    });
+  }, 0);
+  setTimeout(() => {
+    if (session.closed) {
+      return;
+    }
+    dispatch('onEventReceived', {
+      sessionId: session.sessionId,
+      eventId: generateId(),
+      eventType: EventType.MCP_CMD,
+      payload: JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'notifications/initialized'
+      })
+    });
+  }, 10);
+};
 mock.hooks.hook('createSession', context => {
   const connection = getCurrentConnection();
   if (!connection) {
@@ -146,7 +190,8 @@ mock.hooks.hook('createSession', context => {
     revDataChannels: ['text', 'audio'],
     currentEvent: null,
     tokenConfig,
-    chatId: tokenConfig.chatId
+    chatId: tokenConfig.chatId,
+    userDataJson: context.options.userDataJson
   };
   map.set(session.sessionId, session);
   context.result = {
@@ -154,6 +199,7 @@ mock.hooks.hook('createSession', context => {
     sendDataChannels: session.sendDataChannels,
     revDataChannels: session.revDataChannels
   };
+  scheduleMcpHandshake(session);
 
   // 用于测试断开连接;
   // setTimeout(() => {
@@ -185,6 +231,10 @@ mock.hooks.hook('closeSession', context => {
   const map = mock.data.get('sessionMap');
   const sessionId = context.options.sessionId;
   const session = map.get(sessionId);
+  if (!session) {
+    context.result = true;
+    return;
+  }
   session.closed = true;
   map.delete(sessionId);
   context.result = true;
@@ -221,7 +271,7 @@ mock.hooks.hook('sendEventStart', async context => {
         text: data ? JSON.stringify(data) : ''
       });
     },
-    replyEvent: eventType => {
+    replyEvent: (eventType, payload) => {
       if (session.closed || event.controller.signal.aborted) {
         return;
       }
@@ -231,9 +281,12 @@ mock.hooks.hook('sendEventStart', async context => {
       dispatch('onEventReceived', {
         eventId,
         sessionId: session.sessionId,
-        eventType
+        eventType,
+        payload
       });
     },
+    resolveMcpResponse: () => undefined,
+    rejectMcpResponse: () => undefined,
     asr: {
       finishController: new AbortController(),
       promise: Promise.resolve()
@@ -257,7 +310,12 @@ mock.hooks.hook('unregisterVoiceAmplitudes', context => {
   context.result = true;
 });
 mock.hooks.hook('sendEventEnd', async context => {
-  const session = getSession(context.options.sessionId, context.options.eventId);
+  const map = mock.data.get('sessionMap');
+  const session = map.get(context.options.sessionId);
+  if (!(session !== null && session !== void 0 && session.currentEvent) || session.currentEvent.eventId !== context.options.eventId) {
+    context.result = true;
+    return;
+  }
   context.result = true;
   const event = session.currentEvent;
   if (event.eventId !== context.options.eventId) {
@@ -265,18 +323,184 @@ mock.hooks.hook('sendEventEnd', async context => {
   }
   await mock.sleep(100);
   (async () => {
-    var _ctx$responseSkills;
-    await event.asr.promise;
-    if (session.tokenConfig.onlyAsr) {
+    let streamEnded = false;
+    let hasStreamedResponse = false;
+    const isEventActive = () => {
+      return !streamEnded && !event.controller.signal.aborted && !session.closed && !!session.currentEvent && session.currentEvent.eventId === event.eventId;
+    };
+    const finishEvent = async function () {
+      let delayMs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      if (streamEnded) {
+        return;
+      }
+      if (delayMs > 0) {
+        await mock.sleep(delayMs);
+      }
+      if (!isEventActive()) {
+        var _session$currentEvent;
+        streamEnded = true;
+        if (((_session$currentEvent = session.currentEvent) === null || _session$currentEvent === void 0 ? void 0 : _session$currentEvent.eventId) === event.eventId) {
+          session.currentEvent = null;
+        }
+        return;
+      }
+      streamEnded = true;
       event.replyEvent(EventType.EVENT_END);
       session.currentEvent = null;
+    };
+    await event.asr.promise;
+    if (session.tokenConfig.onlyAsr) {
+      await finishEvent();
       return;
     }
+    event.replyEvent(EventType.EVENT_START);
     const ctx = {
       data: event.data,
       responseText: '',
       wordDelayMs: 100,
-      chatId: session.chatId
+      chatId: session.chatId,
+      writeText: async (text, options) => {
+        var _ref, _options$wordDelayMs;
+        if (!text) {
+          return;
+        }
+        if (options !== null && options !== void 0 && options.delayMs) {
+          await mock.sleep(options.delayMs);
+        }
+        if (!isEventActive()) {
+          return;
+        }
+        const wordDelayMs = (_ref = (_options$wordDelayMs = options === null || options === void 0 ? void 0 : options.wordDelayMs) !== null && _options$wordDelayMs !== void 0 ? _options$wordDelayMs : ctx.wordDelayMs) !== null && _ref !== void 0 ? _ref : 100;
+        const words = splitString(text);
+        const bizId = generateId();
+        hasStreamedResponse = true;
+        event.replyText(StreamFlag.START);
+        for (let i = 0; i < words.length; i++) {
+          const word = words[i];
+          if (wordDelayMs > 0) {
+            await mock.sleep(wordDelayMs);
+          }
+          if (!isEventActive()) {
+            return;
+          }
+          event.replyText(StreamFlag.IN_PROGRESS, {
+            bizType: ReceivedTextPacketType.NLG,
+            eof: ReceivedTextPacketEof.CONTINUE,
+            bizId,
+            data: {
+              content: word,
+              appendMode: 'append',
+              finish: false
+            }
+          });
+        }
+        if (!isEventActive()) {
+          return;
+        }
+        event.replyText(StreamFlag.IN_PROGRESS, {
+          bizType: ReceivedTextPacketType.NLG,
+          eof: ReceivedTextPacketEof.END,
+          bizId,
+          data: {
+            content: '',
+            appendMode: 'append',
+            finish: true
+          }
+        });
+        if (!isEventActive()) {
+          return;
+        }
+        event.replyText(StreamFlag.END);
+      },
+      writeSkill: async (skill, options) => {
+        if (!skill) {
+          return;
+        }
+        if (options !== null && options !== void 0 && options.delayMs) {
+          await mock.sleep(options.delayMs);
+        }
+        if (!isEventActive()) {
+          return;
+        }
+        hasStreamedResponse = true;
+        event.replyText(StreamFlag.IN_PROGRESS, {
+          bizType: ReceivedTextPacketType.SKILL,
+          eof: ReceivedTextPacketEof.END,
+          bizId: generateId(),
+          data: skill
+        });
+      },
+      end: async options => {
+        await finishEvent((options === null || options === void 0 ? void 0 : options.delayMs) || 0);
+      },
+      callMCPTool: async (toolName, params, options) => {
+        if (!isEventActive()) {
+          return undefined;
+        }
+        const requestId = mock.data.get('mcpRequestId') || 1;
+        mock.data.set('mcpRequestId', requestId + 1);
+        const request = {
+          jsonrpc: '2.0',
+          id: requestId,
+          method: 'tools/call',
+          params: {
+            name: toolName,
+            arguments: params || {}
+          }
+        };
+        const shouldWaitResponse = typeof (options === null || options === void 0 ? void 0 : options.waitResponse) === 'boolean' ? options.waitResponse : !!(request !== null && request !== void 0 && request.id) && (request === null || request === void 0 ? void 0 : request.method) !== 'notifications/initialized';
+        await mock.sleep((options === null || options === void 0 ? void 0 : options.delayMs) || 0);
+        if (!isEventActive()) {
+          return undefined;
+        }
+        event.replyEvent(EventType.MCP_CMD, JSON.stringify(request));
+        if (!shouldWaitResponse) {
+          return undefined;
+        }
+        try {
+          var _result$content2;
+          const responsePayload = await new Promise((resolve, reject) => {
+            event.resolveMcpResponse = resolve;
+            event.rejectMcpResponse = reject;
+          });
+          event.resolveMcpResponse = () => undefined;
+          event.rejectMcpResponse = () => undefined;
+          if (!responsePayload) {
+            return undefined;
+          }
+          const response = safeParseJSON(responsePayload);
+          if (!response || typeof response !== 'object') {
+            throw new Error('Invalid MCP response payload');
+          }
+          if (response.error) {
+            throw new Error(response.error.message || 'MCP tool call failed');
+          }
+          const result = response.result || {};
+          if (result.isError) {
+            var _result$content;
+            const text = (_result$content = result.content) === null || _result$content === void 0 || (_result$content = _result$content.find(item => (item === null || item === void 0 ? void 0 : item.type) === 'text')) === null || _result$content === void 0 ? void 0 : _result$content.text;
+            const parsed = typeof text === 'string' ? safeParseJSON(text) : undefined;
+            const message = typeof parsed === 'string' ? parsed : (parsed === null || parsed === void 0 ? void 0 : parsed.message) || (parsed === null || parsed === void 0 ? void 0 : parsed.error) || 'MCP tool call failed';
+            throw new Error(message);
+          }
+          if (result.structuredContent !== undefined) {
+            return result.structuredContent;
+          }
+          const text = (_result$content2 = result.content) === null || _result$content2 === void 0 || (_result$content2 = _result$content2.find(item => (item === null || item === void 0 ? void 0 : item.type) === 'text')) === null || _result$content2 === void 0 ? void 0 : _result$content2.text;
+          if (typeof text === 'string') {
+            var _safeParseJSON;
+            return (_safeParseJSON = safeParseJSON(text)) !== null && _safeParseJSON !== void 0 ? _safeParseJSON : text;
+          }
+          if (result.content !== undefined) {
+            return result.content;
+          }
+          return result;
+        } catch (error) {
+          event.resolveMcpResponse = () => undefined;
+          event.rejectMcpResponse = () => undefined;
+          throw error;
+        }
+      }
     };
     const [error] = await tryCatch(() => mock.hooks.callHook('sendToAIStream', ctx));
     if (error) {
@@ -291,98 +515,80 @@ mock.hooks.hook('sendEventEnd', async context => {
       return;
     }
     if (ctx.data.length === 0) {
-      event.replyEvent(EventType.EVENT_START);
       await mock.sleep(100);
-      if (event.controller.signal.aborted || session.closed) {
+      if (!isEventActive()) {
         return;
       }
-      event.replyEvent(EventType.EVENT_END);
-      session.currentEvent = null;
+      await finishEvent();
       return;
     }
-    const text = ctx.responseText || '⚠️ No mock text response matched!';
-    const wordDelayMs = ctx.wordDelayMs || 100;
-    const words = splitString(text);
-    if (event.controller.signal.aborted || session.closed) {
+    if (streamEnded) {
       return;
     }
-    event.replyEvent(EventType.EVENT_START);
-    await mock.sleep(500);
-    if (event.controller.signal.aborted || session.closed) {
-      return;
-    }
-    const bizId = generateId();
-    event.replyText(StreamFlag.START);
-    for (let i = 0; i < words.length; i++) {
-      const word = words[i];
-      await mock.sleep(wordDelayMs);
-      if (event.controller.signal.aborted || session.closed) {
-        return;
-      }
-      event.replyText(StreamFlag.IN_PROGRESS, {
-        bizType: ReceivedTextPacketType.NLG,
-        eof: ReceivedTextPacketEof.CONTINUE,
-        bizId,
-        data: {
-          content: word,
-          appendMode: 'append',
-          finish: false
-        }
+    if (!hasStreamedResponse) {
+      var _ctx$responseSkills;
+      const text = ctx.responseText || '⚠️ No mock text response matched!';
+      await mock.sleep(500);
+      await ctx.writeText(text, {
+        wordDelayMs: ctx.wordDelayMs
       });
-    }
-    await mock.sleep(100);
-    if (event.controller.signal.aborted || session.closed) {
-      return;
-    }
-    event.replyText(StreamFlag.IN_PROGRESS, {
-      bizType: ReceivedTextPacketType.NLG,
-      eof: ReceivedTextPacketEof.END,
-      bizId,
-      data: {
-        content: '',
-        appendMode: 'append',
-        finish: true
-      }
-    });
-    await mock.sleep(10);
-    if (event.controller.signal.aborted || session.closed) {
-      return;
-    }
-    if ((_ctx$responseSkills = ctx.responseSkills) !== null && _ctx$responseSkills !== void 0 && _ctx$responseSkills.length) {
-      for (let i = 0; i < ctx.responseSkills.length; i++) {
-        const skill = ctx.responseSkills[i];
-        await mock.sleep(100);
-        if (event.controller.signal.aborted || session.closed) {
-          return;
+      if ((_ctx$responseSkills = ctx.responseSkills) !== null && _ctx$responseSkills !== void 0 && _ctx$responseSkills.length) {
+        for (let i = 0; i < ctx.responseSkills.length; i++) {
+          await ctx.writeSkill(ctx.responseSkills[i], {
+            delayMs: 100
+          });
         }
-        event.replyText(StreamFlag.IN_PROGRESS, {
-          bizType: ReceivedTextPacketType.SKILL,
-          eof: ReceivedTextPacketEof.END,
-          bizId,
-          data: skill
-        });
       }
     }
-    event.replyText(StreamFlag.END);
-    await mock.sleep(500);
-    if (event.controller.signal.aborted || session.closed) {
+    if (streamEnded || !isEventActive()) {
       return;
     }
-    event.replyEvent(EventType.EVENT_END);
-    session.currentEvent = null;
+    await finishEvent(500);
   })();
 });
 mock.hooks.hook('sendEventPayloadEnd', async context => {
-  getSession(context.options.sessionId, context.options.eventId);
+  const map = mock.data.get('sessionMap');
+  const session = map.get(context.options.sessionId);
+  if (!session || !session.currentEvent || session.currentEvent.eventId !== context.options.eventId) {
+    context.result = true;
+    return;
+  }
   context.result = true;
   await mock.sleep(100);
 });
 mock.hooks.hook('sendEventChatBreak', async context => {
-  const session = getSession(context.options.sessionId, context.options.eventId);
+  const map = mock.data.get('sessionMap');
+  const session = map.get(context.options.sessionId);
+  if (!(session !== null && session !== void 0 && session.currentEvent) || session.currentEvent.eventId !== context.options.eventId) {
+    context.result = true;
+    return;
+  }
+  session.currentEvent.rejectMcpResponse(new Error('sendEventChatBreak'));
   session.currentEvent.controller.abort(new Error('sendEventChatBreak'));
   session.currentEvent = null;
   context.result = true;
 });
+mock.hooks.hook('sendEvent', async context => {
+  var _context$options;
+  if (((_context$options = context.options) === null || _context$options === void 0 ? void 0 : _context$options.eventType) !== EventType.MCP_CMD) {
+    context.result = true;
+    return;
+  }
+  const session = getSession(context.options.sessionId);
+  if (session.currentEvent && session.currentEvent.eventId === context.options.eventId) {
+    session.currentEvent.resolveMcpResponse(context.options.payload);
+  } else {
+    const sentEvents = mock.data.get('sentEvents') || [];
+    sentEvents.push({
+      sessionId: context.options.sessionId,
+      eventId: context.options.eventId,
+      eventType: context.options.eventType,
+      payload: context.options.payload
+    });
+    mock.data.set('sentEvents', sentEvents);
+  }
+  context.result = true;
+});
 mock.hooks.hook('startRecordAndSendAudioData', async context => {
   const session = getSession(context.options.sessionId);
   if (!session.currentEvent) {
@@ -584,10 +790,10 @@ mock.hooks.hook('queryRecordList', context => {
 mock.hooks.hook('deleteRecordList', context => {
   const options = context.options;
   const records = filterRecords(options);
-  records.map(_ref => {
+  records.map(_ref2 => {
     let {
       id
-    } = _ref;
+    } = _ref2;
     return mock.deleteRecord(id);
   });
   context.result = true;

package/dist/utils/errors.js

@@ -96,9 +96,11 @@ export async function tryCatchTTT(fn) {
       code,
       message
     } = error;
-    message = "".concat(message, " (original_code: ").concat(code || '-', ")");
+    const originalCode = code;
+    message = "".concat(message, " (original_code: ").concat(originalCode || '-', ")");
     code = transformErrorCode(code);
     const e = removeTopStackFrame(new AIStreamError(message, code));
+    e.originalCode = originalCode;
     return [e, null];
   }
   return [null, result];

package/dist/utils/mock.d.ts

@@ -16,6 +16,20 @@ export interface SendToAIStreamContext {
     responseText: string | undefined;
     wordDelayMs: number;
     responseSkills?: ReceivedTextSkillPacketBody[];
+    writeText: (text: string, options?: {
+        delayMs?: number;
+        wordDelayMs?: number;
+    }) => Promise<void>;
+    writeSkill: (skill: ReceivedTextSkillPacketBody, options?: {
+        delayMs?: number;
+    }) => Promise<void>;
+    end: (options?: {
+        delayMs?: number;
+    }) => Promise<void>;
+    callMCPTool: (toolName: string, params?: Record<string, any>, options?: {
+        delayMs?: number;
+        waitResponse?: boolean;
+    }) => Promise<any>;
 }
 interface AsrDetectionContext {
     responseText: string | undefined;
@@ -40,9 +54,9 @@ declare const mock: {
     emitter: Emitter;
     hooks: import("hookable").Hookable<MockHooks, string>;
     getRecords: <T = any>() => Row<T>[];
-    getRecord: <T_1 = any>(id: number) => Row<T_1> | undefined;
-    setRecord: <T_2 = any>(entry: Row<T_2>) => void;
-    updateRecord: <T_3 = any>(entry: Row<T_3>) => void;
+    getRecord: <T = any>(id: number) => Row<T> | undefined;
+    setRecord: <T = any>(entry: Row<T>) => void;
+    updateRecord: <T = any>(entry: Row<T>) => void;
     deleteRecord: (id: number) => void;
     clearRecords: () => void;
     getId: () => number;

package/dist/utils/object.d.ts

@@ -5,4 +5,3 @@ export interface Resolvable<T = void> {
     state: 'pending' | 'fulfilled' | 'rejected';
 }
 export declare const createResolvable: <T = void>() => Resolvable<T>;
-export declare function deepMerge(target: any, source: any): any;

package/dist/utils/object.js

@@ -22,27 +22,4 @@ export const createResolvable = () => {
     };
   });
   return ret;
-};
-export function deepMerge(target, source) {
-  if (typeof target !== 'object' || target === null) {
-    return source; // 如果目标不是对象，直接返回来源
-  }
-  if (typeof source !== 'object' || source === null) {
-    return target; // 如果来源不是对象，返回目标
-  }
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const sourceValue = source[key];
-      const targetValue = target[key];
-
-      // 如果是对象，递归合并
-      if (typeof sourceValue === 'object' && sourceValue !== null) {
-        target[key] = deepMerge(Array.isArray(targetValue) ? [] : targetValue || {}, sourceValue);
-      } else {
-        // 否则直接赋值
-        target[key] = sourceValue;
-      }
-    }
-  }
-  return target;
-}
+};

package/dist/utils/observer.d.ts

@@ -1,4 +1,4 @@
-import { AudioBody, ConnectStateBody, EventBody, FileBody, ImageBody, SessionStateBody, TextBody, VideoBody } from '../AIStreamTypes';
+import { AudioBody, ConnectStateBody, EventBody, FileBody, ImageBody, SessionEventBody, SessionStateBody, TextBody, VideoBody } from '../AIStreamTypes';
 export type AIStreamDataEntry = {
     type: 'text';
     body: TextBody;
@@ -23,10 +23,14 @@ export type AIStreamDataEntry = {
 } | {
     type: 'sessionState';
     body: SessionStateBody;
+} | {
+    type: 'sessionEvent';
+    body: SessionEventBody;
 };
 export interface AIStreamObserverOptions {
-    sessionState?: boolean;
     connectionState?: boolean;
+    sessionState?: boolean;
+    sessionEvent?: boolean;
     event?: boolean;
     text?: boolean;
     audio?: boolean;

package/dist/utils/observer.js

@@ -5,7 +5,7 @@ import "core-js/modules/web.dom-collections.iterator.js";
 import { ConnectState, EventType, SessionState, StreamFlag } from '../AIStreamTypes';
 import { listenAudioReceived, listenConnectStateChanged, listenEventReceived, listenImageReceived, listenSessionStateChanged, listenTextReceived } from './ttt';
 import logger from './logger';
-const types = ['connectionState', 'sessionState', 'event', 'text', 'audio', 'video', 'file', 'image'];
+const types = ['connectionState', 'sessionState', 'sessionEvent', 'event', 'text', 'audio', 'video', 'file', 'image'];
 export class AIStreamObserverPool {
   constructor() {
     _defineProperty(this, "isStarted", false);
@@ -13,6 +13,7 @@ export class AIStreamObserverPool {
     this.observerMap = {
       connectionState: new Set(),
       sessionState: new Set(),
+      sessionEvent: new Set(),
       event: new Set(),
       text: new Set(),
       audio: new Set(),
@@ -33,7 +34,7 @@ export class AIStreamObserverPool {
         state = "".concat(ConnectState[entry.body.connectState], " ").concat(entry.body.code || '');
       } else if (entry.type === 'sessionState') {
         state = "".concat(SessionState[entry.body.sessionState], " ").concat(entry.body.code || '');
-      } else if (entry.type === 'event') {
+      } else if (entry.type === 'event' || entry.type === 'sessionEvent') {
         state = "".concat(EventType[entry.body.eventType]);
       } else if ((_entry$body = entry.body) !== null && _entry$body !== void 0 && _entry$body.streamFlag) {
         state = "".concat(StreamFlag[entry.body.streamFlag]);
@@ -66,10 +67,19 @@ export class AIStreamObserverPool {
     })), listenSessionStateChanged(body => handle({
       type: 'sessionState',
       body
-    })), listenEventReceived(body => handle({
-      type: 'event',
-      body
-    })), listenTextReceived(body => handle({
+    })), listenEventReceived(body => {
+      if (body.eventType === EventType.MCP_CMD) {
+        handle({
+          type: 'sessionEvent',
+          body
+        });
+      } else {
+        handle({
+          type: 'event',
+          body
+        });
+      }
+    }), listenTextReceived(body => handle({
       type: 'text',
       body
     })), listenAudioReceived(body => handle({
@@ -91,6 +101,7 @@ export class AIStreamObserverPool {
     this.observerMap = {
       connectionState: new Set(),
       sessionState: new Set(),
+      sessionEvent: new Set(),
       event: new Set(),
       text: new Set(),
       audio: new Set(),

package/dist/utils/promisify.d.ts

@@ -13,6 +13,6 @@ interface AsyncTTTFnParams<P> {
 }
 export declare const getEnableMock: () => boolean;
 export declare const setEnableMock: (enable: boolean) => boolean;
-export declare function promisify<T extends AsyncTTTFnParams<any>>(fn: (options: any) => void, enableMock?: boolean): (options?: Omit<T, 'success' | 'fail'>) => Promise<Parameters<NonNullable<T["success"]>>[0]>;
+export declare function promisify<T extends AsyncTTTFnParams<any>>(fn: (options: any) => void, enableMock?: boolean): (options?: Omit<T, "success" | "fail">) => Promise<Parameters<NonNullable<T["success"]>>[0]>;
 export declare function listening<T>(on: (listener: (params: T) => void) => void, off: (listener: (params: T) => void) => void, enableMock?: boolean): (listener: (params: T) => void) => () => void;
 export {};