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

package/dist/chat/ChatAgent.d.ts

@@ -0,0 +1,157 @@
+import { Hookable } from 'hookable';
+import { AbortSignalObject, AddHookCallback, ChatAgentHooks, ChatAgentHooksWithOrder, ChatAgentPlugin, ComposeHandler, InputBlock, ChatMessageObject, StreamResponseInstance } from './types';
+import ChatSession from './ChatSession';
+import ChatMessage from './ChatMessage';
+type AddHook<T extends keyof ChatAgentHooks> = AddHookCallback<ChatAgentHooks, T>;
+/**
+ * ChatAgent
+ *
+ * @description ChatAgent is the core class of the chat agent, which is responsible for managing the chat session and the lifecycle of the chat agent.
+ */
+export default class ChatAgent<P extends Record<string, unknown> = Record<string, any>> {
+    private started;
+    readonly hooks: Hookable<ChatAgentHooksWithOrder>;
+    /**
+     * ChatSession
+     * The chat session associated with the chat agent
+     *
+     * @description ChatSession is used to manage the chat session, including the messages, tiles, etc.
+     */
+    readonly session: ChatSession;
+    /**
+     * onAgentStart hook
+     * This hook is called after the chat agent starts, you can use it to initialize the chat agent.
+     *
+     * @param fn hook callback
+     */
+    readonly onAgentStart: AddHook<'onAgentStart'>;
+    /**
+     * onChatStart hook
+     * This hook is called after the chat agent starts a new chat, you can use it to initialize messages.
+     *
+     * @param fn hook callback
+     */
+    readonly onChatStart: AddHook<'onChatStart'>;
+    /**
+     * onChatResume hook
+     * This hook is called after the chat agent resumes a chat, you can use it to resume the messages.
+     *
+     * @param fn hook callback
+     */
+    readonly onChatResume: AddHook<'onChatResume'>;
+    /**
+     * onMessageListInit hook
+     * This hook is called after onChatStart or onChatResume, it is used to initialize the message list, prepare the messages to show.
+     *
+     * @param fn hook callback
+     */
+    readonly onMessageListInit: AddHook<'onMessageListInit'>;
+    /**
+     * onInputBlocksPush hook
+     * This hook is called after the input blocks are pushed to the chat agent, you can use it to handle the input blocks, and send the input blocks to the assistant.
+     *
+     * @param fn hook callback
+     */
+    readonly onInputBlocksPush: AddHook<'onInputBlocksPush'>;
+    /**
+     * onMessageChange hook
+     * This hook is called after the message.show(), update() or remove(), you can use it to handle the message change.
+     *
+     * @param fn hook callback
+     */
+    readonly onMessageChange: AddHook<'onMessageChange'>;
+    /**
+     * onMessagePersist hook
+     * This hook is called after the message.persist(), you can use it to handle the message persist to the assistant.
+     *
+     * @param fn hook callback
+     */
+    readonly onMessagePersist: AddHook<'onMessagePersist'>;
+    /**
+     * onTileEvent hook
+     * This hook is called after the tile event is emitted, agent.emitTileEvent(), you can use it to handle the tile event.
+     *
+     * @param fn hook callback
+     */
+    readonly onTileEvent: AddHook<'onTileEvent'>;
+    /**
+     * onAgentDispose hook
+     * This hook is called before the chat agent is disposed, you can use it to clean up the resources.
+     *
+     * @param fn hook callback
+     */
+    readonly onAgentDispose: AddHook<'onAgentDispose'>;
+    /**
+     * onUserAbort hook
+     * This hook is called after the user aborts the chat, you can use it to handle the user abort event.
+     *
+     * @param fn hook callback
+     */
+    readonly onUserAbort: AddHook<'onUserAbort'>;
+    /**
+     * onError hook
+     * This hook is called after an error occurs, you can use it to handle the error.
+     *
+     * @param fn hook callback
+     */
+    readonly onError: AddHook<'onError'>;
+    pluginHooks: Hookable[];
+    /**
+     * Plugins
+     * The plugins applied to the chat agent
+     *
+     * @description Plugins are used to extend the functionality of the chat agent, you can apply a plugin to the chat agent by calling the applyPlugin method.
+     */
+    plugins: P;
+    constructor();
+    runWithCatchError: <T>(fn: () => T) => T;
+    /**
+     * Apply a plugin to the chat agent
+     *
+     * @param plugin ChatAgentPlugin
+     */
+    applyPlugin: <T extends Record<string, unknown>>(plugin: ChatAgentPlugin<T>) => void;
+    /**
+     * Start the chat agent
+     */
+    start: () => Promise<void>;
+    /**
+     * Dispose the chat agent
+     */
+    dispose: () => Promise<void>;
+    /**
+     * Push input blocks to the chat agent, which will trigger the onInputBlocksPush hook
+     *
+     * @param blocks input blocks, including text, image, video, etc.
+     * @param signal abort signal
+     */
+    pushInputBlocks: (blocks: InputBlock[], signal?: AbortSignalObject) => Promise<void>;
+    /**
+     * Create a new message object associated with the chat agent
+     *
+     * @param data message data, including role, status, etc.
+     */
+    createMessage: (data?: Partial<ChatMessageObject>) => ChatMessage;
+    /**
+     * Persist a message to the chat agent, which will trigger the onMessagePersist hook
+     *
+     * @param tileId tile id
+     * @param payload message payload
+     */
+    emitTileEvent: (tileId: string, payload: any) => Promise<void>;
+    /**
+     * Remove a message to the chat agent, which will trigger the onMessageChange hook
+     *
+     * @param messageId message id
+     */
+    removeMessage: (messageId: string) => Promise<void>;
+    /**
+     * Start a stream to show the response from the StreamResponseInstance, which will trigger the onMessageUpdate hook
+     *
+     * @param message render message instance
+     * @param response stream response instance
+     * @param composeHandler compose handler
+     */
+    flushStreamToShow: (message: ChatMessage, response: StreamResponseInstance, composeHandler: ComposeHandler) => Promise<ChatMessage[]>;
+}
+export {};

