@typia/langchain 12.0.0-dev.20260225

package/LICENSE

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

package/README.md

@@ -0,0 +1,73 @@
+# `@typia/langchain`
+
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/typia/blob/master/LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/typia.svg)](https://www.npmjs.com/package/typia)
+[![NPM Downloads](https://img.shields.io/npm/dm/typia.svg)](https://www.npmjs.com/package/typia)
+
+[LangChain.js](https://github.com/langchain-ai/langchainjs) integration for [`typia`](https://github.com/samchon/typia).
+
+Converts typia controllers to LangChain `DynamicStructuredTool[]` with automatic validation.
+
+## Setup
+
+```bash
+npm install @typia/langchain @langchain/core
+npm install typia
+npx typia setup
+```
+
+## Usage
+
+### From TypeScript class
+
+```typescript
+import { ChainValues, Runnable } from "@langchain/core";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { ChatOpenAI } from "@langchain/openai";
+import { toLangChainTools } from "@typia/langchain";
+import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
+import typia from "typia";
+
+const tools: DynamicStructuredTool[] = toLangChainTools({
+  controllers: [
+    typia.llm.controller<Calculator>("Calculator", new Calculator()),
+  ],
+});
+
+const agent: Runnable = createToolCallingAgent({
+  llm: new ChatOpenAI({ model: "gpt-4o" }),
+  tools,
+  prompt: ChatPromptTemplate.fromMessages([
+    ["system", "You are a helpful assistant."],
+    ["human", "{input}"],
+    ["placeholder", "{agent_scratchpad}"],
+  ]),
+});
+const executor: AgentExecutor = new AgentExecutor({ agent, tools });
+const result: ChainValues = await executor.invoke({ input: "What is 10 + 5?" });
+```
+
+### From OpenAPI document
+
+```typescript
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { toLangChainTools } from "@typia/langchain";
+import { HttpLlm } from "@typia/utils";
+
+const tools: DynamicStructuredTool[] = toLangChainTools({
+  controllers: [
+    HttpLlm.controller({
+      name: "petStore",
+      document: yourOpenApiDocument,
+      connection: { host: "https://api.example.com" },
+    }),
+  ],
+});
+```
+
+## Features
+
+- No manual schema definition — generates everything from TypeScript types or OpenAPI
+- Automatic argument validation with LLM-friendly error feedback
+- Supports both class-based (`typia.llm.controller`) and HTTP-based (`HttpLlm.controller`) controllers

package/lib/index.d.ts

@@ -0,0 +1,60 @@
+import type { DynamicStructuredTool } from "@langchain/core/tools";
+import { IHttpLlmController, ILlmController } from "@typia/interface";
+/**
+ * Convert typia controllers to LangChain tools.
+ *
+ * Converts TypeScript class methods via `typia.llm.controller<Class>()` or
+ * OpenAPI operations via `HttpLlm.controller()` to LangChain tools.
+ *
+ * Every tool call is validated by typia. If LLM provides invalid arguments,
+ * returns validation error formatted by {@link stringifyValidationFailure}
+ * so that LLM can correct them automatically.
+ *
+ * @param props Conversion properties
+ * @returns Array of LangChain DynamicStructuredTool
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
+ * import typia from "typia";
+ * import { toLangChainTools } from "@typia/langchain";
+ *
+ * class Calculator {
+ *   add(input: { a: number; b: number }): number {
+ *     return input.a + input.b;
+ *   }
+ * }
+ *
+ * const tools = toLangChainTools({
+ *   controllers: [
+ *     typia.llm.controller<Calculator>("calculator", new Calculator()),
+ *   ],
+ * });
+ *
+ * const llm = new ChatOpenAI({ model: "gpt-4" });
+ * const agent = createToolCallingAgent({ llm, tools, prompt });
+ * const executor = new AgentExecutor({ agent, tools });
+ * await executor.invoke({ input: "What is 10 + 5?" });
+ * ```
+ */
+export declare function toLangChainTools(props: {
+    /**
+     * List of controllers to convert to LangChain 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 add controller name as prefix to tool names.
+     *
+     * If `true`, tool names become `{controllerName}_{methodName}`.
+     * If `false`, tool names are just `{methodName}`.
+     *
+     * @default true
+     */
+    prefix?: boolean | undefined;
+}): DynamicStructuredTool[];

package/lib/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLangChainTools = toLangChainTools;
+const LangChainToolsRegistrar_1 = require("./internal/LangChainToolsRegistrar");
+/**
+ * Convert typia controllers to LangChain tools.
+ *
+ * Converts TypeScript class methods via `typia.llm.controller<Class>()` or
+ * OpenAPI operations via `HttpLlm.controller()` to LangChain tools.
+ *
+ * Every tool call is validated by typia. If LLM provides invalid arguments,
+ * returns validation error formatted by {@link stringifyValidationFailure}
+ * so that LLM can correct them automatically.
+ *
+ * @param props Conversion properties
+ * @returns Array of LangChain DynamicStructuredTool
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
+ * import typia from "typia";
+ * import { toLangChainTools } from "@typia/langchain";
+ *
+ * class Calculator {
+ *   add(input: { a: number; b: number }): number {
+ *     return input.a + input.b;
+ *   }
+ * }
+ *
+ * const tools = toLangChainTools({
+ *   controllers: [
+ *     typia.llm.controller<Calculator>("calculator", new Calculator()),
+ *   ],
+ * });
+ *
+ * const llm = new ChatOpenAI({ model: "gpt-4" });
+ * const agent = createToolCallingAgent({ llm, tools, prompt });
+ * const executor = new AgentExecutor({ agent, tools });
+ * await executor.invoke({ input: "What is 10 + 5?" });
+ * ```
+ */
+function toLangChainTools(props) {
+    return LangChainToolsRegistrar_1.LangChainToolsRegistrar.convert(props);
+}
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AA2CA,4CAsBC;AA9DD,gFAA6E;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,SAAgB,gBAAgB,CAAC,KAoBhC;IACC,OAAO,iDAAuB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAChD,CAAC"}

package/lib/index.mjs

@@ -0,0 +1,46 @@
+import { LangChainToolsRegistrar } from './internal/LangChainToolsRegistrar.mjs';
+
+/**
+ * Convert typia controllers to LangChain tools.
+ *
+ * Converts TypeScript class methods via `typia.llm.controller<Class>()` or
+ * OpenAPI operations via `HttpLlm.controller()` to LangChain tools.
+ *
+ * Every tool call is validated by typia. If LLM provides invalid arguments,
+ * returns validation error formatted by {@link stringifyValidationFailure}
+ * so that LLM can correct them automatically.
+ *
+ * @param props Conversion properties
+ * @returns Array of LangChain DynamicStructuredTool
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
+ * import typia from "typia";
+ * import { toLangChainTools } from "@typia/langchain";
+ *
+ * class Calculator {
+ *   add(input: { a: number; b: number }): number {
+ *     return input.a + input.b;
+ *   }
+ * }
+ *
+ * const tools = toLangChainTools({
+ *   controllers: [
+ *     typia.llm.controller<Calculator>("calculator", new Calculator()),
+ *   ],
+ * });
+ *
+ * const llm = new ChatOpenAI({ model: "gpt-4" });
+ * const agent = createToolCallingAgent({ llm, tools, prompt });
+ * const executor = new AgentExecutor({ agent, tools });
+ * await executor.invoke({ input: "What is 10 + 5?" });
+ * ```
+ */
+function toLangChainTools(props) {
+    return LangChainToolsRegistrar.convert(props);
+}
+
+export { toLangChainTools };
+//# sourceMappingURL=index.mjs.map

package/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../src/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACG,SAAU,gBAAgB,CAAC,KAoBhC,EAAA;AACC,IAAA,OAAO,uBAAuB,CAAC,OAAO,CAAC,KAAK,CAAC;AAC/C;;;;"}

package/lib/internal/LangChainToolsRegistrar.d.ts

@@ -0,0 +1,8 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { IHttpLlmController, ILlmController } from "@typia/interface";
+export declare namespace LangChainToolsRegistrar {
+    const convert: (props: {
+        controllers: Array<ILlmController | IHttpLlmController>;
+        prefix?: boolean | undefined;
+    }) => DynamicStructuredTool[];
+}

package/lib/internal/LangChainToolsRegistrar.js

@@ -0,0 +1,111 @@
+"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.LangChainToolsRegistrar = void 0;
+const tools_1 = require("@langchain/core/tools");
+const utils_1 = require("@typia/utils");
+const zod_1 = require("zod");
+var LangChainToolsRegistrar;
+(function (LangChainToolsRegistrar) {
+    LangChainToolsRegistrar.convert = (props) => {
+        var _a;
+        const prefix = (_a = props.prefix) !== null && _a !== void 0 ? _a : true;
+        const tools = [];
+        for (const controller of props.controllers) {
+            if (controller.protocol === "class") {
+                convertClassController(tools, controller, prefix);
+            }
+            else {
+                convertHttpController(tools, controller, prefix);
+            }
+        }
+        return tools;
+    };
+    const convertClassController = (tools, controller, prefix) => {
+        const execute = controller.execute;
+        for (const func of controller.application.functions) {
+            const method = execute[func.name];
+            if (typeof method !== "function") {
+                throw new Error(`Method "${func.name}" not found on controller "${controller.name}"`);
+            }
+            const toolName = prefix
+                ? `${controller.name}_${func.name}`
+                : func.name;
+            tools.push(createTool({
+                name: toolName,
+                function: func,
+                execute: (args) => __awaiter(this, void 0, void 0, function* () { return method.call(execute, args); }),
+            }));
+        }
+    };
+    const convertHttpController = (tools, controller, prefix) => {
+        const application = controller.application;
+        const connection = controller.connection;
+        for (const func of application.functions) {
+            const toolName = prefix
+                ? `${controller.name}_${func.name}`
+                : func.name;
+            tools.push(createTool({
+                name: toolName,
+                function: func,
+                execute: (args) => __awaiter(this, void 0, void 0, function* () {
+                    if (controller.execute !== undefined) {
+                        const response = yield controller.execute({
+                            connection,
+                            application,
+                            function: func,
+                            arguments: args,
+                        });
+                        return response.body;
+                    }
+                    return utils_1.HttpLlm.execute({
+                        application,
+                        function: func,
+                        connection,
+                        input: args,
+                    });
+                }),
+            }));
+        }
+    };
+    // Schema that accepts any object - bypasses LangChain's validation
+    // so typia can handle all validation with proper error messages.
+    // LangChain validates JSON Schema using @cfworker/json-schema which
+    // throws ToolInputParsingException before reaching our func.
+    const passthroughSchema = zod_1.z.record(zod_1.z.unknown());
+    const createTool = (entry) => {
+        var _a;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new tools_1.DynamicStructuredTool({
+            name: entry.name,
+            description: (_a = entry.function.description) !== null && _a !== void 0 ? _a : "",
+            schema: passthroughSchema,
+            func: (args) => __awaiter(this, void 0, void 0, function* () {
+                const validation = entry.function.validate(args);
+                if (!validation.success) {
+                    return (0, utils_1.stringifyValidationFailure)(validation);
+                }
+                try {
+                    const result = yield entry.execute(validation.data);
+                    return result === undefined
+                        ? "Success"
+                        : JSON.stringify(result, null, 2);
+                }
+                catch (error) {
+                    return error instanceof Error
+                        ? `${error.name}: ${error.message}`
+                        : String(error);
+                }
+            }),
+        });
+    };
+})(LangChainToolsRegistrar || (exports.LangChainToolsRegistrar = LangChainToolsRegistrar = {}));
+//# sourceMappingURL=LangChainToolsRegistrar.js.map

package/lib/internal/LangChainToolsRegistrar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LangChainToolsRegistrar.js","sourceRoot":"","sources":["../../src/internal/LangChainToolsRegistrar.ts"],"names":[],"mappings":"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"}

package/lib/internal/LangChainToolsRegistrar.mjs

@@ -0,0 +1,100 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { stringifyValidationFailure, HttpLlm } from '@typia/utils';
+import { z } from 'zod';
+
+var LangChainToolsRegistrar;
+(function (LangChainToolsRegistrar) {
+    LangChainToolsRegistrar.convert = (props) => {
+        const prefix = props.prefix ?? true;
+        const tools = [];
+        for (const controller of props.controllers) {
+            if (controller.protocol === "class") {
+                convertClassController(tools, controller, prefix);
+            }
+            else {
+                convertHttpController(tools, controller, prefix);
+            }
+        }
+        return tools;
+    };
+    const convertClassController = (tools, controller, prefix) => {
+        const execute = controller.execute;
+        for (const func of controller.application.functions) {
+            const method = execute[func.name];
+            if (typeof method !== "function") {
+                throw new Error(`Method "${func.name}" not found on controller "${controller.name}"`);
+            }
+            const toolName = prefix
+                ? `${controller.name}_${func.name}`
+                : func.name;
+            tools.push(createTool({
+                name: toolName,
+                function: func,
+                execute: async (args) => method.call(execute, args),
+            }));
+        }
+    };
+    const convertHttpController = (tools, controller, prefix) => {
+        const application = controller.application;
+        const connection = controller.connection;
+        for (const func of application.functions) {
+            const toolName = prefix
+                ? `${controller.name}_${func.name}`
+                : func.name;
+            tools.push(createTool({
+                name: toolName,
+                function: func,
+                execute: async (args) => {
+                    if (controller.execute !== undefined) {
+                        const response = await controller.execute({
+                            connection,
+                            application,
+                            function: func,
+                            arguments: args,
+                        });
+                        return response.body;
+                    }
+                    return HttpLlm.execute({
+                        application,
+                        function: func,
+                        connection,
+                        input: args,
+                    });
+                },
+            }));
+        }
+    };
+    // Schema that accepts any object - bypasses LangChain's validation
+    // so typia can handle all validation with proper error messages.
+    // LangChain validates JSON Schema using @cfworker/json-schema which
+    // throws ToolInputParsingException before reaching our func.
+    const passthroughSchema = z.record(z.unknown());
+    const createTool = (entry) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new DynamicStructuredTool({
+            name: entry.name,
+            description: entry.function.description ?? "",
+            schema: passthroughSchema,
+            func: async (args) => {
+                const validation = entry.function.validate(args);
+                if (!validation.success) {
+                    return stringifyValidationFailure(validation);
+                }
+                try {
+                    const result = await entry.execute(validation.data);
+                    return result === undefined
+                        ? "Success"
+                        : JSON.stringify(result, null, 2);
+                }
+                catch (error) {
+                    return error instanceof Error
+                        ? `${error.name}: ${error.message}`
+                        : String(error);
+                }
+            },
+        });
+    };
+})(LangChainToolsRegistrar || (LangChainToolsRegistrar = {}));
+
+export { LangChainToolsRegistrar };
+//# sourceMappingURL=LangChainToolsRegistrar.mjs.map

package/lib/internal/LangChainToolsRegistrar.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LangChainToolsRegistrar.mjs","sources":["../../src/internal/LangChainToolsRegistrar.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@typia/langchain",
+  "version": "12.0.0-dev.20260225",
+  "description": "LangChain.js integration for typia",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.mjs",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samchon/typia"
+  },
+  "author": "Jeongho Nam",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/samchon/typia/issues"
+  },
+  "homepage": "https://typia.io",
+  "dependencies": {
+    "zod": "^3.25.0",
+    "@typia/interface": "^12.0.0-dev.20260225",
+    "@typia/utils": "^12.0.0-dev.20260225"
+  },
+  "peerDependencies": {
+    "@langchain/core": ">=0.3.0"
+  },
+  "devDependencies": {
+    "@langchain/core": "^0.3.44",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "rimraf": "^6.1.2",
+    "rollup": "^4.56.0",
+    "rollup-plugin-auto-external": "^2.0.0",
+    "rollup-plugin-node-externals": "^8.1.2",
+    "tinyglobby": "^0.2.12",
+    "typescript": "~5.9.3"
+  },
+  "sideEffects": false,
+  "files": [
+    "LICENSE",
+    "README.md",
+    "package.json",
+    "lib",
+    "src"
+  ],
+  "keywords": [
+    "langchain",
+    "typia",
+    "llm",
+    "llm-function-calling",
+    "ai",
+    "claude",
+    "openai",
+    "chatgpt",
+    "gemini",
+    "validation",
+    "json-schema",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf lib && tsc && rollup -c",
+    "dev": "rimraf lib && tsc --watch"
+  },
+  "module": "lib/index.mjs",
+  "types": "lib/index.d.ts"
+}

