@ray-js/t-agent 0.0.5-beta-1

package/dist/chat/index.d.ts

@@ -0,0 +1,12 @@
+import ChatAgent from './ChatAgent';
+import StreamResponse from './StreamResponse';
+import ChatTile from './ChatTile';
+import ChatBubbleTile from './ChatBubbleTile';
+import ChatMessage from './ChatMessage';
+import { generateId, safeParseJSON, sleep, generateInt, isAbortError, debounce, shuffleWithSeed } from './utils';
+import Logger, { getLogger } from './Logger';
+import { Emitter, EmitterEvent } from './Emitter';
+export { createHooks, Hookable } from 'hookable';
+export { ChatAgent, StreamResponse, ChatTile, ChatBubbleTile, ChatMessage, generateId, generateInt, safeParseJSON, getLogger, Logger, Emitter, EmitterEvent, isAbortError, sleep, debounce, shuffleWithSeed, };
+export * from './createChatAgent';
+export * from './types';

package/dist/chat/index.js

@@ -0,0 +1,12 @@
+import ChatAgent from './ChatAgent';
+import StreamResponse from './StreamResponse';
+import ChatTile from './ChatTile';
+import ChatBubbleTile from './ChatBubbleTile';
+import ChatMessage from './ChatMessage';
+import { generateId, safeParseJSON, sleep, generateInt, isAbortError, debounce, shuffleWithSeed } from './utils';
+import Logger, { getLogger } from './Logger';
+import { Emitter, EmitterEvent } from './Emitter';
+export { createHooks, Hookable } from 'hookable';
+export { ChatAgent, StreamResponse, ChatTile, ChatBubbleTile, ChatMessage, generateId, generateInt, safeParseJSON, getLogger, Logger, Emitter, EmitterEvent, isAbortError, sleep, debounce, shuffleWithSeed };
+export * from './createChatAgent';
+export * from './types';

package/dist/chat/types.d.ts