package/dist/chat/ChatAgent.js

@@ -0,0 +1,276 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const _excluded = ["hooks"];
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.async-iterator.js";
+import "core-js/modules/es.promise.finally.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+function _asyncIterator(r) { var n, t, o, e = 2; for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) { if (t && null != (n = r[t])) return n.call(r); if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r)); t = "@@asyncIterator", o = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
+function AsyncFromSyncIterator(r) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var n = r.done; return Promise.resolve(r.value).then(function (r) { return { value: r, done: n }; }); } return AsyncFromSyncIterator = function (r) { this.s = r, this.n = r.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function () { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function (r) { var n = this.s.return; return void 0 === n ? Promise.resolve({ value: r, done: !0 }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); }, throw: function (r) { var n = this.s.return; return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(r); }
+import { createHooks } from 'hookable';
+import { BubbleTileStatus, ChatMessageStatus } from './types';
+import ChatSession from './ChatSession';
+import ChatMessage from './ChatMessage';
+import { getLogger } from './Logger';
+import { isAbortError } from './utils';
+const logger = getLogger('TAgent/ChatAgent');
+/**
+ * ChatAgent
+ *
+ * @description ChatAgent is the core class of the chat agent, which is responsible for managing the chat session and the lifecycle of the chat agent.
+ */
+export default class ChatAgent {
+  constructor() {
+    _defineProperty(this, "started", false);
+    _defineProperty(this, "pluginHooks", []);
+    /**
+     * Plugins
+     * The plugins applied to the chat agent
+     *
+     * @description Plugins are used to extend the functionality of the chat agent, you can apply a plugin to the chat agent by calling the applyPlugin method.
+     */
+    _defineProperty(this, "plugins", {});
+    _defineProperty(this, "runWithCatchError", fn => {
+      try {
+        const ret = fn();
+        if (ret && ret.then) {
+          return ret.catch(error => {
+            this.hooks.callHook('onError:before', error).finally(() => this.hooks.callHook('onError', error)).finally(() => this.hooks.callHook('onError:after', error));
+            return Promise.reject(error);
+          });
+        }
+        return ret;
+      } catch (error) {
+        this.hooks.callHook('onError:before', error).finally(() => this.hooks.callHook('onError', error)).finally(() => this.hooks.callHook('onError:after', error));
+        throw error;
+      }
+    });
+    /**
+     * Apply a plugin to the chat agent
+     *
+     * @param plugin ChatAgentPlugin
+     */
+    _defineProperty(this, "applyPlugin", plugin => {
+      const handler = plugin(this);
+      if (handler) {
+        const {
+            hooks
+          } = handler,
+          rest = _objectWithoutProperties(handler, _excluded);
+        if (hooks) {
+          this.pluginHooks.push(hooks);
+        }
+        this.plugins = _objectSpread(_objectSpread({}, this.plugins), rest);
+      }
+    });
+    /**
+     * Start the chat agent
+     */
+    _defineProperty(this, "start", () => {
+      return this.runWithCatchError(async () => {
+        if (this.started) {
+          return;
+        }
+        await this.hooks.callHook('onAgentStart:before');
+        this.started = true;
+        await this.hooks.callHook('onAgentStart');
+        const result = {
+          messages: []
+        };
+        if (this.session.isNewChat) {
+          await this.hooks.callHook('onChatStart:before', result);
+          await this.hooks.callHook('onChatStart', result);
+          await this.hooks.callHook('onChatStart:after', result);
+          logger.debug('onChatStart', result);
+        } else {
+          await this.hooks.callHook('onChatResume:before', result);
+          await this.hooks.callHook('onChatResume', result);
+          await this.hooks.callHook('onChatResume:after', result);
+          logger.debug('onChatResume', result);
+        }
+        await this.hooks.callHook('onMessageListInit:before', result);
+        await this.hooks.callHook('onMessageListInit', result);
+        this.session.initMessages(result.messages);
+        await this.hooks.callHook('onMessageListInit:after', result);
+        await this.hooks.callHook('onAgentStart:after');
+      });
+    });
+    /**
+     * Dispose the chat agent
+     */
+    _defineProperty(this, "dispose", () => {
+      return this.runWithCatchError(async () => {
+        await this.hooks.callHook('onAgentDispose:before');
+        await this.hooks.callHook('onAgentDispose');
+        await this.session.dispose();
+        this.started = false;
+        for (const hook of this.pluginHooks) {
+          hook.removeAllHooks();
+        }
+        await this.hooks.callHook('onAgentDispose:after');
+        this.hooks.removeAllHooks();
+      });
+    });
+    /**
+     * Push input blocks to the chat agent, which will trigger the onInputBlocksPush hook
+     *
+     * @param blocks input blocks, including text, image, video, etc.
+     * @param signal abort signal
+     */
+    _defineProperty(this, "pushInputBlocks", (blocks, signal) => {
+      logger.debug('pushInputBlocks', blocks);
+      return this.runWithCatchError(async () => {
+        await this.hooks.callHook('onInputBlocksPush:before', blocks, signal);
+        await this.hooks.callHook('onInputBlocksPush', blocks, signal);
+        await this.hooks.callHook('onInputBlocksPush:after', blocks, signal);
+      });
+    });
+    /**
+     * Create a new message object associated with the chat agent
+     *
+     * @param data message data, including role, status, etc.
+     */
+    _defineProperty(this, "createMessage", data => {
+      return new ChatMessage(this, data || {});
+    });
+    /**
+     * Persist a message to the chat agent, which will trigger the onMessagePersist hook
+     *
+     * @param tileId tile id
+     * @param payload message payload
+     */
+    _defineProperty(this, "emitTileEvent", (tileId, payload) => {
+      logger.debug('emitTileEvent', {
+        tileId,
+        payload
+      });
+      return this.runWithCatchError(async () => {
+        const tile = this.session.getTileById(tileId);
+        await this.hooks.callHook('onTileEvent:before', tile, payload);
+        await this.hooks.callHook('onTileEvent', tile, payload);
+        await this.hooks.callHook('onTileEvent:after', tile, payload);
+      });
+    });
+    /**
+     * Remove a message to the chat agent, which will trigger the onMessageChange hook
+     *
+     * @param messageId message id
+     */
+    _defineProperty(this, "removeMessage", messageId => {
+      return this.runWithCatchError(async () => {
+        const message = this.session.messages.get(messageId);
+        if (!message) {
+          return;
+        }
+        await message.remove();
+      });
+    });
+    /**
+     * Start a stream to show the response from the StreamResponseInstance, which will trigger the onMessageUpdate hook
+     *
+     * @param message render message instance
+     * @param response stream response instance
+     * @param composeHandler compose handler
+     */
+    _defineProperty(this, "flushStreamToShow", async (message, response, composeHandler) => {
+      const {
+        attachmentCompose
+      } = composeHandler;
+      let {
+        textCompose,
+        errorCompose
+      } = composeHandler;
+      message.bubble.setIsMarkdown(true);
+      if (!message.isShow) {
+        await message.show();
+      }
+      const messages = [message];
+      textCompose = textCompose || ((_, text) => Promise.resolve(text));
+      let text = await textCompose(message, '', ChatMessageStatus.START);
+      await message.bubble.setText(text).update();
+      await this.runWithCatchError(async () => {
+        try {
+          const parts = response.parts();
+          var _iteratorAbruptCompletion = false;
+          var _didIteratorError = false;
+          var _iteratorError;
+          try {
+            for (var _iterator = _asyncIterator(parts), _step; _iteratorAbruptCompletion = !(_step = await _iterator.next()).done; _iteratorAbruptCompletion = false) {
+              const part = _step.value;
+              {
+                message.setMeta(part.meta);
+                if (part.type === 'text') {
+                  text = await textCompose(message, part.text, ChatMessageStatus.UPDATING);
+                  await message.set({
+                    status: ChatMessageStatus.UPDATING
+                  }).bubble.setText(text).update();
+                }
+                if (part.type === 'attachment' && attachmentCompose) {
+                  const list = (await attachmentCompose(message, part)) || [];
+                  for (const m of list) {
+                    m.set({
+                      status: ChatMessageStatus.FINISH
+                    });
+                    await m.show();
+                    messages.push(m);
+                  }
+                }
+                if (part.type === 'error') {
+                  if (part.level === 'error') {
+                    throw part.error;
+                  } else {
+                    await message.bubble.setStatus(BubbleTileStatus.WARNING).setText(part.error.message).update();
+                  }
+                }
+              }
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (_iteratorAbruptCompletion && _iterator.return != null) {
+                await _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+          text = await textCompose(message, text, ChatMessageStatus.FINISH);
+          await message.set({
+            status: ChatMessageStatus.FINISH
+          }).bubble.setText(text).update();
+        } catch (error) {
+          errorCompose = errorCompose || ((_, text, error) => Promise.resolve((error === null || error === void 0 ? void 0 : error.message) || ''));
+          const info = await errorCompose(message, text, error);
+          let status = BubbleTileStatus.ERROR;
+          if (isAbortError(error)) {
+            status = BubbleTileStatus.WARNING;
+          }
+          await message.set({
+            status: ChatMessageStatus.FINISH
+          }).bubble.setStatus(status).setText(text).setInfo(info).update();
+          throw error;
+        }
+      });
+      return messages;
+    });
+    this.hooks = createHooks();
+    const _hooks = ['onAgentStart', 'onChatStart', 'onChatResume', 'onMessageListInit', 'onInputBlocksPush', 'onMessageChange', 'onMessagePersist', 'onTileEvent', 'onAgentDispose', 'onUserAbort', 'onError'];
+    for (const hook of _hooks) {
+      this[hook] = (fn, type) => {
+        if (type === 'before') {
+          return this.hooks.hook("".concat(hook, ":before"), fn);
+        }
+        if (type === 'after') {
+          return this.hooks.hook("".concat(hook, ":after"), fn);
+        }
+        return this.hooks.hook(hook, fn);
+      };
+    }
+    this.session = new ChatSession(this);
+  }
+}

package/dist/chat/ChatBubbleTile.d.ts

@@ -0,0 +1,32 @@
+import ChatTile from './ChatTile';
+import ChatMessage from './ChatMessage';
+import { BubbleTileData, BubbleTileStatus, InputBlock } from './types';
+export default class ChatBubbleTile extends ChatTile<BubbleTileData> {
+    private textTile;
+    get isMarkdown(): any;
+    setIsMarkdown(value: boolean): this;
+    get text(): string;
+    setText(text: string): this;
+    get status(): BubbleTileStatus;
+    setStatus(status: BubbleTileStatus): this;
+    get info(): string;
+    setInfo(info: string): this;
+    constructor(_message: ChatMessage, data?: BubbleTileData, children?: ChatTile[], id?: string);
+    private ensureTextTile;
+    /**
+     * 使用 AIMessageContent[] 初始化气泡，text 会指向第一条 text content
+     * @param blocks
+     */
+    initWithInputBlocks(blocks: InputBlock[]): this;
+    toObject(): {
+        data: {
+            status: BubbleTileStatus;
+            info: string;
+        };
+        id: string;
+        type: string;
+        locked: boolean;
+        children: import("./types").ChatTileObject<any>[];
+        fallback?: import("./types").TipTileData | undefined;
+    };
+}

package/dist/chat/ChatBubbleTile.js

@@ -0,0 +1,104 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/web.dom-collections.iterator.js";
+import ChatTile from './ChatTile';
+import { BubbleTileStatus } from './types';
+import { generateId } from './utils';
+export default class ChatBubbleTile extends ChatTile {
+  get isMarkdown() {
+    var _this$textTile;
+    return ((_this$textTile = this.textTile) === null || _this$textTile === void 0 || (_this$textTile = _this$textTile.data) === null || _this$textTile === void 0 ? void 0 : _this$textTile.markdown) || false;
+  }
+  setIsMarkdown(value) {
+    this.ensureTextTile();
+    this.textTile.data.markdown = value;
+    return this;
+  }
+  get text() {
+    var _this$textTile2;
+    if (!((_this$textTile2 = this.textTile) !== null && _this$textTile2 !== void 0 && _this$textTile2.data)) {
+      return '';
+    }
+    return this.textTile.data.text;
+  }
+  setText(text) {
+    this.ensureTextTile();
+    this.textTile.data.text = text;
+    return this;
+  }
+  get status() {
+    return this.data.status || BubbleTileStatus.NORMAL;
+  }
+  setStatus(status) {
+    this.data.status = status;
+    return this;
+  }
+  get info() {
+    return this.data.info || '';
+  }
+  setInfo(info) {
+    this.data.info = info;
+    return this;
+  }
+  constructor(_message) {
+    let data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      status: BubbleTileStatus.NORMAL
+    };
+    let children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    let id = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : generateId(16);
+    super(_message, 'bubble', data, children, id);
+  }
+  ensureTextTile() {
+    if (!this.textTile) {
+      for (const child of this.children) {
+        if (child.type === 'text') {
+          this.textTile = child;
+          break;
+        }
+      }
+      if (!this.textTile) {
+        this.textTile = new ChatTile(this.message, 'text', {
+          text: ''
+        });
+        this.children.push(this.textTile);
+      }
+    }
+  }
+
+  /**
+   * 使用 AIMessageContent[] 初始化气泡，text 会指向第一条 text content
+   * @param blocks
+   */
+  initWithInputBlocks(blocks) {
+    this.textTile = null;
+    this.children = [];
+    for (const block of blocks) {
+      if (block.type === 'text') {
+        if (!this.textTile) {
+          this.textTile = new ChatTile(this.message, 'text', {
+            text: block.text
+          });
+          this.setText(block.text);
+          this.children.push(this.textTile);
+        }
+      } else if (block.type === 'image_url') {
+        this.message.addTile('image', {
+          src: block.image_url.url
+        });
+      } else if (block.type === 'video_url') {
+        this.message.addTile('video', {
+          src: block.video_url.url,
+          thumbUrl: block.video_url.thumb_url
+        });
+      }
+    }
+    return this;
+  }
+  toObject() {
+    return _objectSpread(_objectSpread({}, super.toObject()), {}, {
+      data: {
+        status: this.status,
+        info: this.info
+      }
+    });
+  }
+}

package/dist/chat/ChatMessage.d.ts

@@ -0,0 +1,32 @@
+import { ChatMessageObject, ChatMessageObjectMeta, ChatMessageStatus } from './types';
+import ChatTile from './ChatTile';
+import ChatBubbleTile from './ChatBubbleTile';
+import ChatAgent from './ChatAgent';
+export default class ChatMessage implements ChatMessageObject {
+    private agent;
+    id: string;
+    private _isShow;
+    protected _bubble: ChatBubbleTile;
+    role: 'user' | 'assistant' | string;
+    tiles: ChatTile[];
+    status: ChatMessageStatus;
+    meta: ChatMessageObjectMeta;
+    get isShow(): boolean;
+    get bubble(): ChatBubbleTile;
+    constructor(agent: ChatAgent, data: Partial<ChatMessageObject>);
+    private initTiles;
+    show(): Promise<void>;
+    update(): Promise<void>;
+    remove(): Promise<void>;
+    _setIsShow(): void;
+    persist(payload: any): Promise<void>;
+    setTilesLocked(locked: boolean): this;
+    removeTile(tile: ChatTile): void;
+    addTile(type: string, data: any, id?: string): ChatTile<any>;
+    set(data: Omit<Partial<ChatMessageObject>, 'id'>): this;
+    setMetaValue(key: string, value: any): this;
+    setMeta(meta: Record<string, any>, override?: boolean): this;
+    deleteMetaValue(key: string): this;
+    findTileByType<T>(type: string): ChatTile<T>[];
+    toObject(): ChatMessageObject;
+}