langchain 0.2.6 → 0.2.8

package/dist/agents/openai_tools/index.d.ts

@@ -2,6 +2,7 @@ import type { StructuredToolInterface } from "@langchain/core/tools";
 import type { BaseChatModel, BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { OpenAIClient } from "@langchain/openai";
+import { ToolDefinition } from "@langchain/core/language_models/base";
 import { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from "./output_parser.js";
 import { AgentRunnableSequence } from "../agent.js";
 export { OpenAIToolsAgentOutputParser, type ToolsAgentStep };
@@ -18,7 +19,7 @@ export type CreateOpenAIToolsAgentParams = {
         tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];
     }>;
     /** Tools this agent has access to. */
-    tools: StructuredToolInterface[];
+    tools: StructuredToolInterface[] | ToolDefinition[];
     /** The prompt to use, must have an input key of `agent_scratchpad`. */
     prompt: ChatPromptTemplate;
     /**

package/dist/agents/structured_chat/index.cjs

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStructuredChatAgent = exports.StructuredChatAgent = void 0;
 const zod_to_json_schema_1 = require("zod-to-json-schema");
+const base_1 = require("@langchain/core/language_models/base");
 const runnables_1 = require("@langchain/core/runnables");
 const prompts_1 = require("@langchain/core/prompts");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
 const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
 const agent_js_1 = require("../agent.cjs");
 const outputParser_js_1 = require("./outputParser.cjs");
@@ -215,7 +217,16 @@ async function createStructuredChatAgent({ llm, tools, prompt, streamRunnable, }
     if (missingVariables.length > 0) {
         throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
     }
-    const toolNames = tools.map((tool) => tool.name);
+    let toolNames = [];
+    if (tools.every(base_1.isOpenAITool)) {
+        toolNames = tools.map((tool) => tool.function.name);
+    }
+    else if (tools.every(function_calling_1.isStructuredTool)) {
+        toolNames = tools.map((tool) => tool.name);
+    }
+    else {
+        throw new Error("All tools must be either OpenAI or Structured tools, not a mix.");
+    }
     const partialedPrompt = await prompt.partial({
         tools: (0, render_js_1.renderTextDescriptionAndArgs)(tools),
         tool_names: toolNames.join(", "),

package/dist/agents/structured_chat/index.d.ts

@@ -1,5 +1,5 @@
 import type { StructuredToolInterface } from "@langchain/core/tools";
-import type { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { type BaseLanguageModelInterface, type ToolDefinition } from "@langchain/core/language_models/base";
 import type { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseMessagePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
 import { AgentStep } from "@langchain/core/agents";
@@ -99,7 +99,7 @@ export type CreateStructuredChatAgentParams = {
     /** LLM to use as the agent. */
     llm: BaseLanguageModelInterface;
     /** Tools this agent has access to. */
-    tools: StructuredToolInterface[];
+    tools: (StructuredToolInterface | ToolDefinition)[];
     /**
      * The prompt to use. Must have input keys for
      * `tools`, `tool_names`, and `agent_scratchpad`.

package/dist/agents/structured_chat/index.js

@@ -1,6 +1,8 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { isOpenAITool, } from "@langchain/core/language_models/base";
 import { RunnablePassthrough } from "@langchain/core/runnables";
 import { ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate, PromptTemplate, } from "@langchain/core/prompts";
+import { isStructuredTool } from "@langchain/core/utils/function_calling";
 import { LLMChain } from "../../chains/llm_chain.js";
 import { Agent, AgentRunnableSequence, } from "../agent.js";
 import { StructuredChatOutputParserWithRetries } from "./outputParser.js";
@@ -211,7 +213,16 @@ export async function createStructuredChatAgent({ llm, tools, prompt, streamRunn
     if (missingVariables.length > 0) {
         throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
     }
-    const toolNames = tools.map((tool) => tool.name);
+    let toolNames = [];
+    if (tools.every(isOpenAITool)) {
+        toolNames = tools.map((tool) => tool.function.name);
+    }
+    else if (tools.every(isStructuredTool)) {
+        toolNames = tools.map((tool) => tool.name);
+    }
+    else {
+        throw new Error("All tools must be either OpenAI or Structured tools, not a mix.");
+    }
     const partialedPrompt = await prompt.partial({
         tools: renderTextDescriptionAndArgs(tools),
         tool_names: toolNames.join(", "),

package/dist/agents/tool_calling/index.d.ts

@@ -1,6 +1,7 @@
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
+import { ToolDefinition } from "@langchain/core/language_models/base";
 import { AgentRunnableSequence } from "../agent.js";
 import { ToolsAgentStep } from "./output_parser.js";
 /**
@@ -14,7 +15,7 @@ export type CreateToolCallingAgentParams = {
      */
     llm: BaseChatModel;
     /** Tools this agent has access to. */
-    tools: StructuredToolInterface[];
+    tools: StructuredToolInterface[] | ToolDefinition[];
     /** The prompt to use, must have an input key of `agent_scratchpad`. */
     prompt: ChatPromptTemplate;
     /**

package/dist/document_loaders/fs/multi_file.cjs

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiFileLoader = void 0;
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const base_js_1 = require("../base.cjs");
+const directory_js_1 = require("./directory.cjs");
+/**
+ * A document loader that loads documents from multiple files. It extends the
+ * `BaseDocumentLoader` class and implements the `load()` method.
+ * @example
+ * ```typescript
+ *
+ * const multiFileLoader = new MultiFileLoader(
+ *   ["path/to/file1.pdf", "path/to/file2.txt"],
+ *   {
+ *     ".pdf": (path: string) => new PDFLoader(path),
+ *   },
+ * );
+ *
+ * const docs = await multiFileLoader.load();
+ * console.log({ docs });
+ *
+ * ```
+ */
+class MultiFileLoader extends base_js_1.BaseDocumentLoader {
+    constructor(filePaths, loaders, unknown = directory_js_1.UnknownHandling.Warn) {
+        super();
+        Object.defineProperty(this, "filePaths", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: filePaths
+        });
+        Object.defineProperty(this, "loaders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: loaders
+        });
+        Object.defineProperty(this, "unknown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: unknown
+        });
+        if (Object.keys(loaders).length === 0) {
+            throw new Error("Must provide at least one loader");
+        }
+        for (const extension in loaders) {
+            if (Object.hasOwn(loaders, extension)) {
+                if (extension[0] !== ".") {
+                    throw new Error(`Extension must start with a dot: ${extension}`);
+                }
+            }
+        }
+    }
+    /**
+     * Loads the documents from the provided file paths. It checks if the file
+     * is a directory and ignores it. If a file is a file, it checks if there
+     * is a corresponding loader function for the file extension in the `loaders`
+     * mapping. If there is, it loads the documents. If there is no
+     * corresponding loader function and `unknown` is set to `Warn`, it logs a
+     * warning message. If `unknown` is set to `Error`, it throws an error.
+     * @returns A promise that resolves to an array of loaded documents.
+     */
+    async load() {
+        const documents = [];
+        for (const filePath of this.filePaths) {
+            const fullPath = (0, node_path_1.resolve)(filePath);
+            const fileStat = await (0, promises_1.stat)(fullPath);
+            if (fileStat.isDirectory()) {
+                console.warn(`Ignoring directory: ${fullPath}`);
+                continue;
+            }
+            const loaderFactory = this.loaders[(0, node_path_1.extname)(fullPath)];
+            if (loaderFactory) {
+                const loader = loaderFactory(fullPath);
+                documents.push(...(await loader.load()));
+            }
+            else {
+                switch (this.unknown) {
+                    case directory_js_1.UnknownHandling.Ignore:
+                        break;
+                    case directory_js_1.UnknownHandling.Warn:
+                        console.warn(`Unknown file type: ${fullPath}`);
+                        break;
+                    case directory_js_1.UnknownHandling.Error:
+                        throw new Error(`Unknown file type: ${fullPath}`);
+                    default:
+                        throw new Error(`Unknown unknown handling: ${this.unknown}`);
+                }
+            }
+        }
+        return documents;
+    }
+}
+exports.MultiFileLoader = MultiFileLoader;

