@agentica/core 0.17.1 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentica/core",
-  "version": "0.17.1",
+  "version": "0.19.0",
   "description": "Agentic AI Library specialized in LLM Function Calling",
   "author": "Wrtn Technologies",
   "license": "MIT",

package/src/context/internal/AgenticaOperationComposer.spec.ts

@@ -1,11 +1,21 @@
 import type { IHttpLlmFunction, ILlmFunction, IValidation } from "@samchon/openapi";
 
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
 import type { IAgenticaConfig } from "../../structures/IAgenticaConfig";
 import type { IAgenticaController } from "../../structures/IAgenticaController";
 import type { IMcpLlmFunction } from "../../structures/mcp/IMcpLlmFunction";
 
+import { assertMcpLlmApplication } from "../../functional/assertMcpLlmApplication";
+
 import { compose, divide, getOperations, toClassOperations, toHttpOperations, toMcpOperations } from "./AgenticaOperationComposer";
 
+const client = new Client({
+  name: "calculator",
+  version: "1.0.0",
+});
+
 // test helper functions
 function createMockHttpFunction(name: string, method: "get" | "post" | "patch" | "put" | "delete", path: string): IHttpLlmFunction<any> {
   return {
@@ -60,23 +70,28 @@ function createMockClassController(name: string, functions: ILlmFunction<any>[])
   };
 }
 