@@ -0,0 +1,177 @@
+import type ChatTile from './ChatTile';
+import type ChatMessage from './ChatMessage';
+import type ChatAgent from './ChatAgent';
+import type { Hookable } from 'hookable';
+import type { EventCallback, EventOptions } from './Emitter';
+export interface BubbleTileData {
+    status: BubbleTileStatus;
+    info?: string;
+}
+export interface TextTileData {
+    text: string;
+    markdown: boolean;
+}
+export interface ImageTileData {
+    src: string;
+}
+export interface VideoTileData {
+    src: string;
+    thumbUrl: string;
+    bizType?: string;
+}
+export interface TipTileData {
+    text: string;
+}
+export interface ButtonsTileData {
+    buttons: Array<{
+        text: string;
+        type?: string;
+        clickPayload: any;
+    }>;
+}
+export interface TimeTileData {
+    timestamp: number;
+}
+export interface RecommendationsTileData {
+    sort?: 'random' | 'order';
+    size?: number;
+    recommendations: Array<{
+        text: string;
+        clickPayload: any;
+    }>;
+}
+export interface DocumentsTileData {
+    documents: Array<{
+        title: string;
+        url: string;
+    }>;
+}
+export interface CardTileData {
+    card: ChatCardObject;
+}
+export declare enum ChatCardType {
+    CUSTOM = "custom",
+    BUILD_IN = "buildIn",
+    LOW_CODE = "lowCode"
+}
+export interface ChatCardObject<T = any> {
+    cardCode: string;
+    cardType: ChatCardType;
+    cardData: T;
+}
+export interface ChatTileObject<T = any> {
+    id: string;
+    type: string;
+    locked: boolean;
+    children: ChatTileObject[];
+    fallback?: TipTileData;
+    data: T;
+}
+export declare enum ChatMessageStatus {
+    START = 0,
+    UPDATING = 1,
+    FINISH = 2
+}
+/**
+ * 用于渲染的消息
+ */
+export interface ChatMessageObject {
+    id: string;
+    role: 'user' | 'assistant' | string;
+    tiles: ChatTileObject[];
+    status: ChatMessageStatus;
+    meta: ChatMessageObjectMeta;
+}
+export interface ChatMessageObjectMeta {
+    requestId?: string;
+    primaryIds?: Record<string, number>;
+    raw?: any;
+    [key: string]: any;
+}
+export interface InputBlock {
+    type: string;
+    [key: string]: any;
+}
+export declare enum BubbleTileStatus {
+    NORMAL = "normal",
+    WARNING = "warning",
+    ERROR = "error"
+}
+export interface AbortSignalObject {
+    aborted: boolean;
+    onabort: EventCallback;
+    reason: any;
+    throwIfAborted(): void;
+    addEventListener(type: string, callback: EventCallback, options?: EventOptions): void;
+    removeEventListener(type: string, callback: EventCallback): void;
+}
+export interface ChatAgentHooks {
+    onAgentStart: () => void;
+    onAgentDispose: () => void;
+    onChatStart: (result: {
+        messages: ChatMessage[];
+    }) => void;
+    onChatResume: (result: {
+        messages: ChatMessage[];
+    }) => void;
+    onMessageListInit: (result: {
+        messages: ChatMessage[];
+    }) => void;
+    onInputBlocksPush: (blocks: InputBlock[], signal?: AbortSignalObject) => void;
+    onMessageChange: (type: 'show' | 'update' | 'remove', message: ChatMessage) => void;
+    onMessagePersist: (payload: any, message: ChatMessage) => void;
+    onTileEvent: (tile: ChatTile, payload: any) => void;
+    onUserAbort: (reason: any) => void;
+    onError: (error: any) => void;
+}
+export type ChatAgentHooksWithOrder<K extends keyof ChatAgentHooks = keyof ChatAgentHooks> = {
+    [T in K]: ChatAgentHooks[K];
+} & {
+    [T in `${keyof ChatAgentHooks}:before`]: ChatAgentHooks[K];
+} & {
+    [T in `${keyof ChatAgentHooks}:after`]: ChatAgentHooks[K];
+};
+export interface ChatSessionHooks {
+    onChange: (key: string, value: any, oldValue: any) => void;
+}
+export type ChatAgentPluginHandler = {
+    [key: string]: unknown;
+    hooks?: Hookable;
+};
+export type ChatAgentPlugin<T extends ChatAgentPluginHandler = Record<string, any>> = (agent: ChatAgent) => T;
+export type AddHookCallback<H, T extends keyof H> = (fn: H[T], type?: 'before' | 'after' | undefined) => () => void;
+export interface ErrorPart {
+    type: 'error';
+    level: 'error' | 'warn';
+    error: Error;
+    meta: Record<string, any>;
+}
+export interface TextPart {
+    type: 'text';
+    delta: string;
+    text: string;
+    meta: Record<string, any>;
+}
+export interface AttachmentPart {
+    id: string;
+    type: 'attachment';
+    attachmentType: string;
+    attachment: any;
+    meta: Record<string, any>;
+}
+export type MessagePart = TextPart | AttachmentPart | ErrorPart;
+export declare enum FinishReason {
+    STOP = "stop",
+    ABORT = "abort",
+    ERROR = "error"
+}
+export type StreamResponseInstance = {
+    parts: () => AsyncIterable<MessagePart>;
+    cancel: (reason: any) => Promise<void>;
+};
+export type GetChatPluginHandler<T extends (...args: any[]) => (agent: ChatAgent) => unknown> = Omit<ReturnType<ReturnType<T>>, 'hooks'>;
+export interface ComposeHandler {
+    textCompose?: (message: ChatMessage, text: string, status: ChatMessageStatus) => Promise<string>;
+    attachmentCompose?: (message: ChatMessage, attachment: AttachmentPart) => Promise<ChatMessage[]>;
+    errorCompose?: (message: ChatMessage, text: string, error: any) => Promise<string>;
+}

package/dist/chat/types.js

@@ -0,0 +1,29 @@
+export let ChatCardType = /*#__PURE__*/function (ChatCardType) {
+  ChatCardType["CUSTOM"] = "custom";
+  ChatCardType["BUILD_IN"] = "buildIn";
+  ChatCardType["LOW_CODE"] = "lowCode";
+  return ChatCardType;
+}({});
+export let ChatMessageStatus = /*#__PURE__*/function (ChatMessageStatus) {
+  ChatMessageStatus[ChatMessageStatus["START"] = 0] = "START";
+  ChatMessageStatus[ChatMessageStatus["UPDATING"] = 1] = "UPDATING";
+  ChatMessageStatus[ChatMessageStatus["FINISH"] = 2] = "FINISH";
+  return ChatMessageStatus;
+}({});
+
+/**
+ * 用于渲染的消息
+ */
+
+export let BubbleTileStatus = /*#__PURE__*/function (BubbleTileStatus) {
+  BubbleTileStatus["NORMAL"] = "normal";
+  BubbleTileStatus["WARNING"] = "warning";
+  BubbleTileStatus["ERROR"] = "error";
+  return BubbleTileStatus;
+}({});
+export let FinishReason = /*#__PURE__*/function (FinishReason) {
+  FinishReason["STOP"] = "stop";
+  FinishReason["ABORT"] = "abort";
+  FinishReason["ERROR"] = "error";
+  return FinishReason;
+}({});

