@ray-js/t-agent-plugin-aistream 0.2.0-beta-1

package/dist/utils/actions.d.ts

@@ -0,0 +1,48 @@
+import { InputBlock } from '../AIStreamTypes';
+export interface TTTActionOpenRoute {
+    type: 'openRoute';
+    url: string;
+}
+export interface TTTActionOpenMiniApp {
+    type: 'openMiniApp';
+    appId?: string;
+    path?: string;
+    extraData?: Record<string, any>;
+    shortLink?: string;
+    position?: string;
+    aiPtChannel?: string;
+}
+export interface TTTActionOpenH5 {
+    type: 'openH5';
+    url: string;
+    title?: string;
+}
+export interface TTTActionSendMessage {
+    type: 'sendMessage';
+    blocks: InputBlock[];
+    sendImmediately?: boolean;
+}
+export interface TTTActionSendSkill {
+    type: 'sendSkill';
+    block?: string;
+    options: {
+        domain: string;
+        intent: string;
+        [key: string]: any;
+    };
+}
+export interface TTTActionBuildIn {
+    type: 'buildIn';
+    name: 'questionnaire' | 'homeLocation' | string;
+    data?: any;
+}
+export type TTTAction = TTTActionOpenRoute | TTTActionOpenMiniApp | TTTActionOpenH5 | TTTActionSendMessage | TTTActionSendSkill | TTTActionBuildIn;
+export declare function runTTTAction(action: TTTAction, options: {
+    onSendSkills?: (block: string, options: {
+        domain: string;
+        intent: string;
+        [key: string]: string;
+    }) => Promise<void> | void;
+    onSendMessages?: (blocks: InputBlock[], sendImmediately: boolean) => Promise<void> | void;
+    onBuildIn?: (name: string, data: any) => Promise<void> | void;
+}): Promise<void>;

package/dist/utils/actions.js

@@ -0,0 +1,76 @@
+import "core-js/modules/es.regexp.exec.js";
+import { canIUseRouter, navigateToMiniProgram, openInnerH5, router } from './ttt';
+import logger from './logger';
+import { parseMiniAppURL } from './url';
+export async function runTTTAction(action, options) {
+  switch (action.type) {
+    case 'openRoute':
+      {
+        if (!action.url) {
+          return;
+        }
+        if (/^http(s)?:\/\//.test(action.url)) {
+          await openInnerH5({
+            url: action.url
+          });
+          return;
+        }
+        const mini = parseMiniAppURL(action.url);
+        if (mini) {
+          await navigateToMiniProgram(mini);
+        } else {
+          const {
+            result
+          } = await canIUseRouter({
+            url: action.url
+          });
+          if (result) {
+            await router({
+              url: action.url
+            });
+          } else {
+            throw new Error('openRoute not allowed');
+          }
+        }
+        break;
+      }
+    case 'openMiniApp':
+      await navigateToMiniProgram({
+        appId: action.appId,
+        path: action.path,
+        shortLink: action.shortLink,
+        extraData: action.extraData,
+        position: action.position,
+        aiPtChannel: action.aiPtChannel
+      });
+      break;
+    case 'openH5':
+      await openInnerH5({
+        url: action.url,
+        title: action.title
+      });
+      break;
+    case 'sendMessage':
+      if (options.onSendMessages) {
+        var _action$sendImmediate;
+        await options.onSendMessages(action.blocks, (_action$sendImmediate = action.sendImmediately) !== null && _action$sendImmediate !== void 0 ? _action$sendImmediate : false);
+      } else {
+        logger.error('onSendMessages not provided');
+      }
+      break;
+    case 'sendSkill':
+      if (options.onSendSkills) {
+        await options.onSendSkills(action.block, action.options);
+      } else {
+        logger.error('onSendSkills not provided');
+      }
+      break;
+    case 'buildIn':
+      if (options.onBuildIn) {
+        await options.onBuildIn(action.name, action.data);
+      } else {
+        logger.error('onBuildIn not provided');
+      }
+      break;
+  }
+}

package/dist/utils/apis.d.ts

@@ -0,0 +1,15 @@
+interface ItAgentMessageAppraise {
+    aiPtChannel: string;
+    /** 小程序 ID */
+    miniProgramId: string;
+    /** 请求 ID, 消息id  */
+    requestId: string;
+    /** 评价（1-有帮助，2-无帮助） */
+    approveStatus: 1 | 2;
+}
+/** 聊天智能体消息的反馈评价 */
+export declare const tAgentMessageAppraise: (params: ItAgentMessageAppraise) => Promise<{
+    thingjson?: any;
+    data: string;
+}>;
+export {};

