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

package/dist/chat/ChatMessage.js

@@ -0,0 +1,173 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const _excluded = ["id", "tiles"];
+import "core-js/modules/esnext.iterator.constructor.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 { ChatMessageStatus } from './types';
+import ChatTile from './ChatTile';
+import ChatBubbleTile from './ChatBubbleTile';
+import { deepCloneToPlainObject, deepMerge, generateId } from './utils';
+export default class ChatMessage {
+  get isShow() {
+    return this._isShow;
+  }
+  get bubble() {
+    if (!this._bubble) {
+      for (const tile of this.tiles) {
+        if (tile.type === 'bubble') {
+          this._bubble = tile;
+          break;
+        }
+      }
+      if (!this._bubble) {
+        this._bubble = new ChatBubbleTile(this);
+        this.tiles.push(this._bubble);
+      }
+    }
+    return this._bubble;
+  }
+  constructor(agent, data) {
+    _defineProperty(this, "_isShow", false);
+    _defineProperty(this, "role", 'user');
+    _defineProperty(this, "tiles", []);
+    _defineProperty(this, "status", ChatMessageStatus.START);
+    _defineProperty(this, "meta", {});
+    this.agent = agent;
+    const {
+        id,
+        tiles
+      } = data,
+      rest = _objectWithoutProperties(data, _excluded);
+    Object.assign(this, rest);
+    this.id = id || generateId(16);
+    this.initTiles(null, tiles || []);
+  }
+  initTiles(root, tiles) {
+    for (const tile of tiles) {
+      let r;
+      if (root) {
+        r = root.addTile(tile.type, tile.data, tile.id);
+      } else {
+        r = this.addTile(tile.type, tile.data, tile.id);
+      }
+      if (tile.fallback) {
+        r.setFallback(tile.fallback);
+      }
+      this.initTiles(r, tile.children);
+    }
+  }
+  show() {
+    return this.agent.runWithCatchError(async () => {
+      if (this._isShow) {
+        console.warn('message is already show');
+        return;
+      }
+      await this.agent.hooks.callHook('onMessageChange:before', 'show', this);
+      await this.agent.hooks.callHook('onMessageChange', 'show', this);
+      this._isShow = true;
+      this.agent.session.bindMessage(this);
+      await this.agent.hooks.callHook('onMessageChange:after', 'show', this);
+    });
+  }
+  update() {
+    return this.agent.runWithCatchError(async () => {
+      if (!this._isShow) {
+        console.warn('message is not show');
+        return;
+      }
+      await this.agent.hooks.callHook('onMessageChange:before', 'update', this);
+      await this.agent.hooks.callHook('onMessageChange', 'update', this);
+      for (const tile of this.tiles) {
+        this.agent.session.bindTile(tile);
+      }
+      await this.agent.hooks.callHook('onMessageChange:after', 'update', this);
+    });
+  }
+  remove() {
+    return this.agent.runWithCatchError(async () => {
+      if (!this._isShow) {
+        console.warn('message is not show');
+        return;
+      }
+      await this.agent.hooks.callHook('onMessageChange:before', 'remove', this);
+      await this.agent.hooks.callHook('onMessageChange', 'remove', this);
+      this.agent.session.unbindMessage(this);
+      await this.agent.hooks.callHook('onMessageChange:after', 'remove', this);
+    });
+  }
+  _setIsShow() {
+    this._isShow = true;
+  }
+  persist(payload) {
+    return this.agent.runWithCatchError(async () => {
+      await this.agent.hooks.callHook('onMessagePersist:before', payload, this);
+      await this.agent.hooks.callHook('onMessagePersist', payload, this);
+      await this.agent.hooks.callHook('onMessagePersist:after', payload, this);
+    });
+  }
+  setTilesLocked(locked) {
+    for (const tile of this.tiles) {
+      tile.setLocked(locked);
+    }
+    return this;
+  }
+  removeTile(tile) {
+    const index = this.tiles.findIndex(t => t.id === tile.id);
+    if (index > -1) {
+      this.tiles.splice(index, 1);
+      this.agent.session.unbindTile(tile);
+      tile.children.forEach(t => this.agent.session.unbindTile(t));
+    }
+  }
+  addTile(type, data, id) {
+    const tile = type === 'bubble' ? new ChatBubbleTile(this, data, [], id) : new ChatTile(this, type, data, [], id);
+    this.tiles.push(tile);
+    return tile;
+  }
+  set(data) {
+    Object.assign(this, data);
+    return this;
+  }
+  setMetaValue(key, value) {
+    this.meta[key] = value;
+    return this;
+  }
+  setMeta(meta) {
+    let override = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    if (override) {
+      this.meta = meta;
+    } else {
+      this.meta = deepMerge(this.meta, meta);
+    }
+    return this;
+  }
+  deleteMetaValue(key) {
+    delete this.meta[key];
+    return this;
+  }
+  findTileByType(type) {
+    const ret = [];
+    const tiles = this.tiles;
+    for (const tile of tiles) {
+      if (tile.type === type) {
+        ret.push(tile);
+      }
+      if (tile.children.length > 0) {
+        ret.push(...tile.findByType(type));
+      }
+    }
+    return ret;
+  }
+  toObject() {
+    const meta = deepCloneToPlainObject(this.meta);
+    return {
+      id: this.id,
+      role: this.role,
+      tiles: this.tiles.map(tile => tile.toObject()),
+      status: this.status,
+      meta: meta || {}
+    };
+  }
+}

