langchain 0.0.164 → 0.0.166

package/dist/runnables/remote.cjs

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteRunnable = void 0;
+const index_js_1 = require("../schema/runnable/index.cjs");
+const event_source_parse_js_1 = require("../util/event-source-parse.cjs");
+const document_js_1 = require("../document.cjs");
+const index_js_2 = require("../schema/index.cjs");
+const base_js_1 = require("../prompts/base.cjs");
+const chat_js_1 = require("../prompts/chat.cjs");
+const stream_js_1 = require("../util/stream.cjs");
+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") {
+        const keysArr = Object.keys(obj);
+        const keys = new Set(keysArr);
+        if (isSuperset(keys, new Set(["page_content", "metadata"])))
+            return new document_js_1.Document({
+                pageContent: obj.page_content,
+                metadata: obj.metadata,
+            });
+        if (isSuperset(keys, new Set(["content", "type", "is_chunk"]))) {
+            if (!obj.is_chunk) {
+                if (obj.type === "human") {
+                    return new index_js_2.HumanMessage({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "system") {
+                    return new index_js_2.SystemMessage({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "chat") {
+                    return new index_js_2.ChatMessage({
+                        content: obj.content,
+                        role: obj.role,
+                    });
+                }
+                if (obj.type === "function") {
+                    return new index_js_2.FunctionMessage({
+                        content: obj.content,
+                        name: obj.name,
+                    });
+                }
+                if (obj.type === "ai") {
+                    return new index_js_2.AIMessage({
+                        content: obj.content,
+                    });
+                }
+            }
+            else {
+                if (obj.type === "human") {
+                    return new index_js_2.HumanMessageChunk({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "system") {
+                    return new index_js_2.SystemMessageChunk({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "chat") {
+                    return new index_js_2.ChatMessageChunk({
+                        content: obj.content,
+                        role: obj.role,
+                    });
+                }
+                if (obj.type === "function") {
+                    return new index_js_2.FunctionMessageChunk({
+                        content: obj.content,
+                        name: obj.name,
+                    });
+                }
+                if (obj.type === "ai") {
+                    return new index_js_2.AIMessageChunk({
+                        content: obj.content,
+                    });
+                }
+            }
+        }
+        if (isSuperset(keys, new Set(["text"]))) {
+            return new base_js_1.StringPromptValue(obj.text);
+        }
+        if (isSuperset(keys, new Set(["messages"]))) {
+            return new chat_js_1.ChatPromptValue({
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                messages: obj.messages.map((msg) => revive(msg)),
+            });
+        }
+        // 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;
+}
+class RemoteRunnable extends index_js_1.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",
+            },
+            signal: AbortSignal.timeout(this.options?.timeout ?? 5000),
+        });
+    }
+    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 = (0, event_source_parse_js_1.getMessages)((msg) => {
+                    if (msg.data)
+                        controller.enqueue(deserialize(msg.data));
+                });
+                const onLine = (line, fieldLength, flush) => {
+                    enqueueLine(line, fieldLength, flush);
+                    if (flush)
+                        controller.close();
+                };
+                await (0, event_source_parse_js_1.getBytes)(body, (0, event_source_parse_js_1.getLines)(onLine));
+            },
+        });
+        return stream_js_1.IterableReadableStream.fromReadableStream(stream);
+    }
+}
+exports.RemoteRunnable = RemoteRunnable;

package/dist/runnables/remote.d.ts

