langchain 0.1.12 → 0.1.14

package/dist/runnables/remote.js

@@ -1,337 +1 @@
-import { Runnable, } from "@langchain/core/runnables";
-import { Document } from "@langchain/core/documents";
-import { ChatPromptValue, StringPromptValue, } from "@langchain/core/prompt_values";
-import { LogStreamCallbackHandler, } from "@langchain/core/tracers/log_stream";
-import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, } from "@langchain/core/messages";
-import { GenerationChunk, ChatGenerationChunk, RUN_KEY, } from "@langchain/core/outputs";
-import { getBytes, getLines, getMessages, convertEventStreamToIterableReadableDataStream, } from "@langchain/community/utils/event_source_parse";
-import { IterableReadableStream } from "@langchain/core/utils/stream";
-function isSuperset(set, subset) {
-    for (const elem of subset) {
-        if (!set.has(elem)) {
-            return false;
-        }
-    }
-    return true;
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function revive(obj) {
-    if (Array.isArray(obj))
-        return obj.map(revive);
-    if (typeof obj === "object") {
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        if (!obj || obj instanceof Date) {
-            return obj;
-        }
-        const keysArr = Object.keys(obj);
-        const keys = new Set(keysArr);
-        if (isSuperset(keys, new Set(["page_content", "metadata"]))) {
-            return new Document({
-                pageContent: obj.page_content,
-                metadata: obj.metadata,
-            });
-        }
-        if (isSuperset(keys, new Set(["content", "type", "additional_kwargs"]))) {
-            if (obj.type === "HumanMessage" || obj.type === "human") {
-                return new HumanMessage({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "SystemMessage" || obj.type === "system") {
-                return new SystemMessage({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "ChatMessage" || obj.type === "chat") {
-                return new ChatMessage({
-                    content: obj.content,
-                    role: obj.role,
-                });
-            }
-            if (obj.type === "FunctionMessage" || obj.type === "function") {
-                return new FunctionMessage({
-                    content: obj.content,
-                    name: obj.name,
-                });
-            }
-            if (obj.type === "ToolMessage" || obj.type === "tool") {
-                return new ToolMessage({
-                    content: obj.content,
-                    tool_call_id: obj.tool_call_id,
-                });
-            }
-            if (obj.type === "AIMessage" || obj.type === "ai") {
-                return new AIMessage({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "HumanMessageChunk") {
-                return new HumanMessageChunk({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "SystemMessageChunk") {
-                return new SystemMessageChunk({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "ChatMessageChunk") {
-                return new ChatMessageChunk({
-                    content: obj.content,
-                    role: obj.role,
-                });
-            }
-            if (obj.type === "FunctionMessageChunk") {
-                return new FunctionMessageChunk({
-                    content: obj.content,
-                    name: obj.name,
-                });
-            }
-            if (obj.type === "ToolMessageChunk") {
-                return new ToolMessageChunk({
-                    content: obj.content,
-                    tool_call_id: obj.tool_call_id,
-                });
-            }
-            if (obj.type === "AIMessageChunk") {
-                return new AIMessageChunk({
-                    content: obj.content,
-                });
-            }
-        }
-        if (isSuperset(keys, new Set(["text", "generation_info", "type"]))) {
-            if (obj.type === "ChatGenerationChunk") {
-                return new ChatGenerationChunk({
-                    message: revive(obj.message),
-                    text: obj.text,
-                    generationInfo: obj.generation_info,
-                });
-            }
-            else if (obj.type === "ChatGeneration") {
-                return {
-                    message: revive(obj.message),
-                    text: obj.text,
-                    generationInfo: obj.generation_info,
-                };
-            }
-            else if (obj.type === "GenerationChunk") {
-                return new GenerationChunk({
-                    text: obj.text,
-                    generationInfo: obj.generation_info,
-                });
-            }
-            else if (obj.type === "Generation") {
-                return {
-                    text: obj.text,
-                    generationInfo: obj.generation_info,
-                };
-            }
-        }
-        if (isSuperset(keys, new Set(["tool", "tool_input", "log", "type"]))) {
-            if (obj.type === "AgentAction") {
-                return {
-                    tool: obj.tool,
-                    toolInput: obj.tool_input,
-                    log: obj.log,
-                };
-            }
-        }
-        if (isSuperset(keys, new Set(["return_values", "log", "type"]))) {
-            if (obj.type === "AgentFinish") {
-                return {
-                    returnValues: obj.return_values,
-                    log: obj.log,
-                };
-            }
-        }
-        if (isSuperset(keys, new Set(["generations", "run", "type"]))) {
-            if (obj.type === "LLMResult") {
-                return {
-                    generations: revive(obj.generations),
-                    llmOutput: obj.llm_output,
-                    [RUN_KEY]: obj.run,
-                };
-            }
-        }
-        if (isSuperset(keys, new Set(["messages"]))) {
-            // TODO: Start checking for type: ChatPromptValue and ChatPromptValueConcrete
-            // when LangServe bug is fixed
-            return new ChatPromptValue({
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                messages: obj.messages.map((msg) => revive(msg)),
-            });
-        }
-        if (isSuperset(keys, new Set(["text"]))) {
-            // TODO: Start checking for type: StringPromptValue
-            // when LangServe bug is fixed
-            return new StringPromptValue(obj.text);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const innerRevive = (key) => [
-            key,
-            revive(obj[key]),
-        ];
-        const rtn = Object.fromEntries(keysArr.map(innerRevive));
-        return rtn;
-    }
-    return obj;
-}
-function deserialize(str) {
-    const obj = JSON.parse(str);
-    return revive(obj);
-}
-function removeCallbacks(options) {
-    const rest = { ...options };
-    delete rest.callbacks;
-    return rest;
-}
-export class RemoteRunnable extends Runnable {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "url", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable", "remote"]
-        });
-        const { url, options } = fields;
-        this.url = url.replace(/\/$/, ""); // remove trailing slash
-        this.options = options;
-    }
-    async post(path, body) {
-        return await fetch(`${this.url}${path}`, {
-            method: "POST",
-            body: JSON.stringify(body),
-            headers: {
-                "Content-Type": "application/json",
-                ...this.options?.headers,
-            },
-            signal: AbortSignal.timeout(this.options?.timeout ?? 60000),
-        });
-    }
-    async invoke(input, options) {
-        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const response = await this.post("/invoke", {
-            input,
-            config: removeCallbacks(config),
-            kwargs: kwargs ?? {},
-        });
-        return revive((await response.json()).output);
-    }
-    async _batch(inputs, options, _, batchOptions) {
-        if (batchOptions?.returnExceptions) {
-            throw new Error("returnExceptions is not supported for remote clients");
-        }
-        const configsAndKwargsArray = options?.map((opts) => this._separateRunnableConfigFromCallOptions(opts));
-        const [configs, kwargs] = configsAndKwargsArray?.reduce(([pc, pk], [c, k]) => [
-            [...pc, c],
-            [...pk, k],
-        ], [[], []]) ?? [undefined, undefined];
-        const response = await this.post("/batch", {
-            inputs,
-            config: (configs ?? [])
-                .map(removeCallbacks)
-                .map((config) => ({ ...config, ...batchOptions })),
-            kwargs,
-        });
-        const body = await response.json();
-        if (!body.output)
-            throw new Error("Invalid response from remote runnable");
-        return revive(body.output);
-    }
-    async batch(inputs, options, batchOptions) {
-        if (batchOptions?.returnExceptions) {
-            throw Error("returnExceptions is not supported for remote clients");
-        }
-        return this._batchWithConfig(this._batch.bind(this), inputs, options, batchOptions);
-    }
-    async stream(input, options) {
-        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const response = await this.post("/stream", {
-            input,
-            config,
-            kwargs,
-        });
-        if (!response.ok) {
-            const json = await response.json();
-            const error = new Error(`RemoteRunnable call failed with status code ${response.status}: ${json.message}`);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            error.response = response;
-            throw error;
-        }
-        const { body } = response;
-        if (!body) {
-            throw new Error("Could not begin remote stream. Please check the given URL and try again.");
-        }
-        const stream = new ReadableStream({
-            async start(controller) {
-                const enqueueLine = getMessages((msg) => {
-                    if (msg.data)
-                        controller.enqueue(deserialize(msg.data));
-                });
-                const onLine = (line, fieldLength, flush) => {
-                    enqueueLine(line, fieldLength, flush);
-                    if (flush)
-                        controller.close();
-                };
-                await getBytes(body, getLines(onLine));
-            },
-        });
-        return IterableReadableStream.fromReadableStream(stream);
-    }
-    async *streamLog(input, options, streamOptions) {
-        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const stream = new LogStreamCallbackHandler({
-            ...streamOptions,
-            autoClose: false,
-        });
-        const { callbacks } = config;
-        if (callbacks === undefined) {
-            config.callbacks = [stream];
-        }
-        else if (Array.isArray(callbacks)) {
-            config.callbacks = callbacks.concat([stream]);
-        }
-        else {
-            const copiedCallbacks = callbacks.copy();
-            copiedCallbacks.inheritableHandlers.push(stream);
-            config.callbacks = copiedCallbacks;
-        }
-        // The type is in camelCase but the API only accepts snake_case.
-        const camelCaseStreamOptions = {
-            include_names: streamOptions?.includeNames,
-            include_types: streamOptions?.includeTypes,
-            include_tags: streamOptions?.includeTags,
-            exclude_names: streamOptions?.excludeNames,
-            exclude_types: streamOptions?.excludeTypes,
-            exclude_tags: streamOptions?.excludeTags,
-        };
-        const response = await this.post("/stream_log", {
-            input,
-            config,
-            kwargs,
-            ...camelCaseStreamOptions,
-            diff: false,
-        });
-        const { body } = response;
-        if (!body) {
-            throw new Error("Could not begin remote stream log. Please check the given URL and try again.");
-        }
-        const runnableStream = convertEventStreamToIterableReadableDataStream(body);
-        for await (const log of runnableStream) {
-            yield revive(JSON.parse(log));
-        }
-    }
-}
+export * from "@langchain/core/runnables/remote";

package/dist/stores/message/redis.cjs

@@ -17,5 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const entrypoint_deprecation_js_1 = require("../../util/entrypoint_deprecation.cjs");
 /* #__PURE__ */ (0, entrypoint_deprecation_js_1.logVersion010MigrationWarning)({
     oldEntrypointName: "stores/message/redis",
+    newEntrypointName: "",
+    newPackageName: "@langchain/redis",
 });
 __exportStar(require("@langchain/community/stores/message/redis"), exports);

package/dist/stores/message/redis.js

@@ -1,5 +1,7 @@
 import { logVersion010MigrationWarning } from "../../util/entrypoint_deprecation.js";
 /* #__PURE__ */ logVersion010MigrationWarning({
     oldEntrypointName: "stores/message/redis",
+    newEntrypointName: "",
+    newPackageName: "@langchain/redis",
 });
 export * from "@langchain/community/stores/message/redis";

package/dist/util/migrations/0_0-0_1-migrate-imports.cjs

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateEntrypointsFrom0_0_xTo0_1_x = void 0;
+const ts_morph_1 = require("ts-morph");
+const glob_1 = require("glob");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * @param {string} packagePath
+ * @param {Project} project
+ * @returns {Array<EntrypointAndSymbols> }
+ */
+async function getEntrypointsFromFile(packagePath, project) {
+    // @TODO replace any with LangChainConfig from `@langchain/scripts`
+    const { config } = await import(node_path_1.default.join(packagePath, "langchain.config.js"));
+    const { entrypoints, deprecatedNodeOnly } = config;
+    const result = Object.entries(entrypoints).flatMap(([key, value]) => {
+        if (deprecatedNodeOnly.includes(key)) {
+            return [];
+        }
+        const newFile = project.addSourceFileAtPath(node_path_1.default.join(packagePath, "src", `${value}.ts`));
+        const exportedSymbolsMap = newFile.getExportedDeclarations();
+        const exportedSymbols = Array.from(exportedSymbolsMap.entries()).map(([symbol, declarations]) => ({
+            kind: declarations[0].getKind(),
+            symbol,
+        }));
+        return {
+            entrypoint: key,
+            exportedSymbols,
+        };
+    });
+    return result;
+}
+/**
+ * Finds a matching symbol in the array of exported symbols.
+ * @param {{ symbol: string, kind: SyntaxKind }} target - The target symbol and its kind to find.
+ * @param {Array<EntrypointAndSymbols>} exportedSymbols - The array of exported symbols to search.
+ * @param {string} packageSuffix - The suffix of the package to import from. Eg, core
+ * @returns {{ entrypoint: string, foundSymbol: string } | undefined} The matching symbol or undefined if not found.
+ */
+function findMatchingSymbol(target, exportedSymbols, packageSuffix) {
+    for (const entry of exportedSymbols) {
+        const foundSymbol = entry.exportedSymbols.find(({ symbol, kind }) => symbol === target.symbol && kind === target.kind);
+        if (foundSymbol) {
+            return {
+                entrypoint: entry.entrypoint,
+                foundSymbol: foundSymbol.symbol,
+                packageSuffix,
+            }; // Return the matching entry object
+        }
+    }
+    return undefined;
+}
+/**
+ * @param {Array<EntrypointAndSymbols>} entrypoints
+ * @returns {Array<EntrypointAndSymbols>}
+ */
+function removeLoad(entrypoints) {
+    return entrypoints.flatMap((entrypoint) => {
+        const newEntrypoint = entrypoint.entrypoint === "index" ? "" : `/${entrypoint.entrypoint}`;
+        const withoutLoadOrIndex = entrypoint.exportedSymbols.filter((item) => {
+            if (item.symbol === "load" && newEntrypoint === "load") {
+                return false;
+            }
+            return true;
+        });
+        return {
+            entrypoint: newEntrypoint,
+            exportedSymbols: withoutLoadOrIndex,
+        };
+    });
+}
+function updateImport({ matchingSymbols, namedImport, projectFile, namedImportText, }) {
+    const firstMatchingSymbol = matchingSymbols.find((matchingSymbol) => matchingSymbol);
+    if (firstMatchingSymbol) {
+        console.debug(`Found matching symbol in the "@langchain/${firstMatchingSymbol.packageSuffix}" package.`, {
+            matchingSymbol: firstMatchingSymbol,
+        });
+        namedImport.remove();
+        projectFile.addImportDeclaration({
+            moduleSpecifier: `@langchain/${firstMatchingSymbol.packageSuffix}${firstMatchingSymbol.entrypoint}`,
+            namedImports: [namedImportText],
+        });
+        return true;
+    }
+    return false;
+}
+/**
+ * Find imports from deprecated pre 0.1 LangChain modules and update them to import
+ * from the new LangChain packages.
+ */
+async function updateEntrypointsFrom0_0_xTo0_1_x({ localLangChainPath, codePath, customGlobPattern, customIgnorePattern, skipCheck, }) {
+    const project = new ts_morph_1.Project();
+    const langchainCorePackageEntrypoints = removeLoad(await getEntrypointsFromFile(node_path_1.default.join(localLangChainPath, "langchain-core"), project));
+    const langchainCommunityPackageEntrypoints = removeLoad(await getEntrypointsFromFile(node_path_1.default.join(localLangChainPath, "libs", "langchain-community"), project));
+    const langchainOpenAIPackageEntrypoints = removeLoad(await getEntrypointsFromFile(node_path_1.default.join(localLangChainPath, "libs", "langchain-openai"), project));
+    const langchainCoherePackageEntrypoints = !skipCheck?.includes("cohere" /* UpgradingModule.COHERE */)
+        ? removeLoad(await getEntrypointsFromFile(node_path_1.default.join(localLangChainPath, "libs", "langchain-cohere"), project))
+        : null;
+    const langchainPineconePackageEntrypoints = !skipCheck?.includes("pinecone" /* UpgradingModule.PINECONE */)
+        ? removeLoad(await getEntrypointsFromFile(node_path_1.default.join(localLangChainPath, "libs", "langchain-pinecone"), project))
+        : null;
+    const globPattern = customGlobPattern || "/**/*.ts";
+    const ignorePattern = customIgnorePattern;
+    const allCodebaseFiles = (await (0, glob_1.glob)(node_path_1.default.join(codePath, globPattern), {
+        ignore: ignorePattern,
+    }))
+        .map((filePath) => node_path_1.default.resolve(filePath))
+        .filter((filePath) => !filePath.includes("node_modules/"));
+    for await (const filePath of allCodebaseFiles) {
+        let projectFile;
+        try {
+            projectFile = project.addSourceFileAtPath(filePath);
+            if (!projectFile) {
+                throw new Error(`Failed to add source file at path: ${filePath}`);
+            }
+        }
+        catch (error) {
+            console.error({
+                filePath,
+                error,
+            }, "Error occurred while trying to add source file. Continuing");
+            return;
+        }
+        try {
+            const imports = projectFile.getImportDeclarations();
+            imports.forEach((importItem) => {
+                // Get all imports
+                const module = importItem.getModuleSpecifierValue();
+                // Get only the named imports. Eg: import { foo } from "langchain/util";
+                const namedImports = importItem.getNamedImports();
+                if (!module.startsWith("langchain/")) {
+                    return;
+                }
+                // look at each import and see if it exists in
+                let didUpdate = false;
+                namedImports.forEach((namedImport) => {
+                    const namedImportText = namedImport.getText();
+                    let namedImportKind = null;
+                    const symbol = namedImport.getSymbol();
+                    if (symbol) {
+                        // Resolve alias symbol to its original symbol
+                        const aliasedSymbol = symbol.getAliasedSymbol() || symbol;
+                        // Get the original declarations of the symbol
+                        const declarations = aliasedSymbol.getDeclarations();
+                        if (declarations.length > 0) {
+                            // Assuming the first declaration is the original one
+                            const originalDeclarationKind = declarations[0].getKind();
+                            namedImportKind = originalDeclarationKind;
+                        }
+                    }
+                    // If we couldn't find the kind of the named imports kind, skip it
+                    if (!namedImportKind) {
+                        return;
+                    }
+                    const matchingSymbolCore = findMatchingSymbol({ symbol: namedImportText, kind: namedImportKind }, langchainCorePackageEntrypoints, "core");
+                    const matchingSymbolCommunity = findMatchingSymbol({ symbol: namedImportText, kind: namedImportKind }, langchainCommunityPackageEntrypoints, "community");
+                    const matchingSymbolOpenAI = findMatchingSymbol({ symbol: namedImportText, kind: namedImportKind }, langchainOpenAIPackageEntrypoints, "openai");
+                    const matchingSymbolCohere = langchainCoherePackageEntrypoints
+                        ? findMatchingSymbol({ symbol: namedImportText, kind: namedImportKind }, langchainCoherePackageEntrypoints, "cohere")
+                        : undefined;
+                    const matchingSymbolPinecone = langchainPineconePackageEntrypoints
+                        ? findMatchingSymbol({ symbol: namedImportText, kind: namedImportKind }, langchainPineconePackageEntrypoints, "pinecone")
+                        : undefined;
+                    didUpdate = updateImport({
+                        matchingSymbols: [
+                            matchingSymbolCore,
+                            matchingSymbolOpenAI,
+                            matchingSymbolCohere,
+                            matchingSymbolPinecone,
+                            matchingSymbolCommunity,
+                        ],
+                        namedImport,
+                        projectFile,
+                        namedImportText,
+                    });
+                });
+                if (didUpdate) {
+                    projectFile.saveSync();
+                    // Check if all named imports were removed, and only a file import remains.
+                    // eg: import { foo } from "langchain/anthropic"; -> import "langchain/anthropic";
+                    // if so, remove the import entirely
+                    const importClause = importItem.getImportClause();
+                    if (!importClause ||
+                        (!importClause.getDefaultImport() &&
+                            importClause.getNamedImports().length === 0)) {
+                        importItem.remove();
+                        projectFile.saveSync();
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error({
+                filePath,
+                error,
+            }, "Error occurred while trying to read file. Continuing");
+        }
+        // Remove source file from the project after we're done with it
+        // to prevent OOM errors.
+        if (projectFile) {
+            project.removeSourceFile(projectFile);
+        }
+    }
+}
+exports.updateEntrypointsFrom0_0_xTo0_1_x = updateEntrypointsFrom0_0_xTo0_1_x;

package/dist/util/migrations/0_0-0_1-migrate-imports.d.ts

@@ -0,0 +1,44 @@
+declare const enum UpgradingModule {
+    COHERE = "cohere",
+    PINECONE = "pinecone"
+}
+/**
+ * Find imports from deprecated pre 0.1 LangChain modules and update them to import
+ * from the new LangChain packages.
+ */
+export declare function updateEntrypointsFrom0_0_xTo0_1_x({ localLangChainPath, codePath, customGlobPattern, customIgnorePattern, skipCheck, }: {
+    /**
+     * The absolute path to the locally cloned LangChain repo root.
+     * @example "/Users/username/code/langchainjs"
+     */
+    localLangChainPath: string;
+    /**
+     * The absolute path to the source directory of the codebase to update.
+     * @example "/Users/username/code/my-project/src"
+     */
+    codePath: string;
+    /**
+     * Optionally, pass in a custom glob pattern to match files.
+     * The backslash included in the example and default is only for
+     * JSDoc to escape the asterisk. Do not include unless intentionally.
+     * @example "/*.d.ts"
+     * @default "**\/*.ts"
+     */
+    customGlobPattern?: string;
+    /**
+     * A custom ignore pattern for ignoring files.
+     * The backslash included in the example and default is only for
+     * JSDoc to escape the asterisk. Do not include unless intentionally.
+     * @example ["**\/node_modules/**", "**\/dist/**", "**\/*.d.ts"]
+     * @default node_modules/**
+     */
+    customIgnorePattern?: string[] | string;
+    /**
+     * Optionally skip checking the passed modules for imports to
+     * update.
+     * @example [UpgradingModule.COHERE]
+     * @default undefined
+     */
+    skipCheck?: Array<UpgradingModule>;
+}): Promise<void>;
+export {};