@typia/vercel 12.0.0-dev.20260309 → 12.0.0-dev.20260311

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import type { Tool } from "ai";
 import { IHttpLlmController, ILlmController } from "@typia/interface";
+import type { Tool } from "ai";
 /**
  * Convert typia controllers to Vercel AI SDK tools.
  *
@@ -8,8 +8,8 @@ import { IHttpLlmController, ILlmController } from "@typia/interface";
  * can be used with any LLM provider (OpenAI, Anthropic, Google, etc.).
  *
  * Every tool call is validated by typia. If the LLM provides invalid arguments,
- * returns a validation error formatted by {@link LlmJson.stringify}
- * so the LLM can auto-correct in the next turn.
+ * returns a validation error formatted by {@link LlmJson.stringify} so the LLM
+ * can auto-correct in the next turn.
  *
  * ## Example with OpenAI
  *
@@ -39,9 +39,9 @@ import { IHttpLlmController, ILlmController } from "@typia/interface";
  * ## Example with Anthropic
  *
  * ```typescript
- * import { generateText } from "ai";
  * import { anthropic } from "@ai-sdk/anthropic";
  * import { toVercelTools } from "@typia/vercel";
+ * import { generateText } from "ai";
  *
  * const result = await generateText({
  *   model: anthropic("claude-sonnet-4-20250514"),
@@ -53,14 +53,16 @@ import { IHttpLlmController, ILlmController } from "@typia/interface";
  * ## Example with HTTP Controller (OpenAPI)
  *
  * ```typescript
- * import { generateText } from "ai";
  * import { openai } from "@ai-sdk/openai";
  * import { HttpLlm } from "@typia/utils";
  * import { toVercelTools } from "@typia/vercel";
+ * import { generateText } from "ai";
  *
  * const controller = HttpLlm.controller({
  *   name: "shopping",
- *   document: await fetch("https://api.example.com/swagger.json").then(r => r.json()),
+ *   document: await fetch("https://api.example.com/swagger.json").then(
+ *     (r) => r.json(),
+ *   ),
  *   connection: { host: "https://api.example.com" },
  * });
  *
@@ -71,9 +73,9 @@ import { IHttpLlmController, ILlmController } from "@typia/interface";
  * });
  * ```
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @param props Conversion properties
  * @returns Record of Vercel AI SDK Tools keyed by tool name
- * @author Jeongho Nam - https://github.com/samchon
  */
 export declare function toVercelTools(props: {
     /**
@@ -88,8 +90,8 @@ export declare function toVercelTools(props: {
     /**
      * Whether to prefix tool names with controller name.
      *
-     * If `true`, tool names are formatted as `{controller}_{function}`.
-     * If `false`, only the function name is used (may cause conflicts).
+     * If `true`, tool names are formatted as `{controller}_{function}`. If
+     * `false`, only the function name is used (may cause conflicts).
      *
      * @default true
      */

package/lib/index.js

@@ -10,8 +10,8 @@ const VercelToolsRegistrar_1 = require("./internal/VercelToolsRegistrar");
  * can be used with any LLM provider (OpenAI, Anthropic, Google, etc.).
  *
  * Every tool call is validated by typia. If the LLM provides invalid arguments,
- * returns a validation error formatted by {@link LlmJson.stringify}
- * so the LLM can auto-correct in the next turn.
+ * returns a validation error formatted by {@link LlmJson.stringify} so the LLM
+ * can auto-correct in the next turn.
  *
  * ## Example with OpenAI
  *
@@ -41,9 +41,9 @@ const VercelToolsRegistrar_1 = require("./internal/VercelToolsRegistrar");
  * ## Example with Anthropic
  *
  * ```typescript
- * import { generateText } from "ai";
  * import { anthropic } from "@ai-sdk/anthropic";
  * import { toVercelTools } from "@typia/vercel";
+ * import { generateText } from "ai";
  *
  * const result = await generateText({
  *   model: anthropic("claude-sonnet-4-20250514"),
@@ -55,14 +55,16 @@ const VercelToolsRegistrar_1 = require("./internal/VercelToolsRegistrar");
  * ## Example with HTTP Controller (OpenAPI)
  *
  * ```typescript
- * import { generateText } from "ai";
  * import { openai } from "@ai-sdk/openai";
  * import { HttpLlm } from "@typia/utils";
  * import { toVercelTools } from "@typia/vercel";
+ * import { generateText } from "ai";
  *
  * const controller = HttpLlm.controller({
  *   name: "shopping",
- *   document: await fetch("https://api.example.com/swagger.json").then(r => r.json()),
+ *   document: await fetch("https://api.example.com/swagger.json").then(
+ *     (r) => r.json(),
+ *   ),
  *   connection: { host: "https://api.example.com" },
  * });
  *
@@ -73,9 +75,9 @@ const VercelToolsRegistrar_1 = require("./internal/VercelToolsRegistrar");
  * });
  * ```
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @param props Conversion properties
  * @returns Record of Vercel AI SDK Tools keyed by tool name
- * @author Jeongho Nam - https://github.com/samchon
  */
 function toVercelTools(props) {
     return VercelToolsRegistrar_1.VercelToolsRegistrar.convert(props);

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAgFA,sCAsBC;AAnGD,0EAAuE;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,SAAgB,aAAa,CAAC,KAoB7B;IACC,OAAO,2CAAoB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC7C,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAkFA,sCAsBC;AArGD,0EAAuE;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,SAAgB,aAAa,CAAC,KAoB7B;IACC,OAAO,2CAAoB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC7C,CAAC"}

package/lib/index.mjs

@@ -8,8 +8,8 @@ import { VercelToolsRegistrar } from './internal/VercelToolsRegistrar.mjs';
  * can be used with any LLM provider (OpenAI, Anthropic, Google, etc.).
  *
  * Every tool call is validated by typia. If the LLM provides invalid arguments,
- * returns a validation error formatted by {@link LlmJson.stringify}
- * so the LLM can auto-correct in the next turn.
+ * returns a validation error formatted by {@link LlmJson.stringify} so the LLM
+ * can auto-correct in the next turn.
  *
  * ## Example with OpenAI
  *
@@ -39,9 +39,9 @@ import { VercelToolsRegistrar } from './internal/VercelToolsRegistrar.mjs';
  * ## Example with Anthropic
  *
  * ```typescript
