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

package/dist/AIStreamTypes.d.ts

@@ -846,7 +846,7 @@ export type AudioBody = {
     /** 接收数据通道 Code */
     dataChannel: string;
     /** 数据流类型: 0-仅一包, 1-传输开始, 2-传输中, 3-传输结束 */
-    streamFlag: number;
+    streamFlag: StreamFlag;
     /** 音频缓存路径 */
     path: string;
     /** SessionId 列表, 云端返回，可能为空 */
@@ -1199,6 +1199,10 @@ export type CreateSessionParams = {
          * 音频视频图片文件都只有一路时，例如 bizCode 65537，接收只有 文本、音频 ["text", "audio"]
          */
         revDataChannels: string[];
+        /**
+         * 图片或文件的基本 url
+         */
+        baseCacheDir: string;
     }) => void;
     fail?: (params: {
         errorMsg: string;
@@ -1784,3 +1788,18 @@ export type ReceivedSmartHomeSkill = ReceivedTextSkillPacketBody<BuildInSkillCod
     };
     action: ReceivedSmartHomeSkillAction;
 }, any>;
+export type ReceivedAudioAttachment = {
+    streamFlag: StreamFlag;
+    path: string;
+    pts: number;
+    codecType: number;
+    sampleRate: number;
+    channels: number;
+    bitDepth: number;
+};
+export type ReceivedImageAttachment = {
+    streamFlag: StreamFlag;
+    path: string;
+    width: number;
+    height: number;
+};

package/dist/asr/AsrAgent.d.ts

@@ -73,5 +73,5 @@ export declare class AsrAgent {
     start(): Promise<void>;
     stop(): Promise<void>;
     abort(): Promise<void>;
-    dispose(): void;
+    dispose(): Promise<void>;
 }

package/dist/asr/AsrAgent.js