package/dist/chat/ChatSession.d.ts

@@ -0,0 +1,27 @@
+import { ChatSessionHooks } from './types';
+import { Hookable } from 'hookable';
+import ChatTile from './ChatTile';
+import ChatMessage from './ChatMessage';
+import ChatAgent from './ChatAgent';
+export default class ChatSession {
+    private agent;
+    private data;
+    private tileIdIndex;
+    hooks: Hookable<ChatSessionHooks>;
+    isNewChat: boolean;
+    sessionId: string;
+    readonly messages: Map<string, ChatMessage>;
+    constructor(agent: ChatAgent);
+    set: (key: string, value: any) => Promise<void>;
+    get: <T = any>(key: string, defaultValue?: T | undefined) => any;
+    getData: () => Record<string, any>;
+    initMessages: (messages: ChatMessage[]) => void;
+    getTileById: (id: string) => ChatTile<any> | undefined;
+    bindTile: (tile: ChatTile) => void;
+    unbindTile: (tile: ChatTile) => void;
+    bindMessage: (message: ChatMessage) => void;
+    unbindMessage: (message: ChatMessage) => void;
+    onChange: (fn: ChatSessionHooks['onChange']) => () => void;
+    getLatestMessage: () => ChatMessage | undefined;
+    dispose: () => Promise<void>;
+}

package/dist/chat/ChatSession.js

@@ -0,0 +1,89 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { ChatMessageStatus } from './types';
+import { createHooks } from 'hookable';
+export default class ChatSession {
+  constructor(agent) {
+    _defineProperty(this, "data", new Map());
+    _defineProperty(this, "tileIdIndex", new Map());
+    _defineProperty(this, "isNewChat", true);
+    _defineProperty(this, "sessionId", '');
+    _defineProperty(this, "messages", new Map());
+    _defineProperty(this, "set", async (key, value) => {
+      const oldValue = this.data.get(key);
+      if (oldValue === value) {
+        return;
+      }
+      await this.hooks.callHook('onChange', key, value, oldValue);
+      this.data.set(key, value);
+    });
+    _defineProperty(this, "get", (key, defaultValue) => {
+      if (!this.data.has(key)) {
+        return defaultValue;
+      }
+      return this.data.get(key);
+    });
+    _defineProperty(this, "getData", () => {
+      const ret = {};
+      for (const [key, value] of this.data.entries()) {
+        ret[key] = value;
+      }
+      return ret;
+    });
+    _defineProperty(this, "initMessages", messages => {
+      for (const message of messages) {
+        this.bindMessage(message);
+        message.set({
+          status: ChatMessageStatus.FINISH
+        })._setIsShow();
+      }
+    });
+    _defineProperty(this, "getTileById", id => {
+      return this.tileIdIndex.get(id);
+    });
+    _defineProperty(this, "bindTile", tile => {
+      this.tileIdIndex.set(tile.id, tile);
+      for (const child of tile.children) {
+        this.bindTile(child);
+      }
+    });
+    _defineProperty(this, "unbindTile", tile => {
+      this.tileIdIndex.delete(tile.id);
+      for (const child of tile.children) {
+        this.unbindTile(child);
+      }
+    });
+    _defineProperty(this, "bindMessage", message => {
+      this.messages.set(message.id, message);
+      for (const tile of message.tiles) {
+        this.bindTile(tile);
+      }
+    });
+    _defineProperty(this, "unbindMessage", message => {
+      this.messages.delete(message.id);
+      this.tileIdIndex.forEach(tile => {
+        if (tile.message.id === message.id) {
+          this.tileIdIndex.delete(tile.id);
+        }
+      });
+    });
+    _defineProperty(this, "onChange", fn => this.hooks.hook('onChange', fn));
+    _defineProperty(this, "getLatestMessage", () => {
+      return Array.from(this.messages.values()).pop();
+    });
+    _defineProperty(this, "dispose", async () => {
+      this.hooks.removeAllHooks();
+      this.data.clear();
+      this.tileIdIndex.clear();
+      this.messages.clear();
+    });
+    this.agent = agent;
+    this.hooks = createHooks();
+    const hooks = ['onChange'];
+    for (const hook of hooks) {
+      this[hook] = fn => this.hooks.hook(hook, fn);
+    }
+  }
+}

