@agentica/core 0.19.1 → 0.21.0

package/lib/orchestrate/initialize.js

@@ -85,9 +85,6 @@ const FUNCTION = {
                         title: "Type schema info of the ChatGPT",
                         description: "Type schema info of the ChatGPT.\n\n`IChatGptSchema` is a type schema info of the ChatGPT function calling.\n\n`IChatGptSchema` basically follows the JSON schema definition of the OpenAPI v3.1\nspeciifcation; {@link OpenApiV3_1.IJsonSchema}.\n\nHowever, the `IChatGptSchema` does not follow the entire specification of\nthe OpenAPI v3.1. It has own specific restrictions and definitions. Here is the\nlist of how `IChatGptSchema` is different with the OpenAPI v3.1 JSON schema.\n\n- Decompose mixed type: {@link OpenApiV3_1.IJsonSchema.IMixed}\n- Resolve nullable property: {@link OpenApiV3_1.IJsonSchema.__ISignificant.nullable}\n- Tuple type is banned: {@link OpenApiV3_1.IJsonSchema.ITuple.prefixItems}\n- Constant type is banned: {@link OpenApiV3_1.IJsonSchema.IConstant}\n- Merge {@link OpenApiV3_1.IJsonSchema.IOneOf} to {@link IChatGptSchema.IAnOf}\n- Merge {@link OpenApiV3_1.IJsonSchema.IAllOf} to {@link IChatGptSchema.IObject}\n- Merge {@link OpenApiV3_1.IJsonSchema.IRecursiveReference} to {@link IChatGptSchema.IReference}\n- When {@link IChatGptSchema.IConfig.strict} mode\n  - Every object properties must be required\n  - Do not allow {@link IChatGptSchema.IObject.additionalProperties}\n\nIf compare with the {@link OpenApi.IJsonSchema}, the emended JSON schema specification,\n\n- {@link IChatGptSchema.IAnyOf} instead of the {@link OpenApi.IJsonSchema.IOneOf}\n- {@link IChatGptSchema.IParameters.$defs} instead of the {@link OpenApi.IJsonSchema.IComponents.schemas}\n- {@link IChatGptSchema.IString.enum} instead of the {@link OpenApi.IJsonSchema.IConstant}\n- {@link IChatGptSchema.additionalProperties} is fixed to `false`\n- No tuple type {@link OpenApi.IJsonSchema.ITuple} support\n- When {@link IChatGptSchema.IConfig.strict} mode\n  - Every object properties must be required\n  - Do not allow {@link IChatGptSchema.IObject.additionalProperties}\n\nFor reference, if you've composed the `IChatGptSchema` type with the\n{@link IChatGptSchema.IConfig.reference} `false` option (default is `false`),\nonly the recursived named types would be archived into the\n{@link IChatGptSchema.IParameters.$defs}, and the others would be ecaped from the\n{@link IChatGptSchema.IReference} type.\n\nAlso, OpenAI has banned below constraint properties. Instead, `IChatGptSchema`\nfills the {@link IChatGptSchema.__IAttribute.description} property with\nthe comment text like `\"@format uuid\"`.\n\n- {@link OpenApi.IJsonSchema.INumber.minimum}\n- {@link OpenApi.IJsonSchema.INumber.maximum}\n- {@link OpenApi.IJsonSchema.INumber.multipleOf}\n- {@link OpenApi.IJsonSchema.IString.minLength}\n- {@link OpenApi.IJsonSchema.IString.maxLength}\n- {@link OpenApi.IJsonSchema.IString.format}\n- {@link OpenApi.IJsonSchema.IString.pattern}\n- {@link OpenApi.IJsonSchema.IString.contentMediaType}\n- {@link OpenApi.IJsonSchema.IString.default}\n- {@link OpenApi.IJsonSchema.IArray.minItems}\n- {@link OpenApi.IJsonSchema.IArray.maxItems}\n- {@link OpenApi.IJsonSchema.IArray.unique}\n\nAdditionally, OpenAI cannot define the `description` property to the\n{@link IChatGptSchema.IReference} type, and even does not understand\nthe capsulization to the {@link IChatGptSchema.IAnyOf} type.\nTherefore, the `description` is written to the parent object type,\nnot the reference type.\n\n```json\n{\n  \"type\": \"object\",\n  \"description\": \"### Description of {@link something} property.\\n\\n> Hello?\",\n  \"properties\": {\n    \"something\": {\n      \"$ref\": \"#/$defs/SomeObject\"\n    }\n  }\n}\n```",
                         anyOf: [
-                            {
-                                $ref: "#/$defs/IChatGptSchema.IObject"
-                            },
                             {
                                 type: "object",
                                 properties: {
@@ -295,6 +292,9 @@ const FUNCTION = {
                             {
                                 $ref: "#/$defs/IChatGptSchema.IArray"
                             },
+                            {
+                                $ref: "#/$defs/IChatGptSchema.IObject"
+                            },
                             {
                                 type: "object",
                                 properties: {
@@ -416,6 +416,54 @@ const FUNCTION = {
                             }
                         ]
                     },
+                    "IChatGptSchema.IArray": {
+                        description: "Array type info.\n\n### Description of {@link items} property:\n\n> Items type info.\n> \n> The `items` means the type of the array elements. In other words, it is\n> the type schema info of the `T` in the TypeScript array type `Array<T>`.",
+                        type: "object",
+                        properties: {
+                            items: {
+                                title: "Items type info",
+                                $ref: "#/$defs/IChatGptSchema"
+                            },
+                            type: {
+                                title: "Discriminator value of the type",
+                                description: "Discriminator value of the type.",
+                                type: "string",
+                                "enum": [
+                                    "array"
+                                ]
+                            },
+                            title: {
+                                title: "Title of the schema",
+                                description: "Title of the schema.",
+                                type: "string"
+                            },
+                            description: {
+                                title: "Detailed description of the schema",
+                                description: "Detailed description of the schema.",
+                                type: "string"
+                            },
+                            deprecated: {
+                                title: "Whether the type is deprecated or not",
+                                description: "Whether the type is deprecated or not.",
+                                type: "boolean"
+                            },
+                            example: {
+                                title: "Example value",
+                                description: "Example value."
+                            },
+                            examples: {
+                                description: "List of example values as key-value pairs.\n\n------------------------------\n\nDescription of the current {@link Recordstringany} type:\n\n> Construct a type with a set of properties K of type T",
+                                type: "object",
+                                properties: {},
+                                required: [],
+                                additionalProperties: {}
+                            }
+                        },
+                        required: [
+                            "items",
+                            "type"
+                        ]
+                    },
                     "IChatGptSchema.IObject": {
                         description: "Object type info.\n\n### Description of {@link properties} property:\n\n> Properties of the object.\n> \n> The `properties` means a list of key-value pairs of the object's\n> regular properties. The key is the name of the regular property,\n> and the value is the type schema info.",
                         type: "object",
@@ -431,9 +479,6 @@ const FUNCTION = {
                                     {
                                         type: "boolean"
                                     },
-                                    {
-                                        $ref: "#/$defs/IChatGptSchema.IObject"
-                                    },
                                     {
                                         type: "object",
                                         properties: {
@@ -641,6 +686,9 @@ const FUNCTION = {
                                     {
                                         $ref: "#/$defs/IChatGptSchema.IArray"
                                     },
+                                    {
+                                        $ref: "#/$defs/IChatGptSchema.IObject"
+                                    },
                                     {
                                         type: "object",
                                         properties: {
@@ -811,54 +859,6 @@ const FUNCTION = {
                             "type"
                         ]
                     },
-                    "IChatGptSchema.IArray": {
-                        description: "Array type info.\n\n### Description of {@link items} property:\n\n> Items type info.\n> \n> The `items` means the type of the array elements. In other words, it is\n> the type schema info of the `T` in the TypeScript array type `Array<T>`.",
-                        type: "object",
-                        properties: {
-                            items: {
-                                title: "Items type info",
-                                $ref: "#/$defs/IChatGptSchema"
-                            },
-                            type: {
-                                title: "Discriminator value of the type",
-                                description: "Discriminator value of the type.",
-                                type: "string",
-                                "enum": [
-                                    "array"
-                                ]
-                            },
-                            title: {
-                                title: "Title of the schema",
-                                description: "Title of the schema.",
-                                type: "string"
-                            },
-                            description: {
-                                title: "Detailed description of the schema",
-                                description: "Detailed description of the schema.",
-                                type: "string"
-                            },
-                            deprecated: {
-                                title: "Whether the type is deprecated or not",
-                                description: "Whether the type is deprecated or not.",
-                                type: "boolean"
-                            },
-                            example: {
-                                title: "Example value",
-                                description: "Example value."
-                            },
-                            examples: {
-                                description: "List of example values as key-value pairs.\n\n------------------------------\n\nDescription of the current {@link Recordstringany} type:\n\n> Construct a type with a set of properties K of type T",
-                                type: "object",
-                                properties: {},
-                                required: [],
-                                additionalProperties: {}
-                            }
-                        },
-                        required: [
-                            "items",
-                            "type"
-                        ]
-                    },
                     "IChatGptSchema.IAnyOf": {
                         description: "Union type.\n\nIOneOf` represents an union type of the TypeScript (`A | B | C`).\n\nFor reference, even though your Swagger (or OpenAPI) document has\ndefined `anyOf` instead of the `oneOf`, {@link IChatGptSchema} forcibly\nconverts it to `oneOf` type.",
                         type: "object",
@@ -869,9 +869,6 @@ const FUNCTION = {
                                 type: "array",
                                 items: {
                                     anyOf: [
-                                        {
-                                            $ref: "#/$defs/IChatGptSchema.IObject"
-                                        },
                                         {
                                             type: "object",
                                             properties: {
@@ -1079,6 +1076,9 @@ const FUNCTION = {
                                         {
                                             $ref: "#/$defs/IChatGptSchema.IArray"
                                         },
+                                        {
+                                            $ref: "#/$defs/IChatGptSchema.IObject"
+                                        },
                                         {
                                             type: "object",
                                             properties: {
@@ -1495,9 +1495,6 @@ const FUNCTION = {
                             title: "Expected return type",
                             description: "Expected return type.\n\nIf the target operation returns nothing (`void`), the `output`\nwould be `undefined`.",
                             anyOf: [
-                                {
-                                    $ref: "#/$defs/IChatGptSchema.IObject"
-                                },
                                 {
                                     type: "object",
                                     properties: {
@@ -1705,6 +1702,9 @@ const FUNCTION = {
                                 {
                                     $ref: "#/$defs/IChatGptSchema.IArray"
                                 },
+                                {
+                                    $ref: "#/$defs/IChatGptSchema.IObject"
+                                },
                                 {
                                     type: "object",
                                     properties: {

package/lib/structures/IAgenticaController.d.ts

@@ -1,5 +1,5 @@
-import type { IHttpConnection, IHttpLlmApplication, IHttpLlmFunction, IHttpResponse, ILlmApplication, ILlmFunction, ILlmSchema } from "@samchon/openapi";
-import type { IMcpLlmApplication } from "./mcp/IMcpLlmApplication";
+import type { Client } from "@modelcontextprotocol/sdk/client/index.d.ts";
+import type { IHttpConnection, IHttpLlmApplication, IHttpLlmFunction, IHttpResponse, ILlmApplication, ILlmFunction, ILlmSchema, IMcpLlmApplication } from "@samchon/openapi";
 /**
  * Controller of the Agentica Agent.
  *
@@ -16,7 +16,7 @@ import type { IMcpLlmApplication } from "./mcp/IMcpLlmApplication";
  *
  * @author Samchon
  */
-export type IAgenticaController<Model extends ILlmSchema.Model> = IAgenticaController.IHttp<Model> | IAgenticaController.IClass<Model> | IAgenticaController.IMcp;
+export type IAgenticaController<Model extends ILlmSchema.Model> = IAgenticaController.IHttp<Model> | IAgenticaController.IClass<Model> | IAgenticaController.IMcp<Model>;
 export declare namespace IAgenticaController {
     /**
      * HTTP controller.
@@ -96,7 +96,11 @@ export declare namespace IAgenticaController {
     /**
      * MCP Server controller.
      */
-    export interface IMcp extends IBase<"mcp", IMcpLlmApplication> {
+    export interface IMcp<Model extends ILlmSchema.Model> extends IBase<"mcp", IMcpLlmApplication<Model>> {
+        /**
+         * MCP client for connection.
+         */
+        client: Client;
     }
     interface IBase<Protocol, Application> {
         /**

package/lib/structures/IAgenticaExecutor.d.ts

@@ -47,15 +47,16 @@ export interface IAgenticaExecutor<Model extends ILlmSchema.Model> {
      * conversate with the user.
      *
      * By the way, if you wanna skip the `initialize` agent, you can
-     * do it by configuring the {@link IAgenticaConfig.executor} as
-     * `null` value. In that case, the `initialize` agent will never be
-     * called, and {@link Agentica} just starts from the {@link select}
-     * agent.
+     * do it by configuring the {@link IAgenticaExecutor.initialize} as
+     * `undefined`, `false` or `null` value. In that case, the `initialize`
+     * agent will never be called, and {@link Agentica} just starts from the
+     * {@link select} agent.
      *
      * @param ctx Context of the agent
      * @returns List of prompts generated by the initializer
+     * @default false
      */
-    initialize: null | ((ctx: AgenticaContext<Model>) => Promise<AgenticaHistory<Model>[]>);
+    initialize: boolean | null | ((ctx: AgenticaContext<Model>) => Promise<AgenticaHistory<Model>[]>);
     /**
      * Function selector agent.
      *
@@ -117,11 +118,14 @@ export interface IAgenticaExecutor<Model extends ILlmSchema.Model> {
      * `Describe` agent explains the results of the function callings
      * to the user as markdown content.
      *
+     * If you configure this property as `false` or `null`, the describer
+     * agent will never be used.
+     *
      * @param ctx Context of the agent
      * @param executes List of function calling results
      * @returns List of prompts generated by the describer
      */
-    describe: (ctx: AgenticaContext<Model>, executes: AgenticaExecuteHistory<Model>[]) => Promise<AgenticaHistory<Model>[]>;
+    describe: boolean | null | ((ctx: AgenticaContext<Model>, executes: AgenticaExecuteHistory<Model>[]) => Promise<AgenticaHistory<Model>[]>);
     /**
      * Function canceler agent.
      *

package/lib/structures/IMicroAgenticaExecutor.d.ts

@@ -49,9 +49,12 @@ export interface IMicroAgenticaExecutor<Model extends ILlmSchema.Model> {
      * `Describe` agent explains the results of the function callings
      * to the user as markdown content.
      *
+     * If you configure this property as `false` or `null`, the describer
+     * agent never be used.
+     *
      * @param ctx Context of the agent
      * @param executes List of function calling results
      * @returns List of prompts generated by the describer
      */
-    describe: (ctx: MicroAgenticaContext<Model>, executes: AgenticaExecuteHistory<Model>[]) => Promise<MicroAgenticaHistory<Model>[]>;
+    describe: boolean | null | ((ctx: MicroAgenticaContext<Model>, executes: AgenticaExecuteHistory<Model>[]) => Promise<MicroAgenticaHistory<Model>[]>);
 }

package/lib/structures/mcp/index.d.ts

@@ -1,3 +1 @@
-export * from "./IMcpLlmApplication";
-export * from "./IMcpLlmFunction";
 export * from "./IMcpLlmTransportProps";

package/lib/structures/mcp/index.js

@@ -14,7 +14,5 @@ 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("./IMcpLlmApplication"), exports);
-__exportStar(require("./IMcpLlmFunction"), exports);
 __exportStar(require("./IMcpLlmTransportProps"), exports);
 //# sourceMappingURL=index.js.map

package/lib/structures/mcp/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/structures/mcp/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,uDAAqC;AACrC,oDAAkC;AAClC,0DAAwC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/structures/mcp/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0DAAwC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentica/core",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "description": "Agentic AI Library specialized in LLM Function Calling",
   "author": "Wrtn Technologies",
   "license": "MIT",
@@ -37,12 +37,12 @@
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.9.0",
-    "@samchon/openapi": "^4.0.0",
+    "@samchon/openapi": "^4.2.0",
     "openai": "^4.80.0",
     "typia": "^9.0.1"
   },
   "dependencies": {
-    "@samchon/openapi": "^4.0.0",
+    "@samchon/openapi": "^4.2.0",
     "typia": "^9.0.1",
     "uuid": "^11.0.4"
   },

package/src/MicroAgentica.ts

@@ -131,7 +131,9 @@ export class MicroAgentica<Model extends ILlmSchema.Model> {
       this.operations_.array,
     ) as MicroAgenticaHistory<Model>[];
     const executes: AgenticaExecuteHistory<Model>[] = histories.filter(p => p.type === "execute");
-    if (executes.length) {
+    if (executes.length
+      && ctx.config?.executor?.describe !== null
+      && ctx.config?.executor?.describe !== false) {
       histories.push(...await describe(ctx, executes));
     }
 

package/src/context/AgenticaOperation.ts

@@ -1,8 +1,7 @@
-import type { IHttpLlmFunction, ILlmFunction, ILlmSchema } from "@samchon/openapi";
+import type { IHttpLlmFunction, ILlmFunction, ILlmSchema, IMcpLlmFunction } from "@samchon/openapi";
 
 import type { IAgenticaOperationJson } from "../json/IAgenticaOperationJson";
 import type { IAgenticaController } from "../structures/IAgenticaController";
-import type { IMcpLlmFunction } from "../structures/mcp/IMcpLlmFunction";
 
 /**
  * Operation information in the Agentica Agent.
@@ -22,7 +21,7 @@ import type { IMcpLlmFunction } from "../structures/mcp/IMcpLlmFunction";
 export type AgenticaOperation<Model extends ILlmSchema.Model> =
   | AgenticaOperation.Class<Model>
   | AgenticaOperation.Http<Model>
-  | AgenticaOperation.Mcp;
+  | AgenticaOperation.Mcp<Model>;
 export namespace AgenticaOperation {
   export type Class<Model extends ILlmSchema.Model> = Base<
     "class",
@@ -34,10 +33,10 @@ export namespace AgenticaOperation {
     IAgenticaController.IHttp<Model>,
     IHttpLlmFunction<Model>
   >;
-  export type Mcp = Base<
+  export type Mcp<Model extends ILlmSchema.Model> = Base<
     "mcp",
-    IAgenticaController.IMcp,
-    IMcpLlmFunction
+    IAgenticaController.IMcp<Model>,
+    IMcpLlmFunction<Model>
   >;
 
   interface Base<

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

@@ -1,13 +1,12 @@
-import type { IHttpLlmFunction, ILlmFunction, IValidation } from "@samchon/openapi";
+import type { IChatGptSchema, IHttpLlmFunction, ILlmFunction, IMcpLlmFunction, 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 { assertMcpController } from "../../functional/assertMcpController";
 
 import { compose, divide, getOperations, toClassOperations, toHttpOperations, toMcpOperations } from "./AgenticaOperationComposer";
 
@@ -70,16 +69,18 @@ function createMockClassController(name: string, functions: ILlmFunction<any>[])
   };
 }
 
-async function createMockMcpController(name: string, functions: IMcpLlmFunction[]): Promise<IAgenticaController.IMcp> {
-  return {
+async function createMockMcpController(name: string, functions: IMcpLlmFunction<"chatgpt">[]): Promise<IAgenticaController.IMcp<"chatgpt">> {
+  const controller = await assertMcpController({
+    model: "chatgpt",
     name,
-    protocol: "mcp",
-    application: await assertMcpLlmApplication({
-      client,
-    }).then(v => ({
-      ...v,
+    client,
+  });
+  return {
+    ...controller,
+    application: {
+      ...controller.application,
       functions,
-    })),
+    },
   };
 }
 
@@ -110,7 +111,17 @@ describe("a AgenticaOperationComposer", () => {
       const mockMcpController = await createMockMcpController("mcpController", [
         {
           name: "function4",
-          parameters: {},
+          parameters: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+            required: [],
+            $defs: {},
+          } satisfies IChatGptSchema.IParameters,
+          validate: (data: unknown) => ({
+            success: true,
+            data,
+          }),
         },
       ]);
 
@@ -182,7 +193,17 @@ describe("a AgenticaOperationComposer", () => {
       const mockController = await createMockMcpController("mcpController", [
         {
           name: "function1",
-          parameters: {},
+          parameters: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+            required: [],
+            $defs: {},
+          },
+          validate: (data: unknown) => ({
+            success: true,
+            data,
+          }),
         },
       ]);
 
@@ -245,7 +266,17 @@ describe("a AgenticaOperationComposer", () => {
       const mockController = await createMockMcpController("mcpController", [
         {
           name: "function1",
-          parameters: {},
+          parameters: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+            required: [],
+            $defs: {},
+          },
+          validate: (data: unknown) => ({
+            success: true,
+            data,
+          }),
         },
       ]);
 

package/src/context/internal/AgenticaOperationComposer.ts

@@ -21,7 +21,10 @@ export function compose<Model extends ILlmSchema.Model>(props: {
   config?: IAgenticaConfig<Model> | IMicroAgenticaConfig<Model> | undefined;
 }): AgenticaOperationCollection<Model> {
   const unique: boolean = (props.controllers.length === 1 || (() => {
-    const names = props.controllers.map(controllers => controllers.application.functions.map(func => func.name)).flat();
+    const names = props.controllers.map(
+
+      controllers => controllers.application.functions.map((func: { name: string }) => func.name),
+    ).flat();
     return new Set(names).size === names.length;
   })());
 
@@ -126,19 +129,23 @@ export function toClassOperations<Model extends ILlmSchema.Model>(props: {
  * @internal
  */
 export function toMcpOperations<Model extends ILlmSchema.Model>(props: {
-  controller: IAgenticaController.IMcp;
+  controller: IAgenticaController.IMcp<Model>;
   index: number;
   naming: (func: string, controllerIndex: number) => string;
 }): AgenticaOperation<Model>[] {
   return props.controller.application.functions.map(func => ({
     protocol: "mcp",
     controller: props.controller,
+
     function: func,
+
     name: props.naming(func.name, props.index),
     toJSON: () => ({
       protocol: "mcp",
       controller: props.controller.name,
+
       function: func.name,
+
       name: props.naming(func.name, props.index),
     }),
   }));

package/src/functional/assertMcpController.ts

@@ -0,0 +1,48 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.d.ts";
+import type { ILlmSchema, IMcpLlmApplication, IMcpTool } from "@samchon/openapi";
+
+import { McpLlm } from "@samchon/openapi";
+import typia from "typia";
+
+import type { IAgenticaController } from "../structures/IAgenticaController";
+
+/**
+ * Create an MCP controller with type assertion.
+ *
+ * Create an {@link IAgenticaController.IMcp} instance which represents
+ * an MCP (Model Context Protocol) controller with LLM function calling
+ * schemas and client connection.
+ *
+ * @param props Properties to create the MCP controller
+ * @param props.name Name of the MCP implementation.
+ * @param props.client Client connection to the MCP implementation.
+ * @param props.model Model schema of the LLM function calling.
+ * @param props.options Options to create the MCP controller.
+ * @returns MCP LLM application instance
+ * @author Samchon
+ */
+export async function assertMcpController<Model extends ILlmSchema.Model>(props: {
+  name: string;
+  client: Client;
+  model: Model;
+  options?: Partial<IMcpLlmApplication.IOptions<Model>>;
+}): Promise<IAgenticaController.IMcp<Model>> {
+  // for peerDependencies
+  const { ListToolsResultSchema } = await import("@modelcontextprotocol/sdk/types.js");
+
+  // get list of tools
+  const { tools } = await props.client.request({ method: "tools/list" }, ListToolsResultSchema);
+
+  const application: IMcpLlmApplication<Model> = McpLlm.application<Model>({
+    model: props.model,
+    tools: typia.assert<Array<IMcpTool>>(tools),
+  });
+
+  return {
+    protocol: "mcp",
+    name: props.name,
+    client: props.client,
+
+    application,
+  };
+}

package/src/index.ts

@@ -23,7 +23,7 @@ export * from "./events/MicroAgenticaEvent";
 export * as factory from "./factory";
 
 export * from "./functional/assertHttpLlmApplication";
-export * from "./functional/assertMcpLlmApplication";
+export * from "./functional/assertMcpController";
 export * from "./functional/validateHttpLlmApplication";
 // @TODO: implement validateMcpLlmApplication
 

package/src/orchestrate/call.ts

@@ -72,10 +72,13 @@ export async function call<Model extends ILlmSchema.Model>(
           type: "function",
           function: {
             name: s.name,
+
             description: s.function.description,
             parameters: (
               "separated" in s.function
+
               && s.function.separated !== undefined
+
                 ? (s.function.separated.llm
                   ?? ({
                     type: "object",
@@ -84,6 +87,7 @@ export async function call<Model extends ILlmSchema.Model>(
                     additionalProperties: false,
                     $defs: {},
                   } satisfies IChatGptSchema.IParameters))
+
                 : s.function.parameters) as Record<string, any>,
           },
         }) as OpenAI.ChatCompletionTool,
@@ -368,7 +372,7 @@ async function propagateClass<Model extends ILlmSchema.Model>(props: {
 
 async function propagateMcp<Model extends ILlmSchema.Model>(props: {
   ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>;
-  operation: AgenticaOperation.Mcp;
+  operation: AgenticaOperation.Mcp<Model>;
   call: AgenticaCallEvent<Model>;
   retry: number;
 }): Promise<AgenticaExecuteHistory<Model>> {
@@ -435,12 +439,14 @@ 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,
+async function executeMcpOperation<Model extends ILlmSchema.Model>(
+  operation: AgenticaOperation.Mcp<Model>,
   operationArguments: Record<string, unknown>,
 ): Promise<unknown> {
-  return operation.controller.application.client.callTool({
+  return operation.controller.client.callTool({
+
     method: operation.function.name,
+
     name: operation.function.name,
     arguments: operationArguments,
   }).then(v => v.content);
@@ -512,6 +518,7 @@ async function correct<Model extends ILlmSchema.Model>(
         type: "function",
         function: {
           name: call.operation.name,
+
           description: call.operation.function.description,
           /**
            * @TODO fix it
@@ -519,7 +526,9 @@ async function correct<Model extends ILlmSchema.Model>(
            */
           parameters: (
             "separated" in call.operation.function
+
             && call.operation.function.separated !== undefined
+
               ? (call.operation.function.separated?.llm
                 ?? ({
                   $defs: {},
@@ -528,6 +537,7 @@ async function correct<Model extends ILlmSchema.Model>(
                   additionalProperties: false,
                   required: [],
                 } satisfies IChatGptSchema.IParameters))
+
               : call.operation.function.parameters) as unknown as Record<string, unknown>,
         },
       },