@@ -0,0 +1,28 @@
+import { Runnable, RunnableBatchOptions } from "../schema/runnable/index.js";
+import { RunnableConfig } from "../schema/runnable/config.js";
+import { CallbackManagerForChainRun } from "../callbacks/manager.js";
+import { IterableReadableStream } from "../util/stream.js";
+type RemoteRunnableOptions = {
+    timeout?: number;
+};
+export declare class RemoteRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
+    private url;
+    private options?;
+    lc_namespace: string[];
+    constructor(fields: {
+        url: string;
+        options?: RemoteRunnableOptions;
+    });
+    private post;
+    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
+    _batch(inputs: RunInput[], options?: Partial<CallOptions>[], _?: (CallbackManagerForChainRun | undefined)[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<RunOutput>>;
+}
+export {};

package/dist/runnables/remote.js

@@ -0,0 +1,221 @@
+import { Runnable } from "../schema/runnable/index.js";
+import { getBytes, getLines, getMessages } from "../util/event-source-parse.js";
+import { Document } from "../document.js";
+import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, } from "../schema/index.js";
+import { StringPromptValue } from "../prompts/base.js";
+import { ChatPromptValue } from "../prompts/chat.js";
+import { IterableReadableStream } from "../util/stream.js";
+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") {
+        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", "is_chunk"]))) {
+            if (!obj.is_chunk) {
+                if (obj.type === "human") {
+                    return new HumanMessage({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "system") {
+                    return new SystemMessage({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "chat") {
+                    return new ChatMessage({
+                        content: obj.content,
+                        role: obj.role,
+                    });
+                }
+                if (obj.type === "function") {
+                    return new FunctionMessage({
+                        content: obj.content,
+                        name: obj.name,
+                    });
+                }
+                if (obj.type === "ai") {
+                    return new AIMessage({
+                        content: obj.content,
+                    });
+                }
+            }
+            else {
+                if (obj.type === "human") {
+                    return new HumanMessageChunk({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "system") {
+                    return new SystemMessageChunk({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "chat") {
+                    return new ChatMessageChunk({
+                        content: obj.content,
+                        role: obj.role,
+                    });
+                }
+                if (obj.type === "function") {
+                    return new FunctionMessageChunk({
+                        content: obj.content,
+                        name: obj.name,
+                    });
+                }
+                if (obj.type === "ai") {
+                    return new AIMessageChunk({
+                        content: obj.content,
+                    });
+                }
+            }
+        }
+        if (isSuperset(keys, new Set(["text"]))) {
+            return new StringPromptValue(obj.text);
+        }
+        if (isSuperset(keys, new Set(["messages"]))) {
+            return new ChatPromptValue({
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                messages: obj.messages.map((msg) => revive(msg)),
+            });
+        }
+        // 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",
+            },
+            signal: AbortSignal.timeout(this.options?.timeout ?? 5000),
+        });
+    }
+    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);
+    }
+}

package/dist/schema/index.cjs

@@ -323,7 +323,7 @@ class ChatMessage extends BaseMessage {
 }
 exports.ChatMessage = ChatMessage;
 function isBaseMessage(messageLike) {
-    return typeof messageLike._getType === "function";
+    return typeof messageLike?._getType === "function";
 }
 exports.isBaseMessage = isBaseMessage;
 function coerceMessageLikeToMessage(messageLike) {

package/dist/schema/index.d.ts

@@ -218,7 +218,7 @@ export type BaseMessageLike = BaseMessage | [
     MessageType | "user" | "assistant" | (string & Record<never, never>),
     string
 ] | string;
-export declare function isBaseMessage(messageLike: BaseMessageLike): messageLike is BaseMessage;
+export declare function isBaseMessage(messageLike?: unknown): messageLike is BaseMessage;
 export declare function coerceMessageLikeToMessage(messageLike: BaseMessageLike): BaseMessage;
 /**
  * Represents a chunk of a chat message, which can be concatenated with

package/dist/schema/index.js

@@ -308,7 +308,7 @@ export class ChatMessage extends BaseMessage {
     }
 }
 export function isBaseMessage(messageLike) {
-    return typeof messageLike._getType === "function";
+    return typeof messageLike?._getType === "function";
 }
 export function coerceMessageLikeToMessage(messageLike) {
     if (typeof messageLike === "string") {

package/dist/schema/runnable/base.cjs

@@ -176,12 +176,12 @@ class Runnable extends serializable_js_1.Serializable {
      * @returns A promise that resolves to the output values.
      */
     async _batchWithConfig(func, inputs, options, batchOptions) {
-        const configs = this._getOptionsList((options ?? {}), inputs.length);
-        const callbackManagers = await Promise.all(configs.map(config_js_1.getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, configs[i].runType, undefined, undefined, configs[i].runName)));
+        const optionsList = this._getOptionsList(options ?? {}, inputs.length);
+        const callbackManagers = await Promise.all(optionsList.map(config_js_1.getCallbackMangerForConfig));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName)));
         let outputs;
         try {
-            outputs = await func(inputs, configs, runManagers, batchOptions);
+            outputs = await func(inputs, optionsList, runManagers, batchOptions);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));

package/dist/schema/runnable/base.d.ts