package/dist/chat/ChatTile.d.ts

@@ -0,0 +1,26 @@
+import { ChatTileObject, TipTileData } from './types';
+import ChatMessage from './ChatMessage';
+export default class ChatTile<T = any> implements ChatTileObject<T> {
+    readonly message: ChatMessage;
+    type: string;
+    data: T;
+    children: ChatTile[];
+    id: string;
+    locked: boolean;
+    fallback: undefined;
+    constructor(message: ChatMessage, type: string, data?: T, children?: ChatTile[], id?: string);
+    setLocked(value: boolean): this;
+    addTile(type: string, data: any, id?: string): ChatTile<any>;
+    /**
+     * 同 message 的 show
+     */
+    show(): Promise<void>;
+    /**
+     * 同 message 的 update
+     */
+    update(): Promise<void>;
+    setData(data: T): this;
+    setFallback(fallback: TipTileData): this;
+    findByType(type: string): ChatTile[];
+    toObject(): ChatTileObject;
+}

package/dist/chat/ChatTile.js

@@ -0,0 +1,75 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { generateId } from './utils';
+export default class ChatTile {
+  constructor(message, type) {
+    let data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    let children = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+    let id = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : generateId(16);
+    _defineProperty(this, "locked", false);
+    _defineProperty(this, "fallback", undefined);
+    this.message = message;
+    this.type = type;
+    this.data = data;
+    this.children = children;
+    this.id = id;
+  }
+  setLocked(value) {
+    this.locked = value;
+    // 递归锁定
+    for (const child of this.children) {
+      child.setLocked(value);
+    }
+    return this;
+  }
+  addTile(type, data, id) {
+    const tile = new ChatTile(this.message, type, data, [], id);
+    this.children.push(tile);
+    return tile;
+  }
+
+  /**
+   * 同 message 的 show
+   */
+  show() {
+    return this.message.show();
+  }
+
+  /**
+   * 同 message 的 update
+   */
+  update() {
+    return this.message.update();
+  }
+  setData(data) {
+    this.data = _objectSpread(_objectSpread({}, this.data), data);
+    return this;
+  }
+  setFallback(fallback) {
+    this.fallback = fallback;
+    return this;
+  }
+  findByType(type) {
+    let ret = [];
+    for (const tile of this.children) {
+      if (tile.type === type) {
+        ret.push(tile);
+      }
+      const t = tile.findByType(type);
+      ret = ret.concat(t);
+    }
+    return ret;
+  }
+  toObject() {
+    return {
+      id: this.id,
+      type: this.type,
+      locked: this.locked,
+      fallback: this.fallback,
+      children: this.children.map(child => child.toObject()),
+      data: this.data
+    };
+  }
+}

package/dist/chat/Emitter.d.ts

@@ -0,0 +1,28 @@
+export declare class EmitterEvent<T = any> {
+    type: string;
+    bubbles: boolean;
+    cancelable: boolean;
+    detail?: T;
+    reason?: any;
+    defaultPrevented?: boolean;
+    constructor(type: string, eventInitDict?: {
+        bubbles?: boolean;
+        cancelable?: boolean;
+        reason?: any;
+        detail?: T;
+    });
+}
+export type EventCallback = (event: EmitterEvent) => void;
+export type EventOptions = {
+    once?: boolean;
+};
+export declare class Emitter {
+    readonly listeners: Record<string, {
+        callback: EventCallback;
+        options?: EventOptions;
+    }[]>;
+    constructor();
+    addEventListener(type: string, callback: EventCallback, options?: EventOptions): void;
+    removeEventListener(type: string, callback: EventCallback): void;
+    dispatchEvent(event: EmitterEvent): boolean;
+}

