langchain 0.0.183 → 0.0.185

package/dist/document_loaders/fs/pdf.cjs

@@ -59,9 +59,23 @@ class PDFLoader extends buffer_js_1.BufferLoader {
             if (content.items.length === 0) {
                 continue;
             }
-            const text = content.items
-                .map((item) => item.str)
-                .join("\n");
+            // Eliminate excessive newlines
+            // Source: https://github.com/albertcui/pdf-parse/blob/7086fc1cc9058545cdf41dd0646d6ae5832c7107/lib/pdf-parse.js#L16
+            let lastY;
+            const textItems = [];
+            for (const item of content.items) {
+                if ("str" in item) {
+                    if (lastY === item.transform[5] || !lastY) {
+                        textItems.push(item.str);
+                    }
+                    else {
+                        textItems.push(`\n${item.str}`);
+                    }
+                    // eslint-disable-next-line prefer-destructuring
+                    lastY = item.transform[5];
+                }
+            }
+            const text = textItems.join(" ");
             documents.push(new document_js_1.Document({
                 pageContent: text,
                 metadata: {

package/dist/document_loaders/fs/pdf.js

@@ -56,9 +56,23 @@ export class PDFLoader extends BufferLoader {
             if (content.items.length === 0) {
                 continue;
             }
-            const text = content.items
-                .map((item) => item.str)
-                .join("\n");
+            // Eliminate excessive newlines
+            // Source: https://github.com/albertcui/pdf-parse/blob/7086fc1cc9058545cdf41dd0646d6ae5832c7107/lib/pdf-parse.js#L16
+            let lastY;
+            const textItems = [];
+            for (const item of content.items) {
+                if ("str" in item) {
+                    if (lastY === item.transform[5] || !lastY) {
+                        textItems.push(item.str);
+                    }
+                    else {
+                        textItems.push(`\n${item.str}`);
+                    }
+                    // eslint-disable-next-line prefer-destructuring
+                    lastY = item.transform[5];
+                }
+            }
+            const text = textItems.join(" ");
             documents.push(new Document({
                 pageContent: text,
                 metadata: {

package/dist/document_loaders/web/apify_dataset.cjs

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApifyDatasetLoader = void 0;
 const apify_client_1 = require("apify-client");
+const async_caller_js_1 = require("../../util/async_caller.cjs");
 const base_js_1 = require("../base.cjs");
 const env_js_1 = require("../../util/env.cjs");
 /**
@@ -31,13 +32,18 @@ class ApifyDatasetLoader extends base_js_1.BaseDocumentLoader {
             writable: true,
             value: void 0
         });
-        const apifyApiToken = ApifyDatasetLoader._getApifyApiToken(config.clientOptions);
-        this.apifyClient = new apify_client_1.ApifyClient({
-            ...config.clientOptions,
-            token: apifyApiToken,
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
+        const { clientOptions, datasetMappingFunction, ...asyncCallerParams } = config;
+        const token = ApifyDatasetLoader._getApifyApiToken(clientOptions);
+        this.apifyClient = new apify_client_1.ApifyClient({ ...clientOptions, token });
         this.datasetId = datasetId;
-        this.datasetMappingFunction = config.datasetMappingFunction;
+        this.datasetMappingFunction = datasetMappingFunction;
+        this.caller = new async_caller_js_1.AsyncCaller(asyncCallerParams);
     }
     static _getApifyApiToken(config) {
         return config?.token ?? (0, env_js_1.getEnvironmentVariable)("APIFY_API_TOKEN");
@@ -50,7 +56,7 @@ class ApifyDatasetLoader extends base_js_1.BaseDocumentLoader {
      */
     async load() {
         const datasetItems = (await this.apifyClient.dataset(this.datasetId).listItems({ clean: true })).items;
-        return datasetItems.map(this.datasetMappingFunction);
+        return await Promise.all(datasetItems.map((item) => this.caller.call(async () => this.datasetMappingFunction(item))));
     }
     /**
      * Create an ApifyDatasetLoader by calling an Actor on the Apify platform and waiting for its results to be ready.

package/dist/document_loaders/web/apify_dataset.d.ts

@@ -1,11 +1,16 @@
 import { ActorCallOptions, ApifyClient, ApifyClientOptions, TaskCallOptions } from "apify-client";
+import { AsyncCaller, AsyncCallerParams } from "../../util/async_caller.js";
 import { BaseDocumentLoader, DocumentLoader } from "../base.js";
 import { Document } from "../../document.js";
 /**
  * A type that represents a function that takes a single object (an Apify
  * dataset item) and converts it to an instance of the Document class.
  */
-export type ApifyDatasetMappingFunction<Metadata extends Record<string, any>> = (item: Record<string | number, unknown>) => Document<Metadata>;
+export type ApifyDatasetMappingFunction<Metadata extends Record<string, any>> = (item: Record<string | number, unknown>) => Document<Metadata> | Promise<Document<Metadata>>;
+export interface ApifyDatasetLoaderConfig<Metadata extends Record<string, any>> extends AsyncCallerParams {
+    datasetMappingFunction: ApifyDatasetMappingFunction<Metadata>;
+    clientOptions?: ApifyClientOptions;
+}
 /**
  * A class that extends the BaseDocumentLoader and implements the
  * DocumentLoader interface. It represents a document loader that loads
@@ -14,11 +19,9 @@ export type ApifyDatasetMappingFunction<Metadata extends Record<string, any>> =
 export declare class ApifyDatasetLoader<Metadata extends Record<string, any>> extends BaseDocumentLoader implements DocumentLoader {
     protected apifyClient: ApifyClient;
     protected datasetId: string;
-    protected datasetMappingFunction: (item: Record<string | number, unknown>) => Document<Metadata>;
-    constructor(datasetId: string, config: {
-        datasetMappingFunction: ApifyDatasetMappingFunction<Metadata>;
-        clientOptions?: ApifyClientOptions;
-    });
+    protected datasetMappingFunction: ApifyDatasetMappingFunction<Metadata>;
+    protected caller: AsyncCaller;
+    constructor(datasetId: string, config: ApifyDatasetLoaderConfig<Metadata>);
     private static _getApifyApiToken;
     /**
      * Retrieves the dataset items from the Apify platform and applies the

package/dist/document_loaders/web/apify_dataset.js

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { ApifyClient, } from "apify-client";
+import { AsyncCaller } from "../../util/async_caller.js";
 import { BaseDocumentLoader } from "../base.js";
 import { getEnvironmentVariable } from "../../util/env.js";
 /**
@@ -28,13 +29,18 @@ export class ApifyDatasetLoader extends BaseDocumentLoader {
             writable: true,
             value: void 0
         });
-        const apifyApiToken = ApifyDatasetLoader._getApifyApiToken(config.clientOptions);
-        this.apifyClient = new ApifyClient({
-            ...config.clientOptions,
-            token: apifyApiToken,
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
+        const { clientOptions, datasetMappingFunction, ...asyncCallerParams } = config;
+        const token = ApifyDatasetLoader._getApifyApiToken(clientOptions);
+        this.apifyClient = new ApifyClient({ ...clientOptions, token });
         this.datasetId = datasetId;
-        this.datasetMappingFunction = config.datasetMappingFunction;
+        this.datasetMappingFunction = datasetMappingFunction;
+        this.caller = new AsyncCaller(asyncCallerParams);
     }
     static _getApifyApiToken(config) {
         return config?.token ?? getEnvironmentVariable("APIFY_API_TOKEN");
@@ -47,7 +53,7 @@ export class ApifyDatasetLoader extends BaseDocumentLoader {
      */
     async load() {
         const datasetItems = (await this.apifyClient.dataset(this.datasetId).listItems({ clean: true })).items;
-        return datasetItems.map(this.datasetMappingFunction);
+        return await Promise.all(datasetItems.map((item) => this.caller.call(async () => this.datasetMappingFunction(item))));
     }
     /**
      * Create an ApifyDatasetLoader by calling an Actor on the Apify platform and waiting for its results to be ready.

package/dist/document_loaders/web/pdf.cjs

@@ -52,9 +52,23 @@ class WebPDFLoader extends base_js_1.BaseDocumentLoader {
             if (content.items.length === 0) {
                 continue;
             }
-            const text = content.items
-                .map((item) => item.str)
-                .join("\n");
+            // Eliminate excessive newlines
+            // Source: https://github.com/albertcui/pdf-parse/blob/7086fc1cc9058545cdf41dd0646d6ae5832c7107/lib/pdf-parse.js#L16
+            let lastY;
+            const textItems = [];
+            for (const item of content.items) {
+                if ("str" in item) {
+                    if (lastY === item.transform[5] || !lastY) {
+                        textItems.push(item.str);
+                    }
+                    else {
+                        textItems.push(`\n${item.str}`);
+                    }
+                    // eslint-disable-next-line prefer-destructuring
+                    lastY = item.transform[5];
+                }
+            }
+            const text = textItems.join(" ");
             documents.push(new document_js_1.Document({
                 pageContent: text,
                 metadata: {

package/dist/document_loaders/web/pdf.js

@@ -49,9 +49,23 @@ export class WebPDFLoader extends BaseDocumentLoader {
             if (content.items.length === 0) {
                 continue;
             }
-            const text = content.items
-                .map((item) => item.str)
-                .join("\n");
+            // Eliminate excessive newlines
+            // Source: https://github.com/albertcui/pdf-parse/blob/7086fc1cc9058545cdf41dd0646d6ae5832c7107/lib/pdf-parse.js#L16
+            let lastY;
+            const textItems = [];
+            for (const item of content.items) {
+                if ("str" in item) {
+                    if (lastY === item.transform[5] || !lastY) {
+                        textItems.push(item.str);
+                    }
+                    else {
+                        textItems.push(`\n${item.str}`);
+                    }
+                    // eslint-disable-next-line prefer-destructuring
+                    lastY = item.transform[5];
+                }
+            }
+            const text = textItems.join(" ");
             documents.push(new Document({
                 pageContent: text,
                 metadata: {

package/dist/document_loaders/web/puppeteer.cjs

@@ -63,6 +63,43 @@ class PuppeteerWebBaseLoader extends base_js_1.BaseDocumentLoader {
         const metadata = { source: this.webPath };
         return [new document_js_1.Document({ pageContent: text, metadata })];
     }
+    /**
+     * Static class method used to screenshot a web page and return
+     * it as a {@link Document} object where  the pageContent property
+     * is the screenshot encoded in base64.
+     *
+     * @param {string} url
+     * @param {PuppeteerWebBaseLoaderOptions} options
+     * @returns {Document} A document object containing the screenshot of the page encoded in base64.
+     */
+    static async _screenshot(url, options) {
+        const { launch } = await PuppeteerWebBaseLoader.imports();
+        const browser = await launch({
+            headless: true,
+            defaultViewport: null,
+            ignoreDefaultArgs: ["--disable-extensions"],
+            ...options?.launchOptions,
+        });
+        const page = await browser.newPage();
+        await page.goto(url, {
+            timeout: 180000,
+            waitUntil: "domcontentloaded",
+            ...options?.gotoOptions,
+        });
+        const screenshot = await page.screenshot();
+        const base64 = screenshot.toString("base64");
+        const metadata = { source: url };
+        return new document_js_1.Document({ pageContent: base64, metadata });
+    }
+    /**
+     * Screenshot a web page and return it as a {@link Document} object where
+     * the pageContent property is the screenshot encoded in base64.
+     *
+     * @returns {Promise<Document>} A document object containing the screenshot of the page encoded in base64.
+     */
+    async screenshot() {
+        return PuppeteerWebBaseLoader._screenshot(this.webPath, this.options);
+    }
     /**
      * Static method that imports the necessary Puppeteer modules. It returns
      * a Promise that resolves to an object containing the imported modules.

package/dist/document_loaders/web/puppeteer.d.ts

@@ -40,6 +40,23 @@ export declare class PuppeteerWebBaseLoader extends BaseDocumentLoader implement
      * @returns Promise that resolves to an array of Document objects.
      */
     load(): Promise<Document[]>;
+    /**
+     * Static class method used to screenshot a web page and return
+     * it as a {@link Document} object where  the pageContent property
+     * is the screenshot encoded in base64.
+     *
+     * @param {string} url
+     * @param {PuppeteerWebBaseLoaderOptions} options
+     * @returns {Document} A document object containing the screenshot of the page encoded in base64.
+     */
+    static _screenshot(url: string, options?: PuppeteerWebBaseLoaderOptions): Promise<Document>;
+    /**
+     * Screenshot a web page and return it as a {@link Document} object where
+     * the pageContent property is the screenshot encoded in base64.
+     *
+     * @returns {Promise<Document>} A document object containing the screenshot of the page encoded in base64.
+     */
+    screenshot(): Promise<Document>;
     /**
      * Static method that imports the necessary Puppeteer modules. It returns
      * a Promise that resolves to an object containing the imported modules.

package/dist/document_loaders/web/puppeteer.js

@@ -60,6 +60,43 @@ export class PuppeteerWebBaseLoader extends BaseDocumentLoader {
         const metadata = { source: this.webPath };
         return [new Document({ pageContent: text, metadata })];
     }
+    /**
+     * Static class method used to screenshot a web page and return
+     * it as a {@link Document} object where  the pageContent property
+     * is the screenshot encoded in base64.
+     *
+     * @param {string} url
+     * @param {PuppeteerWebBaseLoaderOptions} options
+     * @returns {Document} A document object containing the screenshot of the page encoded in base64.
+     */
+    static async _screenshot(url, options) {
+        const { launch } = await PuppeteerWebBaseLoader.imports();
+        const browser = await launch({
+            headless: true,
+            defaultViewport: null,
+            ignoreDefaultArgs: ["--disable-extensions"],
+            ...options?.launchOptions,
+        });
+        const page = await browser.newPage();
+        await page.goto(url, {
+            timeout: 180000,
+            waitUntil: "domcontentloaded",
+            ...options?.gotoOptions,
+        });
+        const screenshot = await page.screenshot();
+        const base64 = screenshot.toString("base64");
+        const metadata = { source: url };
+        return new Document({ pageContent: base64, metadata });
+    }
+    /**
+     * Screenshot a web page and return it as a {@link Document} object where
+     * the pageContent property is the screenshot encoded in base64.
+     *
+     * @returns {Promise<Document>} A document object containing the screenshot of the page encoded in base64.
+     */
+    async screenshot() {
+        return PuppeteerWebBaseLoader._screenshot(this.webPath, this.options);
+    }
     /**
      * Static method that imports the necessary Puppeteer modules. It returns
      * a Promise that resolves to an object containing the imported modules.

package/dist/experimental/openai_assistant/index.cjs

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIAssistantRunnable = void 0;
+const openai_1 = require("openai");
+const base_js_1 = require("../../schema/runnable/base.cjs");
+const time_js_1 = require("../../util/time.cjs");
+const base_js_2 = require("../../tools/base.cjs");
+const convert_to_openai_js_1 = require("../../tools/convert_to_openai.cjs");
+class OpenAIAssistantRunnable extends base_js_1.Runnable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "experimental", "openai_assistant"]
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "assistantId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pollIntervalMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1000
+        });
+        Object.defineProperty(this, "asAgent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.client = fields.client ?? new openai_1.OpenAI(fields?.clientOptions);
+        this.assistantId = fields.assistantId;
+        this.asAgent = fields.asAgent ?? this.asAgent;
+    }
+    static async createAssistant({ model, name, instructions, tools, client, clientOptions, asAgent, pollIntervalMs, }) {
+        const formattedTools = tools?.map((tool) => {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (tool instanceof base_js_2.StructuredTool) {
+                return (0, convert_to_openai_js_1.formatToOpenAIAssistantTool)(tool);
+            }
+            return tool;
+        }) ?? [];
+        const oaiClient = client ?? new openai_1.OpenAI(clientOptions);
+        const assistant = await oaiClient.beta.assistants.create({
+            name,
+            instructions,
+            tools: formattedTools,
+            model,
+        });
+        return new this({
+            client: oaiClient,
+            assistantId: assistant.id,
+            asAgent,
+            pollIntervalMs,
+        });
+    }
+    async invoke(input, _options) {
+        let run;
+        if (this.asAgent && input.steps && input.steps.length > 0) {
+            const parsedStepsInput = await this._parseStepsInput(input);
+            run = await this.client.beta.threads.runs.submitToolOutputs(parsedStepsInput.threadId, parsedStepsInput.runId, {
+                tool_outputs: parsedStepsInput.toolOutputs,
+            });
+        }
+        else if (!("threadId" in input)) {
+            const thread = {
+                messages: [
+                    {
+                        role: "user",
+                        content: input.content,
+                        file_ids: input.fileIds,
+                        metadata: input.messagesMetadata,
+                    },
+                ],
+                metadata: input.threadMetadata,
+            };
+            run = await this._createThreadAndRun({
+                ...input,
+                thread,
+            });
+        }
+        else if (!("runId" in input)) {
+            await this.client.beta.threads.messages.create(input.threadId, {
+                content: input.content,
+                role: "user",
+                file_ids: input.file_ids,
+                metadata: input.messagesMetadata,
+            });
+            run = await this._createRun(input);
+        }
+        else {
+            // Submitting tool outputs to an existing run, outside the AgentExecutor
+            // framework.
+            run = await this.client.beta.threads.runs.submitToolOutputs(input.runId, input.threadId, {
+                tool_outputs: input.toolOutputs,
+            });
+        }
+        return this._getResponse(run.id, run.thread_id);
+    }
+    async _parseStepsInput(input) {
+        const { action: { runId, threadId }, } = input.steps[input.steps.length - 1];
+        const run = await this._waitForRun(runId, threadId);
+        const toolCalls = run.required_action?.submit_tool_outputs.tool_calls;
+        if (!toolCalls) {
+            return input;
+        }
+        const toolOutputs = toolCalls.flatMap((toolCall) => {
+            const matchedAction = input.steps.find((step) => step.action.toolCallId === toolCall.id);
+            return matchedAction
+                ? [
+                    {
+                        output: matchedAction.observation,
+                        tool_call_id: matchedAction.action.toolCallId,
+                    },
+                ]
+                : [];
+        });
+        return { toolOutputs, runId, threadId };
+    }
+    async _createRun({ instructions, model, tools, metadata, threadId, }) {
+        const run = this.client.beta.threads.runs.create(threadId, {
+            assistant_id: this.assistantId,
+            instructions,
+            model,
+            tools,
+            metadata,
+        });
+        return run;
+    }
+    async _createThreadAndRun(input) {
+        const params = [
+            "instructions",
+            "model",
+            "tools",
+            "run_metadata",
+        ]
+            .filter((key) => key in input)
+            .reduce((obj, key) => {
+            const newObj = obj;
+            newObj[key] = input[key];
+            return newObj;
+        }, {});
+        const run = this.client.beta.threads.createAndRun({
+            ...params,
+            thread: input.thread,
+            assistant_id: this.assistantId,
+        });
+        return run;
+    }
+    async _waitForRun(runId, threadId) {
+        let inProgress = true;
+        let run = {};
+        while (inProgress) {
+            run = await this.client.beta.threads.runs.retrieve(threadId, runId);
+            inProgress = ["in_progress", "queued"].includes(run.status);
+            if (inProgress) {
+                await (0, time_js_1.sleep)(this.pollIntervalMs);
+            }
+        }
+        return run;
+    }
+    async _getResponse(runId, threadId) {
+        const run = await this._waitForRun(runId, threadId);
+        if (run.status === "completed") {
+            const messages = await this.client.beta.threads.messages.list(threadId, {
+                order: "asc",
+            });
+            const newMessages = messages.data.filter((msg) => msg.run_id === runId);
+            if (!this.asAgent) {
+                return newMessages;
+            }
+            const answer = newMessages.flatMap((msg) => msg.content);
+            if (answer.every((item) => item.type === "text")) {
+                const answerString = answer
+                    .map((item) => item.type === "text" && item.text.value)
+                    .join("\n");
+                return {
+                    returnValues: {
+                        output: answerString,
+                    },
+                    log: "",
+                    runId,
+                    threadId,
+                };
+            }
+        }
+        else if (run.status === "requires_action") {
+            if (!this.asAgent) {
+                return run.required_action?.submit_tool_outputs.tool_calls ?? [];
+            }
+            const actions = [];
+            run.required_action?.submit_tool_outputs.tool_calls.forEach((item) => {
+                const functionCall = item.function;
+                const args = JSON.parse(functionCall.arguments);
+                actions.push({
+                    tool: functionCall.name,
+                    toolInput: args,
+                    toolCallId: item.id,
+                    log: "",
+                    runId,
+                    threadId,
+                });
+            });
+            return actions;
+        }
+        const runInfo = JSON.stringify(run, null, 2);
+        throw new Error(`Unexpected run status ${run.status}.\nFull run info:\n\n${runInfo}`);
+    }
+}
+exports.OpenAIAssistantRunnable = OpenAIAssistantRunnable;

package/dist/experimental/openai_assistant/index.d.ts

@@ -0,0 +1,36 @@
+import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
+import { Runnable } from "../../schema/runnable/base.js";
+import type { RunnableConfig } from "../../schema/runnable/config.js";
+import type { OpenAIAssistantFinish, OpenAIAssistantAction, OpenAIToolType } from "./schema.js";
+import { StructuredTool } from "../../tools/base.js";
+type ThreadMessage = OpenAIClient.Beta.Threads.ThreadMessage;
+type RequiredActionFunctionToolCall = OpenAIClient.Beta.Threads.RequiredActionFunctionToolCall;
+type ExtractRunOutput<AsAgent extends boolean | undefined> = AsAgent extends true ? OpenAIAssistantFinish | OpenAIAssistantAction[] : ThreadMessage[] | RequiredActionFunctionToolCall[];
+export type OpenAIAssistantRunnableInput<AsAgent extends boolean | undefined = undefined> = {
+    client?: OpenAIClient;
+    clientOptions?: ClientOptions;
+    assistantId: string;
+    pollIntervalMs?: number;
+    asAgent?: AsAgent;
+};
+export declare class OpenAIAssistantRunnable<AsAgent extends boolean | undefined, RunInput extends Record<string, any> = Record<string, any>> extends Runnable<RunInput, ExtractRunOutput<AsAgent>> {
+    lc_namespace: string[];
+    private client;
+    assistantId: string;
+    pollIntervalMs: number;
+    asAgent?: AsAgent;
+    constructor(fields: OpenAIAssistantRunnableInput<AsAgent>);
+    static createAssistant<AsAgent extends boolean>({ model, name, instructions, tools, client, clientOptions, asAgent, pollIntervalMs, }: Omit<OpenAIAssistantRunnableInput<AsAgent>, "assistantId"> & {
+        model: string;
+        name?: string;
+        instructions?: string;
+        tools?: OpenAIToolType | Array<StructuredTool>;
+    }): Promise<OpenAIAssistantRunnable<AsAgent, Record<string, any>>>;
+    invoke(input: RunInput, _options?: RunnableConfig): Promise<ExtractRunOutput<AsAgent>>;
+    private _parseStepsInput;
+    private _createRun;
+    private _createThreadAndRun;
+    private _waitForRun;
+    private _getResponse;
+}
+export {};