package/src/index.ts

@@ -0,0 +1,66 @@
+import type { DynamicStructuredTool } from "@langchain/core/tools";
+import { IHttpLlmController, ILlmController } from "@typia/interface";
+
+import { LangChainToolsRegistrar } from "./internal/LangChainToolsRegistrar";
+
+/**
+ * Convert typia controllers to LangChain tools.
+ *
+ * Converts TypeScript class methods via `typia.llm.controller<Class>()` or
+ * OpenAPI operations via `HttpLlm.controller()` to LangChain tools.
+ *
+ * Every tool call is validated by typia. If LLM provides invalid arguments,
+ * returns validation error formatted by {@link stringifyValidationFailure}
+ * so that LLM can correct them automatically.
+ *
+ * @param props Conversion properties
+ * @returns Array of LangChain DynamicStructuredTool
+ *
+ * @example
+ * ```typescript
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
+ * import typia from "typia";
+ * import { toLangChainTools } from "@typia/langchain";
+ *
+ * class Calculator {
+ *   add(input: { a: number; b: number }): number {
+ *     return input.a + input.b;
+ *   }
+ * }
+ *
+ * const tools = toLangChainTools({
+ *   controllers: [
+ *     typia.llm.controller<Calculator>("calculator", new Calculator()),
+ *   ],
+ * });
+ *
+ * const llm = new ChatOpenAI({ model: "gpt-4" });
+ * const agent = createToolCallingAgent({ llm, tools, prompt });
+ * const executor = new AgentExecutor({ agent, tools });
+ * await executor.invoke({ input: "What is 10 + 5?" });
+ * ```
+ */
+export function toLangChainTools(props: {
+  /**
+   * List of controllers to convert to LangChain 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 add controller name as prefix to tool names.
+   *
+   * If `true`, tool names become `{controllerName}_{methodName}`.
+   * If `false`, tool names are just `{methodName}`.
+   *
+   * @default true
+   */
+  prefix?: boolean | undefined;
+}): DynamicStructuredTool[] {
+  return LangChainToolsRegistrar.convert(props);
+}