package/dist/utils/apis.js

@@ -0,0 +1,10 @@
+import { apiRequestByHighway } from './ttt';
+import { HighwayMethod } from '../AIStreamTypes';
+/** 聊天智能体消息的反馈评价 */
+export const tAgentMessageAppraise = params => {
+  return apiRequestByHighway({
+    api: '/v1.0/m/life/ai/agent/chat-panel-mini/mini/history/appraise',
+    data: params,
+    method: HighwayMethod.POST
+  });
+};

package/dist/utils/defaultMock.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/defaultMock.js

@@ -0,0 +1,429 @@
+import "core-js/modules/es.array.sort.js";
+import "core-js/modules/es.json.stringify.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+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 { BizCode, EventType, ReceivedTextPacketEof, ReceivedTextPacketType, StreamFlag } from '../AIStreamTypes';
+import AbortController from './abort';
+function splitString(input) {
+  return input.match(/[a-zA-Z0-9]+\s*|[\u4e00-\u9fff]+\s*|[^\w\s\u4e00-\u9fff]+\s*|[\s]+/g) || [];
+}
+mock.data.set('sessionMap', new Map());
+const getSession = (sessionId, eventId) => {
+  const map = mock.data.get('sessionMap');
+  const session = map.get(sessionId);
+  if (!session) {
+    throw new Error('session not exists');
+  }
+  if (eventId) {
+    if (!session.currentEvent) {
+      throw new Error('event not exists');
+    }
+    if (session.currentEvent.eventId !== eventId) {
+      throw new Error('eventId mismatch');
+    }
+  }
+  return session;
+};
+mock.hooks.hook('getMiniAppConfig', context => {
+  context.result = {
+    config: {}
+  };
+});
+mock.hooks.hook('connect', context => {
+  const {
+    options
+  } = context;
+  const key = "connection-".concat(options.clientType, "-").concat(options.deviceId || '');
+  if (!mock.data.has(key)) {
+    const connectionId = generateId();
+    mock.data.set(key, {
+      connectionId
+    });
+    mock.data.set("connection-".concat(connectionId), key);
+  }
+  context.result = mock.data.get(key);
+});
+mock.hooks.hook('disconnect', context => {
+  const {
+    options: {
+      connectionId
+    }
+  } = context;
+  const key = mock.data.get("connection-".concat(connectionId));
+  mock.data.delete(key);
+  mock.data.delete("connection-".concat(connectionId));
+});
+mock.hooks.hook('queryAgentToken', context => {
+  context.result = {
+    agentToken: generateId(),
+    bizConfig: {
+      bizCode: BizCode.CHAT,
+      sendData: ['audio', 'video', 'text', 'image'],
+      revData: ['text', 'audio']
+    }
+  };
+});
+const dispatch = (type, detail) => {
+  mock.emitter.dispatchEvent(new EmitterEvent(type, {
+    detail
+  }));
+};
+mock.hooks.hook('createSession', context => {
+  const map = mock.data.get('sessionMap');
+  const session = {
+    sessionId: generateId(),
+    sendDataChannels: ['audio', 'video', 'text', 'image'],
+    revDataChannels: ['text', 'audio'],
+    currentEvent: null,
+    replyText: function (streamFlag) {
+      let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      dispatch('onTextReceived', {
+        dataChannel: 'text',
+        sessionIdList: [session.sessionId],
+        streamFlag,
+        text: data ? JSON.stringify(data) : ''
+      });
+    },
+    replyEvent: eventType => {
+      if (!session.currentEvent) {
+        throw new Error('replyEvent event not exists');
+      }
+      dispatch('onEventReceived', {
+        eventId: session.currentEvent.eventId,
+        sessionId: session.sessionId,
+        eventType
+      });
+    }
+  };
+  map.set(session.sessionId, session);
+  context.result = {
+    sessionId: session.sessionId,
+    sendDataChannels: session.sendDataChannels,
+    revDataChannels: session.revDataChannels
+  };
+});
+mock.hooks.hook('closeSession', context => {
+  const map = mock.data.get('sessionMap');
+  const sessionId = context.options.sessionId;
+  map.delete(sessionId);
+  context.result = true;
+});
+mock.hooks.hook('sendEventStart', context => {
+  const {
+    options
+  } = context;
+  const {
+    sessionId
+  } = options;
+  const session = getSession(sessionId);
+  if (session.currentEvent) {
+    throw new Error('sendEventStart already in event');
+  }
+  const eventId = generateId();
+  session.currentEvent = {
+    asrStatus: {
+      controller: new AbortController(),
+      promise: Promise.resolve()
+    },
+    eventId,
+    data: [],
+    controller: new AbortController()
+  };
+  context.result = {
+    eventId
+  };
+});
+mock.hooks.hook('registerRecordAmplitudes', context => {
+  mock.data.set('recordAmplitudesCount', context.options.count);
+  context.result = true;
+});
+mock.hooks.hook('unregisterVoiceAmplitudes', context => {
+  mock.data.delete('recordAmplitudesCount');
+  context.result = true;
+});
+mock.hooks.hook('sendEventEnd', context => {
+  const session = getSession(context.options.sessionId, context.options.eventId);
+  context.result = true;
+  (async () => {
+    const ctx = {
+      data: session.currentEvent.data,
+      responseText: ''
+    };
+    await session.currentEvent.asrStatus.promise;
+    await mock.hooks.callHook('sendToAIStream', ctx);
+    const text = ctx.responseText || '⚠️ No mock text response matched!';
+    const words = splitString(text);
+    session.replyEvent(EventType.EVENT_START);
+    await mock.sleep(500);
+    const bizId = generateId();
+    session.replyText(StreamFlag.START);
+    for (const word of words) {
+      await mock.sleep(100);
+      session.replyText(StreamFlag.IN_PROGRESS, {
+        bizType: ReceivedTextPacketType.NLG,
+        eof: ReceivedTextPacketEof.CONTINUE,
+        bizId,
+        data: {
+          content: word,
+          appendMode: 'append',
+          finish: false
+        }
+      });
+    }
+    session.replyText(StreamFlag.IN_PROGRESS, {
+      bizType: ReceivedTextPacketType.NLG,
+      eof: ReceivedTextPacketEof.END,
+      bizId,
+      data: {
+        content: '',
+        appendMode: 'append',
+        finish: true
+      }
+    });
+    await mock.sleep(10);
+    session.replyText(StreamFlag.END);
+    await mock.sleep(500);
+    session.replyEvent(EventType.EVENT_END);
+    session.currentEvent = null;
+  })();
+});
+mock.hooks.hook('sendEventPayloadEnd', context => {
+  getSession(context.options.sessionId, context.options.eventId);
+  context.result = true;
+});
+mock.hooks.hook('sendEventChatBreak', context => {
+  const session = getSession(context.options.sessionId, context.options.eventId);
+  session.currentEvent.controller.abort(new Error('sendEventChatBreak'));
+  session.currentEvent = null;
+  context.result = true;
+});
+mock.hooks.hook('startRecordAndSendAudioData', context => {
+  const session = getSession(context.options.sessionId);
+  if (!session.currentEvent) {
+    throw new Error('startRecordAndSendAudioData event not exists');
+  }
+  context.result = true;
+  (async () => {
+    const {
+      controller
+    } = session.currentEvent.asrStatus;
+    const count = mock.data.get('recordAmplitudesCount');
+    if (count) {
+      const id = setInterval(() => {
+        dispatch('onRecordAmplitudes', {
+          amplitudes: new Array(count).fill(0).map(() => Math.random())
+        });
+      }, 100);
+      controller.signal.addEventListener('abort', () => {
+        clearInterval(id);
+        mock.data.delete('recordAmplitudesCountId');
+      });
+    }
+    const result = {
+      responseText: ''
+    };
+    await mock.hooks.callHook('asrDetection', result);
+    const responseText = result.responseText || '⚠️ No mock asr response matched!';
+    const bizId = generateId();
+    let finishResolve;
+    session.currentEvent.asrStatus.promise = new Promise(resolve => {
+      finishResolve = resolve;
+    });
+    const parts = splitString(responseText);
+    let text = '';
+    controller.signal.addEventListener('abort', async () => {
+      var _finishResolve;
+      await mock.sleep(300);
+      session.replyText(StreamFlag.IN_PROGRESS, {
+        bizType: ReceivedTextPacketType.ASR,
+        eof: ReceivedTextPacketEof.END,
+        bizId,
+        data: {
+          text
+        }
+      });
+      await mock.sleep(100);
+      session.replyText(StreamFlag.END);
+      (_finishResolve = finishResolve) === null || _finishResolve === void 0 || _finishResolve();
+    });
+    await mock.sleep(100);
+    if (controller.signal.aborted) {
+      return;
+    }
+    session.replyText(StreamFlag.START, {
+      bizType: ReceivedTextPacketType.ASR,
+      eof: ReceivedTextPacketEof.CONTINUE,
+      bizId,
+      data: {
+        text
+      }
+    });
+    for (const part of parts) {
+      if (controller.signal.aborted) {
+        break;
+      }
+      await mock.sleep(300);
+      if (controller.signal.aborted) {
+        break;
+      }
+      text += part;
+      session.replyText(StreamFlag.IN_PROGRESS, {
+        bizType: ReceivedTextPacketType.ASR,
+        eof: ReceivedTextPacketEof.CONTINUE,
+        bizId,
+        data: {
+          text
+        }
+      });
+    }
+  })();
+});
+mock.hooks.hook('stopRecordAndSendAudioData', context => {
+  const session = getSession(context.options.sessionId);
+  if (!session.currentEvent) {
+    throw new Error('stopRecordAndSendAudioData event not exists');
+  }
+  session.currentEvent.asrStatus.controller.abort(new Error('stopRecordAndSendAudioData'));
+  context.result = true;
+});
+mock.hooks.hook('startRecordAndSendVideoData', context => {
+  context.result = true;
+});
+mock.hooks.hook('stopRecordAndSendVideoData', context => {
+  context.result = true;
+});
+mock.hooks.hook('sendImageData', context => {
+  const session = getSession(context.options.sessionId);
+  if (!session.currentEvent) {
+    throw new Error('sendImageData event not exists');
+  }
+  session.currentEvent.data.push({
+    type: 'image',
+    path: context.options.path,
+    userData: context.options.userData
+  });
+  context.result = true;
+});
+mock.hooks.hook('sendTextData', context => {
+  context.result = true;
+  const session = getSession(context.options.sessionId);
+  if (!session.currentEvent) {
+    throw new Error('sendTextData event not exists');
+  }
+  session.currentEvent.data.push({
+    type: 'text',
+    text: context.options.text,
+    userData: context.options.userData
+  });
+});
+const filterRecords = query => {
+  var _query$sortType;
+  const rows = mock.getRecords().filter(row => {
+    var _query$id, _query$bizCode, _query$solutionCode, _query$devId, _query$homeId, _query$type, _query$index, _query$index2, _query$index3;
+    const item = row.record;
+    if ((_query$id = query.id) !== null && _query$id !== void 0 && _query$id.length && !query.id.includes(item.id)) {
+      return false;
+    }
+    if ((_query$bizCode = query.bizCode) !== null && _query$bizCode !== void 0 && _query$bizCode.length && (!item.bizCode || !query.bizCode.includes(item.bizCode))) {
+      return false;
+    }
+    if ((_query$solutionCode = query.solutionCode) !== null && _query$solutionCode !== void 0 && _query$solutionCode.length && (!item.solutionCode || !query.solutionCode.includes(item.solutionCode))) {
+      return false;
+    }
+    if ((_query$devId = query.devId) !== null && _query$devId !== void 0 && _query$devId.length && (!item.devId || !query.devId.includes(item.devId))) {
+      return false;
+    }
+    if ((_query$homeId = query.homeId) !== null && _query$homeId !== void 0 && _query$homeId.length && (item.homeId === undefined || !query.homeId.includes(item.homeId))) {
+      return false;
+    }
+    if ((_query$type = query.type) !== null && _query$type !== void 0 && _query$type.length && (!item.type || !query.type.includes(item.type))) {
+      return false;
+    }
+    if ((_query$index = query.index) !== null && _query$index !== void 0 && _query$index.length && (!item.index || !query.index.includes(item.index))) {
+      return false;
+    }
+    if ((_query$index2 = query.index1) !== null && _query$index2 !== void 0 && _query$index2.length && (!item.index1 || !query.index1.includes(item.index1))) {
+      return false;
+    }
+    if ((_query$index3 = query.index2) !== null && _query$index3 !== void 0 && _query$index3.length && (!item.index2 || !query.index2.includes(item.index2))) {
+      return false;
+    }
+    return true;
+  });
+  const sortType = (_query$sortType = query.sortType) !== null && _query$sortType !== void 0 ? _query$sortType : 0;
+  const result = rows.map(row => row.record).sort((a, b) => {
+    return sortType === 0 ? b.id - a.id : a.id - b.id;
+  });
+  if (query.offset) {
+    return result.slice(query.offset, query.limit ? query.offset + query.limit : undefined);
+  }
+  if (query.limit && query.limit > 0) {
+    return result.slice(0, query.limit);
+  }
+  return result;
+};
+mock.hooks.hook('queryRecordList', context => {
+  const options = context.options;
+
+  // 默认倒序
+  const records = filterRecords(options);
+  context.result = {
+    records,
+    total: records.length
+  };
+});
+mock.hooks.hook('deleteRecordList', context => {
+  const options = context.options;
+  const records = filterRecords(options);
+  records.map(_ref => {
+    let {
+      id
+    } = _ref;
+    return mock.deleteRecord(id);
+  });
+  context.result = true;
+});
+mock.hooks.hook('insertRecord', context => {
+  const options = context.options;
+  const {
+    bizCode,
+    solutionCode,
+    devId,
+    homeId,
+    type,
+    index,
+    index1,
+    index2,
+    data,
+    value,
+    value1,
+    value2
+  } = options;
+  const id = mock.getId();
+  mock.setRecord({
+    id,
+    record: {
+      id,
+      bizCode,
+      solutionCode,
+      devId,
+      homeId,
+      type,
+      index,
+      index1,
+      index2,
+      data,
+      value,
+      value1,
+      value2
+    }
+  });
+  context.result = {
+    id
+  };
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,11 @@
+import './defaultMock';
+export * from './abort';
+export * from './logger';
+export * from './mock';
+export * from './promisify';
+export * from './ttt';
+export * from './url';
+export * from './AIStream';
+export * from './observer';
+export * from './sendMessage';
+export * from './version';

package/dist/utils/index.js

@@ -0,0 +1,11 @@
+import './defaultMock';
+export * from './abort';
+export * from './logger';
+export * from './mock';
+export * from './promisify';
+export * from './ttt';
+export * from './url';
+export * from './AIStream';
+export * from './observer';
+export * from './sendMessage';
+export * from './version';

package/dist/utils/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: import("@ray-js/t-agent").Logger;
+export default logger;

package/dist/utils/logger.js

@@ -0,0 +1,3 @@
+import { getLogger } from '@ray-js/t-agent';
+const logger = getLogger('TAgent/plugins/AIStream');
+export default logger;

package/dist/utils/mock.d.ts

@@ -0,0 +1,48 @@
+import { Emitter } from '@ray-js/t-agent';
+import { Attribute } from '../AIStreamTypes';
+interface TTTCallContext {
+    options: any;
+    result: any;
+}
+interface SendToAIStreamContext {
+    data: Array<{
+        type: 'text';
+        text: string;
+        userData?: Attribute[];
+    } | {
+        type: 'image';
+        path: string;
+        userData?: Attribute[];
+    }>;
+    responseText: string | undefined;
+}
+interface AsrDetectionContext {
+    responseText: string | undefined;
+}
+type MockHooks = {
+    sendToAIStream: (context: SendToAIStreamContext) => any;
+    asrDetection: (context: AsrDetectionContext) => any;
+} & {
+    [fn: string]: (context: TTTCallContext) => any;
+};
+interface Row<T = any> {
+    id: number;
+    record: T;
+}
+declare const mock: {
+    loaded: boolean;
+    lastId: number;
+    database: Map<number, Row<any>>;
+    data: Map<string, any>;
+    sleep: (ms: number) => Promise<void>;
+    generateInt: (min: number, max: number) => number;
+    emitter: Emitter;
+    hooks: import("hookable").Hookable<MockHooks, string>;
+    getRecords: <T = any>() => Row<T>[];
+    getRecord: <T_1 = any>(id: number) => Row<T_1> | undefined;
+    setRecord: <T_2 = any>(entry: Row<T_2>) => void;
+    deleteRecord: (id: number) => void;
+    clearRecords: () => void;
+    getId: () => number;
+};
+export { mock };