@@ -12,9 +12,6 @@ export type RunnableBatchOptions = {
     returnExceptions?: boolean;
 };
 export type RunnableRetryFailedAttemptHandler = (error: any) => any;
-type RunnableConfigAndOptions = RunnableConfig & {
-    runType?: string;
-};
 /**
  * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
  * transformed.
@@ -91,7 +88,9 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      */
     stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<RunOutput>>;
     protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, Omit<Partial<CallOptions>, keyof RunnableConfig>];
-    protected _callWithConfig<T extends RunInput>(func: ((input: T) => Promise<RunOutput>) | ((input: T, config?: RunnableConfig, runManager?: CallbackManagerForChainRun) => Promise<RunOutput>), input: T, options?: RunnableConfigAndOptions): Promise<RunOutput>;
+    protected _callWithConfig<T extends RunInput>(func: ((input: T) => Promise<RunOutput>) | ((input: T, config?: Partial<CallOptions>, runManager?: CallbackManagerForChainRun) => Promise<RunOutput>), input: T, options?: Partial<CallOptions> & {
+        runType?: string;
+    }): Promise<RunOutput>;
     /**
      * Internal method that handles batching and configuration for a runnable
      * It takes a function, input values, and optional configuration, and
@@ -101,13 +100,17 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * @param config Optional configuration for the function execution.
      * @returns A promise that resolves to the output values.
      */
-    _batchWithConfig<T extends RunInput>(func: (inputs: T[], configs?: RunnableConfig[], runManagers?: (CallbackManagerForChainRun | undefined)[], batchOptions?: RunnableBatchOptions) => Promise<(RunOutput | Error)[]>, inputs: T[], options?: Partial<RunnableConfigAndOptions> | Partial<RunnableConfigAndOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    _batchWithConfig<T extends RunInput>(func: (inputs: T[], options?: Partial<CallOptions>[], runManagers?: (CallbackManagerForChainRun | undefined)[], batchOptions?: RunnableBatchOptions) => Promise<(RunOutput | Error)[]>, inputs: T[], options?: Partial<CallOptions & {
+        runType?: string;
+    }> | Partial<CallOptions & {
+        runType?: string;
+    }>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     /**
      * Helper method to transform an Iterator of Input values into an Iterator of
      * Output values, with callbacks.
      * Use this to implement `stream()` or `transform()` in Runnable subclasses.
      */
-    protected _transformStreamWithConfig<I extends RunInput, O extends RunOutput>(inputGenerator: AsyncGenerator<I>, transformer: (generator: AsyncGenerator<I>, runManager?: CallbackManagerForChainRun, options?: Partial<RunnableConfig>) => AsyncGenerator<O>, options?: RunnableConfig & {
+    protected _transformStreamWithConfig<I extends RunInput, O extends RunOutput>(inputGenerator: AsyncGenerator<I>, transformer: (generator: AsyncGenerator<I>, runManager?: CallbackManagerForChainRun, options?: Partial<CallOptions>) => AsyncGenerator<O>, options?: CallOptions & {
         runType?: string;
     }): AsyncGenerator<O>;
     _patchConfig(config?: Partial<CallOptions>, callbackManager?: CallbackManager | undefined): Partial<CallOptions>;
@@ -330,4 +333,3 @@ export declare class RunnableWithFallbacks<RunInput, RunOutput> extends Runnable
     batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
 }
 export declare function _coerceToRunnable<RunInput, RunOutput>(coerceable: RunnableLike<RunInput, RunOutput>): Runnable<RunInput, Exclude<RunOutput, Error>>;
-export {};

package/dist/schema/runnable/base.js

@@ -170,12 +170,12 @@ export class Runnable extends Serializable {
      * @returns A promise that resolves to the output values.
      */
     async _batchWithConfig(func, inputs, options, batchOptions) {
-        const configs = this._getOptionsList((options ?? {}), inputs.length);
-        const callbackManagers = await Promise.all(configs.map(getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, configs[i].runType, undefined, undefined, configs[i].runName)));
+        const optionsList = this._getOptionsList(options ?? {}, inputs.length);
+        const callbackManagers = await Promise.all(optionsList.map(getCallbackMangerForConfig));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName)));
         let outputs;
         try {
-            outputs = await func(inputs, configs, runManagers, batchOptions);
+            outputs = await func(inputs, optionsList, runManagers, batchOptions);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));