@ray-js/t-agent-plugin-aistream 0.2.0-beta-17 → 0.2.0-beta.18

package/dist/utils/AIStream.js

@@ -1,17 +1,18 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const _excluded = ["signal"];
 import "core-js/modules/esnext.iterator.constructor.js";
 import "core-js/modules/esnext.iterator.find.js";
 import "core-js/modules/esnext.iterator.for-each.js";
 import "core-js/modules/esnext.iterator.map.js";
 import "core-js/modules/web.dom-collections.iterator.js";
-import { AIStreamErrorCode, BizTag, ConnectClientType, ConnectState, EventType, SessionState } from '../AIStreamTypes';
-import { closeSession, connect, createSession, disconnect, getCurrentHomeInfo, isConnected, queryAgentToken, registerRecordAmplitudes, sendEventChatBreak, sendEventEnd, sendEventPayloadEnd, sendEventStart, sendImageData, sendTextData, startRecordAndSendAudioData, stopRecordAndSendAudioData, unregisterVoiceAmplitudes } from './ttt';
+import { AIStreamAttributeType, AIStreamErrorCode, AIStreamServerErrorCode, BizTag, ConnectClientType, ConnectState, EventType, NetworkType, SessionState } from '../AIStreamTypes';
+import { closeSession, connect, createSession, disconnect, getCurrentHomeInfo, getNetworkType, isConnected, queryAgentToken, registerRecordAmplitudes, sendEventChatBreak, sendEventEnd, sendEventPayloadEnd, sendEventStart, sendImageData, sendTextData, startRecordAndSendAudioData, stopRecordAndSendAudioData, unregisterVoiceAmplitudes } from './ttt';
 import { AIStreamObserver, AIStreamObserverPool } from './observer';
 import { isAbortError } from '@ray-js/t-agent';
 import logger from './logger';
