@agentica/rpc 0.7.0-dev.20250224

package/LICENSE

@@ -0,0 +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.

package/lib/AgenticaRpcService.d.ts

@@ -0,0 +1,74 @@
+import { Agentica } from "@agentica/core";
+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 declare class AgenticaRpcService implements IAgenticaRpcService {
+    private readonly props;
+    /**
+     * Initializer Constructor.
+     *
+     * @param props Properties to construct the RPC service
+     */
+    constructor(props: AgenticaRpcService.IProps);
+    /**
+     * @inheritDoc
+     */
+    conversate(content: string): Promise<void>;
+}
+export declare namespace AgenticaRpcService {
+    /**
+     * Properties of the {@link AgenticaRpcService}.
+     */
+    interface IProps {
+        /**
+         * Target agent to provide as RPC service.
+         */
+        agent: Agentica;
+        /**
+         * Listener to be binded on the agent.
+         */
+        listener: IAgenticaRpcListener;
+    }
+}

package/lib/AgenticaRpcService.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgenticaRpcService = void 0;
+/**
+ * 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
+ */
+class AgenticaRpcService {
+    /**
+     * Initializer Constructor.
+     *
+     * @param props Properties to construct the RPC service
+     */
+    constructor(props) {
+        this.props = props;
+        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", (evt) => __awaiter(this, void 0, void 0, function* () {
+            const args = yield listener.call(primitive(evt));
+            if (!!args)
+                evt.arguments = args;
+        }));
+        agent.on("execute", (evt) => listener.execute(primitive(evt)));
+    }
+    /**
+     * @inheritDoc
+     */
+    conversate(content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.props.agent.conversate(content);
+        });
+    }
+}
+exports.AgenticaRpcService = AgenticaRpcService;
+/**
+ * @internal
+ */
+const primitive = (obj) => JSON.parse(JSON.stringify(obj));
+//# sourceMappingURL=AgenticaRpcService.js.map

package/lib/AgenticaRpcService.js.map

@@ -0,0 +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;CACF;AAhCD,gDAgCC;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

@@ -0,0 +1,112 @@
+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>;
+}

package/lib/IAgenticaRpcListener.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAgenticaRpcListener.js.map

package/lib/IAgenticaRpcListener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAgenticaRpcListener.js","sourceRoot":"","sources":["../src/IAgenticaRpcListener.ts"],"names":[],"mappings":""}

package/lib/IAgenticaRpcService.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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>;
+}

package/lib/IAgenticaRpcService.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IAgenticaRpcService.js.map

package/lib/IAgenticaRpcService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAgenticaRpcService.js","sourceRoot":"","sources":["../src/IAgenticaRpcService.ts"],"names":[],"mappings":""}

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./IAgenticaRpcListener"), exports);
+__exportStar(require("./IAgenticaRpcService"), exports);
+__exportStar(require("./AgenticaRpcService"), exports);
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,yDAAuC;AACvC,wDAAsC;AACtC,uDAAqC"}

package/lib/index.mjs

@@ -0,0 +1,24 @@
+class AgenticaRpcService {
+    constructor(props) {
+        this.props = props;
+        const {agent, listener} = props;
+        agent.on("text", (evt => listener.text(primitive(evt))));
+        agent.on("describe", (evt => listener.describe(primitive(evt))));
+        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 = await listener.call(primitive(evt));
+            if (!!args) evt.arguments = args;
+        }));
+        agent.on("execute", (evt => listener.execute(primitive(evt))));
+    }
+    async conversate(content) {
+        await this.props.agent.conversate(content);
+    }
+}
+
+const primitive = obj => JSON.parse(JSON.stringify(obj));
+
+export { AgenticaRpcService };
+//# sourceMappingURL=index.mjs.map

package/lib/index.mjs.map

@@ -0,0 +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","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;;;;AAuBtC,MAAMX,YAAgBY,OACpBC,KAAKC,MAAMD,KAAKE,UAAUH;;"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@agentica/rpc",
+  "version": "0.7.0-dev.20250224",
+  "main": "lib/index.js",
+  "description": "Agentic AI Library specialized in LLM Function Calling",
+  "scripts": {
+    "prepare": "ts-patch install",
+    "build": "rimraf lib && tsc && rollup -c",
+    "dev": "rimraf lib && tsc --watch"
+  },
+  "author": "Wrtn Technologies",
+  "homepage": "https://wrtnlabs.io/agentica",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wrtnlabs/agentica"
+  },
+  "bugs": {
+    "url": "https://github.com/wrtnlabs/agentica/issues"
+  },
+  "keywords": [
+    "openai",
+    "chatgpt",
+    "anthropic",
+    "claude",
+    "ai",
+    "chatbot",
+    "nestia",
+    "swagger",
+    "openapi"
+  ],
+  "files": [
+    "README.md",
+    "LICENSE",
+    "package.json",
+    "lib",
+    "src"
+  ],
+  "dependencies": {
+    "@agentica/core": "^0.7.0-dev.20250224",
+    "@samchon/openapi": "^2.4.3",
+    "@samchon/shopping-api": "^0.15.0",
+    "chalk": "4.1.2",
+    "openai": "^4.80.0",
+    "tstl": "^3.0.0",
+    "typia": "^7.6.4"
+  },
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^22.13.4",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.34.8",
+    "ts-patch": "^3.3.0",
+    "typescript": "~5.7.3"
+  },
+  "module": "lib/index.mjs",
+  "typings": "lib/index.d.ts"
+}

package/src/AgenticaRpcService.ts

@@ -0,0 +1,104 @@
+import { Agentica } 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);
+  }
+}
+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>;

package/src/IAgenticaRpcListener.ts

@@ -0,0 +1,121 @@
+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>;
+}

package/src/IAgenticaRpcService.ts

@@ -0,0 +1,29 @@
+/**
+ * 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>;
+}

package/src/index.ts

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