@langchain/core 0.1.23 → 0.1.24

package/dist/runnables/remote.js

@@ -0,0 +1,374 @@
+import { Runnable } from "./base.js";
+import { Document } from "../documents/index.js";
+import { ChatPromptValue, StringPromptValue } from "../prompt_values.js";
+import { LogStreamCallbackHandler, } from "../tracers/log_stream.js";
+import { AIMessage, AIMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, isBaseMessage, } from "../messages/index.js";
+import { GenerationChunk, ChatGenerationChunk, RUN_KEY } from "../outputs.js";
+import { getBytes, getLines, getMessages, convertEventStreamToIterableReadableDataStream, } from "../utils/event_source_parse.js";
+import { IterableReadableStream } from "../utils/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") {
+        // 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;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function serialize(input) {
+    if (Array.isArray(input))
+        return input.map(serialize);
+    if (isBaseMessage(input)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const serializedMessage = {
+            content: input.content,
+            type: input._getType(),
+            additional_kwargs: input.additional_kwargs,
+            name: input.name,
+            example: false,
+        };
+        if (ToolMessage.isInstance(input)) {
+            serializedMessage.tool_call_id = input.tool_call_id;
+        }
+        else if (ChatMessage.isInstance(input)) {
+            serializedMessage.role = input.role;
+        }
+        return serializedMessage;
+    }
+    if (typeof input === "object") {
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!input || input instanceof Date) {
+            return input;
+        }
+        const keysArr = Object.keys(input);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const innerSerialize = (key) => [
+            key,
+            serialize(input[key]),
+        ];
+        const rtn = Object.fromEntries(keysArr.map(innerSerialize));
+        return rtn;
+    }
+    return input;
+}
+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 fetch(`${this.url}${path}`, {
+            method: "POST",
+            body: JSON.stringify(serialize(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: removeCallbacks(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: removeCallbacks(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));
+        }
+    }
+}

package/dist/utils/event_source_parse.cjs

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertEventStreamToIterableReadableDataStream = exports.getMessages = exports.getLines = exports.getBytes = exports.EventStreamContentType = void 0;
+const stream_js_1 = require("./stream.cjs");
+exports.EventStreamContentType = "text/event-stream";
+function isNodeJSReadable(x) {
+    return x != null && typeof x === "object" && "on" in x;
+}
+/**
+ * Converts a ReadableStream into a callback pattern.
+ * @param stream The input ReadableStream.
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
+ */
+async function getBytes(stream, onChunk) {
+    // stream is a Node.js Readable / PassThrough stream
+    // this can happen if node-fetch is polyfilled
+    if (isNodeJSReadable(stream)) {
+        return new Promise((resolve) => {
+            stream.on("readable", () => {
+                let chunk;
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    chunk = stream.read();
+                    if (chunk == null) {
+                        onChunk(new Uint8Array(), true);
+                        break;
+                    }
+                    onChunk(chunk);
+                }
+                resolve();
+            });
+        });
+    }
+    const reader = stream.getReader();
+    // CHANGED: Introduced a "flush" mechanism to process potential pending messages when the stream ends.
+    //          This change is essential to ensure that we capture every last piece of information from streams,
+    //          such as those from Azure OpenAI, which may not terminate with a blank line. Without this
+    //          mechanism, we risk ignoring a possibly significant last message.
+    //          See https://github.com/langchain-ai/langchainjs/issues/1299 for details.
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const result = await reader.read();
+        if (result.done) {
+            onChunk(new Uint8Array(), true);
+            break;
+        }
+        onChunk(result.value);
+    }
+}
+exports.getBytes = getBytes;
+/**
+ * Parses arbitary byte chunks into EventSource line buffers.
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
+ * @param onLine A function that will be called on each new EventSource line.
+ * @returns A function that should be called for each incoming byte chunk.
+ */
+function getLines(onLine) {
+    let buffer;
+    let position; // current read position
+    let fieldLength; // length of the `field` portion of the line
+    let discardTrailingNewline = false;
+    // return a function that can process each incoming byte chunk:
+    return function onChunk(arr, flush) {
+        if (flush) {
+            onLine(arr, 0, true);
+            return;
+        }
+        if (buffer === undefined) {
+            buffer = arr;
+            position = 0;
+            fieldLength = -1;
+        }
+        else {
+            // we're still parsing the old line. Append the new bytes into buffer:
+            buffer = concat(buffer, arr);
+        }
+        const bufLength = buffer.length;
+        let lineStart = 0; // index where the current line starts
+        while (position < bufLength) {
+            if (discardTrailingNewline) {
+                if (buffer[position] === 10 /* ControlChars.NewLine */) {
+                    lineStart = ++position; // skip to next char
+                }
+                discardTrailingNewline = false;
+            }
+            // start looking forward till the end of line:
+            let lineEnd = -1; // index of the \r or \n char
+            for (; position < bufLength && lineEnd === -1; ++position) {
+                switch (buffer[position]) {
+                    case 58 /* ControlChars.Colon */:
+                        if (fieldLength === -1) {
+                            // first colon in line
+                            fieldLength = position - lineStart;
+                        }
+                        break;
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore:7029 \r case below should fallthrough to \n:
+                    case 13 /* ControlChars.CarriageReturn */:
+                        discardTrailingNewline = true;
+                    // eslint-disable-next-line no-fallthrough
+                    case 10 /* ControlChars.NewLine */:
+                        lineEnd = position;
+                        break;
+                }
+            }
+            if (lineEnd === -1) {
+                // We reached the end of the buffer but the line hasn't ended.
+                // Wait for the next arr and then continue parsing:
+                break;
+            }
+            // we've reached the line end, send it out:
+            onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+            lineStart = position; // we're now on the next line
+            fieldLength = -1;
+        }
+        if (lineStart === bufLength) {
+            buffer = undefined; // we've finished reading it
+        }
+        else if (lineStart !== 0) {
+            // Create a new view into buffer beginning at lineStart so we don't
+            // need to copy over the previous lines when we get the new arr:
+            buffer = buffer.subarray(lineStart);
+            position -= lineStart;
+        }
+    };
+}
+exports.getLines = getLines;
+/**
+ * Parses line buffers into EventSourceMessages.
+ * @param onId A function that will be called on each `id` field.
+ * @param onRetry A function that will be called on each `retry` field.
+ * @param onMessage A function that will be called on each message.
+ * @returns A function that should be called for each incoming line buffer.
+ */
+function getMessages(onMessage, onId, onRetry) {
+    let message = newMessage();
+    const decoder = new TextDecoder();
+    // return a function that can process each incoming line buffer:
+    return function onLine(line, fieldLength, flush) {
+        if (flush) {
+            if (!isEmpty(message)) {
+                onMessage?.(message);
+                message = newMessage();
+            }
+            return;
+        }
+        if (line.length === 0) {
+            // empty line denotes end of message. Trigger the callback and start a new message:
+            onMessage?.(message);
+            message = newMessage();
+        }
+        else if (fieldLength > 0) {
+            // exclude comments and lines with no values
+            // line is of format "<field>:<value>" or "<field>: <value>"
+            // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+            const field = decoder.decode(line.subarray(0, fieldLength));
+            const valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* ControlChars.Space */ ? 2 : 1);
+            const value = decoder.decode(line.subarray(valueOffset));
+            switch (field) {
+                case "data":
+                    // if this message already has data, append the new value to the old.
+                    // otherwise, just set to the new value:
+                    message.data = message.data ? message.data + "\n" + value : value; // otherwise,
+                    break;
+                case "event":
+                    message.event = value;
+                    break;
+                case "id":
+                    onId?.((message.id = value));
+                    break;
+                case "retry": {
+                    const retry = parseInt(value, 10);
+                    if (!Number.isNaN(retry)) {
+                        // per spec, ignore non-integers
+                        onRetry?.((message.retry = retry));
+                    }
+                    break;
+                }
+            }
+        }
+    };
+}
+exports.getMessages = getMessages;
+function concat(a, b) {
+    const res = new Uint8Array(a.length + b.length);
+    res.set(a);
+    res.set(b, a.length);
+    return res;
+}
+function newMessage() {
+    // data, event, and id must be initialized to empty strings:
+    // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+    // retry should be initialized to undefined so we return a consistent shape
+    // to the js engine all the time: https://mathiasbynens.be/notes/shapes-ics#takeaways
+    return {
+        data: "",
+        event: "",
+        id: "",
+        retry: undefined,
+    };
+}
+function convertEventStreamToIterableReadableDataStream(stream) {
+    const dataStream = new ReadableStream({
+        async start(controller) {
+            const enqueueLine = getMessages((msg) => {
+                if (msg.data)
+                    controller.enqueue(msg.data);
+            });
+            const onLine = (line, fieldLength, flush) => {
+                enqueueLine(line, fieldLength, flush);
+                if (flush)
+                    controller.close();
+            };
+            await getBytes(stream, getLines(onLine));
+        },
+    });
+    return stream_js_1.IterableReadableStream.fromReadableStream(dataStream);
+}
+exports.convertEventStreamToIterableReadableDataStream = convertEventStreamToIterableReadableDataStream;
+function isEmpty(message) {
+    return (message.data === "" &&
+        message.event === "" &&
+        message.id === "" &&
+        message.retry === undefined);
+}