- * import { generateText } from "ai";
  * import { anthropic } from "@ai-sdk/anthropic";
  * import { toVercelTools } from "@typia/vercel";
+ * import { generateText } from "ai";
  *
  * const result = await generateText({
  *   model: anthropic("claude-sonnet-4-20250514"),
@@ -53,14 +53,16 @@ import { VercelToolsRegistrar } from './internal/VercelToolsRegistrar.mjs';
  * ## Example with HTTP Controller (OpenAPI)
  *
  * ```typescript
- * import { generateText } from "ai";
  * import { openai } from "@ai-sdk/openai";
  * import { HttpLlm } from "@typia/utils";
  * import { toVercelTools } from "@typia/vercel";
+ * import { generateText } from "ai";
  *
  * const controller = HttpLlm.controller({
  *   name: "shopping",
- *   document: await fetch("https://api.example.com/swagger.json").then(r => r.json()),
+ *   document: await fetch("https://api.example.com/swagger.json").then(
+ *     (r) => r.json(),
+ *   ),
  *   connection: { host: "https://api.example.com" },
  * });
  *
@@ -71,9 +73,9 @@ import { VercelToolsRegistrar } from './internal/VercelToolsRegistrar.mjs';
  * });
  * ```
  *
+ * @author Jeongho Nam - https://github.com/samchon
  * @param props Conversion properties
  * @returns Record of Vercel AI SDK Tools keyed by tool name
- * @author Jeongho Nam - https://github.com/samchon
  */
 function toVercelTools(props) {
     return VercelToolsRegistrar.convert(props);

package/lib/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EG;AACG,SAAU,aAAa,CAAC,KAoB7B,EAAA;AACC,IAAA,OAAO,oBAAoB,CAAC,OAAO,CAAC,KAAK,CAAC;AAC5C;;;;"}
+{"version":3,"file":"index.mjs","sources":["../src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EG;AACG,SAAU,aAAa,CAAC,KAoB7B,EAAA;AACC,IAAA,OAAO,oBAAoB,CAAC,OAAO,CAAC,KAAK,CAAC;AAC5C;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typia/vercel",
-  "version": "12.0.0-dev.20260309",
+  "version": "12.0.0-dev.20260311",
   "description": "Vercel AI SDK integration for typia",
   "main": "lib/index.js",
   "exports": {
@@ -22,8 +22,8 @@
   },
   "homepage": "https://typia.io",
   "dependencies": {
-    "@typia/interface": "^12.0.0-dev.20260309",
-    "@typia/utils": "^12.0.0-dev.20260309"
+    "@typia/utils": "^12.0.0-dev.20260311",
+    "@typia/interface": "^12.0.0-dev.20260311"
   },
   "peerDependencies": {
     "ai": ">=4.0.0"

package/src/index.ts

@@ -1,103 +1,105 @@
-import type { Tool } from "ai";
-import { IHttpLlmController, ILlmController } from "@typia/interface";
-
-import { VercelToolsRegistrar } from "./internal/VercelToolsRegistrar";
-
-/**
- * Convert typia controllers to Vercel AI SDK tools.
- *
- * Transforms TypeScript class methods via `typia.llm.controller<Class>()` or
- * OpenAPI operations via `HttpLlm.controller()` into Vercel AI SDK tools that
- * can be used with any LLM provider (OpenAI, Anthropic, Google, etc.).
- *
- * Every tool call is validated by typia. If the LLM provides invalid arguments,
- * returns a validation error formatted by {@link LlmJson.stringify}
- * so the LLM can auto-correct in the next turn.
- *
- * ## Example with OpenAI
- *
- * ```typescript
- * import { generateText } from "ai";
- * import { openai } from "@ai-sdk/openai";
- * import typia from "typia";
- * import { toVercelTools } from "@typia/vercel";
- *
- * class Calculator {
- *   /&#42;&#42; Add two numbers together. &#42;/
- *   add(props: { a: number; b: number }): number {
- *     return props.a + props.b;
- *   }
- * }
- *
- * const controller = typia.llm.controller<Calculator>("calc", new Calculator());
- * const tools = toVercelTools({ controllers: [controller] });
- *
- * const result = await generateText({
- *   model: openai("gpt-4o"),
- *   tools,
- *   prompt: "What is 15 + 27?",
- * });
- * ```
- *
- * ## Example with Anthropic
- *
- * ```typescript
- * import { generateText } from "ai";
- * import { anthropic } from "@ai-sdk/anthropic";
- * import { toVercelTools } from "@typia/vercel";
- *
- * const result = await generateText({
- *   model: anthropic("claude-sonnet-4-20250514"),
- *   tools: toVercelTools({ controllers: [controller] }),
- *   prompt: "Calculate 100 * 50",
- * });
- * ```
- *
- * ## Example with HTTP Controller (OpenAPI)
- *
- * ```typescript
- * import { generateText } from "ai";
- * import { openai } from "@ai-sdk/openai";
- * import { HttpLlm } from "@typia/utils";
- * import { toVercelTools } from "@typia/vercel";
- *
- * const controller = HttpLlm.controller({
- *   name: "shopping",
- *   document: await fetch("https://api.example.com/swagger.json").then(r => r.json()),
- *   connection: { host: "https://api.example.com" },
- * });
- *
- * const result = await generateText({
- *   model: openai("gpt-4o"),
- *   tools: toVercelTools({ controllers: [controller] }),
- *   prompt: "Search for laptops under $1000",
- * });
- * ```
- *
- * @param props Conversion properties
- * @returns Record of Vercel AI SDK Tools keyed by tool name
- * @author Jeongho Nam - https://github.com/samchon
- */
-export function toVercelTools(props: {
-  /**
-   * List of controllers to convert to Vercel tools.
-   *
-   * - {@link ILlmController}: from `typia.llm.controller<Class>()`, converts all
-   *   methods of the class to tools
-   * - {@link IHttpLlmController}: from `HttpLlm.controller()`, converts all
-   *   operations from OpenAPI document to tools
-   */
-  controllers: Array<ILlmController | IHttpLlmController>;
-
-  /**
-   * Whether to prefix tool names with controller name.
-   *
-   * If `true`, tool names are formatted as `{controller}_{function}`.
-   * If `false`, only the function name is used (may cause conflicts).
-   *
-   * @default true
-   */
-  prefix?: boolean | undefined;
-}): Record<string, Tool> {
-  return VercelToolsRegistrar.convert(props);
-}
+import { IHttpLlmController, ILlmController } from "@typia/interface";
+import type { Tool } from "ai";
+
+import { VercelToolsRegistrar } from "./internal/VercelToolsRegistrar";
+
+/**
+ * Convert typia controllers to Vercel AI SDK tools.
+ *
+ * Transforms TypeScript class methods via `typia.llm.controller<Class>()` or
+ * OpenAPI operations via `HttpLlm.controller()` into Vercel AI SDK tools that
+ * can be used with any LLM provider (OpenAI, Anthropic, Google, etc.).
+ *
+ * Every tool call is validated by typia. If the LLM provides invalid arguments,
+ * returns a validation error formatted by {@link LlmJson.stringify} so the LLM
+ * can auto-correct in the next turn.
+ *
+ * ## Example with OpenAI
+ *
+ * ```typescript
+ * import { generateText } from "ai";
+ * import { openai } from "@ai-sdk/openai";
+ * import typia from "typia";
+ * import { toVercelTools } from "@typia/vercel";
+ *
+ * class Calculator {
+ *   /&#42;&#42; Add two numbers together. &#42;/
+ *   add(props: { a: number; b: number }): number {
+ *     return props.a + props.b;
+ *   }
+ * }
+ *
+ * const controller = typia.llm.controller<Calculator>("calc", new Calculator());
+ * const tools = toVercelTools({ controllers: [controller] });
+ *
+ * const result = await generateText({
+ *   model: openai("gpt-4o"),
+ *   tools,
+ *   prompt: "What is 15 + 27?",
+ * });
+ * ```
+ *
+ * ## Example with Anthropic
+ *
+ * ```typescript
+ * import { anthropic } from "@ai-sdk/anthropic";
+ * import { toVercelTools } from "@typia/vercel";
+ * import { generateText } from "ai";
+ *
+ * const result = await generateText({
+ *   model: anthropic("claude-sonnet-4-20250514"),
+ *   tools: toVercelTools({ controllers: [controller] }),
+ *   prompt: "Calculate 100 * 50",
+ * });
+ * ```
+ *
+ * ## Example with HTTP Controller (OpenAPI)
+ *
+ * ```typescript
+ * import { openai } from "@ai-sdk/openai";
+ * import { HttpLlm } from "@typia/utils";
+ * import { toVercelTools } from "@typia/vercel";
+ * import { generateText } from "ai";
+ *
+ * const controller = HttpLlm.controller({
+ *   name: "shopping",
+ *   document: await fetch("https://api.example.com/swagger.json").then(
+ *     (r) => r.json(),
+ *   ),
+ *   connection: { host: "https://api.example.com" },
+ * });
+ *
+ * const result = await generateText({
+ *   model: openai("gpt-4o"),
+ *   tools: toVercelTools({ controllers: [controller] }),
+ *   prompt: "Search for laptops under $1000",
+ * });
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param props Conversion properties
+ * @returns Record of Vercel AI SDK Tools keyed by tool name
+ */
+export function toVercelTools(props: {
+  /**
+   * List of controllers to convert to Vercel tools.
+   *
+   * - {@link ILlmController}: from `typia.llm.controller<Class>()`, converts all
+   *   methods of the class to tools
+   * - {@link IHttpLlmController}: from `HttpLlm.controller()`, converts all
+   *   operations from OpenAPI document to tools
+   */
+  controllers: Array<ILlmController | IHttpLlmController>;
+
+  /**
+   * Whether to prefix tool names with controller name.
+   *
+   * If `true`, tool names are formatted as `{controller}_{function}`. If
+   * `false`, only the function name is used (may cause conflicts).
+   *
+   * @default true
+   */
+  prefix?: boolean | undefined;
+}): Record<string, Tool> {
+  return VercelToolsRegistrar.convert(props);
+}

package/src/internal/VercelToolsRegistrar.ts

@@ -1,180 +1,180 @@
-import {
-  IHttpLlmController,
-  IHttpLlmFunction,
-  ILlmController,
-  ILlmFunction,
-  ILlmSchema,
-  IValidation,
-} from "@typia/interface";
-import { HttpLlm, LlmJson } from "@typia/utils";
-import { jsonSchema, tool } from "ai";
-import type { Tool } from "ai";
-import type { JSONSchema7 } from "json-schema";
-
-export namespace VercelToolsRegistrar {
-  /**
-   * Convert typia controllers to Vercel AI SDK tools.
-   *
-   * @param props Conversion properties
-   * @returns Record of Vercel AI SDK Tools
-   */
-  export const convert = (props: {
-    controllers: Array<ILlmController | IHttpLlmController>;
-    prefix?: boolean | undefined;
-  }): Record<string, Tool> => {
-    const tools: Record<string, Tool> = {};
-    const prefix: boolean = props.prefix ?? true;
-
-    for (const controller of props.controllers) {
-      if (controller.protocol === "class") {
-        registerClassController({
-          tools,
-          controller,
-          prefix,
-        });
-      } else {
-        registerHttpController({
-          tools,
-          controller,
-          prefix,
-        });
-      }
-    }
-
-    return tools;
-  };
-
-  const registerClassController = (props: {
-    tools: Record<string, Tool>;
-    controller: ILlmController;
-    prefix: boolean;
-  }): void => {
-    const { tools, controller, prefix } = props;
-    const execute: Record<string, unknown> = controller.execute;
-
-    for (const func of controller.application.functions) {
-      const toolName: string = prefix
-        ? `${controller.name}_${func.name}`
-        : func.name;
-
-      if (tools[toolName] !== undefined) {
-        throw new Error(
-          `Duplicate tool name "${toolName}" from controller "${controller.name}"`,
-        );
-      }
-
-      const method: unknown = execute[func.name];
-      if (typeof method !== "function") {
-        throw new Error(
-          `Method "${func.name}" not found on controller "${controller.name}"`,
-        );
-      }
-
-      tools[toolName] = createTool({
-        func,
-        execute: async (args: unknown) => method.call(execute, args),
-      });
-    }
-  };
-
-  const registerHttpController = (props: {
-    tools: Record<string, Tool>;
-    controller: IHttpLlmController;
-    prefix: boolean;
-  }): void => {
-    const { tools, controller, prefix } = props;
-    const application = controller.application;
-    const connection = controller.connection;
-
-    for (const func of application.functions) {
-      const toolName: string = prefix
-        ? `${controller.name}_${func.name}`
-        : func.name;
-
-      if (tools[toolName] !== undefined) {
-        throw new Error(
-          `Duplicate tool name "${toolName}" from controller "${controller.name}"`,
-        );
-      }
-
-      tools[toolName] = createTool({
-        func,
-        execute: async (args: unknown) => {
-          if (controller.execute !== undefined) {
-            const response = await controller.execute({
-              connection,
-              application,
-              function: func,
-              arguments: args as object,
-            });
-            return response.body;
-          }
-          return HttpLlm.execute({
-            application,
-            function: func,
-            connection,
-            input: args as object,
-          });
-        },
-      });
-    }
-  };
-
-  const createTool = (props: {
-    func: ILlmFunction | IHttpLlmFunction;
-    execute: (args: unknown) => Promise<unknown>;
-  }): Tool => {
-    const { func, execute } = props;
-
-    return tool({
-      description: func.description,
-
-      // Convert ILlmSchema.IParameters to Vercel jsonSchema
-      parameters: jsonSchema<object>(
-        convertParameters(func.parameters) as JSONSchema7,
-      ),
-
-      execute: async (args: object) => {
-        // Coerce and validate using typia's built-in functions
-        const coerced: unknown = LlmJson.coerce(args, func.parameters);
-        const validation: IValidation<unknown> = func.validate(coerced);
-        if (!validation.success) {
-          // Return validation error in LLM-friendly format
-          return {
-            error: true,
-            message: LlmJson.stringify(validation),
-          };
-        }
-
-        try {
-          const result: unknown = await execute(validation.data);
-          return result === undefined ? { success: true } : result;
-        } catch (error) {
-          return {
-            error: true,
-            message:
-              error instanceof Error
-                ? `${error.name}: ${error.message}`
-                : String(error),
-          };
-        }
-      },
-    });
-  };
-
-  const convertParameters = (params: ILlmSchema.IParameters): JSONSchema7 => {
-    const schema: JSONSchema7 = {
-      type: "object",
-      properties: params.properties as JSONSchema7["properties"],
-      required: params.required,
-      additionalProperties: params.additionalProperties,
-    };
-
-    // Add $defs if present
-    if (Object.keys(params.$defs).length > 0) {
-      schema.$defs = params.$defs as JSONSchema7["$defs"];
-    }
-
-    return schema;
-  };
-}
+import {
+  IHttpLlmController,
+  IHttpLlmFunction,
+  ILlmController,
+  ILlmFunction,
+  ILlmSchema,
+  IValidation,
+} from "@typia/interface";
+import { HttpLlm, LlmJson } from "@typia/utils";
+import { jsonSchema, tool } from "ai";
+import type { Tool } from "ai";
+import type { JSONSchema7 } from "json-schema";
+
+export namespace VercelToolsRegistrar {
+  /**
+   * Convert typia controllers to Vercel AI SDK tools.
+   *
+   * @param props Conversion properties
+   * @returns Record of Vercel AI SDK Tools
+   */
+  export const convert = (props: {
+    controllers: Array<ILlmController | IHttpLlmController>;
+    prefix?: boolean | undefined;
+  }): Record<string, Tool> => {
+    const tools: Record<string, Tool> = {};
+    const prefix: boolean = props.prefix ?? true;
+
+    for (const controller of props.controllers) {
+      if (controller.protocol === "class") {
+        registerClassController({
+          tools,
+          controller,
+          prefix,
+        });
+      } else {
+        registerHttpController({
+          tools,
+          controller,
+          prefix,
+        });
+      }
+    }
+
+    return tools;
+  };
+
+  const registerClassController = (props: {
+    tools: Record<string, Tool>;
+    controller: ILlmController;
+    prefix: boolean;
+  }): void => {
+    const { tools, controller, prefix } = props;
+    const execute: Record<string, unknown> = controller.execute;
+
+    for (const func of controller.application.functions) {
+      const toolName: string = prefix
+        ? `${controller.name}_${func.name}`
+        : func.name;
+
+      if (tools[toolName] !== undefined) {
+        throw new Error(
+          `Duplicate tool name "${toolName}" from controller "${controller.name}"`,
+        );
+      }
+
+      const method: unknown = execute[func.name];
+      if (typeof method !== "function") {
+        throw new Error(
+          `Method "${func.name}" not found on controller "${controller.name}"`,
+        );
+      }
+
+      tools[toolName] = createTool({
+        func,
+        execute: async (args: unknown) => method.call(execute, args),
+      });
+    }
+  };
+
+  const registerHttpController = (props: {
+    tools: Record<string, Tool>;
+    controller: IHttpLlmController;
+    prefix: boolean;
+  }): void => {
+    const { tools, controller, prefix } = props;
+    const application = controller.application;
+    const connection = controller.connection;
+
+    for (const func of application.functions) {
+      const toolName: string = prefix
+        ? `${controller.name}_${func.name}`
+        : func.name;
+
+      if (tools[toolName] !== undefined) {
+        throw new Error(
+          `Duplicate tool name "${toolName}" from controller "${controller.name}"`,
+        );
+      }
+
+      tools[toolName] = createTool({
+        func,
+        execute: async (args: unknown) => {
+          if (controller.execute !== undefined) {
+            const response = await controller.execute({
+              connection,
+              application,
+              function: func,
+              arguments: args as object,
+            });
+            return response.body;
+          }
+          return HttpLlm.execute({
+            application,
+            function: func,
+            connection,
+            input: args as object,
+          });
+        },
+      });
+    }
+  };
+
+  const createTool = (props: {
+    func: ILlmFunction | IHttpLlmFunction;
+    execute: (args: unknown) => Promise<unknown>;
+  }): Tool => {
+    const { func, execute } = props;
+
+    return tool({
+      description: func.description,
+
+      // Convert ILlmSchema.IParameters to Vercel jsonSchema
+      parameters: jsonSchema<object>(
+        convertParameters(func.parameters) as JSONSchema7,
+      ),
+
+      execute: async (args: object) => {
+        // Coerce and validate using typia's built-in functions
+        const coerced: unknown = LlmJson.coerce(args, func.parameters);
+        const validation: IValidation<unknown> = func.validate(coerced);
+        if (!validation.success) {
+          // Return validation error in LLM-friendly format
+          return {
+            error: true,
+            message: LlmJson.stringify(validation),
+          };
+        }
+
+        try {
+          const result: unknown = await execute(validation.data);
+          return result === undefined ? { success: true } : result;
+        } catch (error) {
+          return {
+            error: true,
+            message:
+              error instanceof Error
+                ? `${error.name}: ${error.message}`
+                : String(error),
+          };
+        }
+      },
+    });
+  };
+
+  const convertParameters = (params: ILlmSchema.IParameters): JSONSchema7 => {
+    const schema: JSONSchema7 = {
+      type: "object",
+      properties: params.properties as JSONSchema7["properties"],
+      required: params.required,
+      additionalProperties: params.additionalProperties,
+    };
+
+    // Add $defs if present
+    if (Object.keys(params.$defs).length > 0) {
+      schema.$defs = params.$defs as JSONSchema7["$defs"];
+    }
+
+    return schema;
+  };
+}