package/dist/chat/utils.d.ts

@@ -0,0 +1,32 @@
+export declare function generateId(length?: number): string;
+export declare function generateInt(min: number, max: number): number;
+export declare function deepCloneToPlainObject(obj: any): any;
+export declare function safeParseJSON<T = any>(str: any): T | undefined;
+export declare function deepMerge(target: any, source: any): any;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function isAbortError(reason: any): any;
+type AnyFunction = (...arguments_: readonly any[]) => unknown;
+/**
+ * Creates a debounced function that delays execution until `wait` milliseconds have passed since its last invocation.
+ *
+ * Set the `immediate` option to `true` to execute the function immediately at the start of the `wait` interval, preventing issues such as double-clicks on a button.
+ *
+ * The returned function has the following methods:
+ *
+ * - `.isPending` indicates whether the debounce delay is currently active.
+ * - `.clear()` cancels any scheduled executions.
+ * - `.flush()` if an execution is scheduled then it will be immediately executed and the timer will be cleared.
+ * - `.trigger()` executes the function immediately and clears the timer if it was previously set.
+ */
+export declare function debounce<F extends AnyFunction>(function_: F, wait?: number, options?: {
+    immediate?: boolean;
+}): DebouncedFunction<F>;
+interface DebouncedFunction<F extends AnyFunction> {
+    (...arguments_: Parameters<F>): ReturnType<F> | undefined;
+    readonly isPending: boolean;
+    clear(): void;
+    flush(): void;
+    trigger(): void;
+}
+export declare function shuffleWithSeed<T>(array: T[], seed: string): T[];
+export {};

package/dist/chat/utils.js