-function createMockMcpController(name: string, functions: IMcpLlmFunction[]): IAgenticaController.IMcp {
+async function createMockMcpController(name: string, functions: IMcpLlmFunction[]): Promise<IAgenticaController.IMcp> {
   return {
     name,
     protocol: "mcp",
-    application: {
-      transport: {
-        type: "sse",
-        url: new URL("https://example.com"),
-      },
+    application: await assertMcpLlmApplication({
+      client,
+    }).then(v => ({
+      ...v,
       functions,
-    },
+    })),
   };
 }
 
 describe("a AgenticaOperationComposer", () => {
+  beforeAll(async () => {
+    await client.connect(new StdioClientTransport({
+      command: "npx",
+      args: ["-y", "@wrtnlabs/calculator-mcp"],
+    }));
+  });
   describe("compose", () => {
-    it("should compose operations from controllers", () => {
+    it("should compose operations from controllers", async () => {
       // Mock controllers
       const mockHttpController = createMockHttpController("httpController", [
         createMockHttpFunction("function1", "get", "/api/function1"),
@@ -92,7 +107,7 @@ describe("a AgenticaOperationComposer", () => {
         },
       ]);
 
-      const mockMcpController = createMockMcpController("mcpController", [
+      const mockMcpController = await createMockMcpController("mcpController", [
         {
           name: "function4",
           parameters: {},
@@ -163,8 +178,8 @@ describe("a AgenticaOperationComposer", () => {
       expect(result[0]?.name).toBe("_0_function1");
     });
 
-    it("should get operations from mcp controllers", () => {
-      const mockController = createMockMcpController("mcpController", [
+    it("should get operations from mcp controllers", async () => {
+      const mockController = await createMockMcpController("mcpController", [
         {
           name: "function1",
           parameters: {},
@@ -226,8 +241,8 @@ describe("a AgenticaOperationComposer", () => {
   });
 
   describe("toMcpOperations", () => {
-    it("should convert mcp controller to operations", () => {
-      const mockController = createMockMcpController("mcpController", [
+    it("should convert mcp controller to operations", async () => {
+      const mockController = await createMockMcpController("mcpController", [
         {
           name: "function1",
           parameters: {},

package/src/functional/assertMcpLlmApplication.ts

@@ -1,4 +1,6 @@
-import type { IMcpLlmApplication, IMcpLlmTransportProps } from "../structures/mcp";
+import type { Client } from "@modelcontextprotocol/sdk/client/index.d.ts";
+
+import type { IMcpLlmApplication } from "../structures/mcp";
 /**
  * Create an MCP LLM application instance with type assertion.
  *
@@ -12,38 +14,19 @@ import type { IMcpLlmApplication, IMcpLlmTransportProps } from "../structures/mc
  * @returns MCP LLM application instance
  * @author Samchon
  */
-export async function assertMcpLlmApplication(props: IMcpLlmTransportProps): Promise<IMcpLlmApplication> {
+export async function assertMcpLlmApplication(props: {
+  client: Client;
+}): Promise<IMcpLlmApplication> {
   // for peerDependencies
-  const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
-  const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
-  const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
   const { ListToolsResultSchema } = await import("@modelcontextprotocol/sdk/types.js");
 
-  const client = new Client({
-    name: "get_tool_list",
-    version: "1.0.0",
-  });
-
-  const transport = (() => {
-    switch (props.type) {
-      case "sse":
-        return new SSEClientTransport(props.url);
-      case "stdio":
-        return new StdioClientTransport(props);
-      default:
-        props satisfies never;
-        throw new Error("Invalid transport type");
-    }
-  })();
-  await client.connect(transport);
-
-  const toolList = await client.request({ method: "tools/list" }, ListToolsResultSchema);
+  const toolList = await props.client.request({ method: "tools/list" }, ListToolsResultSchema);
   return {
     functions: toolList.tools.map(tool => ({
       name: tool.name,
       description: tool.description,
       parameters: tool.inputSchema,
     })),
-    transport: props,
+    client: props.client,
   };
 }

package/src/orchestrate/call.ts

@@ -435,34 +435,15 @@ async function executeClassOperation<Model extends ILlmSchema.Model>(operation:
   return ((execute as Record<string, unknown>)[operation.function.name] as (...args: unknown[]) => Promise<unknown>)(operationArguments);
 }
 
-async function executeMcpOperation(operation: AgenticaOperation.Mcp, operationArguments: Record<string, unknown>): Promise<unknown> {
-  // for peerDependencies
-  const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
-  const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
-  const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
-
-  const client = new Client({
-    name: operation.name,
-    version: "1.0.0",
-  });
-
-  const transport = (() => {
-    switch (operation.controller.application.transport.type) {
-      case "sse":
-        return new SSEClientTransport(operation.controller.application.transport.url);
-      case "stdio":
-        // @TODO: implement StdioClientTransport cache
-        // StdioClientTransport and connects a new child process every time it is initialized and connected.
-        // This results in significant latency and resource waste.
-        return new StdioClientTransport(operation.controller.application.transport);
-      default:
-        operation.controller.application.transport satisfies never;
-        throw new Error("Unsupported transport type");
-    }
-  })();
-  await client.connect(transport);
-  const result = await client.callTool({ method: operation.function.name, name: operation.function.name, arguments: operationArguments });
-  return result.content;
+async function executeMcpOperation(
+  operation: AgenticaOperation.Mcp,
+  operationArguments: Record<string, unknown>,
+): Promise<unknown> {
+  return operation.controller.application.client.callTool({
+    method: operation.function.name,
+    name: operation.function.name,
+    arguments: operationArguments,
+  }).then(v => v.content);
 }
 
 async function correct<Model extends ILlmSchema.Model>(

package/src/structures/mcp/IMcpLlmApplication.ts

@@ -1,17 +1,10 @@
-import type { IMcpLlmFunction } from "./IMcpLlmFunction";
-import type { IMcpLlmTransportProps } from "./IMcpLlmTransportProps";
+import type { Client } from "@modelcontextprotocol/sdk/client/index.d.ts";
 
+import type { IMcpLlmFunction } from "./IMcpLlmFunction";
 /**
  * MCP LLM application.
  */
 export interface IMcpLlmApplication {
-  /**
-   * Functions of the MCP server.
-   */
+  client: Client;
   functions: IMcpLlmFunction[];
-
-  /**
-   * Transport properties of the MCP server.
-   */
-  transport: IMcpLlmTransportProps;
 }