package/dist/document_loaders/fs/multi_file.d.ts

@@ -0,0 +1,37 @@
+import { Document } from "@langchain/core/documents";
+import { BaseDocumentLoader } from "../base.js";
+import { type LoadersMapping, UnknownHandling } from "./directory.js";
+/**
+ * A document loader that loads documents from multiple files. It extends the
+ * `BaseDocumentLoader` class and implements the `load()` method.
+ * @example
+ * ```typescript
+ *
+ * const multiFileLoader = new MultiFileLoader(
+ *   ["path/to/file1.pdf", "path/to/file2.txt"],
+ *   {
+ *     ".pdf": (path: string) => new PDFLoader(path),
+ *   },
+ * );
+ *
+ * const docs = await multiFileLoader.load();
+ * console.log({ docs });
+ *
+ * ```
+ */
+export declare class MultiFileLoader extends BaseDocumentLoader {
+    filePaths: string[];
+    loaders: LoadersMapping;
+    unknown: UnknownHandling;
+    constructor(filePaths: string[], loaders: LoadersMapping, unknown?: UnknownHandling);
+    /**
+     * Loads the documents from the provided file paths. It checks if the file
+     * is a directory and ignores it. If a file is a file, it checks if there
+     * is a corresponding loader function for the file extension in the `loaders`
+     * mapping. If there is, it loads the documents. If there is no
+     * corresponding loader function and `unknown` is set to `Warn`, it logs a
+     * warning message. If `unknown` is set to `Error`, it throws an error.
+     * @returns A promise that resolves to an array of loaded documents.
+     */
+    load(): Promise<Document[]>;
+}