package/dist/utils/event_source_parse.d.ts

@@ -0,0 +1,39 @@
+import { IterableReadableStream } from "./stream.js";
+export declare const EventStreamContentType = "text/event-stream";
+/**
+ * Represents a message sent in an event stream
+ * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format
+ */
+export interface EventSourceMessage {
+    /** The event ID to set the EventSource object's last event ID value. */
+    id: string;
+    /** A string identifying the type of event described. */
+    event: string;
+    /** The event data */
+    data: string;
+    /** The reconnection interval (in milliseconds) to wait before retrying the connection */
+    retry?: number;
+}
+/**
+ * Converts a ReadableStream into a callback pattern.
+ * @param stream The input ReadableStream.
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
+ */
+export declare function getBytes(stream: ReadableStream<Uint8Array>, onChunk: (arr: Uint8Array, flush?: boolean) => void): Promise<void>;
+/**
+ * Parses arbitary byte chunks into EventSource line buffers.
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
+ * @param onLine A function that will be called on each new EventSource line.
+ * @returns A function that should be called for each incoming byte chunk.
+ */
+export declare function getLines(onLine: (line: Uint8Array, fieldLength: number, flush?: boolean) => void): (arr: Uint8Array, flush?: boolean) => void;
+/**
+ * Parses line buffers into EventSourceMessages.
+ * @param onId A function that will be called on each `id` field.
+ * @param onRetry A function that will be called on each `retry` field.
+ * @param onMessage A function that will be called on each message.
+ * @returns A function that should be called for each incoming line buffer.
+ */
+export declare function getMessages(onMessage?: (msg: EventSourceMessage) => void, onId?: (id: string) => void, onRetry?: (retry: number) => void): (line: Uint8Array, fieldLength: number, flush?: boolean) => void;
+export declare function convertEventStreamToIterableReadableDataStream(stream: ReadableStream): IterableReadableStream<any>;