@agentica/rpc 0.43.2 → 0.44.0-dev.20260313

package/src/AgenticaRpcListener.ts

@@ -1,7 +1,7 @@
-// export class AgenticaRpcListener {
-//   public constructor() {}
-
-//   public on() {}
-
-//   public off() {}
-// }
+// export class AgenticaRpcListener {
+//   public constructor() {}
+
+//   public on() {}
+
+//   public off() {}
+// }

package/src/AgenticaRpcService.ts

@@ -1,124 +1,124 @@
-import type { Agentica, IAgenticaController } from "@agentica/core";
-
-import type { IAgenticaRpcListener } from "./IAgenticaRpcListener";
-import type { IAgenticaRpcService } from "./IAgenticaRpcService";
-
-/**
- * RPC service for the {@link Agentica}.
- *
- * `AgenticaRpcService` is class defining an AI agent service
- * provided from the server to clients through the RPC (Remote Procedure Call)
- * paradigm in the websocket protocol.
- *
- * Client connecting to the `AgenticaRpcService` providing websocket server
- * will call the {@link conversate} function remotely through its basic
- * interface type {@link IAgenticaRpcService} with the RPC paradigm.
- *
- * Also, the client provides the {@link IAgenticaRpcListener} type to the
- * server, so that `AgenticaRpcService` will remotely call the
- * {@link IAgenticaRpcListener listener}'s functions internally.
- *
- * You can open the WebSocket server of the AI agent like below:
- *
- * ```typescript
- * import {
- *   IAgenticaRpcListener,
- *   IAgenticaRpcService,
- *   Agentica,
- *   AgenticaRpcService,
- * } from "@agentica/core";
- * import { WebSocketServer } from "tgrid";
- *
- * const server: WebSocketServer<
- *   null,
- *   IAgenticaRpcService,
- *   IAgenticaRpcListener
- * > = new WebSocketServer();
- * await server.open(3001, async (acceptor) => {
- *   await acceptor.accept(
- *     new AgenticaRpcService({
- *       agent: new Agentica({ ... }),
- *       listener: acceptor.getDriver(),
- *     }),
- *   );
- * });
- * ```
- *
- * @author Samchon
- */
-export class AgenticaRpcService
-implements IAgenticaRpcService {
-  /**
-   * Initializer Constructor.
-   *
-   * @param props Properties to construct the RPC service
-   */
-  public constructor(private readonly props: AgenticaRpcService.IProps) {
-    const { agent, listener } = props;
-
-    // ESSENTIAL LISTENERS
-    agent.on("userMessage", async (event) => {
-      listener.userMessage!(event.toJSON()).catch(() => {});
-    });
-    agent.on("assistantMessage", async (evt) => {
-      await evt.join();
-      listener.assistantMessage(evt.toJSON()).catch(() => {});
-    });
-    agent.on("describe", async (evt) => {
-      await evt.join();
-      listener.describe(evt.toJSON()).catch(() => {});
-    });
-
-    // OPTIONAL LISTENERS
-    agent.on("initialize", async (evt) => {
-      listener.initialize!(evt.toJSON()).catch(() => {});
-    });
-    agent.on("select", async (evt) => {
-      listener.select!(evt.toJSON()).catch(() => {});
-    });
-    agent.on("cancel", async (evt) => {
-      listener.cancel!(evt.toJSON()).catch(() => {});
-    });
-    agent.on("call", async (evt) => {
-      const args: object | null | undefined | void = await listener.call!(
-        evt.toJSON(),
-      );
-      if (args != null) {
-        evt.arguments = args;
-      }
-    });
-    agent.on("execute", async (evt) => {
-      listener.execute!(evt.toJSON()).catch(() => {});
-    });
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public async conversate(content: string | Parameters<typeof Agentica.prototype.conversate>[0]): Promise<void> {
-    await this.props.agent.conversate(content);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public async getControllers(): Promise<IAgenticaController[]> {
-    return this.props.agent.getControllers() as IAgenticaController[];
-  }
-}
-export namespace AgenticaRpcService {
-  /**
-   * Properties of the {@link AgenticaRpcService}.
-   */
-  export interface IProps {
-    /**
-     * Target agent to provide as RPC service.
-     */
-    agent: Agentica;
-
-    /**
-     * Listener to be binded on the agent.
-     */
-    listener: IAgenticaRpcListener;
-  }
-}
+import type { Agentica, IAgenticaController } from "@agentica/core";
+
+import type { IAgenticaRpcListener } from "./IAgenticaRpcListener";
+import type { IAgenticaRpcService } from "./IAgenticaRpcService";
+
+/**
+ * RPC service for the {@link Agentica}.
+ *
+ * `AgenticaRpcService` is class defining an AI agent service
+ * provided from the server to clients through the RPC (Remote Procedure Call)
+ * paradigm in the websocket protocol.
+ *
+ * Client connecting to the `AgenticaRpcService` providing websocket server
+ * will call the {@link conversate} function remotely through its basic
+ * interface type {@link IAgenticaRpcService} with the RPC paradigm.
+ *
+ * Also, the client provides the {@link IAgenticaRpcListener} type to the
+ * server, so that `AgenticaRpcService` will remotely call the
+ * {@link IAgenticaRpcListener listener}'s functions internally.
+ *
+ * You can open the WebSocket server of the AI agent like below:
+ *
+ * ```typescript
+ * import {
+ *   IAgenticaRpcListener,
+ *   IAgenticaRpcService,
+ *   Agentica,
+ *   AgenticaRpcService,
+ * } from "@agentica/core";
+ * import { WebSocketServer } from "tgrid";
+ *
+ * const server: WebSocketServer<
+ *   null,
+ *   IAgenticaRpcService,
+ *   IAgenticaRpcListener
+ * > = new WebSocketServer();
+ * await server.open(3001, async (acceptor) => {
+ *   await acceptor.accept(
+ *     new AgenticaRpcService({
+ *       agent: new Agentica({ ... }),
+ *       listener: acceptor.getDriver(),
+ *     }),
+ *   );
+ * });
+ * ```
+ *
+ * @author Samchon
+ */
+export class AgenticaRpcService
+implements IAgenticaRpcService {
+  /**
+   * Initializer Constructor.
+   *
+   * @param props Properties to construct the RPC service
+   */
+  public constructor(private readonly props: AgenticaRpcService.IProps) {
+    const { agent, listener } = props;
+
+    // ESSENTIAL LISTENERS
+    agent.on("userMessage", async (event) => {
+      listener.userMessage!(event.toJSON()).catch(() => {});
+    });
+    agent.on("assistantMessage", async (evt) => {
+      await evt.join();
+      listener.assistantMessage(evt.toJSON()).catch(() => {});
+    });
+    agent.on("describe", async (evt) => {
+      await evt.join();
+      listener.describe(evt.toJSON()).catch(() => {});
+    });
+
+    // OPTIONAL LISTENERS
+    agent.on("initialize", async (evt) => {
+      listener.initialize!(evt.toJSON()).catch(() => {});
+    });
+    agent.on("select", async (evt) => {
+      listener.select!(evt.toJSON()).catch(() => {});
+    });
+    agent.on("cancel", async (evt) => {
+      listener.cancel!(evt.toJSON()).catch(() => {});
+    });
+    agent.on("call", async (evt) => {
+      const args: object | null | undefined | void = await listener.call!(
+        evt.toJSON(),
+      );
+      if (args != null) {
+        evt.arguments = args;
+      }
+    });
+    agent.on("execute", async (evt) => {
+      listener.execute!(evt.toJSON()).catch(() => {});
+    });
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public async conversate(content: string | Parameters<typeof Agentica.prototype.conversate>[0]): Promise<void> {
+    await this.props.agent.conversate(content);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public async getControllers(): Promise<IAgenticaController[]> {
+    return this.props.agent.getControllers() as IAgenticaController[];
+  }
+}
+export namespace AgenticaRpcService {
+  /**
+   * Properties of the {@link AgenticaRpcService}.
+   */
+  export interface IProps {
+    /**
+     * Target agent to provide as RPC service.
+     */
+    agent: Agentica;
+
+    /**
+     * Listener to be binded on the agent.
+     */
+    listener: IAgenticaRpcListener;
+  }
+}

package/src/IAgenticaRpcListener.ts

@@ -1,125 +1,125 @@
-import type { IAgenticaEventJson } from "@agentica/core";
-
-/**
- * RPC interface of AI agent listener.
- *
- * `IAgenticaRpcListener` is an interface defining an AI agent listener
- * provided from the client to server through the RPC (Remote Procedure Call)
- * paradigm in the websocket protocol.
- *
- * It has defined the event listener functions of {@link AgenticaEvent}
- * types. If you skip some event typed functions' implementations,
- * the skipped event would be ignored.
- *
- * Also, the event like listener functions of `IAgenticaRpcListener` type
- * are remotely called when a client calls the
- * {@link IAgenticaRpcService.conversate} function remotely, so that the
- * server responses to the client by the event listener functions.
- *
- * You can connect to the WebSocket server of the AI agent like below:
- *
- * ```typescript
- * import { IAgenticaRpcListener, IAgenticaRpcService } from "@agentica/core";
- * import { Driver, WebSocketConnector } from "tgrid";
- *
- * const connector: WebSocketConnector<
- *   null,
- *   IAgenticaRpcListener,
- *   IAgenticaRpcService
- * > = new WebSocketConnector(null, {
- *   text: async (evt) => {
- *     console.log(evt.role, evt.text);
- *   },
- *   describe: async (evt) => {
- *     console.log("describer", evt.text);
- *   },
- * });
- * await connector.connect("ws://localhost:3001");
- *
- * const driver: Driver<IAgenticaRpcService> = connector.getDriver();
- * await driver.conversate("Hello, what you can do?");
- * ```
- *
- * @author Samchon
- */
-export interface IAgenticaRpcListener {
-  /**
-   * Describe the function executions' results.
-   *
-   * Inform description message of the function execution's results from
-   * the AI agent server to client.
-   *
-   * @param evt Event of a description of function execution results
-   */
-  describe: (evt: IAgenticaEventJson.IDescribe) => Promise<void>;
-
-  /**
-   * Assistant conversation message.
-   *
-   * @param evt Event of assistant conversation
-   */
-  assistantMessage: (evt: IAgenticaEventJson.IAssistantMessage) => Promise<void>;
-
-  /**
-   * User conversation message.
-   *
-   * @param evt Event of user conversation
-   */
-  userMessage?: (evt: IAgenticaEventJson.IUserMessage) => Promise<void>;
-
-  /**
-   * Initialize the AI agent.
-   *
-   * Informs an initialization of controller functions from
-   * the AI agent server to client.
-   *
-   * @param evt Event of initialization
-   */
-  initialize?: (evt: IAgenticaEventJson.IInitialize) => Promise<void>;
-
-  /**
-   * Select a function to call.
-   *
-   * Informs a selected function to call from the AI agent server to client.
-   *
-   * @param evt Event of selecting a function to call
-   */
-  select?: (evt: IAgenticaEventJson.ISelect) => Promise<void>;
-
-  /**
-   * Cancel a function to call.
-   *
-   * Informs a canceling function to call from the AI agent server to client.
-   *
-   * @param evt Event of canceling a function to call
-   */
-  cancel?: (evt: IAgenticaEventJson.ICancel) => Promise<void>;
-
-  /**
-   * Call a function.
-   *
-   * Informs a function calling from the AI agent server to client.
-   *
-   * This event comes before the function execution, so that if you return
-   * a different value from the original {@link IAgenticaEventJson.ICall.arguments},
-   * you can modify the arguments of the function calling.
-   *
-   * Otherwise you do not return anything (`undefined`) or `null` value, the
-   * arguments of the function calling would not be modified. Also, if you are
-   * not interested in the function calling event, you can skit its
-   * implementation.
-   *
-   * @param evt Event of a function calling
-   * @return New arguments if you want to modify, otherwise null or undefined
-   */
-  call?: (evt: IAgenticaEventJson.ICall) => Promise<object | null | void | undefined>;
-
-  /**
-   * Executition of a function.
-   *
-   * Informs a function execution from the AI agent server to client.
-   *
-   * @param evt Event of a function execution
-   */
-  execute?: (evt: IAgenticaEventJson.IExecute) => Promise<void>;
-}
+import type { IAgenticaEventJson } from "@agentica/core";
+
+/**
+ * RPC interface of AI agent listener.
+ *
+ * `IAgenticaRpcListener` is an interface defining an AI agent listener
+ * provided from the client to server through the RPC (Remote Procedure Call)
+ * paradigm in the websocket protocol.
+ *
+ * It has defined the event listener functions of {@link AgenticaEvent}
+ * types. If you skip some event typed functions' implementations,
+ * the skipped event would be ignored.
+ *
+ * Also, the event like listener functions of `IAgenticaRpcListener` type
+ * are remotely called when a client calls the
+ * {@link IAgenticaRpcService.conversate} function remotely, so that the
+ * server responses to the client by the event listener functions.
+ *
+ * You can connect to the WebSocket server of the AI agent like below:
+ *
+ * ```typescript
+ * import { IAgenticaRpcListener, IAgenticaRpcService } from "@agentica/core";
+ * import { Driver, WebSocketConnector } from "tgrid";
+ *
+ * const connector: WebSocketConnector<
+ *   null,
+ *   IAgenticaRpcListener,
+ *   IAgenticaRpcService
+ * > = new WebSocketConnector(null, {
+ *   text: async (evt) => {
+ *     console.log(evt.role, evt.text);
+ *   },
+ *   describe: async (evt) => {
+ *     console.log("describer", evt.text);
+ *   },
+ * });
+ * await connector.connect("ws://localhost:3001");
+ *
+ * const driver: Driver<IAgenticaRpcService> = connector.getDriver();
+ * await driver.conversate("Hello, what you can do?");
+ * ```
+ *
+ * @author Samchon
+ */
+export interface IAgenticaRpcListener {
+  /**
+   * Describe the function executions' results.
+   *
+   * Inform description message of the function execution's results from
+   * the AI agent server to client.
+   *
+   * @param evt Event of a description of function execution results
+   */
+  describe: (evt: IAgenticaEventJson.IDescribe) => Promise<void>;
+
+  /**
+   * Assistant conversation message.
+   *
+   * @param evt Event of assistant conversation
+   */
+  assistantMessage: (evt: IAgenticaEventJson.IAssistantMessage) => Promise<void>;
+
+  /**
+   * User conversation message.
+   *
+   * @param evt Event of user conversation
+   */
+  userMessage?: (evt: IAgenticaEventJson.IUserMessage) => Promise<void>;
+
+  /**
+   * Initialize the AI agent.
+   *
+   * Informs an initialization of controller functions from
+   * the AI agent server to client.
+   *
+   * @param evt Event of initialization
+   */
+  initialize?: (evt: IAgenticaEventJson.IInitialize) => Promise<void>;
+
+  /**
+   * Select a function to call.
+   *
+   * Informs a selected function to call from the AI agent server to client.
+   *
+   * @param evt Event of selecting a function to call
+   */
+  select?: (evt: IAgenticaEventJson.ISelect) => Promise<void>;
+
+  /**
+   * Cancel a function to call.
+   *
+   * Informs a canceling function to call from the AI agent server to client.
+   *
+   * @param evt Event of canceling a function to call
+   */
+  cancel?: (evt: IAgenticaEventJson.ICancel) => Promise<void>;
+
+  /**
+   * Call a function.
+   *
+   * Informs a function calling from the AI agent server to client.
+   *
+   * This event comes before the function execution, so that if you return
+   * a different value from the original {@link IAgenticaEventJson.ICall.arguments},
+   * you can modify the arguments of the function calling.
+   *
+   * Otherwise you do not return anything (`undefined`) or `null` value, the
+   * arguments of the function calling would not be modified. Also, if you are
+   * not interested in the function calling event, you can skit its
+   * implementation.
+   *
+   * @param evt Event of a function calling
+   * @return New arguments if you want to modify, otherwise null or undefined
+   */
+  call?: (evt: IAgenticaEventJson.ICall) => Promise<object | null | void | undefined>;
+
+  /**
+   * Executition of a function.
+   *
+   * Informs a function execution from the AI agent server to client.
+   *
+   * @param evt Event of a function execution
+   */
+  execute?: (evt: IAgenticaEventJson.IExecute) => Promise<void>;
+}

package/src/IAgenticaRpcService.ts

@@ -1,44 +1,44 @@
-import type { AgenticaUserMessageContent, IAgenticaController } from "@agentica/core";
-
-/**
- * RPC interface of AI agent service.
- *
- * `IAgenticaRpcService` is an interface defining an AI agent service
- * provided from the server to client through the RPC (Remote Procedure Call)
- * paradigm in the websocket protocol.
- *
- * The client will call the {@link conversate} function remotely, and the
- * server responses to the client by calling the client's
- * {@link IAgenticaRpcListener} functions remotely too.
- *
- * @author Samchon
- */
-export interface IAgenticaRpcService {
-  /**
-   * Conversate with the AI agent.
-   *
-   * User talks to the AI agent with the content.
-   *
-   * When AI agent responds some actions like conversating or executing
-   * LLM (Large Language Model) function calling, the functions defined in the
-   * {@link IAgenticaRpcListener} would be called through the RPC
-   * (Remote Procedure Call) paradigm.
-   *
-   * @param content The content to talk
-   * @returns Returned when the conversation process is completely done
-   */
-  conversate: (
-    content:
-      | string
-      | AgenticaUserMessageContent
-      | Array<AgenticaUserMessageContent>,
-  ) => Promise<void>;
-
-  /**
-   * Get controllers.
-   *
-   * Get controllers, collection of functions that would be
-   * called by the AI chatbot.
-   */
-  getControllers: () => Promise<IAgenticaController[]>;
-}
+import type { AgenticaUserMessageContent, IAgenticaController } from "@agentica/core";
+
+/**
+ * RPC interface of AI agent service.
+ *
+ * `IAgenticaRpcService` is an interface defining an AI agent service
+ * provided from the server to client through the RPC (Remote Procedure Call)
+ * paradigm in the websocket protocol.
+ *
+ * The client will call the {@link conversate} function remotely, and the
+ * server responses to the client by calling the client's
+ * {@link IAgenticaRpcListener} functions remotely too.
+ *
+ * @author Samchon
+ */
+export interface IAgenticaRpcService {
+  /**
+   * Conversate with the AI agent.
+   *
+   * User talks to the AI agent with the content.
+   *
+   * When AI agent responds some actions like conversating or executing
+   * LLM (Large Language Model) function calling, the functions defined in the
+   * {@link IAgenticaRpcListener} would be called through the RPC
+   * (Remote Procedure Call) paradigm.
+   *
+   * @param content The content to talk
+   * @returns Returned when the conversation process is completely done
+   */
+  conversate: (
+    content:
+      | string
+      | AgenticaUserMessageContent
+      | Array<AgenticaUserMessageContent>,
+  ) => Promise<void>;
+
+  /**
+   * Get controllers.
+   *
+   * Get controllers, collection of functions that would be
+   * called by the AI chatbot.
+   */
+  getControllers: () => Promise<IAgenticaController[]>;
+}