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

package/dist/utils/ttt.d.ts

@@ -0,0 +1,99 @@
+import { ApiRequestByAtopParams, ApiRequestByHighwayParams, AudioBody, AuthorizeParams, AuthorizePolicyStatusParams, CanIUseRouterParams, CheckConnectParams, CheckConnectResult, 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 } 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 isDevTools: () => boolean;
+export declare const apiRequestByAtop: (options?: Omit<ApiRequestByAtopParams, "success" | "fail"> | undefined) => Promise<{
+    thing_json_?: any;
+    data: string;
+}>;
+export declare const apiRequestByHighway: (options?: Omit<ApiRequestByHighwayParams, "success" | "fail"> | undefined) => Promise<{
+    thingjson?: any;
+    data: string;
+}>;
+export declare const createNativeEventManager: (options: {
+    name: string;
+}) => any;
+export declare const getCurrentHomeInfo: (options?: Omit<GetCurrentHomeInfoParams, "success" | "fail"> | undefined) => Promise<{
+    homeName: string;
+    homeId: string;
+    longitude: string;
+    latitude: string;
+    address: string;
+    admin: boolean;
+}>;
+export declare const authorize: (options?: Omit<AuthorizeParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const getAppInfo: (options?: Omit<GetAppInfoParams, "success" | "fail"> | undefined) => Promise<{
+    serverTimestamp: number;
+    appVersion: string;
+    language: string;
+    countryCode: string;
+    regionCode: string;
+    appName: string;
+    appIcon: string;
+    appEnv?: number | undefined;
+    appBundleId: string;
+    appScheme: string;
+    appId: string;
+    clientId?: string | undefined;
+}>;
+export declare const canIUseRouter: (options?: Omit<CanIUseRouterParams, "success" | "fail"> | undefined) => Promise<{
+    result: boolean;
+}>;
+export declare const router: (options?: Omit<RouterParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const navigateToMiniProgram: (options?: Omit<NavigateToMiniProgramParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const openInnerH5: (options?: Omit<OpenInnerH5Params, "success" | "fail"> | undefined) => Promise<null>;
+export declare const authorizePolicyStatus: (options?: Omit<AuthorizePolicyStatusParams, "success" | "fail"> | undefined) => Promise<{
+    sign: import("../AIStreamTypes").AuthorizePolicySign;
+}>;
+export declare const registerChannel: (options?: Omit<RegisterChannelParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const listenReceiveMessage: (listener: (params: EventChannelMessageParams) => void) => () => void;
+export declare const openMiniWidget: (options?: Omit<OpenMiniWidgetParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const isConnectSync: (params: CheckConnectParams) => CheckConnectResult;
+export declare const connect: (options?: Omit<ConnectParams, "success" | "fail"> | undefined) => Promise<{
+    connectionId: string;
+}>;
+export declare const disconnect: (options?: Omit<DisconnectParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const queryAgentToken: (options?: Omit<QueryAgentTokenParams, "success" | "fail"> | undefined) => Promise<{
+    agentToken: string;
+    bizConfig: import("../AIStreamTypes").BizConfig;
+}>;
+export declare const createSession: (options?: Omit<CreateSessionParams, "success" | "fail"> | undefined) => Promise<{
+    sessionId: string;
+    sendDataChannels: string[];
+    revDataChannels: string[];
+}>;
+export declare const closeSession: (options?: Omit<CloseSessionParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const sendEventStart: (options?: Omit<SendEventStartParams, "success" | "fail"> | undefined) => Promise<{
+    eventId: string;
+}>;
+export declare const sendEventPayloadEnd: (options?: Omit<SendEventPayloadEndParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const sendEventEnd: (options?: Omit<SendEventEndParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const sendEventChatBreak: (options?: Omit<SendEventChatBreakParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const startRecordAndSendAudioData: (options?: Omit<StartRecordAndSendAudioDataParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const stopRecordAndSendAudioData: (options?: Omit<StopRecordAndSendAudioDataParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const sendImageData: (options?: Omit<SendImageDataParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const sendTextData: (options?: Omit<SendTextDataParams, "success" | "fail"> | undefined) => Promise<null>;
+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 listenEventReceived: (listener: (params: EventBody) => 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;
+export declare const listenConnectStateChanged: (listener: (params: ConnectStateBody) => void) => () => void;
+export declare const listenSessionStateChanged: (listener: (params: SessionStateBody) => void) => () => void;
+export declare const listenRecordAmplitudes: (listener: (params: RecordAmplitudesBody) => void) => () => void;
+export declare const queryRecordList: (options?: Omit<QueryRecordListParams, "success" | "fail"> | undefined) => Promise<{
+    records: import("../AIStreamTypes").RecordBody[];
+    total: number;
+}>;
+export declare const deleteRecordList: (options?: Omit<DeleteRecordListParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const updateRecord: (options?: Omit<UpdateRecordParams, "success" | "fail"> | undefined) => Promise<null>;
+export declare const insertRecord: (options?: Omit<InsertRecordParams, "success" | "fail"> | undefined) => Promise<{
+    id: number;
+}>;

package/dist/utils/ttt.js

@@ -0,0 +1,97 @@
+import { listening, promisify } from './promisify';
+import { ConnectClientType, ConnectState } from '../AIStreamTypes';
+import { generateId } from '@ray-js/t-agent';
+export const getMiniAppConfig = promisify(ty.getMiniAppConfig, true);
+export const getAccountInfo = promisify(ty.getAccountInfo, true);
+export const isDevTools = () => {
+  return ty.getSystemInfoSync().brand === 'devtools';
+};
+export const apiRequestByAtop = promisify(ty.apiRequestByAtop);
+export const apiRequestByHighway = promisify(ty.apiRequestByHighway);
+export const createNativeEventManager = options => {
+  if (isDevTools) {
+    return {
+      onListener: () => null,
+      offerListener: () => null
+    };
+  }
+  return ty.createNativeEventManager(options);
+};
+export const getCurrentHomeInfo = promisify(ty.home.getCurrentHomeInfo);
+export const authorize = promisify(ty.authorize, true);
+export const getAppInfo = promisify(ty.getAppInfo);
+export const canIUseRouter = promisify(ty.canIUseRouter);
+export const router = promisify(ty.router);
+export const navigateToMiniProgram = promisify(ty.navigateToMiniProgram);
+export const openInnerH5 = promisify(ty.openInnerH5);
+export const authorizePolicyStatus = promisify(
+// @ts-ignore
+ty.authorizePolicyStatus);
+export const registerChannel = promisify(ty.registerChannel);
+export const listenReceiveMessage = listening(ty.onReceiveMessage, ty.offReceiveMessage);
+export const openMiniWidget = promisify(ty.openMiniWidget);
+export const isConnectSync = params => {
+  if (isDevTools()) {
+    return {
+      connected: true,
+      state: ConnectState.CONNECTED,
+      connectionId: generateId(),
+      clientType: ConnectClientType.APP
+    };
+  }
+  return ty.aistream.isConnectedSync(params);
+};
+export const connect = promisify(ty.aistream.connect, true);
+export const disconnect = promisify(ty.aistream.disconnect, true);
+export const queryAgentToken = promisify(ty.aistream.queryAgentToken, true);
+export const createSession = promisify(ty.aistream.createSession, true);
+export const closeSession = promisify(ty.aistream.closeSession, true);
+export const sendEventStart = promisify(ty.aistream.sendEventStart, true);
+export const sendEventPayloadEnd = promisify(ty.aistream.sendEventPayloadEnd, true);
+export const sendEventEnd = promisify(ty.aistream.sendEventEnd, true);
+export const sendEventChatBreak = promisify(ty.aistream.sendEventChatBreak, true);
+export const startRecordAndSendAudioData = promisify(ty.aistream.startRecordAndSendAudioData, true);
+export const stopRecordAndSendAudioData = promisify(ty.aistream.stopRecordAndSendAudioData, true);
+
+// export const startRecordAndSendVideoData = promisify<StartRecordAndSendVideoDataParams>(
+//   ty.aistream.startRecordAndSendVideoData,
+//   true
+// );
+//
+// export const stopRecordAndSendVideoData = promisify<StopRecordAndSendVideoDataParams>(
+//   ty.aistream.stopRecordAndSendVideoData,
+//   true
+// );
+
+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 sendFileData = promisify<SendFileDataParams>(ty.aistream.sendFileData);
+
+export const listenEventReceived = listening(ty.aistream.onEventReceived, ty.aistream.offEventReceived, true);
+export const listenAudioReceived = listening(ty.aistream.onAudioReceived, ty.aistream.offAudioReceived, true);
+
+// export const listenVideoReceived = listening<VideoBody>(
+//   ty.aistream.onVideoReceived,
+//   ty.aistream.offVideoReceived,
+//   true
+// );
+
+export const listenTextReceived = listening(ty.aistream.onTextReceived, ty.aistream.offTextReceived, true);
+export const listenImageReceived = listening(ty.aistream.onImageReceived, ty.aistream.offImageReceived, true);
+
+// export const listenFileReceived = listening<FileBody>(
+//   ty.aistream.onFileReceived,
+//   ty.aistream.offFileReceived,
+//   true
+// );
+
+export const listenConnectStateChanged = listening(ty.aistream.onConnectStateChanged, ty.aistream.offConnectStateChanged, true);
+export const listenSessionStateChanged = listening(ty.aistream.onSessionStateChanged, ty.aistream.offSessionStateChanged, true);
+export const listenRecordAmplitudes = listening(ty.aistream.onRecordAmplitudes, ty.aistream.offRecordAmplitudes, true);
+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);

package/dist/utils/url.d.ts

@@ -0,0 +1,11 @@
+export declare function parseMiniAppURL(url: string): {
+    appId: string;
+    path: string;
+    query: Record<string, string | undefined>;
+    queryStr: string;
+} | {
+    query: Record<string, string | undefined>;
+    queryStr: string;
+    appId: string;
+    path?: undefined;
+} | null;

package/dist/utils/url.js

@@ -0,0 +1,31 @@
+import Url from 'url-parse';
+export function parseMiniAppURL(url) {
+  if (!url || !(url.startsWith('tuyaSmart://miniApp') || url.startsWith('thingsmart://miniApp'))) {
+    return null;
+  }
+  const u = new Url(url, true);
+  const uq = new Url(url, false);
+  if (u.query.url) {
+    const url = new Url(u.query.url, true);
+    const uq = new Url(u.query.url, false);
+    return {
+      appId: url.hostname,
+      path: url.pathname,
+      query: url.query,
+      queryStr: uq.query
+    };
+  }
+  if (u.query.uniqueCode) {
+    return {
+      query: u.query,
+      queryStr: uq.query,
+      appId: u.query.uniqueCode
+    };
+  }
+  return {
+    appId: '',
+    path: u.pathname,
+    query: u.query,
+    queryStr: u.query.toString()
+  };
+}

package/dist/utils/version.d.ts

@@ -0,0 +1 @@
+export declare function isVersionMatch(range: string, version: string): boolean;

package/dist/utils/version.js

@@ -0,0 +1,63 @@
+import "core-js/modules/es.string.trim.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.every.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/esnext.iterator.some.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+function parseVersion(v) {
+  const parts = v.split('.');
+  if (parts.length !== 3 || parts.some(p => isNaN(Number(p)))) {
+    throw new Error("Invalid version: ".concat(v));
+  }
+  return parts.map(Number);
+}
+function compareVersions(a, b) {
+  const [a1, a2, a3] = parseVersion(a);
+  const [b1, b2, b3] = parseVersion(b);
+  if (a1 !== b1) return a1 - b1;
+  if (a2 !== b2) return a2 - b2;
+  return a3 - b3;
+}
+function matchSingleCondition(version, condition) {
+  const trimmed = condition.trim();
+  if (!trimmed) return true;
+  if (trimmed.startsWith('^')) {
+    const base = trimmed.slice(1);
+    const [major] = parseVersion(base);
+    return compareVersions(version, base) >= 0 && parseVersion(version)[0] === major;
+  }
+  if (trimmed.startsWith('~')) {
+    const base = trimmed.slice(1);
+    const [major, minor] = parseVersion(base);
+    const [vMajor, vMinor] = parseVersion(version);
+    return compareVersions(version, base) >= 0 && vMajor === major && vMinor === minor;
+  }
+  if (trimmed.startsWith('>=')) {
+    return compareVersions(version, trimmed.slice(2)) >= 0;
+  }
+  if (trimmed.startsWith('>')) {
+    return compareVersions(version, trimmed.slice(1)) > 0;
+  }
+  if (trimmed.startsWith('<=')) {
+    return compareVersions(version, trimmed.slice(2)) <= 0;
+  }
+  if (trimmed.startsWith('<')) {
+    return compareVersions(version, trimmed.slice(1)) < 0;
+  }
+  if (trimmed.startsWith('=')) {
+    return compareVersions(version, trimmed.slice(1)) === 0;
+  }
+
+  // 默认等于
+  return compareVersions(version, trimmed) === 0;
+}
+export function isVersionMatch(range, version) {
+  try {
+    parseVersion(version);
+    const conditions = range.split(' ').filter(Boolean);
+    return conditions.every(cond => matchSingleCondition(version, cond));
+  } catch (err) {
+    return false;
+  }
+}

package/dist/withAIStream.d.ts

@@ -0,0 +1,64 @@
+import { ChatAgent, ChatMessage, ComposeHandler, InputBlock } from '@ray-js/t-agent';
+import { ConnectClientType } from './AIStreamTypes';
+import { ChatHistoryStore, StoredMessageObject } from './ChatHistoryStore';
+export interface AIStreamOptions {
+    /** client 类型: 1-作为设备代理, 2-作为 App */
+    clientType?: ConnectClientType;
+    /** 代理的设备ID, clientType == 1 时必传 */
+    deviceId?: string;
+    agentId?: string;
+    channel?: string;
+    /** 打开小程序的链接，取链接参数字段 aiPtChannel */
+    aiPtChannel?: string;
+    sessionId?: string;
+    tokenApi?: string;
+    tokenApiVersion?: string;
+    /** 历史消息数量，默认1000，为0的话，则已分页的方式取全部数据 */
+    historySize?: number;
+    /** 是否支持多模态 */
+    multiModal?: boolean;
+    wireInput?: boolean;
+    /** 索引ID，如果传了 createChatHistoryStore，则会覆盖 */
+    indexId?: string;
+    /** 家庭id，不填默认当前家庭 */
+    homeId?: number;
+    /** 自定义消息存储, 返回的实例需要实现 ChatHistoryStore 接口 */
+    createChatHistoryStore?: (agent: ChatAgent) => ChatHistoryStore;
+    messageOptions?: {
+        device_id?: string;
+        [key: string]: string;
+    };
+}
+export interface AIStreamHooks {
+    onMessageParse: (msgItem: StoredMessageObject, result: {
+        messages: ChatMessage[];
+    }) => void;
+    onSkillCompose: (skill: any, respMsg: ChatMessage, result: {
+        messages: ChatMessage[];
+    }) => void;
+}
+export declare function withAIStream(options?: AIStreamOptions): (agent: ChatAgent) => {
+    hooks: import("hookable").Hookable<any, string>;
+    assistant: {
+        send: (blocks: InputBlock[], signal?: AbortSignal, extraOptions?: Record<string, any>) => {
+            response: import("@ray-js/t-agent").StreamResponse;
+            metaPromise: Promise<Record<string, any>>;
+        };
+        chat: (blocks: InputBlock[], signal?: AbortSignal, options?: {
+            sendBy?: string | undefined;
+            responseBy?: string | undefined;
+            extraOptions?: Record<string, any> | undefined;
+        } | undefined) => Promise<ChatMessage[]>;
+        composeHandler: ComposeHandler;
+        options: AIStreamOptions;
+        removeMessage: (message: ChatMessage) => Promise<void>;
+        clearAllMessages: () => Promise<void>;
+        feedback: ({ requestId, type, }: {
+            requestId: string;
+            type: 'like' | 'unlike';
+        }) => Promise<{
+            thingjson?: any;
+            data: string;
+        } | null>;
+    };
+};