@typia/langchain 13.0.0-dev.20260619.1 → 13.0.0-dev.20260701.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typia/langchain",
-  "version": "13.0.0-dev.20260619.1",
+  "version": "13.0.0-dev.20260701.1",
   "description": "LangChain.js integration for typia",
   "main": "lib/index.js",
   "exports": {
@@ -22,8 +22,8 @@
   },
   "homepage": "https://typia.io",
   "dependencies": {
-    "@typia/interface": "^13.0.0-dev.20260619.1",
-    "@typia/utils": "^13.0.0-dev.20260619.1"
+    "@typia/interface": "^13.0.0-dev.20260701.1",
+    "@typia/utils": "^13.0.0-dev.20260701.1"
   },
   "peerDependencies": {
     "@langchain/core": ">=1.0.0"
@@ -38,7 +38,7 @@
     "rollup": "^4.56.0",
     "rollup-plugin-node-externals": "^8.1.2",
     "tinyglobby": "^0.2.12",
-    "ttsc": "^0.16.0"
+    "ttsc": "^0.16.7"
   },
   "sideEffects": false,
   "files": [

package/src/index.ts

@@ -1,64 +1,64 @@
-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 { initChatModel } from "langchain/chat_models/universal";
- *   import typia from "typia";
- *   import { toLangChainTools } from "@typia/langchain";
- *
- *   class Calculator {
- *     add(input: { a: number; b: number }): { value: number } {
- *       return { value: input.a + input.b };
- *     }
- *   }
- *
- *   const tools = toLangChainTools({
- *     controllers: [
- *       typia.llm.controller<Calculator>("calculator", new Calculator()),
- *     ],
- *   });
- *
- *   const llm = await initChatModel();
- *   const modelWithTools = llm.bindTools(tools);
- *   const result = await modelWithTools.invoke("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 false
-   */
-  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 { initChatModel } from "langchain/chat_models/universal";
+ *   import typia from "typia";
+ *   import { toLangChainTools } from "@typia/langchain";
+ *
+ *   class Calculator {
+ *     add(input: { a: number; b: number }): { value: number } {
+ *       return { value: input.a + input.b };
+ *     }
+ *   }
+ *
+ *   const tools = toLangChainTools({
+ *     controllers: [
+ *       typia.llm.controller<Calculator>("calculator", new Calculator()),
+ *     ],
+ *   });
+ *
+ *   const llm = await initChatModel();
+ *   const modelWithTools = llm.bindTools(tools);
+ *   const result = await modelWithTools.invoke("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 false
+   */
+  prefix?: boolean | undefined;
+}): DynamicStructuredTool[] {
+  return LangChainToolsRegistrar.convert(props);
+}

package/src/internal/LangChainToolsRegistrar.ts

@@ -1,149 +1,149 @@
-import {
-  DynamicStructuredTool,
-  ToolInputParsingException,
-} from "@langchain/core/tools";
-import {
-  IHttpLlmController,
-  IHttpLlmFunction,
-  ILlmController,
-  ILlmFunction,
-  IValidation,
-} from "@typia/interface";
-import { HttpLlm, LlmJson } from "@typia/utils";
-
-export namespace LangChainToolsRegistrar {
-  export const convert = (props: {
-    controllers: Array<ILlmController | IHttpLlmController>;
-    prefix?: boolean | undefined;
-  }): DynamicStructuredTool[] => {
-    const prefix: boolean = props.prefix ?? false;
-    const tools: DynamicStructuredTool[] = [];
-
-    // check duplicate tool names
-    if (prefix === false && props.controllers.length >= 2) {
-      const names: Map<string, string> = new Map();
-      const duplicates: string[] = [];
-      for (const controller of props.controllers) {
-        for (const func of controller.application.functions) {
-          const existing: string | undefined = names.get(func.name);
-          if (existing !== undefined)
-            duplicates.push(
-              `"${func.name}" in "${controller.name}" (conflicts with "${existing}")`,
-            );
-          else names.set(func.name, controller.name);
-        }
-      }
-      if (duplicates.length > 0)
-        throw new Error(
-          `Duplicate tool names found:\n  - ${duplicates.join("\n  - ")}`,
-        );
-    }
-
-    // convert controllers to 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: DynamicStructuredTool[],
-    controller: ILlmController,
-    prefix: boolean,
-  ): void => {
-    const execute: Record<string, unknown> = controller.execute;
-
-    for (const func of controller.application.functions) {
-      const toolName: string = prefix
-        ? `${controller.name}_${func.name}`
-        : func.name;
-
-      const method: unknown = execute[func.name];
-      if (typeof method !== "function") {
-        throw new Error(
-          `Method "${func.name}" not found on controller "${controller.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,
-            });
-          },
-        }),
-      );
-    }
-  };
-
-  const createTool = (entry: {
-    name: string;
-    function: ILlmFunction | IHttpLlmFunction;
-    execute: (args: unknown) => Promise<unknown>;
-  }): DynamicStructuredTool =>
-    new DynamicStructuredTool<any>({
-      name: entry.name,
-      description: entry.function.description ?? "",
-      schema: entry.function.parameters,
-      func: async (args: unknown): Promise<unknown> => {
-        const coerced: unknown = LlmJson.coerce(
-          args,
-          entry.function.parameters,
-        );
-        const valid: IValidation<unknown> = entry.function.validate(coerced);
-        if (valid.success === false)
-          throw new ToolInputParsingException(
-            `Type errors in "${entry.name}" arguments:\n\n` +
-              `\`\`\`json\n${LlmJson.stringify(valid)}\n\`\`\``,
-            JSON.stringify(coerced),
-          );
-        const result: unknown = await entry.execute(valid.data);
-        return result === undefined
-          ? { success: true }
-          : { success: true, data: result };
-      },
-    });
-}
+import {
+  DynamicStructuredTool,
+  ToolInputParsingException,
+} from "@langchain/core/tools";
+import {
+  IHttpLlmController,
+  IHttpLlmFunction,
+  ILlmController,
+  ILlmFunction,
+  IValidation,
+} from "@typia/interface";
+import { HttpLlm, LlmJson } from "@typia/utils";
+
+export namespace LangChainToolsRegistrar {
+  export const convert = (props: {
+    controllers: Array<ILlmController | IHttpLlmController>;
+    prefix?: boolean | undefined;
+  }): DynamicStructuredTool[] => {
+    const prefix: boolean = props.prefix ?? false;
+    const tools: DynamicStructuredTool[] = [];
+
+    // check duplicate tool names
+    if (prefix === false && props.controllers.length >= 2) {
+      const names: Map<string, string> = new Map();
+      const duplicates: string[] = [];
+      for (const controller of props.controllers) {
+        for (const func of controller.application.functions) {
+          const existing: string | undefined = names.get(func.name);
+          if (existing !== undefined)
+            duplicates.push(
+              `"${func.name}" in "${controller.name}" (conflicts with "${existing}")`,
+            );
+          else names.set(func.name, controller.name);
+        }
+      }
+      if (duplicates.length > 0)
+        throw new Error(
+          `Duplicate tool names found:\n  - ${duplicates.join("\n  - ")}`,
+        );
+    }
+
+    // convert controllers to 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: DynamicStructuredTool[],
+    controller: ILlmController,
+    prefix: boolean,
+  ): void => {
+    const execute: Record<string, unknown> = controller.execute;
+
+    for (const func of controller.application.functions) {
+      const toolName: string = prefix
+        ? `${controller.name}_${func.name}`
+        : func.name;
+
+      const method: unknown = execute[func.name];
+      if (typeof method !== "function") {
+        throw new Error(
+          `Method "${func.name}" not found on controller "${controller.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,
+            });
+          },
+        }),
+      );
+    }
+  };
+
+  const createTool = (entry: {
+    name: string;
+    function: ILlmFunction | IHttpLlmFunction;
+    execute: (args: unknown) => Promise<unknown>;
+  }): DynamicStructuredTool =>
+    new DynamicStructuredTool<any>({
+      name: entry.name,
+      description: entry.function.description ?? "",
+      schema: entry.function.parameters,
+      func: async (args: unknown): Promise<unknown> => {
+        const coerced: unknown = LlmJson.coerce(
+          args,
+          entry.function.parameters,
+        );
+        const valid: IValidation<unknown> = entry.function.validate(coerced);
+        if (valid.success === false)
+          throw new ToolInputParsingException(
+            `Type errors in "${entry.name}" arguments:\n\n` +
+              `\`\`\`json\n${LlmJson.stringify(valid)}\n\`\`\``,
+            JSON.stringify(coerced),
+          );
+        const result: unknown = await entry.execute(valid.data);
+        return result === undefined
+          ? { success: true }
+          : { success: true, data: result };
+      },
+    });
+}