package/dist/document_loaders/fs/multi_file.js

@@ -0,0 +1,94 @@
+import { extname, resolve } from "node:path";
+import { stat } from "node:fs/promises";
+import { BaseDocumentLoader } from "../base.js";
+import { UnknownHandling } from "./directory.js";
+/**
+ * A document loader that loads documents from multiple files. It extends the
+ * `BaseDocumentLoader` class and implements the `load()` method.
+ * @example
+ * ```typescript
+ *
+ * const multiFileLoader = new MultiFileLoader(
+ *   ["path/to/file1.pdf", "path/to/file2.txt"],
+ *   {
+ *     ".pdf": (path: string) => new PDFLoader(path),
+ *   },
+ * );
+ *
+ * const docs = await multiFileLoader.load();
+ * console.log({ docs });
+ *
+ * ```
+ */
+export class MultiFileLoader extends BaseDocumentLoader {
+    constructor(filePaths, loaders, unknown = UnknownHandling.Warn) {
+        super();
+        Object.defineProperty(this, "filePaths", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: filePaths
+        });
+        Object.defineProperty(this, "loaders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: loaders
+        });
+        Object.defineProperty(this, "unknown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: unknown
+        });
+        if (Object.keys(loaders).length === 0) {
+            throw new Error("Must provide at least one loader");
+        }
+        for (const extension in loaders) {
+            if (Object.hasOwn(loaders, extension)) {
+                if (extension[0] !== ".") {
+                    throw new Error(`Extension must start with a dot: ${extension}`);
+                }
+            }
+        }
+    }
+    /**
+     * Loads the documents from the provided file paths. It checks if the file
+     * is a directory and ignores it. If a file is a file, it checks if there
+     * is a corresponding loader function for the file extension in the `loaders`
+     * mapping. If there is, it loads the documents. If there is no
+     * corresponding loader function and `unknown` is set to `Warn`, it logs a
+     * warning message. If `unknown` is set to `Error`, it throws an error.
+     * @returns A promise that resolves to an array of loaded documents.
+     */
+    async load() {
+        const documents = [];
+        for (const filePath of this.filePaths) {
+            const fullPath = resolve(filePath);
+            const fileStat = await stat(fullPath);
+            if (fileStat.isDirectory()) {
+                console.warn(`Ignoring directory: ${fullPath}`);
+                continue;
+            }
+            const loaderFactory = this.loaders[extname(fullPath)];
+            if (loaderFactory) {
+                const loader = loaderFactory(fullPath);
+                documents.push(...(await loader.load()));
+            }
+            else {
+                switch (this.unknown) {
+                    case UnknownHandling.Ignore:
+                        break;
+                    case UnknownHandling.Warn:
+                        console.warn(`Unknown file type: ${fullPath}`);
+                        break;
+                    case UnknownHandling.Error:
+                        throw new Error(`Unknown file type: ${fullPath}`);
+                    default:
+                        throw new Error(`Unknown unknown handling: ${this.unknown}`);
+                }
+            }
+        }
+        return documents;
+    }
+}

