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

package/dist/AIStreamTypes.d.ts

@@ -692,18 +692,18 @@ export declare enum AIStreamErrorCode {
     ASR_EMPTY = "asr-empty"
 }
 export declare enum AIStreamAppErrorCode {
-    GENERIC_ERROR = 39001,
-    INVALID_PARAMS = 39002,
-    HTTP_REQUEST_FAILED = 39003,
-    CONNECTION_INVALID = 39004,
-    SESSION_ID_INVALID = 39005,
-    EVENT_ID_INVALID = 39006,
-    DATA_CHANNEL_NOT_FOUND = 39007,
-    INVALID_DATA_PACKET = 39008,
-    FILE_DATA_READ_ERROR = 39009,
-    DATA_SEND_FAILED = 39010,
-    CONNECTION_CLOSED_BY_REMOTE = 39012,
-    AUDIO_UNEXPECTEDLY_RESET = 39014,
+    GENERIC_ERROR = 39001,// 通用错误，用于一些杂项错误
+    INVALID_PARAMS = 39002,// 参数不合法，详见备注
+    HTTP_REQUEST_FAILED = 39003,// HTTP 请求失败
+    CONNECTION_INVALID = 39004,// Connection 未连接
+    SESSION_ID_INVALID = 39005,// SessionId 不存在
+    EVENT_ID_INVALID = 39006,// EventId 为空
+    DATA_CHANNEL_NOT_FOUND = 39007,// DataChannel 不存在
+    INVALID_DATA_PACKET = 39008,// 数据包不合法
+    FILE_DATA_READ_ERROR = 39009,// 文件数据读取异常
+    DATA_SEND_FAILED = 39010,// 发送数据失败
+    CONNECTION_CLOSED_BY_REMOTE = 39012,// Connection 被远端关闭
+    AUDIO_UNEXPECTEDLY_RESET = 39014,// 音频组件被重置
     RECONNECT = 39016
 }
 export declare enum AIStreamServerErrorCode {
@@ -846,7 +846,7 @@ export type AudioBody = {
     /** 接收数据通道 Code */
     dataChannel: string;
     /** 数据流类型: 0-仅一包, 1-传输开始, 2-传输中, 3-传输结束 */
-    streamFlag: number;
+    streamFlag: StreamFlag;
     /** 音频缓存路径 */
     path: string;
     /** SessionId 列表, 云端返回，可能为空 */
@@ -1031,7 +1031,7 @@ export type RecordAmplitudesBody = {
     amplitudes: number[];
 };
 export declare enum NetworkType {
-    NONE = "none",
+    NONE = "none",// 无网络
     CELL_2G = "2g",
     CELL_3G = "3g",
     CELL_4G = "4g",
@@ -1199,6 +1199,10 @@ export type CreateSessionParams = {
          * 音频视频图片文件都只有一路时，例如 bizCode 65537，接收只有 文本、音频 ["text", "audio"]
          */
         revDataChannels: string[];
+        /**
+         * 图片或文件的基本 url
+         */
+        baseCacheDir: string;
     }) => void;
     fail?: (params: {
         errorMsg: string;
@@ -1703,8 +1707,8 @@ export type InsertRecordParams = {
     complete?: () => void;
 };
 export declare enum ReceivedTextPacketType {
-    ASR = "ASR",
-    SKILL = "SKILL",
+    ASR = "ASR",// ASR 识别的文本
+    SKILL = "SKILL",// 数据
     NLG = "NLG"
 }
 export declare enum ReceivedTextPacketEof {
@@ -1731,7 +1735,7 @@ export type ReceivedTextNlgPacket = ReceivedTextPacketBase<ReceivedTextPacketTyp
     finish: boolean;
 }>;
 export declare enum BuildInSkillCode {
-    SEARCH_KNOWLEDGE = "searchKnowledge",
+    SEARCH_KNOWLEDGE = "searchKnowledge",// 知识库搜索
     SMART_HOME = "smart_home"
 }
 export type ReceivedTextSkillPacketBody<Code = BuildInSkillCode | string, G = any, C = any> = {
@@ -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

@@ -36,9 +36,9 @@ export interface AsrAgentOptions {
     eventIdPrefix?: string;
 }
 export declare enum AsrAgentStatus {
-    PENDING = "pending",
-    RECORDING = "recording",
-    ASR = "asr",
+    PENDING = "pending",// 等待开始
+    RECORDING = "recording",// 录音中
+    ASR = "asr",// ASR 处理中
     ABORTING = "aborting"
 }
 export declare class AsrAgent {
@@ -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;
@@ -347,8 +346,12 @@ export class AsrAgent {
     if (this.disposed) {
       return;
     }
+    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,148 @@ 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 状态。
+      //
+      // 注意：音频按流式分多包下发，格式头（codecType/sampleRate/channels/bitDepth）
+      // 只在 START 包里携带，END 包通常只带最终的 path/pts。因此不能只取 END 包，
+      // 需要按音频流 id（part.id 在同一段音频的所有分包间一致）聚合，
+      // 把 START 包的格式参数与 END 包的 path 合并后再建 tile，
+      // 否则持久化后点击播放时格式参数会全部丢失，只剩 path。
+      onAttachmentsEnd((parts, respMsg) => {
+        const audioMap = new Map();
+        parts.forEach(i => {
+          var _audio$path, _audio$pts, _audio$codecType, _audio$sampleRate, _audio$channels, _audio$bitDepth;
+          if (i.attachmentType !== 'audio') {
+            return;
+          }
+          const audio = i.attachment;
+          const entry = audioMap.get(i.id) || {
+            audio: {},
+            complete: false
+          };
+
+          // 合并各分包：后到的非空字段覆盖，空字段保留先前值（END 包不会用 undefined 覆盖掉格式参数）
+          entry.audio = {
+            path: (_audio$path = audio.path) !== null && _audio$path !== void 0 ? _audio$path : entry.audio.path,
+            pts: (_audio$pts = audio.pts) !== null && _audio$pts !== void 0 ? _audio$pts : entry.audio.pts,
+            codecType: (_audio$codecType = audio.codecType) !== null && _audio$codecType !== void 0 ? _audio$codecType : entry.audio.codecType,
+            sampleRate: (_audio$sampleRate = audio.sampleRate) !== null && _audio$sampleRate !== void 0 ? _audio$sampleRate : entry.audio.sampleRate,
+            channels: (_audio$channels = audio.channels) !== null && _audio$channels !== void 0 ? _audio$channels : entry.audio.channels,
+            bitDepth: (_audio$bitDepth = audio.bitDepth) !== null && _audio$bitDepth !== void 0 ? _audio$bitDepth : entry.audio.bitDepth
+          };
+          if (audio.streamFlag === StreamFlag.ONLY_ONE || audio.streamFlag === StreamFlag.END) {
+            entry.complete = true;
+            // END 包的 path 是最终完整文件，确保覆盖
+            if (audio.path) {
+              entry.audio.path = audio.path;
+            }
+          }
+          audioMap.set(i.id, entry);
+        });
+        audioMap.forEach(_ref => {
+          let {
+            audio,
+            complete
+          } = _ref;
+          if (complete) {
+            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/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

@@ -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,13 +76,14 @@ export declare class AIStreamSession {
     sessionId: string | null;
     sendDataChannels: string[];
     revDataChannels: string[];
+    baseCacheDir: string;
     disposed: boolean;
     private activeEvent?;
     private activeObserver?;
     private promise;
     tokenExtParamsResolvable: import("./object").Resolvable<{
         [key: string]: any;
-        chatId?: string | undefined;
+        chatId?: string;
     }>;
     private listeners;
     constructor(connection: AIStreamConnection, pool: AIStreamObserverPool, options: AIStreamSessionOptions);

package/dist/utils/AIStream.js

@@ -22,48 +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;
@@ -130,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) {
@@ -145,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());
@@ -248,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;
@@ -274,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++) {
@@ -287,7 +325,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);
@@ -302,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;
         }
@@ -396,6 +438,7 @@ export class AIStreamSession {
   cleanup() {
     logger.debug('AIStreamSession cleanup');
     this.cleanupEvent();
+    this.connection.unregisterSession(this);
     this.sessionId = null;
     this.sendDataChannels = [];
     this.revDataChannels = [];