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

package/dist/AIStreamTypes.d.ts

@@ -655,19 +655,47 @@ export declare enum FileFormat {
     SWEEPER_MAP = 6
 }
 export declare enum AIStreamErrorCode {
-    AIStreamError = -1,
+    UNKNOWN_ERROR = "unknown-error",
+    NETWORK_OFFLINE = "network-offline",
+    INVALID_PARAMS = "invalid-params",
+    SESSION_CREATE_FAILED = "session-create-failed",
+    CONNECTION_CLOSED = "connection-closed",
+    EVENT_EXISTS = "event-exists",
+    EVENT_DISPOSED = "event-disposed",
+    EVENT_CLOSED = "event-closed",
+    EVENT_ABORTED = "event-aborted",
+    EVENT_WRITE_FAILED = "event-write-failed",
+    EVENT_NO_DATA_CODE = "event-no-data-code",
+    STREAM_EXISTS = "stream-exists",
+    TIMEOUT = "timeout",
+    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
+}
+export declare enum AIStreamServerErrorCode {
     OK = 200,
-    BadRequest = 400,
-    Unauthenticated = 401,
-    NotFound = 404,
-    RequestTimeout = 408,
-    InternalServerError = 500,
-    GatewayTimeout = 504,
-    CloseByClient = 601,
-    CloseByReuse = 602,
-    CloseByIO = 603,
-    CloseByKeepalive = 604,
-    CloseByExpire = 605
+    BAD_REQUEST = 400,
+    UNAUTHENTICATED = 401,
+    NOT_FOUND = 404,
+    REQUEST_TIMEOUT = 408,
+    INTERNAL_SERVER_ERROR = 500,
+    GATEWAY_TIMEOUT = 504,
+    CLOSE_BY_CLIENT = 601,
+    CLOSE_BY_REUSE = 602,
+    CLOSE_BY_IO = 603,
+    CLOSE_BY_KEEPALIVE = 604,
+    CLOSE_BY_EXPIRE = 605
 }
 export declare enum BizCode {
     CHAT = 65537
@@ -713,6 +741,60 @@ export interface AIStreamChatAttribute {
     'sys.workflow'?: AIStreamChatSysWorkflow;
     [key: string]: string;
 }
+export type StartPlayAudioParams = {
+    /** 音频缓存路径 */
+    path: string;
+    /**
+     * 音频编码类型，表示音频数据的编码格式（目前仅支持 PCM 播放）
+     * - 100: ADPCM
+     * - 101: PCM
+     * - 102: AACRaw
+     * - 103: AACADTS
+     * - 104: AACLATM
+     * - 105: G711U
+     * - 106: G711A
+     * - 107: G726
+     * - 108: SPEEX
+     * - 109: MP3
+     * - 110: G722
+     * - 111: Opus
+     */
+    codecType: number;
+    /**
+     * 音频采样率，单位Hz
+     * 表示每秒采样次数，常见值：8000, 16000, 44100等
+     * 数据类型：uint32，最大值：2^32-1
+     */
+    sampleRate: number;
+    /**
+     * 音频通道数
+     * - 0: 单声道
+     * - 1: 立体声
+     * 数据类型：uint16
+     */
+    channels: number;
+    /**
+     * 音频位深，表示每个采样点的位数
+     * 常见值：8, 16, 24, 32等
+     * 数据类型：uint16，最大值：2^16-1
+     */
+    bitDepth: number;
+    /**
+     * 微秒级时间戳
+     * 用于音频回放时的同步
+     */
+    pts?: number;
+    success?: (params: null) => void;
+    fail?: (params: {
+        errorMsg: string;
+        errorCode: string | number;
+        innerError: {
+            errorCode: string | number;
+            errorMsg: string;
+        };
+    }) => void;
+    complete?: () => void;
+};
 export type Attribute = {
     /** Attribute 类型 */
     type: AIStreamAttributeType;
@@ -732,16 +814,57 @@ export type EventBody = {
     userData?: Attribute[];
 };
 export type AudioBody = {
-    /** 接收数据通道 */
+    /** 接收数据通道 Code */
     dataChannel: string;
     /** 数据流类型: 0-仅一包, 1-传输开始, 2-传输中, 3-传输结束 */
-    streamFlag: StreamFlag;
-    /** 音频缓存路径，传输结束后可访问(streamFlag == 1 || StreamFlag == 3) */
+    streamFlag: number;
+    /** 音频缓存路径 */
     path: string;
     /** 扩展属性 */
     userData?: Attribute[];
     /** SessionId 列表, 云端返回，可能为空 */
     sessionIdList?: string[];
+    /**
+     * 微秒级时间戳
+     * 用于音频回放时的同步
+     */
+    pts?: number;
+    /**
+     * 音频编码类型，表示音频数据的编码格式
+     * - 100: ADPCM
+     * - 101: PCM
+     * - 102: AACRaw
+     * - 103: AACADTS
+     * - 104: AACLATM
+     * - 105: G711U
+     * - 106: G711A
+     * - 107: G726
+     * - 108: SPEEX
+     * - 109: MP3
+     * - 110: G722
+     * - 111: Opus
+     * 仅 streamFlag == 0 || == 1 时有值
+     */
+    codecType?: number;
+    /**
+     * 音频采样率，单位Hz
+     * 表示每秒采样次数，常见值：8000, 16000, 44100等
+     * 仅 streamFlag == 0 || == 1 时有值
+     */
+    sampleRate?: number;
+    /**
+     * 音频通道数
+     * - 0: 单声道
+     * - 1: 立体声
+     * 仅 streamFlag == 0 || == 1 时有值
+     */
+    channels?: number;
+    /**
+     * 音频位深，表示每个采样点的位数
+     * 常见值：8, 16, 24, 32等
+     * 仅 streamFlag == 0 || == 1 时有值
+     */
+    bitDepth?: number;
 };
 export type VideoBody = {
     /** 接收数据通道 */
@@ -803,7 +926,7 @@ export type ConnectStateBody = {
     /** 连接状态: 0-初始化，1-连接中，2-鉴权中，3-已连接，4-被云端断开，5-主动关闭 */
     connectState: ConnectState;
     /** 被云端断开错误码 */
-    code?: AIStreamErrorCode;
+    code?: AIStreamServerErrorCode;
 };
 export type SessionStateBody = {
     /** 会话 id */
@@ -811,12 +934,37 @@ export type SessionStateBody = {
     /** 会话状态: 0-会话创建成功, 1-会话创建失败, 2-会话被云端关闭 */
     sessionState: SessionState;
     /** 会话被关闭原因 */
-    code?: AIStreamErrorCode;
+    code?: AIStreamServerErrorCode;
 };
 export type RecordAmplitudesBody = {
     /** 振幅数据 */
     amplitudes: number[];
 };
+export declare enum NetworkType {
+    NONE = "none",
+    CELL_2G = "2g",
+    CELL_3G = "3g",
+    CELL_4G = "4g",
+    CELL_5G = "5g",
+    WIFI = "wifi"
+}
+export type GetNetworkTypeParams = {
+    complete?: () => void;
+    success?: (params: {
+        /** 网络类型 */
+        networkType: NetworkType;
+        /** 信号强弱，单位 dbm */
+        signalStrength: number;
+    }) => void;
+    fail?: (params: {
+        errorMsg: string;
+        errorCode: string | number;
+        innerError: {
+            errorCode: string | number;
+            errorMsg: string;
+        };
+    }) => void;
+};
 export type CheckConnectParams = {
     /** client 类型: 1-作为设备代理, 2-作为 App */
     clientType: ConnectClientType;
@@ -956,7 +1104,7 @@ export type CloseSessionParams = {
     /** 会话 id */
     sessionId: string;
     /** 关闭原因, 非异常则使用 200 来关闭 */
-    code: AIStreamErrorCode;
+    code: AIStreamServerErrorCode;
     success?: (params: null) => void;
     fail?: (params: {
         errorMsg: string;
@@ -1445,14 +1593,16 @@ export type ReceivedTextSkillPacketBody<Code = BuildInSkillCode | string, G = an
 export type ReceivedTextSkillPacket<Code = BuildInSkillCode | string, G = any, C = any> = ReceivedTextPacketBase<ReceivedTextPacketType.SKILL, ReceivedTextSkillPacketBody<Code, G, C>>;
 export type ReceivedTextPacket = ReceivedTextAsrPacket | ReceivedTextNlgPacket | ReceivedTextSkillPacket;
 export type ReceivedSearchKnowledgeSkill = ReceivedTextSkillPacketBody<BuildInSkillCode.SEARCH_KNOWLEDGE, any, {
-    documents: Array<{
-        libCode: string;
-        itemId: string;
-        itemType: 'KNOWLEDGE';
-        title: string;
-        url: string;
-        contentBody: string;
-    }>;
+    data: {
+        documents: Array<{
+            libCode: string;
+            itemId: string;
+            itemType: 'KNOWLEDGE';
+            title: string;
+            url: string;
+            contentBody: string;
+        }>;
+    };
 }>;
 export interface ReceivedSmartHomeSkillDevice {
     devId: string;

package/dist/AIStreamTypes.js

@@ -118,21 +118,51 @@ export let FileFormat = /*#__PURE__*/function (FileFormat) {
   return FileFormat;
 }({});
 export let AIStreamErrorCode = /*#__PURE__*/function (AIStreamErrorCode) {
-  AIStreamErrorCode[AIStreamErrorCode["AIStreamError"] = -1] = "AIStreamError";
-  AIStreamErrorCode[AIStreamErrorCode["OK"] = 200] = "OK";
-  AIStreamErrorCode[AIStreamErrorCode["BadRequest"] = 400] = "BadRequest";
-  AIStreamErrorCode[AIStreamErrorCode["Unauthenticated"] = 401] = "Unauthenticated";
-  AIStreamErrorCode[AIStreamErrorCode["NotFound"] = 404] = "NotFound";
-  AIStreamErrorCode[AIStreamErrorCode["RequestTimeout"] = 408] = "RequestTimeout";
-  AIStreamErrorCode[AIStreamErrorCode["InternalServerError"] = 500] = "InternalServerError";
-  AIStreamErrorCode[AIStreamErrorCode["GatewayTimeout"] = 504] = "GatewayTimeout";
-  AIStreamErrorCode[AIStreamErrorCode["CloseByClient"] = 601] = "CloseByClient";
-  AIStreamErrorCode[AIStreamErrorCode["CloseByReuse"] = 602] = "CloseByReuse";
-  AIStreamErrorCode[AIStreamErrorCode["CloseByIO"] = 603] = "CloseByIO";
-  AIStreamErrorCode[AIStreamErrorCode["CloseByKeepalive"] = 604] = "CloseByKeepalive";
-  AIStreamErrorCode[AIStreamErrorCode["CloseByExpire"] = 605] = "CloseByExpire";
+  AIStreamErrorCode["UNKNOWN_ERROR"] = "unknown-error";
+  AIStreamErrorCode["NETWORK_OFFLINE"] = "network-offline";
+  AIStreamErrorCode["INVALID_PARAMS"] = "invalid-params";
+  AIStreamErrorCode["SESSION_CREATE_FAILED"] = "session-create-failed";
+  AIStreamErrorCode["CONNECTION_CLOSED"] = "connection-closed";
+  AIStreamErrorCode["EVENT_EXISTS"] = "event-exists";
+  AIStreamErrorCode["EVENT_DISPOSED"] = "event-disposed";
+  AIStreamErrorCode["EVENT_CLOSED"] = "event-closed";
+  AIStreamErrorCode["EVENT_ABORTED"] = "event-aborted";
+  AIStreamErrorCode["EVENT_WRITE_FAILED"] = "event-write-failed";
+  AIStreamErrorCode["EVENT_NO_DATA_CODE"] = "event-no-data-code";
+  AIStreamErrorCode["STREAM_EXISTS"] = "stream-exists";
+  AIStreamErrorCode["TIMEOUT"] = "timeout";
+  AIStreamErrorCode["ASR_EMPTY"] = "asr-empty";
   return AIStreamErrorCode;
 }({});
+export let AIStreamAppErrorCode = /*#__PURE__*/function (AIStreamAppErrorCode) {
+  AIStreamAppErrorCode[AIStreamAppErrorCode["GENERIC_ERROR"] = 39001] = "GENERIC_ERROR";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["INVALID_PARAMS"] = 39002] = "INVALID_PARAMS";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["HTTP_REQUEST_FAILED"] = 39003] = "HTTP_REQUEST_FAILED";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["CONNECTION_INVALID"] = 39004] = "CONNECTION_INVALID";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["SESSION_ID_INVALID"] = 39005] = "SESSION_ID_INVALID";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["EVENT_ID_INVALID"] = 39006] = "EVENT_ID_INVALID";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["DATA_CHANNEL_NOT_FOUND"] = 39007] = "DATA_CHANNEL_NOT_FOUND";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["INVALID_DATA_PACKET"] = 39008] = "INVALID_DATA_PACKET";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["FILE_DATA_READ_ERROR"] = 39009] = "FILE_DATA_READ_ERROR";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["DATA_SEND_FAILED"] = 39010] = "DATA_SEND_FAILED";
+  AIStreamAppErrorCode[AIStreamAppErrorCode["CONNECTION_CLOSED_BY_REMOTE"] = 39012] = "CONNECTION_CLOSED_BY_REMOTE";
+  return AIStreamAppErrorCode;
+}({});
+export let AIStreamServerErrorCode = /*#__PURE__*/function (AIStreamServerErrorCode) {
+  AIStreamServerErrorCode[AIStreamServerErrorCode["OK"] = 200] = "OK";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["UNAUTHENTICATED"] = 401] = "UNAUTHENTICATED";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["NOT_FOUND"] = 404] = "NOT_FOUND";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["CLOSE_BY_CLIENT"] = 601] = "CLOSE_BY_CLIENT";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["CLOSE_BY_REUSE"] = 602] = "CLOSE_BY_REUSE";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["CLOSE_BY_IO"] = 603] = "CLOSE_BY_IO";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["CLOSE_BY_KEEPALIVE"] = 604] = "CLOSE_BY_KEEPALIVE";
+  AIStreamServerErrorCode[AIStreamServerErrorCode["CLOSE_BY_EXPIRE"] = 605] = "CLOSE_BY_EXPIRE";
+  return AIStreamServerErrorCode;
+}({});
 export let BizCode = /*#__PURE__*/function (BizCode) {
   BizCode[BizCode["CHAT"] = 65537] = "CHAT";
   return BizCode;
@@ -162,6 +192,15 @@ export let AIStreamChatSysWorkflow = /*#__PURE__*/function (AIStreamChatSysWorkf
   AIStreamChatSysWorkflow["LLM_TTS"] = "llm-tts";
   return AIStreamChatSysWorkflow;
 }({});
+export let NetworkType = /*#__PURE__*/function (NetworkType) {
+  NetworkType["NONE"] = "none";
+  NetworkType["CELL_2G"] = "2g";
+  NetworkType["CELL_3G"] = "3g";
+  NetworkType["CELL_4G"] = "4g";
+  NetworkType["CELL_5G"] = "5g";
+  NetworkType["WIFI"] = "wifi";
+  return NetworkType;
+}({});
 
 /**
  *@description 发起通道连接，若此前已连接会直接回调成功

package/dist/buildIn/withBuildIn.js

@@ -55,10 +55,10 @@ export function withBuildIn() {
             continue;
           }
           const content = skill;
-          if (!((_content$custom = content.custom) !== null && _content$custom !== void 0 && _content$custom.documents)) {
+          if (!((_content$custom = content.custom) !== null && _content$custom !== void 0 && (_content$custom = _content$custom.data) !== null && _content$custom !== void 0 && _content$custom.documents)) {
             continue;
           }
-          for (const doc of content.custom.documents) {
+          for (const doc of content.custom.data.documents) {
             data.documents.push({
               title: doc.title,
               url: doc.url

package/dist/utils/AIStream.d.ts

@@ -1,5 +1,6 @@
 import { Attribute, BizTag, ConnectClientType, ConnectState, FileFormat, VideoCameraType } from '../AIStreamTypes';
 import { AIStreamDataEntry, AIStreamObserverPool } from './observer';
+import { AIStreamError } from './errors';
 interface AIStreamConnectionOptions {
     /** client 类型: 1-作为设备代理, 2-作为 App */
     clientType: ConnectClientType;
@@ -124,15 +125,15 @@ export declare class AIStreamEvent {
     }): void;
     on(name: 'close', callback: () => void): void;
     on(name: 'finish', callback: () => void): void;