package/dist/document_loaders/tests/multi_file.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/document_loaders/tests/multi_file.test.js

@@ -0,0 +1,49 @@
+import * as url from "node:url";
+import * as path from "node:path";
+import { test, expect } from "@jest/globals";
+import { MultiFileLoader } from "../fs/multi_file.js";
+import { CSVLoader } from "../fs/csv.js";
+import { PDFLoader } from "../fs/pdf.js";
+import { TextLoader } from "../fs/text.js";
+import { JSONLoader } from "../fs/json.js";
+import { UnknownHandling } from "../fs/directory.js";
+test("Test MultiFileLoader", async () => {
+    const baseDirectory = path.resolve(path.dirname(url.fileURLToPath(import.meta.url)), "./example_data");
+    const filePaths = [
+        path.resolve(baseDirectory, "1706.03762.pdf"),
+        path.resolve(baseDirectory, "Jacob_Lee_Resume_2023.pdf"),
+        path.resolve(baseDirectory, "Star_Wars_The_Clone_Wars_S06E07_Crisis_at_the_Heart.csv"),
+        path.resolve(baseDirectory, "Star_Wars_The_Clone_Wars_S06E07_Crisis_at_the_Heart.json"),
+        path.resolve(baseDirectory, "complex.json"),
+        path.resolve(baseDirectory, "example.txt"),
+        path.resolve(baseDirectory, "example_separator.csv"),
+    ];
+    const loader = new MultiFileLoader(filePaths, {
+        ".csv": (p) => {
+            if (p.includes("separator.csv")) {
+                return new CSVLoader(p, { column: "html", separator: "｜" });
+            }
+            return new CSVLoader(p, "html");
+        },
+        ".pdf": (p) => new PDFLoader(p),
+        ".txt": (p) => new TextLoader(p),
+        ".json": (p) => new JSONLoader(p),
+    }, UnknownHandling.Ignore);
+    const docs = await loader.load();
+    expect(docs.length).toBe(123);
+    const expectedSources = [
+        // PDF
+        ...Array.from({ length: 15 }, (_) => path.resolve(baseDirectory, "1706.03762.pdf")),
+        path.resolve(baseDirectory, "Jacob_Lee_Resume_2023.pdf"),
+        // CSV
+        ...Array.from({ length: 32 }, (_) => path.resolve(baseDirectory, "Star_Wars_The_Clone_Wars_S06E07_Crisis_at_the_Heart.csv")),
+        // JSON
+        ...Array.from({ length: 32 }, (_) => path.resolve(baseDirectory, "Star_Wars_The_Clone_Wars_S06E07_Crisis_at_the_Heart.json")),
+        ...Array.from({ length: 10 }, (_) => path.resolve(baseDirectory, "complex.json")),
+        // TXT
+        path.resolve(baseDirectory, "example.txt"),
+        // CSV
+        ...Array.from({ length: 32 }, (_) => path.resolve(baseDirectory, "example_separator.csv")),
+    ];
+    expect(docs.map((d) => d.metadata.source).sort()).toEqual(expectedSources);
+});