@agentica/rpc 0.8.3 → 0.9.0-dev.20250302

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Wrtn Technologies
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025 Wrtn Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,177 +1,177 @@
-# `@agentica/rpc`
-![agentica-conceptual-diagram](https://github.com/user-attachments/assets/d7ebbd1f-04d3-4b0d-9e2a-234e29dd6c57)
-
-[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/wrtnlabs/agentica/blob/master/LICENSE)
-[![npm version](https://img.shields.io/npm/v/@agentica/rpc.svg)](https://www.npmjs.com/package/@agentica/rpc)
-[![Downloads](https://img.shields.io/npm/dm/@agentica/rpc.svg)](https://www.npmjs.com/package/@agentica/rpc)
-[![Build Status](https://github.com/wrtnlabs/agentica/workflows/build/badge.svg)](https://github.com/wrtnlabs/agentica/actions?query=workflow%3Abuild)
-
-RPC module of Agentica for WebSocket Communication
-
-Agentica is the simplest Agentiic AI library specialized in **LLM Function Calling**, and `@agentica/rpc` is an RPC (Remote Procedure Call) wrapper module. If you combine the RPC wrapper module with [`TGrid`](https://github.com/samchon/tgrid), you can develop the WebSocket AI Chatbot.
-
-```typescript
-import { IAgenticaRpcListener, IAgenticaRpcService } from "@agentica/rpc";
-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?");
-```
-
-
-
-
-## How to use
-### Setup
-```bash
-npm install @agentica/core @agentica/rpc @samchon/openapi typia tgrid
-npx typia setup
-```
-
-Install `@agentica/rpc` with its dependent libraries.
-
-Note that, you have to install not only `@agentica/core` and `@agentica/rpc`, but also [`@samchon/openapi`](https://github.com/samchon/openapi), [`typia`](https://github.com/samchon/typia) and [`tgrid`](https://github.com/samchon/tgrid) too.
-
-`@samchon/openapi` is an OpenAPI specification library which can convert Swagger/OpenAPI document to LLM function calling schema. And `typia` is a transformer (compiler) library which can compose LLM function calling schema from a TypeScript class type. And then `tgrid` is an RPC (REmote Procedure Call) framework supporting the websocket protocol.
-
-By the way, as `typia` is a transformer library analyzing TypeScript source code in the compilation level, it needs additional setup command `npx typia setup`. Also, if your client (frontend) application is not using the standard TypeScript compiler (not `tsc`), you have to setup [`@ryoppippi/unplugin-typia`](https://typia.io/docs/setup/#unplugin-typia) too.
-
-### Server Application
-```typescript
-import { Agentica } from "@agentica/core";
-import {
-  AgenticaRpcService,
-  IAgenticaRpcListener,
-  IAgenticaRpcService,
-} from "@agentica/rpc";
-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(),
-    }),
-  );
-});
-```
-
-When developing backend server, wrap `Agentica` to `AgenticaRpcService`.
-
-If you're developing WebSocket protocol backend server, create a new `Agentica` instance, and wrap it to the `AgenticaRpcService` class. And then open the websocket server like above code. The WebSocket server will call the client functions of the `IAgenticaRpcListener` remotely.
-
-### Client Application
-```typescript
-import { IAgenticaRpcListener, IAgenticaRpcService } from "@agentica/rpc";
-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?");
-```
-
-When developing frontend application, define `IAgenticaRpcListener` instance.
-
-Otherwise you're developing WebSocket protocol client application, connect to the websocket backend server with its URL address, and provide `IAgenticaRpcListener` instance for event listening.
-
-And then call the backend server's function `IAgenticaRpcService.conversate()` remotely through the `Driver<IAgenticaRpcService>` wrapping. The backend server will call your `IAgenticaRpcListener` functions remotely through the RPC paradigm.
-
-
-
-
-## Principles
-### Remote Procedure Call
-```mermaid
-sequenceDiagram
-box Client Application
-  actor User
-  participant Driver as Driver<Listener>
-  participant Connector as Communicator (Client)
-end
-box Server Application
-  participant Acceptor as Communicator (Server)
-  actor Provider
-end
-User->>Driver: 1. calls a function
-Activate User
-Activate Driver
-Driver->>Connector: 2. delivers the function call
-Activate Connector
-Deactivate Driver
-Connector-->>Acceptor: 3. sends a protocolized<br/>network message<br/>meaning a function call
-Deactivate Connector
-Activate Acceptor
-Acceptor->>Provider: 4. calls the function
-Provider->>Acceptor: 5. returns a value
-Acceptor-->>Connector: 6. sends a protocolized<br/>network message<br/>meaning a return value
-Deactivate Acceptor
-Activate Connector
-Connector->>Driver: 7. delivers the return value
-Deactivate Connector
-Activate Driver
-Driver->>User: 8. returns the value
-Deactivate Driver
-Deactivate User
-```
-
-WebSocket protocol with RPC paradigm for AI chatbot.
-
-`@agentica/rpc` supports WebSocket protocol that is utilizing [`TGrid`](https://github.com/samchon/tgrid) and its RPC (Remote Procedure Call) paradigm for easy and type safe development. In the RPC paradigm, client application can call a function of `IAgenticaRpcService` remotely as if it were its own object.
-
-Internally, the RPC has composed with three elements; [`Communicator`](https://tgrid.com/docs/features/components/#communicator), [`Provider`](https://tgrid.com/docs/features/components/#provider) and [`Driver`](https://tgrid.com/docs/features/components/#driver). The first `Communicator` takes a responsibility of (WebSocket) network communication. The next `Provider` means an object providing to the remote system for RPC, and `Driver` is a proxy instance realizing the RPC to the remote provided `Provider` instance.
-
-For example, below client application code is calling `IAgenticaRpcService.conversate()` function remotely through the `Driver<IAgenticaRpcService>` typed instance. In that case, `IAgenticaRpcService` is the `Provider` instance from server to client. And `WebSocketConnector` is the communicator taking responsibility of WebSocket communication.
-
-```typescript
-import { IAgenticaRpcListener, IAgenticaRpcService } from "@agentica/rpc";
-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?");
+# `@agentica/rpc`
+![agentica-conceptual-diagram](https://github.com/user-attachments/assets/d7ebbd1f-04d3-4b0d-9e2a-234e29dd6c57)
+
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/wrtnlabs/agentica/blob/master/LICENSE)
+[![npm version](https://img.shields.io/npm/v/@agentica/rpc.svg)](https://www.npmjs.com/package/@agentica/rpc)
+[![Downloads](https://img.shields.io/npm/dm/@agentica/rpc.svg)](https://www.npmjs.com/package/@agentica/rpc)
+[![Build Status](https://github.com/wrtnlabs/agentica/workflows/build/badge.svg)](https://github.com/wrtnlabs/agentica/actions?query=workflow%3Abuild)
+
+RPC module of Agentica for WebSocket Communication
+
+Agentica is the simplest Agentiic AI library specialized in **LLM Function Calling**, and `@agentica/rpc` is an RPC (Remote Procedure Call) wrapper module. If you combine the RPC wrapper module with [`TGrid`](https://github.com/samchon/tgrid), you can develop the WebSocket AI Chatbot.
+
+```typescript
+import { IAgenticaRpcListener, IAgenticaRpcService } from "@agentica/rpc";
+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?");
+```
+
+
+
+
+## How to use
+### Setup
+```bash
+npm install @agentica/core @agentica/rpc @samchon/openapi typia tgrid
+npx typia setup
+```
+
+Install `@agentica/rpc` with its dependent libraries.
+
+Note that, you have to install not only `@agentica/core` and `@agentica/rpc`, but also [`@samchon/openapi`](https://github.com/samchon/openapi), [`typia`](https://github.com/samchon/typia) and [`tgrid`](https://github.com/samchon/tgrid) too.
+
+`@samchon/openapi` is an OpenAPI specification library which can convert Swagger/OpenAPI document to LLM function calling schema. And `typia` is a transformer (compiler) library which can compose LLM function calling schema from a TypeScript class type. And then `tgrid` is an RPC (REmote Procedure Call) framework supporting the websocket protocol.
+
+By the way, as `typia` is a transformer library analyzing TypeScript source code in the compilation level, it needs additional setup command `npx typia setup`. Also, if your client (frontend) application is not using the standard TypeScript compiler (not `tsc`), you have to setup [`@ryoppippi/unplugin-typia`](https://typia.io/docs/setup/#unplugin-typia) too.
+
+### Server Application
+```typescript
+import { Agentica } from "@agentica/core";
+import {
+  AgenticaRpcService,
+  IAgenticaRpcListener,
+  IAgenticaRpcService,
+} from "@agentica/rpc";
+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(),
+    }),
+  );
+});
+```
+
+When developing backend server, wrap `Agentica` to `AgenticaRpcService`.
+
+If you're developing WebSocket protocol backend server, create a new `Agentica` instance, and wrap it to the `AgenticaRpcService` class. And then open the websocket server like above code. The WebSocket server will call the client functions of the `IAgenticaRpcListener` remotely.
+
+### Client Application
+```typescript
+import { IAgenticaRpcListener, IAgenticaRpcService } from "@agentica/rpc";
+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?");
+```
+
+When developing frontend application, define `IAgenticaRpcListener` instance.
+
+Otherwise you're developing WebSocket protocol client application, connect to the websocket backend server with its URL address, and provide `IAgenticaRpcListener` instance for event listening.
+
+And then call the backend server's function `IAgenticaRpcService.conversate()` remotely through the `Driver<IAgenticaRpcService>` wrapping. The backend server will call your `IAgenticaRpcListener` functions remotely through the RPC paradigm.
+
+
+
+
+## Principles
+### Remote Procedure Call
+```mermaid
+sequenceDiagram
+box Client Application
+  actor User
+  participant Driver as Driver<Listener>
+  participant Connector as Communicator (Client)
+end
+box Server Application
+  participant Acceptor as Communicator (Server)
+  actor Provider
+end
+User->>Driver: 1. calls a function
+Activate User
+Activate Driver
+Driver->>Connector: 2. delivers the function call
+Activate Connector
+Deactivate Driver
+Connector-->>Acceptor: 3. sends a protocolized<br/>network message<br/>meaning a function call
+Deactivate Connector
+Activate Acceptor
+Acceptor->>Provider: 4. calls the function
+Provider->>Acceptor: 5. returns a value
+Acceptor-->>Connector: 6. sends a protocolized<br/>network message<br/>meaning a return value
+Deactivate Acceptor
+Activate Connector
+Connector->>Driver: 7. delivers the return value
+Deactivate Connector
+Activate Driver
+Driver->>User: 8. returns the value
+Deactivate Driver
+Deactivate User
+```
+
+WebSocket protocol with RPC paradigm for AI chatbot.
+
+`@agentica/rpc` supports WebSocket protocol that is utilizing [`TGrid`](https://github.com/samchon/tgrid) and its RPC (Remote Procedure Call) paradigm for easy and type safe development. In the RPC paradigm, client application can call a function of `IAgenticaRpcService` remotely as if it were its own object.
+
+Internally, the RPC has composed with three elements; [`Communicator`](https://tgrid.com/docs/features/components/#communicator), [`Provider`](https://tgrid.com/docs/features/components/#provider) and [`Driver`](https://tgrid.com/docs/features/components/#driver). The first `Communicator` takes a responsibility of (WebSocket) network communication. The next `Provider` means an object providing to the remote system for RPC, and `Driver` is a proxy instance realizing the RPC to the remote provided `Provider` instance.
+
+For example, below client application code is calling `IAgenticaRpcService.conversate()` function remotely through the `Driver<IAgenticaRpcService>` typed instance. In that case, `IAgenticaRpcService` is the `Provider` instance from server to client. And `WebSocketConnector` is the communicator taking responsibility of WebSocket communication.
+
+```typescript
+import { IAgenticaRpcListener, IAgenticaRpcService } from "@agentica/rpc";
+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?");
 ```

package/lib/AgenticaRpcService.d.ts

@@ -1,4 +1,5 @@
 import { Agentica, IAgenticaController } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 import { Primitive } from "typia";
 import { IAgenticaRpcListener } from "./IAgenticaRpcListener";
 import { IAgenticaRpcService } from "./IAgenticaRpcService";
@@ -45,14 +46,14 @@ import { IAgenticaRpcService } from "./IAgenticaRpcService";
  *
  * @author Samchon
  */
-export declare class AgenticaRpcService implements IAgenticaRpcService {
+export declare class AgenticaRpcService<Model extends ILlmSchema.Model> implements IAgenticaRpcService<Model> {
     private readonly props;
     /**
      * Initializer Constructor.
      *
      * @param props Properties to construct the RPC service
      */
-    constructor(props: AgenticaRpcService.IProps);
+    constructor(props: AgenticaRpcService.IProps<Model>);
     /**
      * @inheritDoc
      */
@@ -60,20 +61,20 @@ export declare class AgenticaRpcService implements IAgenticaRpcService {
     /**
      * @inheritDoc
      */
-    getControllers(): Promise<Primitive<IAgenticaController>[]>;
+    getControllers(): Promise<Primitive<IAgenticaController<Model>>[]>;
 }
 export declare namespace AgenticaRpcService {
     /**
      * Properties of the {@link AgenticaRpcService}.
      */
-    interface IProps {
+    interface IProps<Model extends ILlmSchema.Model> {
         /**
          * Target agent to provide as RPC service.
          */
-        agent: Agentica;
+        agent: Agentica<Model>;
         /**
          * Listener to be binded on the agent.
          */
-        listener: IAgenticaRpcListener;
+        listener: IAgenticaRpcListener<Model>;
     }
 }

package/lib/AgenticaRpcService.js.map

@@ -1 +1 @@
-{"version":3,"file":"AgenticaRpcService.js","sourceRoot":"","sources":["../src/AgenticaRpcService.ts"],"names":[],"mappings":";;;;;;;;;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAa,kBAAkB;IAC7B;;;;OAIG;IACH,YAAoC,KAAgC;QAAhC,UAAK,GAAL,KAAK,CAA2B;QAClE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;QAElC,sBAAsB;QACtB,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzD,KAAK,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAEjE,qBAAqB;QACrB,KAAK,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAW,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACtE,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9D,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9D,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAO,GAAG,EAAE,EAAE;YAC7B,MAAM,IAAI,GAA8B,MAAM,QAAQ,CAAC,IAAK,CAC1D,SAAS,CAAC,GAAG,CAAC,CACf,CAAC;YACF,IAAI,CAAC,CAAC,IAAI;gBAAE,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC;QACnC,CAAC,CAAA,CAAC,CAAC;QACH,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;OAEG;IACU,UAAU,CAAC,OAAe;;YACrC,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC7C,CAAC;KAAA;IAED;;OAEG;IACU,cAAc;;YACzB,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,cAAc,EAAmF,CAAC;QAC5H,CAAC;KAAA;CACF;AAvCD,gDAuCC;AAkBD;;GAEG;AACH,MAAM,SAAS,GAAG,CAAI,GAAM,EAAgB,EAAE,CAC5C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAiB,CAAC"}
+{"version":3,"file":"AgenticaRpcService.js","sourceRoot":"","sources":["../src/AgenticaRpcService.ts"],"names":[],"mappings":";;;;;;;;;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAa,kBAAkB;IAG7B;;;;OAIG;IACH,YAAoC,KAAuC;QAAvC,UAAK,GAAL,KAAK,CAAkC;QACzE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC;QAElC,sBAAsB;QACtB,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzD,KAAK,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAEjE,qBAAqB;QACrB,KAAK,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAW,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACtE,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9D,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC9D,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAO,GAAG,EAAE,EAAE;YAC7B,MAAM,IAAI,GAA8B,MAAM,QAAQ,CAAC,IAAK,CAC1D,SAAS,CAAC,GAAG,CAAC,CACf,CAAC;YACF,IAAI,CAAC,CAAC,IAAI;gBAAE,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC;QACnC,CAAC,CAAA,CAAC,CAAC;QACH,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAQ,CAAC,SAAS,CAAC,GAAU,CAAC,CAAC,CAAC,CAAC;IACzE,CAAC;IAED;;OAEG;IACU,UAAU,CAAC,OAAe;;YACrC,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC7C,CAAC;KAAA;IAED;;OAEG;IACU,cAAc;;YAGzB,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,cAAc,EAEM,CAAC;QAC/C,CAAC;KAAA;CACF;AA7CD,gDA6CC;AAkBD;;GAEG;AACH,MAAM,SAAS,GAAG,CAAI,GAAM,EAAgB,EAAE,CAC5C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAiB,CAAC"}

package/lib/IAgenticaRpcListener.d.ts

@@ -1,4 +1,5 @@
 import { IAgenticaEvent } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 import { Primitive } from "typia";
 /**
  * RPC interface of AI agent listener.
@@ -42,7 +43,7 @@ import { Primitive } from "typia";
  *
  * @author Samchon
  */
-export interface IAgenticaRpcListener {
+export interface IAgenticaRpcListener<Model extends ILlmSchema.Model> {
     /**
      * Describe the function executions' results.
      *
@@ -51,13 +52,13 @@ export interface IAgenticaRpcListener {
      *
      * @param evt Event of a description of function execution results
      */
-    describe(evt: Primitive<IAgenticaEvent.IDescribe>): Promise<void>;
+    describe(evt: Primitive<IAgenticaEvent.IDescribe<Model>>): Promise<void>;
     /**
      * Text conversation message.
      *
      * @param evt Event of a text conversation message
      */
-    text(evt: Primitive<IAgenticaEvent.IText>): Promise<void>;
+    text(evt: IAgenticaEvent.IText): Promise<void>;
     /**
      * Initialize the AI agent.
      *
@@ -66,7 +67,7 @@ export interface IAgenticaRpcListener {
      *
      * @param evt Event of initialization
      */
-    initialize?(evt: Primitive<IAgenticaEvent.IInitialize>): Promise<void>;
+    initialize?(evt: IAgenticaEvent.IInitialize): Promise<void>;
     /**
      * Select a function to call.
      *
@@ -74,7 +75,7 @@ export interface IAgenticaRpcListener {
      *
      * @param evt Event of selecting a function to call
      */
-    select?(evt: Primitive<IAgenticaEvent.ISelect>): Promise<void>;
+    select?(evt: Primitive<IAgenticaEvent.ISelect<Model>>): Promise<void>;
     /**
      * Cancel a function to call.
      *
@@ -82,7 +83,7 @@ export interface IAgenticaRpcListener {
      *
      * @param evt Event of canceling a function to call
      */
-    cancel?(evt: Primitive<IAgenticaEvent.ICancel>): Promise<void>;
+    cancel?(evt: Primitive<IAgenticaEvent.ICancel<Model>>): Promise<void>;
     /**
      * Call a function.
      *
@@ -100,7 +101,7 @@ export interface IAgenticaRpcListener {
      * @param evt Event of a function calling
      * @return New arguments if you want to modify, otherwise null or undefined
      */
-    call?(evt: Primitive<IAgenticaEvent.ICall>): Promise<object | null | undefined>;
+    call?(evt: Primitive<IAgenticaEvent.ICall<Model>>): Promise<object | null | undefined>;
     /**
      * Executition of a function.
      *
@@ -108,5 +109,5 @@ export interface IAgenticaRpcListener {
      *
      * @param evt Event of a function execution
      */
-    execute?(evt: Primitive<IAgenticaEvent.IExecute>): Promise<void>;
+    execute?(evt: IAgenticaEvent.IExecute<Model>): Promise<void>;
 }

package/lib/IAgenticaRpcService.d.ts

@@ -1,4 +1,5 @@
 import { IAgenticaController } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
 import { Primitive } from "typia";
 /**
  * RPC interface of AI agent service.
@@ -13,7 +14,7 @@ import { Primitive } from "typia";
  *
  * @author Samchon
  */
-export interface IAgenticaRpcService {
+export interface IAgenticaRpcService<Model extends ILlmSchema.Model> {
     /**
      * Conversate with the AI agent.
      *
@@ -34,5 +35,5 @@ export interface IAgenticaRpcService {
      * Get controllers, collection of functions that would be
      * called by the AI chatbot.
      */
-    getControllers(): Promise<Primitive<IAgenticaController[]>>;
+    getControllers(): Promise<Primitive<IAgenticaController<Model>[]>>;
 }

package/lib/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/AgenticaRpcService.ts"],"sourcesContent":[null],"names":["AgenticaRpcService","constructor","props","this","agent","listener","on","evt","text","primitive","describe","initialize","select","cancel","async","args","call","arguments","execute","conversate","content","getControllers","obj","JSON","parse","stringify"],"mappings":"MAiDaA;IAMX,WAAAC,CAAoCC;QAAAC,KAAKD,QAALA;QAClC,OAAME,OAAOC,YAAeH;QAG5BE,MAAME,GAAG,SAASC,OAAQF,SAASG,KAAKC,UAAUF;QAClDH,MAAME,GAAG,aAAaC,OAAQF,SAASK,SAASD,UAAUF;QAG1DH,MAAME,GAAG,eAAeC,OAAQF,SAASM,WAAYF,UAAUF;QAC/DH,MAAME,GAAG,WAAWC,OAAQF,SAASO,OAAQH,UAAUF;QACvDH,MAAME,GAAG,WAAWC,OAAQF,SAASQ,OAAQJ,UAAUF;QACvDH,MAAME,GAAG,SAAQQ,MAAOP;YACtB,MAAMQ,aAAwCV,SAASW,KACrDP,UAAUF;YAEZ,MAAMQ,MAAMR,IAAIU,YAAYF;AAAI;QAElCX,MAAME,GAAG,YAAYC,OAAQF,SAASa,QAAST,UAAUF;;IAMpD,gBAAMY,CAAWC;cAChBjB,KAAKD,MAAME,MAAMe,WAAWC;;IAM7B,oBAAMC;QACX,OAAOlB,KAAKD,MAAME,MAAMiB;;;;AAuB5B,MAAMZ,YAAgBa,OACpBC,KAAKC,MAAMD,KAAKE,UAAUH;;"}
+{"version":3,"file":"index.mjs","sources":["../src/AgenticaRpcService.ts"],"sourcesContent":[null],"names":["AgenticaRpcService","constructor","props","this","agent","listener","on","evt","text","primitive","describe","initialize","select","cancel","async","args","call","arguments","execute","conversate","content","getControllers","obj","JSON","parse","stringify"],"mappings":"MAkDaA;IAQX,WAAAC,CAAoCC;QAAAC,KAAKD,QAALA;QAClC,OAAME,OAAOC,YAAeH;QAG5BE,MAAME,GAAG,SAASC,OAAQF,SAASG,KAAKC,UAAUF;QAClDH,MAAME,GAAG,aAAaC,OAAQF,SAASK,SAASD,UAAUF;QAG1DH,MAAME,GAAG,eAAeC,OAAQF,SAASM,WAAYF,UAAUF;QAC/DH,MAAME,GAAG,WAAWC,OAAQF,SAASO,OAAQH,UAAUF;QACvDH,MAAME,GAAG,WAAWC,OAAQF,SAASQ,OAAQJ,UAAUF;QACvDH,MAAME,GAAG,SAAQQ,MAAOP;YACtB,MAAMQ,aAAwCV,SAASW,KACrDP,UAAUF;YAEZ,MAAMQ,MAAMR,IAAIU,YAAYF;AAAI;QAElCX,MAAME,GAAG,YAAYC,OAAQF,SAASa,QAAST,UAAUF;;IAMpD,gBAAMY,CAAWC;cAChBjB,KAAKD,MAAME,MAAMe,WAAWC;;IAM7B,oBAAMC;QAGX,OAAOlB,KAAKD,MAAME,MAAMiB;;;;AAyB5B,MAAMZ,YAAgBa,OACpBC,KAAKC,MAAMD,KAAKE,UAAUH;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentica/rpc",
-  "version": "0.8.3",
+  "version": "0.9.0-dev.20250302",
   "main": "lib/index.js",
   "description": "Agentic AI Library specialized in LLM Function Calling",
   "scripts": {
@@ -37,13 +37,13 @@
     "src"
   ],
   "dependencies": {
-    "@agentica/core": "^0.8.3",
-    "@samchon/openapi": "^2.4.3",
+    "@agentica/core": "^0.9.0-dev.20250302",
+    "@samchon/openapi": "^3.0.0",
     "@samchon/shopping-api": "^0.15.0",
     "chalk": "4.1.2",
     "openai": "^4.80.0",
     "tstl": "^3.0.0",
-    "typia": "^7.6.4"
+    "typia": "^8.0.0"
   },
   "devDependencies": {
     "@rollup/plugin-terser": "^0.4.4",
@@ -53,7 +53,7 @@
     "rollup": "^4.34.8",
     "ts-patch": "^3.3.0",
     "typedoc": "^0.27.7",
-    "typescript": "~5.7.3"
+    "typescript": "~5.8.2"
   },
   "module": "lib/index.mjs",
   "typings": "lib/index.d.ts"

package/src/AgenticaRpcService.ts

@@ -1,111 +1,118 @@
-import { Agentica, IAgenticaController } from "@agentica/core";
-import { Primitive } from "typia";
-
-import { IAgenticaRpcListener } from "./IAgenticaRpcListener";
-import { 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("text", (evt) => listener.text(primitive(evt)));
-    agent.on("describe", (evt) => listener.describe(primitive(evt)));
-
-    // OPTIONAL LISTENERS
-    agent.on("initialize", (evt) => listener.initialize!(primitive(evt)));
-    agent.on("select", (evt) => listener.select!(primitive(evt)));
-    agent.on("cancel", (evt) => listener.cancel!(primitive(evt)));
-    agent.on("call", async (evt) => {
-      const args: object | null | undefined = await listener.call!(
-        primitive(evt),
-      );
-      if (!!args) evt.arguments = args;
-    });
-    agent.on("execute", (evt) => listener.execute!(primitive(evt)));
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public async conversate(content: string): Promise<void> {
-    await this.props.agent.conversate(content);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public async getControllers(): Promise<Primitive<IAgenticaController>[]> {
-    return this.props.agent.getControllers() satisfies ReadonlyArray<IAgenticaController> as Primitive<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;
-  }
-}
-
-/**
- * @internal
- */
-const primitive = <T>(obj: T): Primitive<T> =>
-  JSON.parse(JSON.stringify(obj)) as Primitive<T>;
+import { Agentica, IAgenticaController } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
+import { Primitive } from "typia";
+
+import { IAgenticaRpcListener } from "./IAgenticaRpcListener";
+import { 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<Model extends ILlmSchema.Model>
+  implements IAgenticaRpcService<Model>
+{
+  /**
+   * Initializer Constructor.
+   *
+   * @param props Properties to construct the RPC service
+   */
+  public constructor(private readonly props: AgenticaRpcService.IProps<Model>) {
+    const { agent, listener } = props;
+
+    // ESSENTIAL LISTENERS
+    agent.on("text", (evt) => listener.text(primitive(evt)));
+    agent.on("describe", (evt) => listener.describe(primitive(evt)));
+
+    // OPTIONAL LISTENERS
+    agent.on("initialize", (evt) => listener.initialize!(primitive(evt)));
+    agent.on("select", (evt) => listener.select!(primitive(evt)));
+    agent.on("cancel", (evt) => listener.cancel!(primitive(evt)));
+    agent.on("call", async (evt) => {
+      const args: object | null | undefined = await listener.call!(
+        primitive(evt),
+      );
+      if (!!args) evt.arguments = args;
+    });
+    agent.on("execute", (evt) => listener.execute!(primitive(evt as any)));
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public async conversate(content: string): Promise<void> {
+    await this.props.agent.conversate(content);
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public async getControllers(): Promise<
+    Primitive<IAgenticaController<Model>>[]
+  > {
+    return this.props.agent.getControllers() satisfies ReadonlyArray<
+      IAgenticaController<Model>
+    > as Primitive<IAgenticaController<Model>>[];
+  }
+}
+export namespace AgenticaRpcService {
+  /**
+   * Properties of the {@link AgenticaRpcService}.
+   */
+  export interface IProps<Model extends ILlmSchema.Model> {
+    /**
+     * Target agent to provide as RPC service.
+     */
+    agent: Agentica<Model>;
+
+    /**
+     * Listener to be binded on the agent.
+     */
+    listener: IAgenticaRpcListener<Model>;
+  }
+}
+
+/**
+ * @internal
+ */
+const primitive = <T>(obj: T): Primitive<T> =>
+  JSON.parse(JSON.stringify(obj)) as Primitive<T>;

package/src/IAgenticaRpcListener.ts

@@ -1,121 +1,122 @@
-import { IAgenticaEvent } from "@agentica/core";
-import { Primitive } from "typia";
-
-/**
- * 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 IAgenticaEvent}
- * 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: Primitive<IAgenticaEvent.IDescribe>): Promise<void>;
-
-  /**
-   * Text conversation message.
-   *
-   * @param evt Event of a text conversation message
-   */
-  text(evt: Primitive<IAgenticaEvent.IText>): 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: Primitive<IAgenticaEvent.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: Primitive<IAgenticaEvent.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: Primitive<IAgenticaEvent.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 IAgenticaEvent.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: Primitive<IAgenticaEvent.ICall>,
-  ): Promise<object | null | 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: Primitive<IAgenticaEvent.IExecute>): Promise<void>;
-}
+import { IAgenticaEvent } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
+import { Primitive } from "typia";
+
+/**
+ * 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 IAgenticaEvent}
+ * 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<Model extends ILlmSchema.Model> {
+  /**
+   * 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: Primitive<IAgenticaEvent.IDescribe<Model>>): Promise<void>;
+
+  /**
+   * Text conversation message.
+   *
+   * @param evt Event of a text conversation message
+   */
+  text(evt: IAgenticaEvent.IText): 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: IAgenticaEvent.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: Primitive<IAgenticaEvent.ISelect<Model>>): 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: Primitive<IAgenticaEvent.ICancel<Model>>): 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 IAgenticaEvent.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: Primitive<IAgenticaEvent.ICall<Model>>,
+  ): Promise<object | null | 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: IAgenticaEvent.IExecute<Model>): Promise<void>;
+}

package/src/IAgenticaRpcService.ts

@@ -1,40 +1,41 @@
-import { IAgenticaController } from "@agentica/core";
-import { Primitive } from "typia";
-
-/**
- * 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): Promise<void>;
-
-  /**
-   * Get controllers.
-   *
-   * Get controllers, collection of functions that would be
-   * called by the AI chatbot.
-   */
-  getControllers(): Promise<Primitive<IAgenticaController[]>>;
-}
+import { IAgenticaController } from "@agentica/core";
+import { ILlmSchema } from "@samchon/openapi";
+import { Primitive } from "typia";
+
+/**
+ * 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<Model extends ILlmSchema.Model> {
+  /**
+   * 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): Promise<void>;
+
+  /**
+   * Get controllers.
+   *
+   * Get controllers, collection of functions that would be
+   * called by the AI chatbot.
+   */
+  getControllers(): Promise<Primitive<IAgenticaController<Model>[]>>;
+}

package/src/index.ts

@@ -1,3 +1,3 @@
-export * from "./IAgenticaRpcListener";
-export * from "./IAgenticaRpcService";
-export * from "./AgenticaRpcService";
+export * from "./IAgenticaRpcListener";
+export * from "./IAgenticaRpcService";
+export * from "./AgenticaRpcService";