@@ -0,0 +1,207 @@
+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";
+/* eslint no-bitwise: 0 */
+
+export function generateId() {
+  let length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 16;
+  const characters = '0123456789abcdefghijklmnopqrstuvwxyz';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    result += characters[randomIndex];
+  }
+  return result;
+}
+export function generateInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1) + min);
+}
+export function deepCloneToPlainObject(obj) {
+  // 判断是否是对象或数组
+  if (obj === null || typeof obj !== 'object') {
+    return undefined;
+  }
+
+  // 如果是 Date 或其他不可直接 JSON 化的类型
+  if (obj instanceof Date) {
+    return obj.toISOString();
+  }
+  if (obj instanceof Array) {
+    return obj.map(item => deepCloneToPlainObject(item)).filter(item => item !== undefined); // 移除 undefined 项
+  }
+  if (obj instanceof Object) {
+    const plainObject = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        const value = deepCloneToPlainObject(obj[key]);
+        if (value !== undefined) {
+          // 只添加可以转换的值
+          plainObject[key] = value;
+        }
+      }
+    }
+    return plainObject;
+  }
+
+  // 如果遇到其他类型，直接忽略返回 undefined
+  return undefined;
+}
+export function safeParseJSON(str) {
+  if (str && typeof str === 'string') {
+    try {
+      return JSON.parse(str);
+    } catch (e) {
+      console.warn('safeParseJSON error:', e);
+    }
+  }
+  if (str && typeof str === 'object') {
+    return str;
+  }
+  return undefined;
+}
+export function deepMerge(target, source) {
+  if (typeof target !== 'object' || target === null) {
+    return source; // 如果目标不是对象，直接返回来源
+  }
+  if (typeof source !== 'object' || source === null) {
+    return target; // 如果来源不是对象，返回目标
+  }
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+
+      // 如果是对象，递归合并
+      if (typeof sourceValue === 'object' && sourceValue !== null) {
+        target[key] = deepMerge(Array.isArray(targetValue) ? [] : targetValue || {}, sourceValue);
+      } else {
+        // 否则直接赋值
+        target[key] = sourceValue;
+      }
+    }
+  }
+  return target;
+}
+export const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+export function isAbortError(reason) {
+  return reason && typeof Error !== 'undefined' && reason instanceof Error && reason.name === 'AbortError';
+}
+/**
+ * Creates a debounced function that delays execution until `wait` milliseconds have passed since its last invocation.
+ *
+ * Set the `immediate` option to `true` to execute the function immediately at the start of the `wait` interval, preventing issues such as double-clicks on a button.
+ *
+ * The returned function has the following methods:
+ *
+ * - `.isPending` indicates whether the debounce delay is currently active.
+ * - `.clear()` cancels any scheduled executions.
+ * - `.flush()` if an execution is scheduled then it will be immediately executed and the timer will be cleared.
+ * - `.trigger()` executes the function immediately and clears the timer if it was previously set.
+ */
+export function debounce(function_) {
+  let wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (typeof function_ !== 'function') {
+    throw new TypeError("Expected the first parameter to be a function, got `".concat(typeof function_, "`."));
+  }
+  if (wait < 0) {
+    throw new RangeError('`wait` must not be negative.');
+  }
+  const {
+    immediate = false
+  } = options;
+  let storedContext;
+  let storedArguments;
+  let timeoutId;
+  let timestamp;
+  let result;
+  function run() {
+    const callContext = storedContext;
+    const callArguments = storedArguments;
+    storedContext = undefined;
+    storedArguments = undefined;
+    result = function_.apply(callContext, callArguments);
+    return result;
+  }
+  function later() {
+    const last = Date.now() - timestamp;
+    if (last < wait && last >= 0) {
+      timeoutId = setTimeout(later, wait - last);
+    } else {
+      timeoutId = undefined;
+      if (!immediate) {
+        result = run();
+      }
+    }
+  }
+  const debounced = function () {
+    if (storedContext && this !== storedContext && Object.getPrototypeOf(this) === Object.getPrototypeOf(storedContext)) {
+      throw new Error('Debounced method called with different contexts of the same prototype.');
+    }
+    storedContext = this;
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    storedArguments = arguments_;
+    timestamp = Date.now();
+    const callNow = immediate && !timeoutId;
+    if (!timeoutId) {
+      timeoutId = setTimeout(later, wait);
+    }
+    if (callNow) {
+      result = run();
+    }
+    return result;
+  };
+  Object.defineProperty(debounced, 'isPending', {
+    get() {
+      return timeoutId !== undefined;
+    }
+  });
+  debounced.clear = () => {
+    if (!timeoutId) {
+      return;
+    }
+    clearTimeout(timeoutId);
+    timeoutId = undefined;
+  };
+  debounced.flush = () => {
+    if (!timeoutId) {
+      return;
+    }
+    debounced.trigger();
+  };
+  debounced.trigger = () => {
+    result = run();
+    debounced.clear();
+  };
+  return debounced;
+}
+function seedRandom(seed) {
+  let h = 0;
+  // 将字符串种子转化为哈希值
+  for (let i = 0; i < seed.length; i++) {
+    h = Math.imul(31, h) + seed.charCodeAt(i) | 0;
+  }
+
+  // 返回基于哈希值的随机数生成函数
+  return function () {
+    h ^= h >>> 13;
+    h ^= h << 17;
+    h ^= h >>> 5;
+    return (h >>> 0) / 4294967296;
+  };
+}
+
+// 根据种子随机打乱数组
+export function shuffleWithSeed(array, seed) {
+  const random = seedRandom(seed);
+  const result = array.slice(); // 复制数组，避免修改原数组
+
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(random() * (i + 1)); // 生成 0 到 i 的随机索引
+    [result[i], result[j]] = [result[j], result[i]]; // 交换元素
+  }
+  return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './chat';
+export * from './plugins/ui';
+export * from './plugins/debug';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './chat';
+export * from './plugins/ui';
+export * from './plugins/debug';

package/dist/plugins/debug.d.ts

@@ -0,0 +1,10 @@
+import { ChatAgent } from '../chat';
+export declare function withDebug(options?: {
+    autoStart?: boolean;
+    filter?: string | ((event: string) => boolean);
+}): (agent: ChatAgent) => {
+    debug: {
+        start: () => void;
+        stop: () => void;
+    };
+};