-    on(name: 'error', callback: (error: any) => void): void;
+    on(name: 'error', callback: (error: AIStreamError) => void): void;
     on(name: 'data', callback: (entry: AIStreamDataEntry) => void): void;
     off(name: 'finish', callback: () => void): void;
     off(name: 'close', callback: () => void): void;
-    off(name: 'error', callback: (error: any) => void): void;
+    off(name: 'error', callback: (error: AIStreamError) => void): void;
     off(name: 'data', callback: (entry: AIStreamDataEntry) => void): void;
     emit(name: 'finish'): void;
     emit(name: 'close'): void;
-    emit(name: 'error', data: Error): void;
+    emit(name: 'error', data: AIStreamError): void;
     emit(name: 'data', data: AIStreamDataEntry): void;
     private dispose;
 }

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 { 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);
@@ -187,58 +201,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,
@@ -318,13 +361,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 +379,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 +398,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 +411,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 +432,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 +465,7 @@ export class AIStreamEvent {
         }
         // 一定要等录音开始，才能结束
         if (startPromise) {
-          try {
-            await startPromise;
-          } catch (e) {
-            // pass
-          }
+          await tryCatchTTT(() => startPromise);
           startPromise = null;
         }
         if (source.type === 'audio') {
@@ -435,6 +480,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 +523,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/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]>;

