@ray-js/t-agent-plugin-aistream 0.2.8-beta.1 → 0.2.8-beta.3

package/dist/utils/defaultMock.js

@@ -9,7 +9,7 @@ import "core-js/modules/esnext.iterator.map.js";
 import "core-js/modules/web.dom-collections.iterator.js";
 import { mock } from './mock';
 import { EmitterEvent, generateId, safeParseJSON } from '@ray-js/t-agent';
-import { AIStreamAppErrorCode, AIStreamServerErrorCode, BizCode, ConnectState, EventType, NetworkType, ReceivedTextPacketEof, ReceivedTextPacketType, SessionState, StreamFlag } from '../AIStreamTypes';
+import { AIStreamAppErrorCode, AIStreamServerErrorCode, AudioPlayChangedState, BizCode, ConnectState, EventType, NetworkType, ReceivedTextPacketEof, ReceivedTextPacketType, SessionState, StreamFlag } from '../AIStreamTypes';
 import AbortController from './abort';
 import { tryCatch } from './misc';
 import { TTTError } from './errors';
@@ -309,6 +309,40 @@ mock.hooks.hook('unregisterVoiceAmplitudes', context => {
   mock.data.delete('recordAmplitudesCount');
   context.result = true;
 });
+
+// 模拟 TTS 音频播放：开始时下发 START，3 秒后下发 COMPLETED。
+mock.hooks.hook('startPlayAudio', context => {
+  var _context$options;
+  const path = ((_context$options = context.options) === null || _context$options === void 0 ? void 0 : _context$options.path) || '';
+
+  // 用播放 id 标记本次播放，被主动停止或被新的播放替换时即失效（同一时刻只播一条）
+  const playId = generateId();
+  mock.data.set('audioPlayId', playId);
+  dispatch('onAudioPlayChanged', {
+    path,
+    state: AudioPlayChangedState.START
+  });
+  context.result = true;
+
+  // 模拟 3 秒播放时长，结束后下发 COMPLETED（不阻塞 startPlayAudio 的返回）
+
+  (async () => {
+    await mock.sleep(3000);
+    if (mock.data.get('audioPlayId') !== playId) {
+      return;
+    }
+    mock.data.delete('audioPlayId');
+    dispatch('onAudioPlayChanged', {
+      path,
+      state: AudioPlayChangedState.COMPLETED
+    });
+  })();
+});
+mock.hooks.hook('stopPlayAudio', context => {
+  // 主动停止：让当前播放失效，不再下发 COMPLETED（与真实主动停止一致）
+  mock.data.delete('audioPlayId');
+  context.result = true;
+});
 mock.hooks.hook('sendEventEnd', async context => {
   const map = mock.data.get('sessionMap');
   const session = map.get(context.options.sessionId);
@@ -430,6 +464,43 @@ mock.hooks.hook('sendEventEnd', async context => {
           data: skill
         });
       },
+      writeAudio: async (audio, options) => {
+        if (!audio) {
+          return;
+        }
+        if (options !== null && options !== void 0 && options.delayMs) {
+          await mock.sleep(options.delayMs);
+        }
+        if (!isEventActive()) {
+          return;
+        }
+        hasStreamedResponse = true;
+
+        // START 包：携带完整格式头
+        dispatch('onAudioReceived', {
+          dataChannel: 'audio',
+          sessionIdList: [session.sessionId],
+          streamFlag: StreamFlag.START,
+          path: audio.path,
+          pts: audio.pts,
+          codecType: audio.codecType,
+          sampleRate: audio.sampleRate,
+          channels: audio.channels,
+          bitDepth: audio.bitDepth
+        });
+        if (!isEventActive()) {
+          return;
+        }
+
+        // END 包：只带最终 path/pts，不再携带格式头（与真实协议一致）
+        dispatch('onAudioReceived', {
+          dataChannel: 'audio',
+          sessionIdList: [session.sessionId],
+          streamFlag: StreamFlag.END,
+          path: audio.path,
+          pts: audio.pts
+        });
+      },
       end: async options => {
         await finishEvent((options === null || options === void 0 ? void 0 : options.delayMs) || 0);
       },
@@ -532,6 +603,22 @@ mock.hooks.hook('sendEventEnd', async context => {
       await ctx.writeText(text, {
         wordDelayMs: ctx.wordDelayMs
       });
+
+      // 开启 TTS 时，模拟下发一段 TTS 音频包，与真实协议保持一致
+      if (session.tokenConfig.needTts) {
+        await ctx.writeAudio({
+          path: "/mock/tts-".concat(generateId(), ".mp3"),
+          codecType: 109,
+          // MP3
+          sampleRate: 16000,
+          channels: 0,
+          // 单声道
+          bitDepth: 16,
+          pts: 0
+        }, {
+          delayMs: 100
+        });
+      }
       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], {
@@ -569,8 +656,8 @@ mock.hooks.hook('sendEventChatBreak', async context => {
   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) {
+  var _context$options2;
+  if (((_context$options2 = context.options) === null || _context$options2 === void 0 ? void 0 : _context$options2.eventType) !== EventType.MCP_CMD) {
     context.result = true;
     return;
   }

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

@@ -23,6 +23,21 @@ export interface SendToAIStreamContext {
     writeSkill: (skill: ReceivedTextSkillPacketBody, options?: {
         delayMs?: number;
     }) => Promise<void>;
+    /**
+     * 模拟一段流式音频（TTS）下发。
+     * 真实协议里格式头（codecType/sampleRate/channels/bitDepth）只在 START 包携带，
+     * END 包通常只带最终 path/pts，这里据实模拟，分两包下发。
+     */
+    writeAudio: (audio: {
+        path: string;
+        codecType?: number;
+        sampleRate?: number;
+        channels?: number;
+        bitDepth?: number;
+        pts?: number;
+    }, options?: {
+        delayMs?: number;
+    }) => Promise<void>;
     end: (options?: {
         delayMs?: number;
     }) => Promise<void>;
@@ -54,9 +69,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/observer.d.ts

@@ -45,6 +45,12 @@ export declare class AIStreamObserverPool {
     private observerMap;
     constructor();
     private cancels;
+    private createObserverMap;
+    private isSessionAwareType;
+    private getEntrySessionIds;
+    private collectObservers;
+    private addObserver;
+    private removeObserver;
     start(): void;
     dispose(): void;
     connect(observer: AIStreamObserver): void;

package/dist/utils/observer.js

@@ -10,25 +10,102 @@ export class AIStreamObserverPool {
   constructor() {
     _defineProperty(this, "isStarted", false);
     _defineProperty(this, "cancels", []);
-    this.observerMap = {
-      connectionState: new Set(),
-      sessionState: new Set(),
-      sessionEvent: new Set(),
-      event: new Set(),
-      text: new Set(),
-      audio: new Set(),
-      video: new Set(),
-      file: new Set(),
-      image: new Set()
+    this.observerMap = this.createObserverMap();
+  }
+  createObserverMap() {
+    return {
+      connectionState: {
+        all: new Set(),
+        bySessionId: new Map()
+      },
+      sessionState: {
+        all: new Set(),
+        bySessionId: new Map()
+      },
+      sessionEvent: {
+        all: new Set(),
+        bySessionId: new Map()
+      },
+      event: {
+        all: new Set(),
+        bySessionId: new Map()
+      },
+      text: {
+        all: new Set(),
+        bySessionId: new Map()
+      },
+      audio: {
+        all: new Set(),
+        bySessionId: new Map()
+      },
+      video: {
+        all: new Set(),
+        bySessionId: new Map()
+      },
+      file: {
+        all: new Set(),
+        bySessionId: new Map()
+      },
+      image: {
+        all: new Set(),
+        bySessionId: new Map()
+      }
     };
   }
+  isSessionAwareType(type) {
+    return type !== 'connectionState';
+  }
+  getEntrySessionIds(entry) {
+    if (entry.type === 'event' || entry.type === 'sessionEvent' || entry.type === 'sessionState') {
+      return entry.body.sessionId ? [entry.body.sessionId] : [];
+    }
+    if (entry.type === 'text' || entry.type === 'audio' || entry.type === 'video' || entry.type === 'file' || entry.type === 'image') {
+      return entry.body.sessionIdList || [];
+    }
+    return [];
+  }
+  collectObservers(entry) {
+    const bucket = this.observerMap[entry.type];
+    const observers = new Set(bucket.all);
+    this.getEntrySessionIds(entry).forEach(sessionId => {
+      const sessionObservers = bucket.bySessionId.get(sessionId);
+      sessionObservers === null || sessionObservers === void 0 || sessionObservers.forEach(observer => {
+        observers.add(observer);
+      });
+    });
+    return observers;
+  }
+  addObserver(type, observer) {
+    const sessionId = observer.options.sessionId;
+    const bucket = this.observerMap[type];
+    if (!sessionId || !this.isSessionAwareType(type)) {
+      bucket.all.add(observer);
+      return;
+    }
+    let sessionObservers = bucket.bySessionId.get(sessionId);
+    if (!sessionObservers) {
+      sessionObservers = new Set();
+      bucket.bySessionId.set(sessionId, sessionObservers);
+    }
+    sessionObservers.add(observer);
+  }
+  removeObserver(type, observer) {
+    const bucket = this.observerMap[type];
+    bucket.all.delete(observer);
+    bucket.bySessionId.forEach((sessionObservers, sessionId) => {
+      sessionObservers.delete(observer);
+      if (sessionObservers.size === 0) {
+        bucket.bySessionId.delete(sessionId);
+      }
+    });
+  }
   start() {
     if (this.isStarted) {
       return;
     }
     const handle = entry => {
       var _entry$body;
-      const observers = this.observerMap[entry.type];
+      const observers = this.collectObservers(entry);
       let state = '';
       if (entry.type === 'connectionState') {
         state = "".concat(ConnectState[entry.body.connectState], " ").concat(entry.body.code || '');
@@ -47,18 +124,19 @@ export class AIStreamObserverPool {
             sessionId
           } = observer.options;
           let matched = true;
+          const sessionIdList = entry.body.sessionIdList || [];
           if (dataChannels !== null && dataChannels !== void 0 && dataChannels.length && !dataChannels.includes(entry.body.dataChannel)) {
             matched = false;
           }
-          if (sessionId && !entry.body.sessionIdList.includes(sessionId)) {
+          if (sessionId && !sessionIdList.includes(sessionId)) {
             matched = false;
           }
           if (matched) {
             observer.callback(entry, observer);
           }
-        } else {
+        } else if (!((entry.type === 'event' || entry.type === 'sessionEvent' || entry.type === 'sessionState') && observer.options.sessionId && observer.options.sessionId !== entry.body.sessionId)) {
           observer.callback(entry, observer);
-        }
+        } // noop
       });
     };
     this.cancels = [listenConnectStateChanged(body => handle({
@@ -98,36 +176,26 @@ export class AIStreamObserverPool {
     this.isStarted = false;
     this.cancels.forEach(cancel => cancel());
     this.cancels = [];
-    this.observerMap = {
-      connectionState: new Set(),
-      sessionState: new Set(),
-      sessionEvent: new Set(),
-      event: new Set(),
-      text: new Set(),
-      audio: new Set(),
-      video: new Set(),
-      file: new Set(),
-      image: new Set()
-    };
+    this.observerMap = this.createObserverMap();
   }
   connect(observer) {
     if (!this.isStarted) {
       this.start();
     }
-    types.forEach(key => {
-      const type = key;
+    types.forEach(type => {
       if (observer.options[type]) {
-        this.observerMap[type].add(observer);
+        this.addObserver(type, observer);
       }
     });
   }
   disconnect(observer) {
-    types.forEach(key => {
-      this.observerMap[key].delete(observer);
+    types.forEach(type => {
+      this.removeObserver(type, observer);
     });
     let empty = true;
-    types.forEach(key => {
-      if (this.observerMap[key].size > 0) {
+    types.forEach(type => {
+      const bucket = this.observerMap[type];
+      if (bucket.all.size > 0 || bucket.bySessionId.size > 0) {
         empty = false;
       }
     });

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 {};

package/dist/utils/sendMessage.d.ts

@@ -6,7 +6,6 @@ export interface SendBlocksToAIStreamParams {
     blocks: InputBlock[];
     session: AIStreamSession;
     signal?: AbortSignalObject;
-    enableTts?: boolean;
     eventIdPrefix?: string;
     getUserData: () => Promise<AIStreamUserData>;
 }

package/dist/utils/sendMessage.js

@@ -65,8 +65,10 @@ export function sendBlocksToAIStream(params) {
         if (!closed) {
           logger.debug('sendBlocksToAIStream close');
           closed = true;
-          if (!canceled && !(signal !== null && signal !== void 0 && signal.aborted)) {
+          try {
             controller.close();
+          } catch (error) {
+            logger.debug('sendBlocksToAIStream close ignored', error);
           }
         }
       };
@@ -217,15 +219,17 @@ export function sendBlocksToAIStream(params) {
           if (!imageId) {
             imageId = generateId();
           }
+          const attachment = {
+            streamFlag: data.body.streamFlag,
+            path: data.body.path,
+            width: data.body.width,
+            height: data.body.height
+          };
           enqueue({
             id: imageId,
             type: 'attachment',
             attachmentType: 'image',
-            attachment: {
-              path: data.body.path || null,
-              width: data.body.width || null,
-              height: data.body.height || null
-            },
+            attachment: attachment,
             meta
           });
           if (data.body.streamFlag === StreamFlag.END) {
@@ -235,13 +239,20 @@ export function sendBlocksToAIStream(params) {
           if (!audioId) {
             audioId = generateId();
           }
+          const attachment = {
+            streamFlag: data.body.streamFlag,
+            path: data.body.path,
+            pts: data.body.pts,
+            codecType: data.body.codecType,
+            sampleRate: data.body.sampleRate,
+            channels: data.body.channels,
+            bitDepth: data.body.bitDepth
+          };
           enqueue({
             id: audioId,
             type: 'attachment',
             attachmentType: 'audio',
-            attachment: {
-              path: data.body.path || null
-            },
+            attachment,
             meta
           });
           if (data.body.streamFlag === StreamFlag.END) {
@@ -251,7 +262,7 @@ export function sendBlocksToAIStream(params) {
           if (data.body.sessionState === SessionState.CLOSED || data.body.sessionState === SessionState.CREATE_FAILED) {
             const msg = SessionState[data.body.sessionState];
             const e = new AIStreamError("Session Error: ".concat(msg, ", (original_code: ").concat(data.body.code, ")"), transformErrorCode(data.body.code));
-            emitError(error);
+            emitError(e);
             if (audioEmitter) {
               audioEmitter.dispatchEvent(new EmitterEvent('error', {
                 detail: e
@@ -262,7 +273,7 @@ export function sendBlocksToAIStream(params) {
         } else if (data.type === 'connectionState') {
           if (data.body.connectState === ConnectState.DISCONNECTED || data.body.connectState === ConnectState.CLOSED) {
             const e = new AIStreamError("Session disconnected, (original_code: ".concat(data.body.code, ")"), transformErrorCode(data.body.code));
-            emitError(error);
+            emitError(e);
             if (audioEmitter) {
               audioEmitter.dispatchEvent(new EmitterEvent('error', {
                 detail: e
@@ -303,14 +314,14 @@ export function sendBlocksToAIStream(params) {
         } else if (block.type === 'file_path') {
           event.write({
             type: 'file',
-            format: mimeTypeToFormatMap[block.file_url.mimeType] || 0,
+            format: mimeTypeToFormatMap[block.file_path.mimeType] || 0,
             path: block.file_path.path
           }).catch(emitError);
         } else if (block.type === 'video_path') {
           event.write({
             type: 'file',
             format: FileFormat.MP4,
-            path: block.file_path.path
+            path: block.video_path.path
           }).catch(emitError);
         }
       }
@@ -378,6 +389,8 @@ export function sendBlocksToAIStream(params) {
     }
   });
   return {
+    // web-streams-polyfill's ReadableStream is runtime-compatible but its
+    // getReader() overloads differ from lib.dom's, so cast to satisfy the type.
     response: new StreamResponse(stream),
     metaPromise
   };

package/dist/utils/ttt.d.ts

@@ -36,11 +36,11 @@ export declare const getAppInfo: (options?: Omit<GetAppInfoParams, "success" | "
     regionCode: string;
     appName: string;
     appIcon: string;
-    appEnv?: number | undefined;
+    appEnv?: number;
     appBundleId: string;
     appScheme: string;
     appId: string;
-    clientId?: string | undefined;
+    clientId?: string;
 }>;
 export declare const canIUseRouter: (options?: Omit<CanIUseRouterParams, "success" | "fail"> | undefined) => Promise<{
     result: boolean;
@@ -57,7 +57,7 @@ export declare const openMiniWidget: (options?: Omit<OpenMiniWidgetParams, "succ
 export declare const isConnected: (options?: Omit<IsConnectedParams, "success" | "fail"> | undefined) => Promise<{
     connected: boolean;
     state: number;
-    connectionId?: string | undefined;
+    connectionId?: string;
 }>;
 export declare const connect: (options?: Omit<ConnectParams, "success" | "fail"> | undefined) => Promise<{
     connectionId: string;
@@ -66,12 +66,13 @@ export declare const disconnect: (options?: Omit<DisconnectParams, "success" | "
 export declare const queryAgentToken: (options?: Omit<QueryAgentTokenParams, "success" | "fail"> | undefined) => Promise<{
     agentToken: string;
     bizConfig: import("../AIStreamTypes").BizConfig;
-    extParams?: string | undefined;
+    extParams?: string;
 }>;
 export declare const createSession: (options?: Omit<CreateSessionParams, "success" | "fail"> | undefined) => Promise<{
     sessionId: string;
     sendDataChannels: string[];
     revDataChannels: string[];
+    baseCacheDir: string;
 }>;
 export declare const closeSession: (options?: Omit<CloseSessionParams, "success" | "fail"> | undefined) => Promise<null>;
 export declare const sendEventStart: (options?: Omit<SendEventStartParams, "success" | "fail"> | undefined) => Promise<{

package/dist/utils/ttt.js

@@ -42,6 +42,8 @@ export const sendEventStart = promisify(ty.aistream.sendEventStart, true);
 export const sendEventPayloadEnd = promisify(ty.aistream.sendEventPayloadEnd, true);
 export const sendEventEnd = promisify(ty.aistream.sendEventEnd, true);
 export const sendEventChatBreak = promisify(ty.aistream.sendEventChatBreak, true);
+
+// @ts-ignore
 export const sendEventToAIStream = promisify(ty.aistream.sendEvent, true);
 export const startRecordAndSendAudioData = promisify(ty.aistream.startRecordAndSendAudioData, true);
 export const stopRecordAndSendAudioData = promisify(ty.aistream.stopRecordAndSendAudioData, true);

package/dist/withAIStream.d.ts

@@ -1,4 +1,4 @@
-import { AbortSignalObject, ChatAgent, ChatCardObject, ChatMessage, ChatMessageStatus, ChatTile, GetChatPluginHandler, InputBlock } from '@ray-js/t-agent';
+import { AbortSignalObject, AttachmentPart, ChatAgent, ChatCardObject, ChatMessage, ChatMessageStatus, ChatTile, GetChatPluginHandler, InputBlock } from '@ray-js/t-agent';
 import { TTTAction } from './utils';
 import { AIStreamUserData, ConnectClientType, ReceivedTextSkillPacketBody, SendAIStreamEventParams, SessionEventBody } from './AIStreamTypes';
 import { ChatHistoryStore, StoredMessageObject } from './ChatHistoryStore';
@@ -46,7 +46,13 @@ export interface AIStreamHooks {
     onTextCompose: (respMsg: ChatMessage, status: ChatMessageStatus, result: {
         text: string;
     }) => void;
-    onSkillCompose: (skill: ReceivedTextSkillPacketBody[], respMsg: ChatMessage, result: {
+    onSkillCompose: (skill: ReceivedTextSkillPacketBody, respMsg: ChatMessage, result: {
+        messages: ChatMessage[];
+    }) => void;
+    onAttachmentCompose: (part: AttachmentPart, respMsg: ChatMessage, result: {
+        messages: ChatMessage[];
+    }) => void;
+    onAttachmentsEnd: (parts: AttachmentPart[], respMsg: ChatMessage, result: {
         messages: ChatMessage[];
     }) => void;
     onSkillsEnd: (skills: ReceivedTextSkillPacketBody[], respMsg: ChatMessage, result: {
@@ -73,10 +79,10 @@ export declare function withAIStream(options?: AIStreamOptions): (agent: ChatAge
             metaPromise: Promise<Record<string, any>>;
         };
         chat: (blocks: InputBlock[], signal?: AbortSignalObject, options?: {
-            sendBy?: string | undefined;
-            responseBy?: string | undefined;
-            userData?: AIStreamUserData | undefined;
-        } | undefined) => Promise<ChatMessage[]>;
+            sendBy?: string;
+            responseBy?: string;
+            userData?: AIStreamUserData;
+        }) => Promise<ChatMessage[]>;
         options: AIStreamOptions;
         removeMessage: (message: ChatMessage) => Promise<void>;
         clearAllMessages: () => Promise<void>;
@@ -87,15 +93,17 @@ export declare function withAIStream(options?: AIStreamOptions): (agent: ChatAge
             thingjson?: any;
             data: string;
         }>;
-        onSkillCompose: (fn: AIStreamHooks['onSkillCompose']) => () => void;
-        onChatMessageSent: (fn: AIStreamHooks['onChatMessageSent']) => () => void;
-        onTextCompose: (fn: AIStreamHooks['onTextCompose']) => () => void;
-        onSkillsEnd: (fn: AIStreamHooks['onSkillsEnd']) => () => void;
-        onCardsReceived: (fn: AIStreamHooks['onCardsReceived']) => () => void;
-        onUserDataRead: (fn: AIStreamHooks['onUserDataRead']) => () => void;
-        onSessionEventReceived: (fn: AIStreamHooks['onSessionEventReceived']) => () => void;
+        onSkillCompose: (fn: AIStreamHooks["onSkillCompose"]) => () => void;
+        onChatMessageSent: (fn: AIStreamHooks["onChatMessageSent"]) => () => void;
+        onTextCompose: (fn: AIStreamHooks["onTextCompose"]) => () => void;
+        onSkillsEnd: (fn: AIStreamHooks["onSkillsEnd"]) => () => void;
+        onCardsReceived: (fn: AIStreamHooks["onCardsReceived"]) => () => void;
+        onUserDataRead: (fn: AIStreamHooks["onUserDataRead"]) => () => void;
+        onSessionEventReceived: (fn: AIStreamHooks["onSessionEventReceived"]) => () => void;
+        onAttachmentCompose: (fn: AIStreamHooks["onAttachmentCompose"]) => () => void;
+        onAttachmentsEnd: (fn: AIStreamHooks["onAttachmentsEnd"]) => () => void;
         sendEvent: (params: SendAIStreamEventParams) => Promise<null>;
-        onTTTAction: (fn: AIStreamHooks['onTTTAction']) => () => void;
+        onTTTAction: (fn: AIStreamHooks["onTTTAction"]) => () => void;
         getChatId: () => Promise<string>;
     };
 };