package/dist/chat/Emitter.js

@@ -0,0 +1,61 @@
+export class EmitterEvent {
+  constructor(type, eventInitDict) {
+    var _eventInitDict$bubble, _eventInitDict$cancel;
+    this.type = type;
+    this.bubbles = (_eventInitDict$bubble = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles) !== null && _eventInitDict$bubble !== void 0 ? _eventInitDict$bubble : false;
+    this.cancelable = (_eventInitDict$cancel = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable) !== null && _eventInitDict$cancel !== void 0 ? _eventInitDict$cancel : false;
+    this.reason = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.reason;
+    this.detail = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail;
+  }
+}
+export class Emitter {
+  constructor() {
+    Object.defineProperty(this, 'listeners', {
+      value: {},
+      writable: true,
+      configurable: true
+    });
+  }
+  addEventListener(type, callback, options) {
+    if (!(type in this.listeners)) {
+      this.listeners[type] = [];
+    }
+    this.listeners[type].push({
+      callback,
+      options
+    });
+  }
+  removeEventListener(type, callback) {
+    if (!(type in this.listeners)) {
+      return;
+    }
+    const stack = this.listeners[type];
+    for (let i = 0, l = stack.length; i < l; i++) {
+      if (stack[i].callback === callback) {
+        stack.splice(i, 1);
+        return;
+      }
+    }
+  }
+  dispatchEvent(event) {
+    if (!(event.type in this.listeners)) {
+      return false;
+    }
+    const stack = this.listeners[event.type];
+    const stackToCall = stack.slice();
+    for (let i = 0, l = stackToCall.length; i < l; i++) {
+      const listener = stackToCall[i];
+      try {
+        listener.callback.call(this, event);
+      } catch (e) {
+        Promise.resolve().then(() => {
+          throw e;
+        });
+      }
+      if (listener.options && listener.options.once) {
+        this.removeEventListener(event.type, listener.callback);
+      }
+    }
+    return !event.defaultPrevented;
+  }
+}

package/dist/chat/Logger.d.ts

@@ -0,0 +1,16 @@
+export default class Logger {
+    static create(prefix: string): Logger;
+    static setLogLevel(level: string): void;
+    static mute(value?: boolean): void;
+    static setOnErrorHandler(handler: (...args: any[]) => void): void;
+    static _callOnErrorHandler(args: any[]): void;
+    private readonly prefix;
+    constructor(prefix: string);
+    debug(...args: any[]): void;
+    log(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    _output(level: string, args: any[]): void;
+}
+export declare function getLogger(prefix: string): Logger;

package/dist/chat/Logger.js

@@ -0,0 +1,90 @@
+import "core-js/modules/web.dom-collections.iterator.js";
+const LOG_LEVELS = ['debug', 'log', 'info', 'warn', 'error', 'none'];
+const DEFAULT_LOG_LEVEL = 'log';
+let currentLogLevelPos = LOG_LEVELS.indexOf(DEFAULT_LOG_LEVEL);
+let onErrorHandler;
+let muted = false;
+function passLevel(level) {
+  const messageLogLevelPos = LOG_LEVELS.indexOf(level);
+  return messageLogLevelPos >= currentLogLevelPos;
+}
+export default class Logger {
+  static create(prefix) {
+    return new Logger(prefix);
+  }
+  static setLogLevel(level) {
+    const newPos = LOG_LEVELS.indexOf(level);
+    if (newPos === -1) {
+      throw new Error("Incorrect log level: ".concat(level, ". Possible levels are: ").concat(LOG_LEVELS.join(', ')));
+    } else {
+      currentLogLevelPos = newPos;
+    }
+  }
+  static mute() {
+    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    muted = value;
+  }
+  static setOnErrorHandler(handler) {
+    onErrorHandler = handler;
+  }
+  static _callOnErrorHandler(args) {
+    if (onErrorHandler) {
+      try {
+        onErrorHandler(...args);
+      } catch (e) {
+        // better to nothing here to avoid infinite loop as logger.error() usually handles uncaught exceptions
+      }
+    }
+  }
+  constructor(prefix) {
+    this.prefix = prefix ? ["[".concat(prefix, "]")] : [];
+  }
+  debug() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    this._output('debug', args);
+  }
+  log() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    this._output('log', args);
+  }
+  info() {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    this._output('info', args);
+  }
+  warn() {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    this._output('warn', args);
+  }
+  error() {
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
+    }
+    this._output('error', args);
+    Logger._callOnErrorHandler(args);
+  }
+  _output(level, args) {
+    if (!muted && passLevel(level)) {
+      args = [...this.prefix, ...args];
+      if (typeof console[level] === 'function') {
+        console[level](...args);
+      } else {
+        console.log(...args);
+      }
+    }
+  }
+}
+const loggers = {};
+export function getLogger(prefix) {
+  if (!loggers[prefix]) {
+    loggers[prefix] = Logger.create(prefix);
+  }
+  return loggers[prefix];
+}