package/dist/utils/errors.js

@@ -1,3 +1,6 @@
+import "core-js/modules/web.dom-collections.iterator.js";
+import { AIStreamAppErrorCode, AIStreamErrorCode, AIStreamServerErrorCode } from '../AIStreamTypes';
+import { tryCatch } from './misc';
 export class BaseError extends Error {
   constructor(message, code) {
     super(message);
@@ -16,27 +19,87 @@ export class TTTError extends BaseError {
     this.name = 'TTTError';
   }
 }
-export class AIStreamConnectionError extends BaseError {
+export class AIStreamError extends BaseError {
   constructor(message, code) {
     super(message, code);
     this.message = message;
     this.code = code;
-    this.name = 'AIStreamConnectionError';
+    this.name = 'AIStreamError';
   }
 }
-export class AIStreamSessionError extends BaseError {
-  constructor(message, code) {
-    super(message, code);
-    this.message = message;
-    this.code = code;
-    this.name = 'AIStreamSessionError';
+
+/**
+ * 移除错误对象的顶部栈帧
+ *
+ * @param error 需要处理的错误对象
+ * @returns 移除顶部栈帧后的错误对象
+ */
+function removeTopStackFrame(error) {
+  if (!error.stack) {
+    return error;
+  }
+
+  // 按行分割错误栈信息
+  const stackLines = error.stack.split('\n');
+
+  // 检查是否有足够的行来移除
+  if (stackLines.length <= 1) {
+    return error;
   }
+
+  // 保留第一行错误信息，移除第二行(顶部栈帧)
+  const newStack = [stackLines[0]].concat(stackLines.slice(2)).join('\n');
+  error.stack = newStack;
+  return error;
 }
-export class AIStreamEventError extends BaseError {
-  constructor(message, code) {
-    super(message, code);
-    this.message = message;
-    this.code = code;
-    this.name = 'AIStreamEventError';
+export const transformErrorCode = code => {
+  switch (code) {
+    case AIStreamAppErrorCode.GENERIC_ERROR:
+      return AIStreamErrorCode.UNKNOWN_ERROR;
+    case AIStreamAppErrorCode.INVALID_PARAMS:
+    case AIStreamAppErrorCode.CONNECTION_INVALID:
+    case AIStreamAppErrorCode.SESSION_ID_INVALID:
+    case AIStreamAppErrorCode.EVENT_ID_INVALID:
+    case AIStreamAppErrorCode.INVALID_DATA_PACKET:
+    case AIStreamAppErrorCode.FILE_DATA_READ_ERROR:
+    case AIStreamAppErrorCode.DATA_CHANNEL_NOT_FOUND:
+      return AIStreamErrorCode.INVALID_PARAMS;
+    case AIStreamAppErrorCode.HTTP_REQUEST_FAILED:
+      return AIStreamErrorCode.SESSION_CREATE_FAILED;
+    case AIStreamAppErrorCode.CONNECTION_CLOSED_BY_REMOTE:
+      return AIStreamErrorCode.CONNECTION_CLOSED;
+    case AIStreamServerErrorCode.OK:
+    case AIStreamServerErrorCode.CLOSE_BY_CLIENT:
+    case AIStreamServerErrorCode.CLOSE_BY_EXPIRE:
+    case AIStreamServerErrorCode.CLOSE_BY_IO:
+    case AIStreamServerErrorCode.CLOSE_BY_KEEPALIVE:
+    case AIStreamServerErrorCode.CLOSE_BY_REUSE:
+      return AIStreamErrorCode.CONNECTION_CLOSED;
+    case AIStreamServerErrorCode.BAD_REQUEST:
+    case AIStreamServerErrorCode.NOT_FOUND:
+    case AIStreamServerErrorCode.UNAUTHENTICATED:
+      return AIStreamErrorCode.INVALID_PARAMS;
+    case AIStreamServerErrorCode.INTERNAL_SERVER_ERROR:
+      return AIStreamErrorCode.UNKNOWN_ERROR;
+    case AIStreamServerErrorCode.REQUEST_TIMEOUT:
+    case AIStreamServerErrorCode.GATEWAY_TIMEOUT:
+      return AIStreamErrorCode.TIMEOUT;
+  }
+  return AIStreamErrorCode.UNKNOWN_ERROR;
+};
+
+// 函数实现
+export async function tryCatchTTT(fn) {
+  const [error, result] = await tryCatch(fn);
+  if (error) {
+    let {
+      code,
+      message
+    } = error;
+    message = "".concat(message, " (original_code: ").concat(code || '-', ")");
+    code = transformErrorCode(code);
+    const e = removeTopStackFrame(new AIStreamError(message, code));
+    return [e, null];
   }
+  return [null, result];
 }

package/dist/utils/sendMessage.d.ts

@@ -8,10 +8,6 @@ export interface SendBlocksToAIStreamParams {
     attribute?: AIStreamChatAttribute;
     signal?: AbortSignal;
 }
-export declare class AIStreamSessionError extends Error {
-    readonly code: number;
-    constructor(message: string, code: number);
-}
 export declare function sendBlocksToAIStream(params: SendBlocksToAIStreamParams): {
     response: StreamResponse;
     metaPromise: Promise<Record<string, any>>;

package/dist/utils/sendMessage.js

@@ -3,10 +3,10 @@ import "core-js/modules/es.json.stringify.js";
 import "core-js/modules/web.dom-collections.iterator.js";
 import '../polyfill';
 import { ReadableStream } from 'web-streams-polyfill';
-import { AIStreamAttributePayloadType, AIStreamAttributeType, AIStreamChatSysWorkflow, ConnectState, FileFormat, ReceivedTextPacketEof, ReceivedTextPacketType, SessionState, StreamFlag } from '../AIStreamTypes';
+import { AIStreamAttributePayloadType, AIStreamAttributeType, AIStreamChatSysWorkflow, AIStreamErrorCode, ConnectState, FileFormat, ReceivedTextPacketEof, ReceivedTextPacketType, SessionState, StreamFlag } from '../AIStreamTypes';
 import { EmitterEvent, generateId, safeParseJSON, StreamResponse } from '@ray-js/t-agent';
 import { tryCatch } from './misc';
-import { AIStreamConnectionError } from './errors';
+import { AIStreamError, transformErrorCode } from './errors';
 import logger from './logger';
 const mimeTypeToFormatMap = {
   'video/mp4': FileFormat.MP4,
@@ -14,13 +14,6 @@ const mimeTypeToFormatMap = {
   'application/json': FileFormat.JSON,
   'application/pdf': FileFormat.PDF
 };
-export class AIStreamSessionError extends Error {
-  constructor(message, code) {
-    super(message);
-    this.name = 'AIStreamSessionError';
-    this.code = code;
-  }
-}
 export function sendBlocksToAIStream(params) {
   logger.debug('sendBlocksToAIStream start');
   const {
@@ -80,6 +73,20 @@ export function sendBlocksToAIStream(params) {
           }
         }
       };
+      const emitError = error => {
+        if (!error) {
+          error = new AIStreamError('Unknown error', AIStreamErrorCode.UNKNOWN_ERROR);
+        }
+        if (!(error instanceof AIStreamError)) {
+          error = new AIStreamError("AIStream Error: ".concat(error.message || 'Unknown error'), transformErrorCode(error.code));
+        }
+        enqueue({
+          type: 'error',
+          level: 'error',
+          error,
+          meta: {}
+        });
+      };
       let pendingCancel = false;
       if (audioEmitter) {
         audioEmitter.addEventListener('confirm', () => {
@@ -108,16 +115,10 @@ export function sendBlocksToAIStream(params) {
         }]
       }));
       if (error) {
-        const e = new AIStreamSessionError(error.message, error.code || 0);
-        enqueue({
-          type: 'error',
-          error: e,
-          level: 'error',
-          meta: {}
-        });
+        emitError(error);
         if (audioEmitter) {
           audioEmitter.dispatchEvent(new EmitterEvent('error', {
-            detail: e
+            detail: error
           }));
         }
         close();
@@ -167,10 +168,9 @@ export function sendBlocksToAIStream(params) {
               if (packet.data.text === '') {
                 logger.debug('sendBlocksToAIStream Receive ASR EOF EMPTY');
                 // 没识别出任何文本
+                const e = new AIStreamError('ASR data is empty', AIStreamErrorCode.ASR_EMPTY);
                 audioEmitter.dispatchEvent(new EmitterEvent('error', {
-                  detail: {
-                    name: 'AsrEmptyError'
-                  }
+                  detail: e
                 }));
               } else {
                 logger.debug('sendBlocksToAIStream Receive ASR EOF', packet.data.text);
@@ -225,13 +225,9 @@ export function sendBlocksToAIStream(params) {
           }
         } else if (data.type === 'sessionState') {
           if (data.body.sessionState === SessionState.CLOSED || data.body.sessionState === SessionState.CREATE_FAILED) {
-            const e = new AIStreamSessionError('Session closed', data.body.code);
-            enqueue({
-              type: 'error',
-              error: e,
-              level: 'error',
-              meta
-            });
+            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);
             if (audioEmitter) {
               audioEmitter.dispatchEvent(new EmitterEvent('error', {
                 detail: e
@@ -241,13 +237,8 @@ export function sendBlocksToAIStream(params) {
           }
         } else if (data.type === 'connectionState') {
           if (data.body.connectState === ConnectState.DISCONNECTED || data.body.connectState === ConnectState.CLOSED) {
-            const e = new AIStreamConnectionError('Connection disconnected', data.body.code);
-            enqueue({
-              type: 'error',
-              error: e,
-              level: 'error',
-              meta
-            });
+            const e = new AIStreamError("Session disconnected, (original_code: ".concat(data.body.code, ")"), transformErrorCode(data.body.code));
+            emitError(error);
             if (audioEmitter) {
               audioEmitter.dispatchEvent(new EmitterEvent('error', {
                 detail: e
@@ -269,14 +260,7 @@ export function sendBlocksToAIStream(params) {
           close();
         }
       });
-      event.on('error', error => {
-        enqueue({
-          type: 'error',
-          level: 'error',
-          error: error instanceof Error ? error : new Error('Unknown error'),
-          meta: {}
-        });
-      });
+      event.on('error', emitError);
       for (const block of blocks) {
         if (block.type === 'text') {
           event.write({
@@ -285,24 +269,24 @@ export function sendBlocksToAIStream(params) {
               type: 'text',
               message: block.text
             })
-          });
+          }).catch(emitError);
         } else if (block.type === 'image_path') {
           event.write({
             type: 'image',
             path: block.image_path.path
-          });
+          }).catch(emitError);
         } else if (block.type === 'file_path') {
           event.write({
             type: 'file',
             format: mimeTypeToFormatMap[block.file_url.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
-          });
+          }).catch(emitError);
         }
       }
       if (audioEmitter) {

package/dist/utils/ttt.d.ts

@@ -1,10 +1,11 @@
-import { ApiRequestByAtopParams, ApiRequestByHighwayParams, AudioBody, AuthorizeParams, AuthorizePolicyStatusParams, CanIUseRouterParams, CloseSessionParams, ConnectParams, ConnectStateBody, CreateSessionParams, DeleteRecordListParams, DisconnectParams, EventBody, EventChannelMessageParams, GetAppInfoParams, GetCurrentHomeInfoParams, GetMiniAppConfigParams, GetAccountInfoParams, ImageBody, InsertRecordParams, NavigateToMiniProgramParams, OpenInnerH5Params, OpenMiniWidgetParams, QueryAgentTokenParams, QueryRecordListParams, RecordAmplitudesBody, RegisterChannelParams, RouterParams, SendEventChatBreakParams, SendEventEndParams, SendEventPayloadEndParams, SendEventStartParams, SendImageDataParams, SendTextDataParams, SessionStateBody, StartRecordAndSendAudioDataParams, StopRecordAndSendAudioDataParams, TextBody, UpdateRecordParams, IsConnectedParams } from '../AIStreamTypes';
+import { ApiRequestByAtopParams, ApiRequestByHighwayParams, AudioBody, AuthorizeParams, AuthorizePolicyStatusParams, CanIUseRouterParams, CloseSessionParams, ConnectParams, ConnectStateBody, CreateSessionParams, DeleteRecordListParams, DisconnectParams, EventBody, EventChannelMessageParams, GetAppInfoParams, GetCurrentHomeInfoParams, GetMiniAppConfigParams, GetAccountInfoParams, ImageBody, InsertRecordParams, NavigateToMiniProgramParams, OpenInnerH5Params, OpenMiniWidgetParams, QueryAgentTokenParams, QueryRecordListParams, RecordAmplitudesBody, RegisterChannelParams, RouterParams, SendEventChatBreakParams, SendEventEndParams, SendEventPayloadEndParams, SendEventStartParams, SendImageDataParams, SendTextDataParams, SessionStateBody, StartRecordAndSendAudioDataParams, StopRecordAndSendAudioDataParams, TextBody, UpdateRecordParams, IsConnectedParams, GetNetworkTypeParams, StartPlayAudioParams } from '../AIStreamTypes';
 export declare const getMiniAppConfig: (options?: Omit<GetMiniAppConfigParams, "success" | "fail"> | undefined) => Promise<{
     config: any;
 }>;
 export declare const getAccountInfo: (options?: Omit<GetAccountInfoParams, "success" | "fail"> | undefined) => Promise<{
     miniProgram: import("../AIStreamTypes").MiniProgramAccountInfo;
 }>;
+export declare const systemInfo: any;
 export declare const isDevTools: () => boolean;
 export declare const apiRequestByAtop: (options?: Omit<ApiRequestByAtopParams, "success" | "fail"> | undefined) => Promise<{
     thing_json_?: any;
@@ -85,7 +86,11 @@ export declare const registerRecordAmplitudes: (options?: Omit<{
     count: number;
 }, "success" | "fail"> | undefined) => Promise<never>;
 export declare const unregisterVoiceAmplitudes: (options?: Omit<any, "success" | "fail"> | undefined) => Promise<unknown>;
+export declare const startPlayAudio: (options?: Omit<StartPlayAudioParams, "success" | "fail"> | undefined) => Promise<null>;
 export declare const listenEventReceived: (listener: (params: EventBody) => void) => () => void;
+export declare const listenAudioPlayEnd: (listener: (params: {
+    path: string;
+}) => void) => () => void;
 export declare const listenAudioReceived: (listener: (params: AudioBody) => void) => () => void;
 export declare const listenTextReceived: (listener: (params: TextBody) => void) => () => void;
 export declare const listenImageReceived: (listener: (params: ImageBody) => void) => () => void;
@@ -101,3 +106,7 @@ export declare const updateRecord: (options?: Omit<UpdateRecordParams, "success"
 export declare const insertRecord: (options?: Omit<InsertRecordParams, "success" | "fail"> | undefined) => Promise<{
     id: number;
 }>;
+export declare const getNetworkType: (options?: Omit<GetNetworkTypeParams, "success" | "fail"> | undefined) => Promise<{
+    networkType: import("../AIStreamTypes").NetworkType;
+    signalStrength: number;
+}>;

package/dist/utils/ttt.js

@@ -1,13 +1,14 @@
 import { listening, promisify } from './promisify';
 export const getMiniAppConfig = promisify(ty.getMiniAppConfig, true);
 export const getAccountInfo = promisify(ty.getAccountInfo);
+export const systemInfo = ty.getSystemInfoSync();
 export const isDevTools = () => {
-  return ty.getSystemInfoSync().brand === 'devtools';
+  return systemInfo.brand === 'devtools';
 };
 export const apiRequestByAtop = promisify(ty.apiRequestByAtop);
 export const apiRequestByHighway = promisify(ty.apiRequestByHighway);
 export const createNativeEventManager = options => {
-  if (isDevTools) {
+  if (isDevTools()) {
     return {
       onListener: () => null,
       offerListener: () => null
@@ -55,10 +56,12 @@ export const sendImageData = promisify(ty.aistream.sendImageData, true);
 export const sendTextData = promisify(ty.aistream.sendTextData, true);
 export const registerRecordAmplitudes = promisify(ty.aistream.registerRecordAmplitudes, true);
 export const unregisterVoiceAmplitudes = promisify(ty.aistream.unregisterVoiceAmplitudes, true);
+export const startPlayAudio = promisify(ty.aistream.startPlayAudio, true);
 
 // export const sendFileData = promisify<SendFileDataParams>(ty.aistream.sendFileData);
 
 export const listenEventReceived = listening(ty.aistream.onEventReceived, ty.aistream.offEventReceived, true);
+export const listenAudioPlayEnd = listening(ty.aistream.onAudioPlayEnd, ty.aistream.onAudioPlayEnd, true);
 export const listenAudioReceived = listening(ty.aistream.onAudioReceived, ty.aistream.offAudioReceived, true);
 
 // export const listenVideoReceived = listening<VideoBody>(
@@ -82,4 +85,5 @@ export const listenRecordAmplitudes = listening(ty.aistream.onRecordAmplitudes,
 export const queryRecordList = promisify(ty.aistream.queryRecordList, true);
 export const deleteRecordList = promisify(ty.aistream.deleteRecordList, true);
 export const updateRecord = promisify(ty.aistream.updateRecord, true);
-export const insertRecord = promisify(ty.aistream.insertRecord, true);
+export const insertRecord = promisify(ty.aistream.insertRecord, true);
+export const getNetworkType = promisify(ty.getNetworkType, true);

package/dist/withAIStream.d.ts

@@ -43,7 +43,7 @@ export declare function withAIStream(options?: AIStreamOptions): (agent: ChatAge
     hooks: import("hookable").Hookable<any, string>;
     aiStream: {
         send: (blocks: InputBlock[], signal?: AbortSignal, extraOptions?: Record<string, any>) => {
-            response: import("@ray-js/t-agent").StreamResponse;
+            response: import("@ray-js/t-agent").StreamResponse; /** 是否将输入块传递给智能体，默认为 true，设置为 false 时，需要你自己编写 onInputBlocksPush Hook 来处理输入块 */
             metaPromise: Promise<Record<string, any>>;
         };
         chat: (blocks: InputBlock[], signal?: AbortSignal, options?: {

package/dist/withAIStream.js

@@ -344,8 +344,10 @@ export function withAIStream() {
       }
       if (message.bubble.text) {
         await message.persist();
-      } else {
+      } else if (message.bubble.status === BubbleTileStatus.NORMAL) {
         await message.remove();
+      } else {
+        await message.persist();
       }
       return [userMsg, ...result.messages];
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ray-js/t-agent-plugin-aistream",
-  "version": "0.2.0-beta-17",
+  "version": "0.2.0-beta.0",
   "author": "Tuya.inc",
   "license": "MIT",
   "private": false,
@@ -35,5 +35,5 @@
   "devDependencies": {
     "@types/url-parse": "^1.4.11"
   },
-  "gitHead": "32e3d3ae017d11825e0bfd4dc4441abe67bd8ef0"
+  "gitHead": "0b5d552289721444563828b03a51a6e8695779db"
 }