-import { AIStreamConnectionError, AIStreamEventError } from './errors';
-import { tryCatch } from './misc';
+import { AIStreamError, tryCatchTTT } from './errors';
 export class AIStreamClient {
   constructor() {
     _defineProperty(this, "pool", new AIStreamObserverPool());
@@ -72,12 +73,24 @@ export class AIStreamConnection {
       }
     };
     this.promise = (async () => {
+      // 检查网络状态
+      {
+        const [error, result] = await tryCatchTTT(() => getNetworkType());
+        if (error || (result === null || result === void 0 ? void 0 : result.networkType) === NetworkType.NONE) {
+          this.cleanup();
+          this.state = ConnectState.DISCONNECTED;
+          // 未连接网络
+          throw new AIStreamError('Network is offline', AIStreamErrorCode.NETWORK_OFFLINE);
+        }
+      }
+
       // 检查连接状态
       {
-        const [error, result] = await tryCatch(() => isConnected(this.options));
+        const [error, result] = await tryCatchTTT(() => isConnected(this.options));
         if (error) {
-          this.promise = null;
-          throw new AIStreamConnectionError(error.message, error.code || AIStreamErrorCode.AIStreamError);
+          this.cleanup();
+          this.state = ConnectState.DISCONNECTED;
+          throw error;
         }
         if (result.connected) {
           this.state = result.state;
@@ -89,10 +102,11 @@ export class AIStreamConnection {
 
       // 未连接的情况，调用 connect
       {
-        const [error, result] = await tryCatch(() => connect(this.options));
+        const [error, result] = await tryCatchTTT(() => connect(this.options));
         if (error) {
-          this.promise = null;
-          throw new AIStreamConnectionError(error.message, error.code || AIStreamErrorCode.AIStreamError);
+          this.cleanup();
+          this.state = ConnectState.DISCONNECTED;
+          throw error;
         }
         this.connectionId = result.connectionId;
         this.state = ConnectState.CONNECTED;
@@ -122,7 +136,7 @@ export class AIStreamConnection {
     if (session.sessionId && this.connectionId) {
       await closeSession({
         sessionId: session.sessionId,
-        code: AIStreamErrorCode.OK
+        code: AIStreamServerErrorCode.OK
       });
     }
     this.activeSessions.delete(session);
@@ -164,12 +178,27 @@ export class AIStreamSession {
       (_this$activeEvent2 = this.activeEvent) === null || _this$activeEvent2 === void 0 || _this$activeEvent2.emit('data', entry);
       if (entry.type === 'event' && entry.body.eventId === this.activeEvent.eventId) {
         const {
-          eventType
+          eventType,
+          userData
         } = entry.body;
         if (eventType === EventType.EVENT_END || eventType === EventType.CHAT_BREAK || eventType === EventType.ONE_SHOT) {
           var _this$activeEvent3;
           (_this$activeEvent3 = this.activeEvent) === null || _this$activeEvent3 === void 0 || _this$activeEvent3.emit('finish');
           this.cleanupEvent();
+        } else if (eventType === EventType.SERVER_ERROR) {
+          var _this$activeEvent4;
+          let code = '';
+          let message = '';
+          for (const item of userData) {
+            if (item.type === AIStreamAttributeType.ERROR_CODE) {
+              code = item.value;
+            } else if (item.type === AIStreamAttributeType.ERROR_MESSAGE) {
+              message = item.value;
+            }
+          }
+          const error = new AIStreamError(message || 'Event error occurred', code || AIStreamErrorCode.UNKNOWN_ERROR);
+          (_this$activeEvent4 = this.activeEvent) === null || _this$activeEvent4 === void 0 || _this$activeEvent4.emit('error', error);
+          this.cleanupEvent();
         }
       }
     });
@@ -187,58 +216,87 @@ export class AIStreamSession {
     this.promise = (async () => {
       try {
         await this.connection._ensureConnected();
-        let ownerId = this.options.ownerId;
-        if (!ownerId) {
-          if (this.connection.options.clientType === ConnectClientType.APP) {
+      } catch (e) {
+        this.promise = null;
+        throw e;
+      }
+      let ownerId = this.options.ownerId;
+      if (!ownerId) {
+        if (this.connection.options.clientType === ConnectClientType.APP) {
+          try {
             const {
               homeId
             } = await getCurrentHomeInfo();
             ownerId = homeId;
-          } else {
-            ownerId = this.connection.options.deviceId;
+          } catch (e) {
+            this.promise = null;
+            throw new AIStreamError('Cannot get current home info by getCurrentHomeInfo', AIStreamErrorCode.INVALID_PARAMS);
           }
-          this.options.ownerId = ownerId;
+        } else {
+          ownerId = this.connection.options.deviceId;
         }
-        const options = _objectSpread({
-          bizTag: BizTag.DEFAULT,
-          ownerId,
-          extParams: {}
-        }, this.options);
-        const {
-          agentToken,
-          bizConfig
-        } = await queryAgentToken(options);
-        const res = await createSession({
+        this.options.ownerId = ownerId;
+      }
+      const options = _objectSpread({
+        bizTag: BizTag.DEFAULT,
+        ownerId,
+        extParams: {}
+      }, this.options);
+      const [error, result] = await tryCatchTTT(() => queryAgentToken(options));
+      if (error) {
+        this.promise = null;
+        throw error;
+      }
+      const {
+        agentToken,
+        bizConfig
+      } = result;
+      {
+        const [err, res] = await tryCatchTTT(() => createSession({
           bizTag: options.bizTag,
           agentToken,
           bizConfig,
           userData: options.userData
-        });
+        }));
+        if (err) {
+          this.promise = null;
+          throw err;
+        }
         this.sessionId = res.sessionId;
         this.sendDataChannels = res.sendDataChannels;
         this.revDataChannels = res.revDataChannels;
-      } finally {
         this.promise = null;
       }
     })();
     return this.promise;
   }
   async startEvent() {
-    var _options$signal;
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     if (this.disposed) {
-      throw new AIStreamEventError('Event has been disposed', AIStreamErrorCode.AIStreamError);
+      throw new AIStreamError('Event has been disposed', AIStreamErrorCode.EVENT_DISPOSED);
     }
     if (this.activeEvent) {
-      throw new AIStreamEventError('Cannot start a new event while another is active', AIStreamErrorCode.AIStreamError);
+      throw new AIStreamError('Cannot start a new event while another is active', AIStreamErrorCode.EVENT_EXISTS);
     }
+    const {
+        signal
+      } = options,
+      rest = _objectWithoutProperties(options, _excluded);
     await this.ensureSession();
-    (_options$signal = options.signal) === null || _options$signal === void 0 || _options$signal.throwIfAborted();
+    if (signal !== null && signal !== void 0 && signal.aborted) {
+      const error = new AIStreamError('start event was aborted', AIStreamErrorCode.EVENT_ABORTED);
+      error.name = 'AbortError';
+      throw error;
+    }
+    const [error, result] = await tryCatchTTT(() => sendEventStart(_objectSpread({
+      sessionId: this.sessionId
+    }, rest)));
+    if (error) {
+      throw error;
+    }
     const {
       eventId
-    } = await sendEventStart(_objectSpread({
-      sessionId: this.sessionId
-    }, options));
+    } = result;
     this.activeEvent = new AIStreamEvent({
       eventId,
       sessionId: this.sessionId,
@@ -277,11 +335,11 @@ export class AIStreamSession {
     return this.activeEvent;
   }
   cleanupEvent() {
-    var _this$activeObserver, _this$activeEvent4;
+    var _this$activeObserver, _this$activeEvent5;
     logger.debug('AIStreamSession cleanupEvent');
     (_this$activeObserver = this.activeObserver) === null || _this$activeObserver === void 0 || _this$activeObserver.disconnect();
     this.activeObserver = null;
-    (_this$activeEvent4 = this.activeEvent) === null || _this$activeEvent4 === void 0 || _this$activeEvent4.emit('close');
+    (_this$activeEvent5 = this.activeEvent) === null || _this$activeEvent5 === void 0 || _this$activeEvent5.emit('close');
     this.activeEvent = null;
   }
   cleanup() {
@@ -318,13 +376,13 @@ export class AIStreamEvent {
   findFirstCode(type) {
     const code = this.sendDataChannels.find(code => code.startsWith(type));
     if (!code) {
-      throw new AIStreamEventError("No available data code for type: ".concat(type), AIStreamErrorCode.AIStreamError);
+      throw new AIStreamError("No available data code for type: ".concat(type), AIStreamErrorCode.EVENT_NO_DATA_CODE);
     }
     return code;
   }
   write(chunk) {
     if (this.closed) {
-      throw new AIStreamEventError('Cannot write to a closed event', AIStreamErrorCode.AIStreamError);
+      throw new AIStreamError('Cannot write to a closed event', AIStreamErrorCode.EVENT_CLOSED);
     }
     const dataChannel = chunk.dataChannel || this.findFirstCode(chunk.type);
     let promise = this.chains[dataChannel];
@@ -336,13 +394,17 @@ export class AIStreamEvent {
         return;
       }
       if (chunk.type === 'text') {
-        await sendTextData({
+        const [error] = await tryCatchTTT(() => sendTextData({
           sessionId: this.sessionId,
           text: chunk.text,
           dataChannel,
           userData: chunk.userData
-        });
+        }));
+        if (error) {
+          throw error;
+        }
       } else if (chunk.type === 'file') {
+        logger.warn('File data sending is not implemented yet');
         // await sendFileData({
         //   sessionId: this.sessionId,
         //   path: chunk.path,
@@ -351,11 +413,12 @@ export class AIStreamEvent {
         //   userData: chunk.userData,
         // });
       } else if (chunk.type === 'image') {
-        await sendImageData({
+        const [error] = await tryCatchTTT(() => sendImageData({
           sessionId: this.sessionId,
           path: chunk.path,
           userData: chunk.userData
-        });
+        }));
+        throw error;
       }
       sendEventPayloadEnd({
         eventId: this.eventId,
@@ -363,18 +426,19 @@ export class AIStreamEvent {
         dataChannel
       });
     }).catch(error => {
-      this.emit('error', error);
-      throw error;
+      const e = new AIStreamError(error.message, error.code || AIStreamErrorCode.EVENT_WRITE_FAILED);
+      this.emit('error', e);
+      throw e;
     });
     return this.chains[dataChannel];
   }
   stream(source) {
     if (this.closed) {
-      throw new AIStreamEventError('Cannot stream to a closed event', AIStreamErrorCode.AIStreamError);
+      throw new AIStreamError('Cannot stream to a closed event', AIStreamErrorCode.EVENT_CLOSED);
     }
     const dataChannel = source.dataChannel || this.findFirstCode(source.type);
     if (this.streams[dataChannel]) {
-      throw new AIStreamEventError("".concat(dataChannel, " stream already exists"), AIStreamErrorCode.AIStreamError);
+      throw new AIStreamError("".concat(dataChannel, " stream already exists"), AIStreamErrorCode.STREAM_EXISTS);
     }
     let startPromise = null;
     const stream = {
@@ -383,7 +447,7 @@ export class AIStreamEvent {
       started: false,
       start: async () => {
         if (this.closed) {
-          throw new AIStreamEventError('Cannot stream to a closed event', AIStreamErrorCode.AIStreamError);
+          throw new AIStreamError('Cannot stream to a closed event', AIStreamErrorCode.EVENT_CLOSED);
         }
         if (stream.started) {
           return;
@@ -416,11 +480,7 @@ export class AIStreamEvent {
         }
         // 一定要等录音开始，才能结束
         if (startPromise) {
-          try {
-            await startPromise;
-          } catch (e) {
-            // pass
-          }
+          await tryCatchTTT(() => startPromise);
           startPromise = null;
         }
         if (source.type === 'audio') {
@@ -435,6 +495,7 @@ export class AIStreamEvent {
             userData: source.userData
           });
         } else if (source.type === 'video') {
+          logger.warn('Video data sending is not implemented yet');
           // const cameraType = source.cameraType || VideoCameraType.BACK;
           // await stopRecordAndSendVideoData({
           //   dataChannel,
@@ -477,7 +538,7 @@ export class AIStreamEvent {
         userData: options === null || options === void 0 ? void 0 : options.userData
       });
     }
-    const error = new Error('This operation was aborted');
+    const error = new AIStreamError('This operation was aborted', AIStreamErrorCode.EVENT_ABORTED);
     error.name = 'AbortError';
     // 发送 break 后，stream 自动会关掉，在这里提前关闭
     Object.values(this.streams).forEach(s => {

package/dist/utils/createAsrAgent.d.ts

@@ -49,7 +49,7 @@ declare class AsrAgent {
  * @example
  * const asrAgent = createAsrAgent({
  *   agentId: 'asr-agent',
- *   tokenApi: 'm.thing.aigc.basic.server.token',
+ *   tokenApi: 'xxxx',
  *   tokenApiVersion: '1.0',
  *   clientType: ConnectClientType.APP,
  *   deviceId: 'deviceId',

package/dist/utils/createAsrAgent.js

@@ -2,7 +2,7 @@ import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import "core-js/modules/es.json.stringify.js";
 import { authorize } from './ttt';
 import { DEFAULT_TOKEN_API, DEFAULT_TOKEN_API_VERSION, globalAIStreamClient } from '../global';
-import { ConnectClientType, AIStreamAttributePayloadType, AIStreamAttributeType, AIStreamChatSysWorkflow } from '../AIStreamTypes';
+import { ConnectClientType, AIStreamAttributePayloadType, AIStreamAttributeType } from '../AIStreamTypes';
 import logger from './logger';
 class AsrAgent {
   constructor(options) {
@@ -51,7 +51,10 @@ class AsrAgent {
     const activeSession = streamConn.createSession({
       api: tokenApi || DEFAULT_TOKEN_API,
       apiVersion: tokenApiVersion || DEFAULT_TOKEN_API_VERSION,
-      solutionCode: agentId
+      solutionCode: agentId,
+      extParams: {
+        onlyAsr: true
+      }
     });
     this.activeSession = activeSession;
     return this.activeSession;
@@ -81,17 +84,15 @@ class AsrAgent {
       onFinish,
       onError
     } = this.options || {};
-    const activeSession = await this.createSession();
-    const attribute = {
-      'processing.interrupt': 'false',
-      'asr.enableVad': 'false',
-      'sys.workflow': AIStreamChatSysWorkflow.ASR
-    };
+    const activeSession = this.createSession();
     const activeEvent = await activeSession.startEvent({
       userData: [{
         type: AIStreamAttributeType.AI_CHAT,
         payloadType: AIStreamAttributePayloadType.STRING,
-        value: JSON.stringify(attribute)
+        value: JSON.stringify({
+          'processing.interrupt': 'false',
+          'asr.enableVad': 'false'
+        })
       }]
     });
     this.activeEvent = activeEvent;
@@ -165,7 +166,7 @@ class AsrAgent {
  * @example
  * const asrAgent = createAsrAgent({
  *   agentId: 'asr-agent',
- *   tokenApi: 'm.thing.aigc.basic.server.token',
+ *   tokenApi: 'xxxx',
  *   tokenApiVersion: '1.0',
  *   clientType: ConnectClientType.APP,
  *   deviceId: 'deviceId',

package/dist/utils/defaultMock.js

@@ -8,9 +8,10 @@ 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 { AIStreamErrorCode, BizCode, ConnectState, EventType, ReceivedTextPacketEof, ReceivedTextPacketType, SessionState, StreamFlag } from '../AIStreamTypes';
+import { AIStreamAppErrorCode, AIStreamServerErrorCode, BizCode, ConnectState, EventType, NetworkType, ReceivedTextPacketEof, ReceivedTextPacketType, SessionState, StreamFlag } from '../AIStreamTypes';
 import AbortController from './abort';
 import { tryCatch } from './misc';
+import { TTTError } from './errors';
 function splitString(input) {
   return input.match(/[a-zA-Z0-9]+\s*|[\u4e00-\u9fff]+\s*|[^\w\s\u4e00-\u9fff]+\s*|[\s]+/g) || [];
 }
@@ -18,31 +19,37 @@ mock.data.set('sessionMap', new Map());
 const getSession = (sessionId, eventId) => {
   const connection = getCurrentConnection();
   if (!connection) {
-    throw new Error('not connected');
+    throw new TTTError('not connect', AIStreamAppErrorCode.CONNECTION_INVALID);
   }
   const map = mock.data.get('sessionMap');
   const session = map.get(sessionId);
   if (!session) {
-    throw new Error('session not exists');
+    throw new TTTError('session is invalid', AIStreamAppErrorCode.SESSION_ID_INVALID);
   }
   if (eventId) {
     if (!session.currentEvent) {
-      throw new Error('event not exists');
+      throw new TTTError('eventId is invalid', AIStreamAppErrorCode.EVENT_ID_INVALID);
     }
     if (session.currentEvent.eventId !== eventId) {
-      throw new Error('eventId mismatch');
+      throw new TTTError('eventId is invalid', AIStreamAppErrorCode.EVENT_ID_INVALID);
     }
   }
   return session;
 };
+const getCurrentConnection = () => {
+  return mock.data.get('currentConnection');
+};
+mock.hooks.hook('getNetworkType', context => {
+  context.result = {
+    networkType: NetworkType.WIFI,
+    signalStrength: 85
+  };
+});
 mock.hooks.hook('getMiniAppConfig', context => {
   context.result = {
     config: {}
   };
 });
-const getCurrentConnection = () => {
-  return mock.data.get('currentConnection');
-};
 mock.hooks.hook('isConnected', context => {
   const connection = getCurrentConnection();
   if (connection) {
@@ -61,13 +68,13 @@ mock.hooks.hook('isConnected', context => {
 mock.hooks.hook('connect', context => {
   let connection = getCurrentConnection();
   if (connection) {
-    throw new Error('already connected');
-  } else {
-    connection = {
-      connectionId: generateId()
-    };
-    mock.data.set('currentConnection', connection);
+    context.result = connection;
+    return;
   }
+  connection = {
+    connectionId: generateId()
+  };
+  mock.data.set('currentConnection', connection);
   context.result = connection;
 });
 mock.hooks.hook('disconnect', context => {
@@ -78,10 +85,10 @@ mock.hooks.hook('disconnect', context => {
   } = context;
   const connection = getCurrentConnection();
   if (!connection) {
-    throw new Error('not connected');
+    return;
   }
   if (connection.connectionId !== connectionId) {
-    throw new Error('connectionId mismatch');
+    throw new TTTError('not connect', AIStreamAppErrorCode.CONNECTION_INVALID);
   }
   mock.data.set('currentConnection', null);
   mock.data.set('sessionMap', new Map());
@@ -104,7 +111,7 @@ const dispatch = (type, detail) => {
 mock.hooks.hook('createSession', context => {
   const connection = getCurrentConnection();
   if (!connection) {
-    throw new Error('not connected');
+    throw new TTTError('not connect', AIStreamAppErrorCode.CONNECTION_INVALID);
   }
   const map = mock.data.get('sessionMap');
   const session = {
@@ -161,12 +168,12 @@ mock.hooks.hook('sendEventStart', async context => {
     sessionId
   } = options;
 
-  // throw new Error('sendEventStart is deprecated, use sendEventStartV2 instead');
+  // throw new TTTError('sendEventStart is deprecated, use sendEventStartV2 instead');
 
   const session = getSession(sessionId);
   await mock.sleep(200);
   if (session.currentEvent) {
-    throw new Error('sendEventStart already in event');
+    throw new TTTError('sendEventStart already in event', AIStreamAppErrorCode.EVENT_ID_INVALID);
   }
   const eventId = generateId();
   const event = {
@@ -176,7 +183,7 @@ mock.hooks.hook('sendEventStart', async context => {
         return;
       }
       if (!session.currentEvent || session.currentEvent.eventId !== eventId) {
-        throw new Error('replyEvent event not exists or not in current event');
+        throw new TTTError('replyEvent event not exists or not in current event', AIStreamAppErrorCode.DATA_SEND_FAILED);
       }
       dispatch('onTextReceived', {
         dataChannel: 'text',
@@ -190,7 +197,7 @@ mock.hooks.hook('sendEventStart', async context => {
         return;
       }
       if (!session.currentEvent || session.currentEvent.eventId !== eventId) {
-        throw new Error('replyEvent event not exists or not in current event');
+        throw new TTTError('replyEvent event not exists or not in current event', AIStreamAppErrorCode.DATA_SEND_FAILED);
       }
       dispatch('onEventReceived', {
         eventId,
@@ -225,7 +232,7 @@ mock.hooks.hook('sendEventEnd', async context => {
   context.result = true;
   const event = session.currentEvent;
   if (event.eventId !== context.options.eventId) {
-    throw new Error('sendEventEnd eventId mismatch');
+    throw new TTTError('sendEventEnd eventId mismatch', AIStreamAppErrorCode.EVENT_ID_INVALID);
   }
   await mock.sleep(100);
   (async () => {
@@ -240,7 +247,7 @@ mock.hooks.hook('sendEventEnd', async context => {
       dispatch('onSessionStateChanged', {
         sessionId: session.sessionId,
         sessionState: SessionState.CLOSED,
-        code: AIStreamErrorCode.InternalServerError
+        code: AIStreamServerErrorCode.INTERNAL_SERVER_ERROR
       });
       session.closed = true;
       const map = mock.data.get('sessionMap');
@@ -340,7 +347,7 @@ mock.hooks.hook('sendEventChatBreak', async context => {
 mock.hooks.hook('startRecordAndSendAudioData', async context => {
   const session = getSession(context.options.sessionId);
   if (!session.currentEvent) {
-    throw new Error('startRecordAndSendAudioData event not exists');
+    throw new TTTError('startRecordAndSendAudioData event not exists', AIStreamAppErrorCode.EVENT_ID_INVALID);
   }
   const event = session.currentEvent;
   context.result = true;
@@ -444,7 +451,7 @@ mock.hooks.hook('startRecordAndSendAudioData', async context => {
 mock.hooks.hook('stopRecordAndSendAudioData', async context => {
   const session = getSession(context.options.sessionId);
   if (!session.currentEvent) {
-    throw new Error('stopRecordAndSendAudioData event not exists');
+    throw new TTTError('stopRecordAndSendAudioData event not exists', AIStreamAppErrorCode.SESSION_ID_INVALID);
   }
   session.currentEvent.asr.finishController.abort(new Error('stopRecordAndSendAudioData'));
   context.result = true;
@@ -459,7 +466,7 @@ mock.hooks.hook('stopRecordAndSendVideoData', context => {
 mock.hooks.hook('sendImageData', context => {
   const session = getSession(context.options.sessionId);
   if (!session.currentEvent) {
-    throw new Error('sendImageData event not exists');
+    throw new TTTError('sendImageData event not exists', AIStreamAppErrorCode.SESSION_ID_INVALID);
   }
   session.currentEvent.data.push({
     type: 'image',
@@ -472,7 +479,7 @@ mock.hooks.hook('sendTextData', context => {
   context.result = true;
   const session = getSession(context.options.sessionId);
   if (!session.currentEvent) {
-    throw new Error('sendTextData event not exists');
+    throw new TTTError('sendTextData event not exists', AIStreamAppErrorCode.SESSION_ID_INVALID);
   }
   session.currentEvent.data.push({
     type: 'text',
@@ -595,7 +602,7 @@ mock.hooks.hook('updateRecord', context => {
     id: [id]
   });
   if (!records.length) {
-    throw new Error('record not exists');
+    throw new TTTError('record not exists', AIStreamAppErrorCode.INVALID_PARAMS);
   }
   const newRecord = _objectSpread(_objectSpread({}, records[0]), options);
   mock.setRecord({

package/dist/utils/errors.d.ts

@@ -1,3 +1,4 @@
+import { AIStreamErrorCode } from '../AIStreamTypes';
 export declare class BaseError extends Error {
     message: string;
     code: string | number;
@@ -9,18 +10,10 @@ export declare class TTTError extends BaseError {
     code: string | number;
     constructor(message: string, code: string | number);
 }
-export declare class AIStreamConnectionError extends BaseError {
-    message: string;
-    code: string | number;
-    constructor(message: string, code: string | number);
-}
-export declare class AIStreamSessionError extends BaseError {
-    message: string;
-    code: string | number;
-    constructor(message: string, code: string | number);
-}
-export declare class AIStreamEventError extends BaseError {
+export declare class AIStreamError extends BaseError {
     message: string;
     code: string | number;
     constructor(message: string, code: string | number);
 }
+export declare const transformErrorCode: (code: string | number) => AIStreamErrorCode;
+export declare function tryCatchTTT<T>(fn: () => Promise<T>): Promise<[AIStreamError, null] | [null, T]>;