package/dist/chat/StreamResponse.d.ts

@@ -0,0 +1,22 @@
+import { MessagePart, StreamResponseInstance } from './types';
+export default class StreamResponse implements StreamResponseInstance {
+    private partStream;
+    /**
+     * Create a new StreamResponse instance.
+     *
+     * @param partStream
+     */
+    constructor(partStream: ReadableStream<MessagePart>);
+    /**
+     * Get all parts of the response as an async iterator.
+     */
+    parts(): {
+        [Symbol.asyncIterator](): AsyncGenerator<MessagePart, void, unknown>;
+    };
+    /**
+     * Cancel the response stream.
+     *
+     * @param reason
+     */
+    cancel(reason: any): Promise<void>;
+}

package/dist/chat/StreamResponse.js

@@ -0,0 +1,47 @@
+import _awaitAsyncGenerator from "@babel/runtime/helpers/esm/awaitAsyncGenerator";
+import _wrapAsyncGenerator from "@babel/runtime/helpers/esm/wrapAsyncGenerator";
+import "core-js/modules/es.symbol.async-iterator.js";
+export default class StreamResponse {
+  /**
+   * Create a new StreamResponse instance.
+   *
+   * @param partStream
+   */
+  constructor(partStream) {
+    this.partStream = partStream;
+  }
+
+  /**
+   * Get all parts of the response as an async iterator.
+   */
+  parts() {
+    const reader = this.partStream.getReader();
+    return {
+      [Symbol.asyncIterator]() {
+        return _wrapAsyncGenerator(function* () {
+          try {
+            while (true) {
+              const {
+                done,
+                value
+              } = yield _awaitAsyncGenerator(reader.read());
+              if (done) break;
+              yield value;
+            }
+          } finally {
+            reader.releaseLock();
+          }
+        })();
+      }
+    };
+  }
+
+  /**
+   * Cancel the response stream.
+   *
+   * @param reason
+   */
+  cancel(reason) {
+    return this.partStream.cancel(reason);
+  }
+}

package/dist/chat/createChatAgent.d.ts

@@ -0,0 +1,6 @@
+import { ChatAgentPlugin } from './types';
+import ChatAgent from './ChatAgent';
+type ExtractPluginReturnType<T extends ChatAgentPlugin<any>[]> = T extends [infer F, ...infer R] ? F extends ChatAgentPlugin<infer U> ? R extends ChatAgentPlugin<any>[] ? U & ExtractPluginReturnType<R> : U : never : Record<string, unknown>;
+export declare function createChatAgent<T extends ChatAgentPlugin<any>[]>(...plugins: T): ChatAgent<Omit<ExtractPluginReturnType<T>, 'hooks'>>;
+export declare function applyChatAgentPlugins<T extends Record<string, unknown>, P extends ChatAgentPlugin<any>[]>(agent: ChatAgent<T>, ...plugins: P): ChatAgent<T & ExtractPluginReturnType<P>>;
+export {};

package/dist/chat/createChatAgent.js

@@ -0,0 +1,21 @@
+import "core-js/modules/web.dom-collections.iterator.js";
+import ChatAgent from './ChatAgent';
+export function createChatAgent() {
+  const agent = new ChatAgent();
+  for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {
+    plugins[_key] = arguments[_key];
+  }
+  for (const plugin of plugins) {
+    agent.applyPlugin(plugin);
+  }
+  return agent;
+}
+export function applyChatAgentPlugins(agent) {
+  for (var _len2 = arguments.length, plugins = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    plugins[_key2 - 1] = arguments[_key2];
+  }
+  for (const plugin of plugins) {
+    agent.applyPlugin(plugin);
+  }
+  return agent;
+}