package/dist/plugins/debug.js

@@ -0,0 +1,33 @@
+import Logger from '../chat/Logger';
+export function withDebug(options) {
+  return agent => {
+    if (agent.plugins.debug) {
+      throw new Error('Debug plugin already exists');
+    }
+    const start = () => {
+      // debugs.push(
+      //   createDebugger(agent.hooks, { tag: 'ChatAgent', filter: options?.filter }),
+      //   createDebugger(agent.session.hooks, { tag: 'ChatSession', filter: options?.filter }),
+      // )
+      // for (const hook of agent.pluginHooks) {
+      //   debugs.push(createDebugger(hook, { tag: 'ChatPlugin', filter: options?.filter }))
+      // }
+      Logger.setLogLevel('debug');
+    };
+    if ((options === null || options === void 0 ? void 0 : options.autoStart) !== false) {
+      Promise.resolve().then(start);
+    }
+    return {
+      debug: {
+        start,
+        stop: () => {
+          Logger.setLogLevel('log');
+          // while (debugs.length) {
+          //   const debug = debugs.pop()
+          //   debug.close()
+          // }
+        }
+      }
+    };
+  };
+}

package/dist/plugins/ui.d.ts

@@ -0,0 +1,28 @@
+import { InputBlock, ChatMessageObject, ChatAgent, GetChatPluginHandler, Emitter } from '../chat';
+export type UIPlugin = GetChatPluginHandler<typeof withUI>;
+export interface UIEventMap {
+    messageListInit: {
+        messages: ChatMessageObject[];
+    };
+    messageChange: {
+        type: 'show' | 'update' | 'remove';
+        message: ChatMessageObject;
+    };
+    scrollToBottom: {
+        animation: boolean;
+    };
+    sendMessage: {
+        blocks: InputBlock[];
+    };
+    setInputBlocks: {
+        blocks: InputBlock[];
+    };
+    [key: string]: any;
+}
+export declare function withUI(): (agent: ChatAgent) => {
+    ui: {
+        emitter: Emitter;
+        emitEvent: <T extends keyof UIEventMap>(eventName: T, detail: UIEventMap[T]) => void;
+        onEvent: <T_1 extends keyof UIEventMap>(eventName: T_1, handler: (detail: UIEventMap[T_1]) => void) => () => void;
+    };
+};

package/dist/plugins/ui.js

@@ -0,0 +1,44 @@
+import "core-js/modules/esnext.iterator.map.js";
+import { Emitter, EmitterEvent } from '../chat';
+export function withUI() {
+  return agent => {
+    if (agent.plugins.ui) {
+      throw new Error('UI plugin already exists');
+    }
+    const emitter = new Emitter();
+    const emitEvent = (eventName, detail) => {
+      emitter.dispatchEvent(new EmitterEvent(eventName, {
+        detail
+      }));
+    };
+    agent.onMessageListInit(_ref => {
+      let {
+        messages
+      } = _ref;
+      const detail = {
+        messages: messages.map(m => m.toObject())
+      };
+      emitEvent('messageListInit', detail);
+    }, 'after');
+    agent.onMessageChange((type, message) => {
+      const detail = {
+        type,
+        message: message.toObject()
+      };
+      emitEvent('messageChange', detail);
+    }, 'after');
+    return {
+      ui: {
+        emitter,
+        emitEvent,
+        onEvent: (eventName, handler) => {
+          const cb = event => handler(event.detail);
+          emitter.addEventListener(eventName, cb);
+          return () => {
+            emitter.removeEventListener(eventName, cb);
+          };
+        }
+      }
+    };
+  };
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@ray-js/t-agent",
+  "version": "0.0.5-beta-1",
+  "author": "Tuya.inc",
+  "license": "MIT",
+  "private": false,
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "maintainers": [
+    "tuya_npm",
+    "tuyafe"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README-zh_CN.md"
+  ],
+  "dependencies": {
+    "hookable": "^5.5.3"
+  },
+  "scripts": {
+    "dev": "ray start --type=component --output dist --emit-declaration-dev",
+    "build": "ray build --type=component --output dist",
+    "clean": "rimraf ./dist"
+  },
+  "gitHead": "c2f10c94fb4031e1c375864e70a69adb3bbadd2d"
+}