package/src/internal/LangChainToolsRegistrar.ts

@@ -0,0 +1,135 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import {
+  IHttpLlmController,
+  IHttpLlmFunction,
+  ILlmController,
+  ILlmFunction,
+  IValidation,
+} from "@typia/interface";
+import { HttpLlm, stringifyValidationFailure } from "@typia/utils";
+import { z } from "zod";
+
+export namespace LangChainToolsRegistrar {
+  export const convert = (props: {
+    controllers: Array<ILlmController | IHttpLlmController>;
+    prefix?: boolean | undefined;
+  }): DynamicStructuredTool[] => {
+    const prefix: boolean = props.prefix ?? true;
+    const tools: DynamicStructuredTool[] = [];
+
+    for (const controller of props.controllers) {
+      if (controller.protocol === "class") {
+        convertClassController(tools, controller, prefix);
+      } else {
+        convertHttpController(tools, controller, prefix);
+      }
+    }
+
+    return tools;
+  };
+
+  const convertClassController = (
+    tools: DynamicStructuredTool[],
+    controller: ILlmController,
+    prefix: boolean,
+  ): void => {
+    const execute: Record<string, unknown> = controller.execute;
+
+    for (const func of controller.application.functions) {
+      const method: unknown = execute[func.name];
+      if (typeof method !== "function") {
+        throw new Error(
+          `Method "${func.name}" not found on controller "${controller.name}"`,
+        );
+      }
+
+      const toolName: string = prefix
+        ? `${controller.name}_${func.name}`
+        : func.name;
+
+      tools.push(
+        createTool({
+          name: toolName,
+          function: func,
+          execute: async (args: unknown) => method.call(execute, args),
+        }),
+      );
+    }
+  };
+
+  const convertHttpController = (
+    tools: DynamicStructuredTool[],
+    controller: IHttpLlmController,
+    prefix: boolean,
+  ): void => {
+    const application = controller.application;
+    const connection = controller.connection;
+
+    for (const func of application.functions) {
+      const toolName: string = prefix
+        ? `${controller.name}_${func.name}`
+        : func.name;
+
+      tools.push(
+        createTool({
+          name: toolName,
+          function: 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,
+            });
+          },
+        }),
+      );
+    }
+  };
+
+  // Schema that accepts any object - bypasses LangChain's validation
+  // so typia can handle all validation with proper error messages.
+  // LangChain validates JSON Schema using @cfworker/json-schema which
+  // throws ToolInputParsingException before reaching our func.
+  const passthroughSchema = z.record(z.unknown());
+
+  const createTool = (entry: {
+    name: string;
+    function: ILlmFunction | IHttpLlmFunction;
+    execute: (args: unknown) => Promise<unknown>;
+  }): DynamicStructuredTool => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new DynamicStructuredTool<any>({
+      name: entry.name,
+      description: entry.function.description ?? "",
+      schema: passthroughSchema,
+      func: async (args: unknown): Promise<string> => {
+        const validation: IValidation<unknown> =
+          entry.function.validate(args);
+        if (!validation.success) {
+          return stringifyValidationFailure(validation);
+        }
+
+        try {
+          const result: unknown = await entry.execute(validation.data);
+          return result === undefined
+            ? "Success"
+            : JSON.stringify(result, null, 2);
+        } catch (error) {
+          return error instanceof Error
+            ? `${error.name}: ${error.message}`
+            : String(error);
+        }
+      },
+    });
+  };
+}