@@ -96,9 +96,8 @@ export class AsrAgent {
     return this.streamConn;
   }
   async createSession() {
-    var _this$activeSession;
-    // 如果有激活的 Session，直接返回
-    if ((_this$activeSession = this.activeSession) !== null && _this$activeSession !== void 0 && _this$activeSession.sessionId) {
+    // 连接断开后 sessionId 会被清空，但同一个 session 对象仍然可以重新 ensureSession。
+    if (this.activeSession && !this.activeSession.disposed) {
       return this.activeSession;
     }
     const {
@@ -339,7 +338,7 @@ export class AsrAgent {
     }
     return this._abort();
   }
-  dispose() {
+  async dispose() {
     if (this.recordDurationTimer) {
       clearTimeout(this.recordDurationTimer);
       this.recordDurationTimer = null;
@@ -349,7 +348,10 @@ export class AsrAgent {
     }
     this.disposed = true;
     if (this.activeSession) {
-      this.activeSession.close();
+      await this.activeSession.close();
+    }
+    if (this.streamConn) {
+      await this.streamConn.close();
     }
     this.audioStream = null;
     this.activeEvent = null;

package/dist/buildIn/withBuildIn.d.ts

@@ -1,5 +1,6 @@
 import { ChatAgent } from '@ray-js/t-agent';
 interface WithBuildInOptions {
+    audioAutoPlay?: boolean;
 }
 export declare function withBuildIn(options?: WithBuildInOptions): (_agent: ChatAgent) => {};
 export {};

package/dist/buildIn/withBuildIn.js

@@ -1,5 +1,12 @@
-import { BuildInSkillCode, ReceivedSmartHomeSkillAction } from '../AIStreamTypes';
-export function withBuildIn() {
+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 { AudioPlayChangedState, BuildInSkillCode, ReceivedSmartHomeSkillAction, StreamFlag } from '../AIStreamTypes';
+import { listenAudioPlayChanged, startPlayAudio, stopPlayAudio } from '../utils';
+
+/** 用于驱动 BubbleToolTile 播放的音频参数 */
+
+export function withBuildIn(options) {
   return _agent => {
     if (!_agent.plugins.aiStream || !_agent.plugins.ui) {
       throw new Error('withBuildIn must be used after withAIStream and withUI');
@@ -12,30 +19,18 @@ export function withBuildIn() {
       createMessage
     } = agent;
     const {
-      onSkillsEnd
+      onSkillsEnd,
+      onAttachmentsEnd,
+      onAttachmentCompose
     } = agent.plugins.aiStream;
-
-    // onAgentStart(async () => {
-    //   const agentId = session.get('AIStream.agentId');
-    //   if (agentId) {
-    //     const _conf = session.get('AIStream.projectConfig');
-    //     if (!_conf) {
-    //       try {
-    //         const config: Record<string, ProjectConfig> = (await getMiniAppConfig({})).config || {};
-    //         const projectConfig = config[agentId];
-    //         if (projectConfig) {
-    //           logger.debug('getMiniAppConfig projectConfig', {
-    //             agentId,
-    //             projectConfig,
-    //           });
-    //           await session.set('AIAssistant.projectConfig', projectConfig);
-    //         }
-    //       } catch (error) {
-    //         logger.warn('getMiniAppConfig error', error);
-    //       }
-    //     }
-    //   }
-    // });
+    onAgentStart(async () => {
+      // 是否开启自动播放
+      await session.set('AIStream.audioAutoPlay', (options === null || options === void 0 ? void 0 : options.audioAutoPlay) || false);
+      // 是否正在播放
+      await session.set('AIStream.audioPlaying', false);
+      // 正在播放的消息 id
+      await session.set('AIStream.playingMessageId', null);
+    });
 
     // 关联文档
 
@@ -155,6 +150,135 @@ export function withBuildIn() {
         }
       });
     })();
+    // 图片
+    (() => {
+      onAttachmentsEnd((parts, respMsg) => {
+        const streamSession = session.get('AIStream.streamSession');
+        const prefix = streamSession.baseCacheDir;
+        parts.forEach(i => {
+          if (i.attachmentType === 'image') {
+            const d = i.attachment;
+            if (d.streamFlag === StreamFlag.ONLY_ONE || d.streamFlag === StreamFlag.END) {
+              respMsg.addTile('image', {
+                src: "".concat(prefix).concat(d.path)
+              });
+            }
+          }
+        });
+      });
+    })();
+    // 语音
+    (() => {
+      // 当前正在播放的消息 id 保存在 session 中，保证同一时刻只播一条；
+      // 组件里的 playing 状态从 session 的 audioPlaying / playingMessageId 派生。
+      // playing 是纯运行时状态，不落到 tile.data（避免被持久化）。
+
+      const setPlayingMessage = async messageId => {
+        await session.set('AIStream.playingMessageId', messageId);
+        await session.set('AIStream.audioPlaying', !!messageId);
+      };
+      const playAudio = audio => {
+        return startPlayAudio({
+          path: audio.path,
+          codecType: audio.codecType,
+          sampleRate: audio.sampleRate,
+          channels: audio.channels,
+          bitDepth: audio.bitDepth,
+          pts: audio.pts
+        });
+      };
+      const stopCurrent = async () => {
+        if (!session.get('AIStream.playingMessageId')) {
+          return;
+        }
+        await stopPlayAudio();
+        await setPlayingMessage(null);
+      };
+
+      // 允许 UI 主动停止当前播放（如顶部“播放中”按钮）
+      agent.plugins.ui.onEvent('audioPlayStop', () => {
+        stopCurrent();
+      });
+      onAttachmentCompose((part, respMsg) => {
+        if (part.attachmentType === 'audio') {
+          const audio = part.attachment;
+          if (audio.streamFlag === StreamFlag.START) {
+            const audioAutoPlay = !!session.get('AIStream.audioAutoPlay');
+            if (audioAutoPlay) {
+              var _respMsg$id;
+              startPlayAudio(audio);
+              setPlayingMessage((_respMsg$id = respMsg === null || respMsg === void 0 ? void 0 : respMsg.id) !== null && _respMsg$id !== void 0 ? _respMsg$id : null);
+            }
+          }
+        }
+      });
+
+      // 音频包结束时，往气泡里插入一个语音播放按钮（BubbleToolTile）。
+      // 只持久化播放所需的音频参数，不含 playing 状态。
+      //
+      // 注意：音频按流式分多包下发，播放所需的完整参数（path + 格式头
+      // codecType/sampleRate/channels/bitDepth）只在首包（START/ONLY_ONE）携带；
+      // 后续 END 等包里这些字段是 0（而非 null/undefined），会污染数据。
+      // 因此只取每段音频的首包，丢弃后续包，按音频流 id（part.id 在同一段音频的
+      // 所有分包间一致）去重。
+      onAttachmentsEnd((parts, respMsg) => {
+        const audioMap = new Map();
+        parts.forEach(i => {
+          if (i.attachmentType !== 'audio') {
+            return;
+          }
+          const audio = i.attachment;
+
+          // 只接收首包，后续包直接丢弃
+          if (audio.streamFlag !== StreamFlag.START && audio.streamFlag !== StreamFlag.ONLY_ONE) {
+            return;
+          }
+          if (audioMap.has(i.id)) {
+            return;
+          }
+          audioMap.set(i.id, {
+            path: audio.path,
+            pts: audio.pts,
+            codecType: audio.codecType,
+            sampleRate: audio.sampleRate,
+            channels: audio.channels,
+            bitDepth: audio.bitDepth
+          });
+        });
+        audioMap.forEach(audio => {
+          respMsg.bubble.addTile('bubbleTool', {
+            audio
+          });
+        });
+      });
+
+      // 播放结束 / 异常时，复位全局播放态
+      listenAudioPlayChanged(body => {
+        if (body.state === AudioPlayChangedState.COMPLETED || body.state === AudioPlayChangedState.ERROR) {
+          setPlayingMessage(null);
+        }
+      });
+
+      // 处理 UI 发来的播放/停止指令
+      onTileEvent(async (tile, payload) => {
+        var _tile$data;
+        if (tile.type !== 'bubbleTool' || (payload === null || payload === void 0 ? void 0 : payload.action) !== 'toggle') {
+          return;
+        }
+        const audio = (_tile$data = tile.data) === null || _tile$data === void 0 ? void 0 : _tile$data.audio;
+        const messageId = tile.message.id;
+        const wasPlayingThis = session.get('AIStream.playingMessageId') === messageId;
+
+        // 先停掉当前正在播放的（无论是不是同一条）
+        await stopCurrent();
+
+        // 点击的是非播放态的按钮 -> 开始播放
+        if (!wasPlayingThis && audio) {
+          await playAudio(audio);
+          await setPlayingMessage(messageId);
+        }
+      });
+    })();
     return {};
   };
 }

package/dist/utils/AIStream.d.ts

@@ -12,19 +12,31 @@ export declare class AIStreamClient {
     pool: AIStreamObserverPool;
     private cached;
     getConnection(options: AIStreamConnectionOptions): AIStreamConnection;
+    releaseConnection(connection: AIStreamConnection): Promise<void>;
+    disposeIfIdle(connection: AIStreamConnection): Promise<void>;
 }
 export declare class AIStreamConnection {
     private readonly pool;
+    private readonly client;
+    readonly cacheKey: string;
     readonly options: AIStreamConnectionOptions;
     private connectionId;
     state: ConnectState;
-    private activeSessions;
+    refCount: number;
+    private allSessions;
+    private sessionsById;
     private promise;
     private observer;
-    constructor(pool: AIStreamObserverPool, options: AIStreamConnectionOptions);
+    constructor(pool: AIStreamObserverPool, client: AIStreamClient, cacheKey: string, options: AIStreamConnectionOptions);
+    retain(): void;
+    release(): void;
     _ensureConnected(): Promise<void>;
     private onStateChanged;
     private cleanup;
+    registerSession(session: AIStreamSession, sessionId: string): void;
+    unregisterSession(session: AIStreamSession): void;
+    hasActiveSessions(): boolean;
+    disposeTransport(): Promise<void>;
     createSession(options: AIStreamSessionOptions): AIStreamSession;
     closeSession(session: AIStreamSession): Promise<void>;
     close(): Promise<void>;
@@ -64,6 +76,7 @@ export declare class AIStreamSession {
     sessionId: string | null;
     sendDataChannels: string[];
     revDataChannels: string[];
+    baseCacheDir: string;
     disposed: boolean;
     private activeEvent?;
     private activeObserver?;

package/dist/utils/AIStream.js

@@ -22,49 +22,67 @@ export class AIStreamClient {
     const key = "".concat(options.clientType, "|").concat(options.deviceId || '');
     let connection = this.cached.get(key);
     if (!connection) {
-      connection = new AIStreamConnection(this.pool, options);
+      connection = new AIStreamConnection(this.pool, this, key, options);
       this.cached.set(key, connection);
     }
+    connection.retain();
     return connection;
   }
+  async releaseConnection(connection) {
+    connection.release();
+    await this.disposeIfIdle(connection);
+  }
+  async disposeIfIdle(connection) {
+    if (connection.refCount > 0 || connection.hasActiveSessions()) {
+      return;
+    }
+    const cached = this.cached.get(connection.cacheKey);
+    if (cached === connection) {
+      this.cached.delete(connection.cacheKey);
+    }
+    await connection.disposeTransport();
+  }
 }
 export class AIStreamConnection {
-  constructor(pool, options) {
+  constructor(pool, client, cacheKey, options) {
     _defineProperty(this, "connectionId", null);
     _defineProperty(this, "state", ConnectState.INIT);
-    _defineProperty(this, "activeSessions", new Set());
+    _defineProperty(this, "refCount", 0);
+    _defineProperty(this, "allSessions", new Set());
+    _defineProperty(this, "sessionsById", new Map());
     _defineProperty(this, "promise", null);
     _defineProperty(this, "observer", null);
     _defineProperty(this, "onStateChanged", entry => {
-      // 一个小程序只能启动一个 connection，所以这里不判断 id
       if (entry.type === 'connectionState') {
         this.state = entry.body.connectState;
-        this.activeSessions.forEach(session => {
-          if (session.sessionId) {
-            session._onStateChanged(entry);
-          }
+        this.allSessions.forEach(session => {
+          session._onStateChanged(entry);
         });
         if (entry.body.connectState === ConnectState.DISCONNECTED || entry.body.connectState === ConnectState.CLOSED || entry.body.connectState === ConnectState.CONNECTING || entry.body.connectState === ConnectState.AUTHORIZING) {
           // 断开事件触发时只做清理，因为连接已经关掉了
           this.cleanup();
         }
       } else if (entry.type === 'sessionState') {
-        this.activeSessions.forEach(session => {
-          if (session.sessionId && session.sessionId === entry.body.sessionId) {
-            session._onStateChanged(entry);
-          }
-        });
+        var _this$sessionsById$ge;
+        (_this$sessionsById$ge = this.sessionsById.get(entry.body.sessionId)) === null || _this$sessionsById$ge === void 0 || _this$sessionsById$ge._onStateChanged(entry);
       } else if (entry.type === 'sessionEvent') {
-        this.activeSessions.forEach(session => {
-          if (session.sessionId && session.sessionId === entry.body.sessionId) {
-            session._onSessionEvent(entry);
-          }
-        });
+        var _this$sessionsById$ge2;
+        (_this$sessionsById$ge2 = this.sessionsById.get(entry.body.sessionId)) === null || _this$sessionsById$ge2 === void 0 || _this$sessionsById$ge2._onSessionEvent(entry);
       }
     });
     this.pool = pool;
+    this.client = client;
+    this.cacheKey = cacheKey;
     this.options = options;
   }
+  retain() {
+    this.refCount += 1;
+  }
+  release() {
+    if (this.refCount > 0) {
+      this.refCount -= 1;
+    }
+  }
   _ensureConnected() {
     if (this.promise) {
       return this.promise;
@@ -131,12 +149,35 @@ export class AIStreamConnection {
     this.state = ConnectState.CLOSED;
     this.connectionId = null;
     this.promise = null;
-    this.activeSessions.forEach(s => s.cleanup());
-    // session 不清空，closeSession 被调用时才清空
+    this.sessionsById.clear();
+    this.allSessions.forEach(session => session.cleanup());
+  }
+  registerSession(session, sessionId) {
+    this.sessionsById.set(sessionId, session);
+  }
+  unregisterSession(session) {
+    if (session.sessionId) {
+      const current = this.sessionsById.get(session.sessionId);
+      if (current === session) {
+        this.sessionsById.delete(session.sessionId);
+      }
+    }
+  }
+  hasActiveSessions() {
+    return this.allSessions.size > 0;
+  }
+  async disposeTransport() {
+    const connectionId = this.connectionId;
+    this.cleanup();
+    if (connectionId && this.options.clientType === ConnectClientType.DEVICE) {
+      await disconnect({
+        connectionId
+      });
+    }
   }
   createSession(options) {
     const session = new AIStreamSession(this, this.pool, options);
-    this.activeSessions.add(session);
+    this.allSessions.add(session);
     return session;
   }
   async closeSession(session) {
@@ -146,28 +187,22 @@ export class AIStreamConnection {
         code: AIStreamServerErrorCode.OK
       });
     }
-    this.activeSessions.delete(session);
+    this.unregisterSession(session);
+    this.allSessions.delete(session);
+    await this.client.disposeIfIdle(this);
   }
-
-  // 断连
   async close() {
-    if (this.connectionId) {
-      // 只有设备端才需要断开连接，App 端由 App 来维持
-      if (this.options.clientType === ConnectClientType.DEVICE) {
-        await disconnect({
-          connectionId: this.connectionId
-        });
-      }
-      this.state = ConnectState.CLOSED;
-      this.cleanup();
-    }
+    await this.client.releaseConnection(this);
   }
 }
+// 这是为了防止代码扫描出来
+const prefix = 'https://';
 export class AIStreamSession {
   constructor(connection, pool, options) {
     _defineProperty(this, "sessionId", null);
     _defineProperty(this, "sendDataChannels", []);
     _defineProperty(this, "revDataChannels", []);
+    _defineProperty(this, "baseCacheDir", "".concat(prefix, "thing.miniapp.com/__tmp__/"));
     _defineProperty(this, "disposed", false);
     _defineProperty(this, "promise", null);
     _defineProperty(this, "tokenExtParamsResolvable", createResolvable());
@@ -249,15 +284,17 @@ export class AIStreamSession {
         var _await$this$tokenExtP;
         chatId = (_await$this$tokenExtP = await this.tokenExtParamsResolvable.promise) === null || _await$this$tokenExtP === void 0 ? void 0 : _await$this$tokenExtP.chatId;
       }
-      const options = _objectSpread(_objectSpread({
+      const options = {
         bizTag: BizTag.DEFAULT,
-        ownerId
-      }, this.options), {}, {
+        ownerId,
+        solutionCode: this.options.solutionCode,
+        api: this.options.api,
+        apiVersion: this.options.apiVersion,
         extParams: _objectSpread(_objectSpread({}, this.options.extParams), {}, {
           // chatId 之前可能是 undefined，这里要覆盖掉
           chatId
         })
-      });
+      };
       const [error, result] = await tryCatchTTT(() => queryAgentToken(options));
       if (error) {
         this.promise = null;
@@ -275,8 +312,8 @@ export class AIStreamSession {
         this.tokenExtParamsResolvable.resolve({});
       }
       let userData = {};
-      if (options.getSessionUserData) {
-        userData = await options.getSessionUserData();
+      if (this.options.getSessionUserData) {
+        userData = await this.options.getSessionUserData();
       }
       let finErr;
       for (let i = 0; i < 30; i++) {
@@ -303,6 +340,10 @@ export class AIStreamSession {
           this.sessionId = res.sessionId;
           this.sendDataChannels = res.sendDataChannels;
           this.revDataChannels = res.revDataChannels;
+          if (res.baseCacheDir) {
+            this.baseCacheDir = res.baseCacheDir;
+          }
+          this.connection.registerSession(this, res.sessionId);
           this.promise = null;
           return;
         }
@@ -397,6 +438,7 @@ export class AIStreamSession {
   cleanup() {
     logger.debug('AIStreamSession cleanup');
     this.cleanupEvent();
+    this.connection.unregisterSession(this);
     this.sessionId = null;
     this.sendDataChannels = [];
     this.revDataChannels = [];

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/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>;