@agentica/rpc 0.43.2 → 0.44.0-dev.20260313

package/src/IMicroAgenticaRpcListener.ts

@@ -1,100 +1,100 @@
-import type { IAgenticaEventJson } from "@agentica/core";
-
-/**
- * RPC interface of Micro agent listener.
- *
- * `IMicroAgenticaRpcListener` 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 MicroAgenticaEvent}
- * types. If you skip some event typed functions' implementations,
- * the skipped event would be ignored.
- *
- * Also, the event like listener functions of `IMicroAgenticaRpcListener` 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 {
- *   IMicroAgenticaRpcListener,
- *   IAgenticaRpcService
- * } from "@agentica/core";
- * import { Driver, WebSocketConnector } from "tgrid";
- *
- * const connector: WebSocketConnector<
- *   null,
- *   IMicroAgenticaRpcListener,
- *   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 IMicroAgenticaRpcListener {
-  /**
-   * 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>;
-
-  /**
-   * 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 Micro agent listener.
+ *
+ * `IMicroAgenticaRpcListener` 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 MicroAgenticaEvent}
+ * types. If you skip some event typed functions' implementations,
+ * the skipped event would be ignored.
+ *
+ * Also, the event like listener functions of `IMicroAgenticaRpcListener` 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 {
+ *   IMicroAgenticaRpcListener,
+ *   IAgenticaRpcService
+ * } from "@agentica/core";
+ * import { Driver, WebSocketConnector } from "tgrid";
+ *
+ * const connector: WebSocketConnector<
+ *   null,
+ *   IMicroAgenticaRpcListener,
+ *   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 IMicroAgenticaRpcListener {
+  /**
+   * 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>;
+
+  /**
+   * 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/MicroAgenticaRpcListener.ts

@@ -1,5 +1,5 @@
-// import type { IMicroAgenticaRpcListener } from "./IMicroAgenticaRpcListener";
-
-// export class McpAgenticaRpcListener {
-//   public constructor(private readonly driver: IMicroAgenticaRpcListener) {}
-// }
+// import type { IMicroAgenticaRpcListener } from "./IMicroAgenticaRpcListener";
+
+// export class McpAgenticaRpcListener {
+//   public constructor(private readonly driver: IMicroAgenticaRpcListener) {}
+// }

package/src/MicroAgenticaRpcService.ts

@@ -1,115 +1,115 @@
-import type { IAgenticaController, MicroAgentica } from "@agentica/core";
-
-import type { IAgenticaRpcService } from "./IAgenticaRpcService";
-import type { IMicroAgenticaRpcListener } from "./IMicroAgenticaRpcListener";
-
-/**
- * RPC service for the {@link MicroAgentica}.
- *
- * `MicroAgenticaRpcService` 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 `MicroAgenticaRpcService` 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 IMicroAgenticaRpcListener} type to the
- * server, so that `MicroAgenticaRpcService` will remotely call the
- * {@link IMicroAgenticaRpcListener listener}'s functions internally.
- *
- * You can open the WebSocket server of the AI agent like below:
- *
- * ```typescript
- * import {
- *   IMicroAgenticaRpcListener,
- *   IAgenticaRpcService,
- *   Agentica,
- *   MicroAgenticaRpcService,
- * } from "@agentica/core";
- * import { WebSocketServer } from "tgrid";
- *
- * const server: WebSocketServer<
- *   null,
- *   IAgenticaRpcService,
- *   IMicroAgenticaRpcListener
- * > = new WebSocketServer();
- * await server.open(3001, async (acceptor) => {
- *   await acceptor.accept(
- *     new MicroAgenticaRpcService({
- *       agent: new MicroAgentica({ ... }),
- *       listener: acceptor.getDriver(),
- *     }),
- *   );
- * });
- * ```
- *
- * @author Samchon
- */
-export class MicroAgenticaRpcService
-implements IAgenticaRpcService {
-  /**
-   * Initializer Constructor.
-   *
-   * @param props Properties to construct the RPC service
-   */
-  public constructor(private readonly props: MicroAgenticaRpcService.IProps) {
-    const { agent, listener } = props;
-
-    // ESSENTIAL LISTENERS
-    agent.on("userMessage", async (evt) => {
-      listener.userMessage!(evt.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("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 MicroAgentica.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 MicroAgenticaRpcService {
-  /**
-   * Properties to construct the RPC service.
-   */
-  export interface IProps {
-    /**
-     * AI agent to be controlled.
-     */
-    agent: MicroAgentica;
-
-    /**
-     * Listener to be notified.
-     */
-    listener: IMicroAgenticaRpcListener;
-  }
-}
+import type { IAgenticaController, MicroAgentica } from "@agentica/core";
+
+import type { IAgenticaRpcService } from "./IAgenticaRpcService";
+import type { IMicroAgenticaRpcListener } from "./IMicroAgenticaRpcListener";
+
+/**
+ * RPC service for the {@link MicroAgentica}.
+ *
+ * `MicroAgenticaRpcService` 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 `MicroAgenticaRpcService` 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 IMicroAgenticaRpcListener} type to the
+ * server, so that `MicroAgenticaRpcService` will remotely call the
+ * {@link IMicroAgenticaRpcListener listener}'s functions internally.
+ *
+ * You can open the WebSocket server of the AI agent like below:
+ *
+ * ```typescript
+ * import {
+ *   IMicroAgenticaRpcListener,
+ *   IAgenticaRpcService,
+ *   Agentica,
+ *   MicroAgenticaRpcService,
+ * } from "@agentica/core";
+ * import { WebSocketServer } from "tgrid";
+ *
+ * const server: WebSocketServer<
+ *   null,
+ *   IAgenticaRpcService,
+ *   IMicroAgenticaRpcListener
+ * > = new WebSocketServer();
+ * await server.open(3001, async (acceptor) => {
+ *   await acceptor.accept(
+ *     new MicroAgenticaRpcService({
+ *       agent: new MicroAgentica({ ... }),
+ *       listener: acceptor.getDriver(),
+ *     }),
+ *   );
+ * });
+ * ```
+ *
+ * @author Samchon
+ */
+export class MicroAgenticaRpcService
+implements IAgenticaRpcService {
+  /**
+   * Initializer Constructor.
+   *
+   * @param props Properties to construct the RPC service
+   */
+  public constructor(private readonly props: MicroAgenticaRpcService.IProps) {
+    const { agent, listener } = props;
+
+    // ESSENTIAL LISTENERS
+    agent.on("userMessage", async (evt) => {
+      listener.userMessage!(evt.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("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 MicroAgentica.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 MicroAgenticaRpcService {
+  /**
+   * Properties to construct the RPC service.
+   */
+  export interface IProps {
+    /**
+     * AI agent to be controlled.
+     */
+    agent: MicroAgentica;
+
+    /**
+     * Listener to be notified.
+     */
+    listener: IMicroAgenticaRpcListener;
+  }
+}

package/src/index.ts

@@ -1,5 +1,5 @@
-export * from "./AgenticaRpcService";
-export * from "./IAgenticaRpcListener";
-export * from "./IAgenticaRpcService";
-export * from "./IMicroAgenticaRpcListener";
-export * from "./MicroAgenticaRpcService";
+export * from "./AgenticaRpcService";
+export * from "./IAgenticaRpcListener";
+export * from "./IAgenticaRpcService";
+export * from "./IMicroAgenticaRpcListener";
+export * from "./MicroAgenticaRpcService";

package/src/structures/IAgenticaAssistantMessageEventProgress.ts

@@ -1,6 +1,6 @@
-export interface IAgenticaAssistantMessageEventProgress {
-  type: "assistantMessagePiece";
-  sequence: number;
-  text: string;
-  done: boolean;
-}
+export interface IAgenticaAssistantMessageEventProgress {
+  type: "assistantMessagePiece";
+  sequence: number;
+  text: string;
+  done: boolean;
+}

package/src/structures/IAgenticaDescribeEventProgress.ts

@@ -1,6 +1,6 @@
-export interface IAgenticaDescribeEventProgress {
-  type: "describeMessageProgress";
-  sequence: number;
-  text: string;
-  done: boolean;
-}
+export interface IAgenticaDescribeEventProgress {
+  type: "describeMessageProgress";
+  sequence: number;
+  text: string;
+  done: boolean;
+}

package/src/structures/IAgenticaDescribeEventStart.ts

@@ -1,6 +1,6 @@
-import type { IAgenticaHistoryJson } from "@agentica/core";
-
-export interface IAgenticaDescribeEventStart {
-  type: "describeMessageStart";
-  executes: IAgenticaHistoryJson.IExecute[];
-}
+import type { IAgenticaHistoryJson } from "@agentica/core";
+
+export interface IAgenticaDescribeEventStart {
+  type: "describeMessageStart";
+  executes: IAgenticaHistoryJson.IExecute[];
+}