@langchain/core 0.1.23 → 0.1.24

package/dist/messages/index.cjs

@@ -348,6 +348,9 @@ class ToolMessage extends BaseMessage {
     _getType() {
         return "tool";
     }
+    static isInstance(message) {
+        return message._getType() === "tool";
+    }
 }
 exports.ToolMessage = ToolMessage;
 /**

package/dist/messages/index.d.ts

@@ -195,6 +195,7 @@ export declare class ToolMessage extends BaseMessage {
     constructor(fields: ToolMessageFieldsWithToolCallId);
     constructor(fields: string | BaseMessageFields, tool_call_id: string, name?: string);
     _getType(): MessageType;
+    static isInstance(message: BaseMessage): message is ToolMessage;
 }
 /**
  * Represents a chunk of a tool message, which can be concatenated

package/dist/messages/index.js

@@ -335,6 +335,9 @@ export class ToolMessage extends BaseMessage {
     _getType() {
         return "tool";
     }
+    static isInstance(message) {
+        return message._getType() === "tool";
+    }
 }
 /**
  * Represents a chunk of a tool message, which can be concatenated

package/dist/prompts/image.cjs

@@ -13,6 +13,12 @@ class ImagePromptTemplate extends base_js_1.BasePromptTemplate {
     }
     constructor(input) {
         super(input);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "prompts", "image"]
+        });
         Object.defineProperty(this, "template", {
             enumerable: true,
             configurable: true,

package/dist/prompts/image.d.ts

@@ -29,6 +29,7 @@ export interface ImagePromptTemplateInput<RunInput extends InputValues = any, Pa
  */
 export declare class ImagePromptTemplate<RunInput extends InputValues = any, PartialVariableName extends string = any> extends BasePromptTemplate<RunInput, ImagePromptValue, PartialVariableName> {
     static lc_name(): string;
+    lc_namespace: string[];
     template: Record<string, unknown>;
     templateFormat: TemplateFormat;
     validateTemplate: boolean;

package/dist/prompts/image.js

@@ -10,6 +10,12 @@ export class ImagePromptTemplate extends BasePromptTemplate {
     }
     constructor(input) {
         super(input);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "prompts", "image"]
+        });
         Object.defineProperty(this, "template", {
             enumerable: true,
             configurable: true,

package/dist/prompts/index.cjs

@@ -22,3 +22,4 @@ __exportStar(require("./prompt.cjs"), exports);
 __exportStar(require("./serde.cjs"), exports);
 __exportStar(require("./string.cjs"), exports);
 __exportStar(require("./template.cjs"), exports);
+__exportStar(require("./image.cjs"), exports);

package/dist/prompts/index.d.ts

@@ -6,3 +6,4 @@ export * from "./prompt.js";
 export * from "./serde.js";
 export * from "./string.js";
 export * from "./template.js";
+export * from "./image.js";

package/dist/prompts/index.js

@@ -6,3 +6,4 @@ export * from "./prompt.js";
 export * from "./serde.js";
 export * from "./string.js";
 export * from "./template.js";
+export * from "./image.js";

package/dist/runnables/remote.cjs

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteRunnable = void 0;
+const base_js_1 = require("./base.cjs");
+const index_js_1 = require("../documents/index.cjs");
+const prompt_values_js_1 = require("../prompt_values.cjs");
+const log_stream_js_1 = require("../tracers/log_stream.cjs");
+const index_js_2 = require("../messages/index.cjs");
+const outputs_js_1 = require("../outputs.cjs");
+const event_source_parse_js_1 = require("../utils/event_source_parse.cjs");
+const stream_js_1 = require("../utils/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") {
+        // 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 index_js_1.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 index_js_2.HumanMessage({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "SystemMessage" || obj.type === "system") {
+                return new index_js_2.SystemMessage({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "ChatMessage" || obj.type === "chat") {
+                return new index_js_2.ChatMessage({
+                    content: obj.content,
+                    role: obj.role,
+                });
+            }
+            if (obj.type === "FunctionMessage" || obj.type === "function") {
+                return new index_js_2.FunctionMessage({
+                    content: obj.content,
+                    name: obj.name,
+                });
+            }
+            if (obj.type === "ToolMessage" || obj.type === "tool") {
+                return new index_js_2.ToolMessage({
+                    content: obj.content,
+                    tool_call_id: obj.tool_call_id,
+                });
+            }
+            if (obj.type === "AIMessage" || obj.type === "ai") {
+                return new index_js_2.AIMessage({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "HumanMessageChunk") {
+                return new index_js_2.HumanMessageChunk({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "SystemMessageChunk") {
+                return new index_js_2.SystemMessageChunk({
+                    content: obj.content,
+                });
+            }
+            if (obj.type === "ChatMessageChunk") {
+                return new index_js_2.ChatMessageChunk({
+                    content: obj.content,
+                    role: obj.role,
+                });
+            }
+            if (obj.type === "FunctionMessageChunk") {
+                return new index_js_2.FunctionMessageChunk({
+                    content: obj.content,
+                    name: obj.name,
+                });
+            }
+            if (obj.type === "ToolMessageChunk") {
+                return new index_js_2.ToolMessageChunk({
+                    content: obj.content,
+                    tool_call_id: obj.tool_call_id,
+                });
+            }
+            if (obj.type === "AIMessageChunk") {
+                return new index_js_2.AIMessageChunk({
+                    content: obj.content,
+                });
+            }
+        }
+        if (isSuperset(keys, new Set(["text", "generation_info", "type"]))) {
+            if (obj.type === "ChatGenerationChunk") {
+                return new outputs_js_1.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 outputs_js_1.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,
+                    [outputs_js_1.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 prompt_values_js_1.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 prompt_values_js_1.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 ((0, index_js_2.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 (index_js_2.ToolMessage.isInstance(input)) {
+            serializedMessage.tool_call_id = input.tool_call_id;
+        }
+        else if (index_js_2.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;
+}
+class RemoteRunnable extends base_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 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 = (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);
+    }
+    async *streamLog(input, options, streamOptions) {
+        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
+        const stream = new log_stream_js_1.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 = (0, event_source_parse_js_1.convertEventStreamToIterableReadableDataStream)(body);
+        for await (const log of runnableStream) {
+            yield revive(JSON.parse(log));
+        }
+    }
+}
+exports.RemoteRunnable = RemoteRunnable;

package/dist/runnables/remote.d.ts

@@ -0,0 +1,31 @@
+import { Runnable, RunnableBatchOptions } from "./base.js";
+import type { RunnableConfig } from "./config.js";
+import { CallbackManagerForChainRun } from "../callbacks/manager.js";
+import { type LogStreamCallbackHandlerInput, type RunLogPatch } from "../tracers/log_stream.js";
+import { IterableReadableStream } from "../utils/stream.js";
+type RemoteRunnableOptions = {
+    timeout?: number;
+    headers?: Record<string, unknown>;
+};
+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>>;
+    streamLog(input: RunInput, options?: Partial<CallOptions>, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<RunLogPatch>;
+}
+export {};