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

package/lib/index.d.ts

@@ -7,43 +7,43 @@ import { IHttpLlmController, ILlmController } from "@typia/interface";
  * 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 LlmJson.stringify}
- * so that LLM can correct them automatically.
- *
- * @param props Conversion properties
- * @returns Array of LangChain DynamicStructuredTool
+ * returns validation error formatted by {@link LlmJson.stringify} so that LLM
+ * can correct them automatically.
  *
  * @example
- * ```typescript
- * import { ChatOpenAI } from "@langchain/openai";
- * import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
- * import typia from "typia";
- * import { toLangChainTools } from "@typia/langchain";
+ *   ```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;
+ *   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 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?" });
- * ```
+ *   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?" });
+ *   ```;
+ *
+ * @param props Conversion properties
+ * @returns Array of LangChain DynamicStructuredTool
  */
 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 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
      */
@@ -51,8 +51,8 @@ export declare function toLangChainTools(props: {
     /**
      * Whether to add controller name as prefix to tool names.
      *
-     * If `true`, tool names become `{controllerName}_{methodName}`.
-     * If `false`, tool names are just `{methodName}`.
+     * If `true`, tool names become `{controllerName}_{methodName}`. If `false`,
+     * tool names are just `{methodName}`.
      *
      * @default true
      */

package/lib/index.js

@@ -9,36 +9,36 @@ const LangChainToolsRegistrar_1 = require("./internal/LangChainToolsRegistrar");
  * 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 LlmJson.stringify}
- * so that LLM can correct them automatically.
- *
- * @param props Conversion properties
- * @returns Array of LangChain DynamicStructuredTool
+ * returns validation error formatted by {@link LlmJson.stringify} so that LLM
+ * can correct them automatically.
  *
  * @example
- * ```typescript
- * import { ChatOpenAI } from "@langchain/openai";
- * import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
- * import typia from "typia";
- * import { toLangChainTools } from "@typia/langchain";
+ *   ```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;
+ *   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 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?" });
- * ```
+ *   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?" });
+ *   ```;
+ *
+ * @param props Conversion properties
+ * @returns Array of LangChain DynamicStructuredTool
  */
 function toLangChainTools(props) {
     return LangChainToolsRegistrar_1.LangChainToolsRegistrar.convert(props);

package/lib/index.mjs

@@ -7,36 +7,36 @@ import { LangChainToolsRegistrar } from './internal/LangChainToolsRegistrar.mjs'
  * 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 LlmJson.stringify}
- * so that LLM can correct them automatically.
- *
- * @param props Conversion properties
- * @returns Array of LangChain DynamicStructuredTool
+ * returns validation error formatted by {@link LlmJson.stringify} so that LLM
+ * can correct them automatically.
  *
  * @example
- * ```typescript
- * import { ChatOpenAI } from "@langchain/openai";
- * import { AgentExecutor, createToolCallingAgent } from "langchain/agents";
- * import typia from "typia";
- * import { toLangChainTools } from "@typia/langchain";
+ *   ```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;
+ *   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 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?" });
- * ```
+ *   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?" });
+ *   ```;
+ *
+ * @param props Conversion properties
+ * @returns Array of LangChain DynamicStructuredTool
  */
 function toLangChainTools(props) {
     return LangChainToolsRegistrar.convert(props);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typia/langchain",
-  "version": "12.0.0-dev.20260309",
+  "version": "12.0.0-dev.20260311",
   "description": "LangChain.js integration for typia",
   "main": "lib/index.js",
   "exports": {
@@ -23,8 +23,8 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "zod": "^3.25.0",
-    "@typia/interface": "^12.0.0-dev.20260309",
-    "@typia/utils": "^12.0.0-dev.20260309"
+    "@typia/interface": "^12.0.0-dev.20260311",
+    "@typia/utils": "^12.0.0-dev.20260311"
   },
   "peerDependencies": {
     "@langchain/core": ">=0.3.0"

package/src/index.ts

@@ -1,66 +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 LlmJson.stringify}
- * 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);
-}
+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 LlmJson.stringify} so that LLM
+ * can correct them automatically.
+ *
+ * @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?" });
+ *   ```;
+ *
+ * @param props Conversion properties
+ * @returns Array of LangChain DynamicStructuredTool
+ */
+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

@@ -1,139 +1,139 @@
-import { DynamicStructuredTool } from "@langchain/core/tools";
-import {
-  IHttpLlmController,
-  IHttpLlmFunction,
-  ILlmController,
-  ILlmFunction,
-  IValidation,
-} from "@typia/interface";
-import { HttpLlm, LlmJson } 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 coerced: unknown = LlmJson.coerce(
-          args,
-          entry.function.parameters,
-        );
-        const validation: IValidation<unknown> =
-          entry.function.validate(coerced);
-        if (!validation.success) {
-          return LlmJson.stringify(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);
-        }
-      },
-    });
-  };
-}
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import {
+  IHttpLlmController,
+  IHttpLlmFunction,
+  ILlmController,
+  ILlmFunction,
+  IValidation,
+} from "@typia/interface";
+import { HttpLlm, LlmJson } 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 coerced: unknown = LlmJson.coerce(
+          args,
+          entry.function.parameters,
+        );
+        const validation: IValidation<unknown> =
+          entry.function.validate(coerced);
+        if (!validation.success) {
+          return LlmJson.stringify(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);
+        }
+      },
+    });
+  };
+}