langchain 0.1.12 → 0.1.14

package/dist/load/import_map.js

@@ -67,28 +67,28 @@ export * as smith from "../smith/index.js";
 export * as runnables__remote from "../runnables/remote.js";
 export * as indexes from "../indexes/index.js";
 import { ChatOpenAI, OpenAI, OpenAIEmbeddings } from "@langchain/openai";
-import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, PipelinePromptTemplate, } from "@langchain/core/prompts";
-import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, } from "@langchain/core/messages";
+import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, ImagePromptTemplate, PipelinePromptTemplate } from "@langchain/core/prompts";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk } from "@langchain/core/messages";
 import { StringPromptValue } from "@langchain/core/prompt_values";
-import { RouterRunnable, RunnableAssign, RunnableBinding, RunnableBranch, RunnableEach, RunnableMap, RunnableParallel, RunnablePassthrough, RunnablePick, RunnableRetry, RunnableSequence, RunnableWithFallbacks, RunnableWithMessageHistory, } from "@langchain/core/runnables";
+import { RouterRunnable, RunnableAssign, RunnableBinding, RunnableBranch, RunnableEach, RunnableMap, RunnableParallel, RunnablePassthrough, RunnablePick, RunnableRetry, RunnableSequence, RunnableWithFallbacks, RunnableWithMessageHistory } from "@langchain/core/runnables";
 import { StringOutputParser } from "@langchain/core/output_parsers";
 import { ChatGenerationChunk, GenerationChunk } from "@langchain/core/outputs";
 import { ChatFireworks } from "@langchain/community/chat_models/fireworks";
 import { Fireworks } from "@langchain/community/llms/fireworks";
 const chat_models__openai = {
-    ChatOpenAI,
+    ChatOpenAI
 };
 export { chat_models__openai };
 const llms__openai = {
-    OpenAI,
+    OpenAI
 };
 export { llms__openai };
 const embeddings__openai = {
-    OpenAIEmbeddings,
+    OpenAIEmbeddings
 };
 export { embeddings__openai };
 const prompts__prompt = {
-    PromptTemplate,
+    PromptTemplate
 };
 export { prompts__prompt };
 const schema__messages = {
@@ -105,24 +105,45 @@ const schema__messages = {
     SystemMessage,
     SystemMessageChunk,
     ToolMessage,
-    ToolMessageChunk,
+    ToolMessageChunk
 };
 export { schema__messages };
+const schema = {
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    BaseMessageChunk,
+    ChatMessage,
+    ChatMessageChunk,
+    FunctionMessage,
+    FunctionMessageChunk,
+    HumanMessage,
+    HumanMessageChunk,
+    SystemMessage,
+    SystemMessageChunk,
+    ToolMessage,
+    ToolMessageChunk
+};
+export { schema };
 const prompts__chat = {
     AIMessagePromptTemplate,
     ChatMessagePromptTemplate,
     ChatPromptTemplate,
     HumanMessagePromptTemplate,
     MessagesPlaceholder,
-    SystemMessagePromptTemplate,
+    SystemMessagePromptTemplate
 };
 export { prompts__chat };
+const prompts__image = {
+    ImagePromptTemplate
+};
+export { prompts__image };
 const prompts__pipeline = {
-    PipelinePromptTemplate,
+    PipelinePromptTemplate
 };
 export { prompts__pipeline };
 const prompts__base = {
-    StringPromptValue,
+    StringPromptValue
 };
 export { prompts__base };
 const schema__runnable = {
@@ -138,23 +159,23 @@ const schema__runnable = {
     RunnableRetry,
     RunnableSequence,
     RunnableWithFallbacks,
-    RunnableWithMessageHistory,
+    RunnableWithMessageHistory
 };
 export { schema__runnable };
 const schema__output_parser = {
-    StringOutputParser,
+    StringOutputParser
 };
 export { schema__output_parser };
 const schema__output = {
     ChatGenerationChunk,
-    GenerationChunk,
+    GenerationChunk
 };
 export { schema__output };
 const chat_models__fireworks = {
-    ChatFireworks,
+    ChatFireworks
 };
 export { chat_models__fireworks };
 const llms__fireworks = {
-    Fireworks,
+    Fireworks
 };
 export { llms__fireworks };

package/dist/runnables/remote.cjs

@@ -1,341 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteRunnable = void 0;
-const runnables_1 = require("@langchain/core/runnables");
-const documents_1 = require("@langchain/core/documents");
-const prompt_values_1 = require("@langchain/core/prompt_values");
-const log_stream_1 = require("@langchain/core/tracers/log_stream");
-const messages_1 = require("@langchain/core/messages");
-const outputs_1 = require("@langchain/core/outputs");
-const event_source_parse_1 = require("@langchain/community/utils/event_source_parse");
-const stream_1 = require("@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 documents_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 messages_1.HumanMessage({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "SystemMessage" || obj.type === "system") {
-                return new messages_1.SystemMessage({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "ChatMessage" || obj.type === "chat") {
-                return new messages_1.ChatMessage({
-                    content: obj.content,
-                    role: obj.role,
-                });
-            }
-            if (obj.type === "FunctionMessage" || obj.type === "function") {
-                return new messages_1.FunctionMessage({
-                    content: obj.content,
-                    name: obj.name,
-                });
-            }
-            if (obj.type === "ToolMessage" || obj.type === "tool") {
-                return new messages_1.ToolMessage({
-                    content: obj.content,
-                    tool_call_id: obj.tool_call_id,
-                });
-            }
-            if (obj.type === "AIMessage" || obj.type === "ai") {
-                return new messages_1.AIMessage({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "HumanMessageChunk") {
-                return new messages_1.HumanMessageChunk({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "SystemMessageChunk") {
-                return new messages_1.SystemMessageChunk({
-                    content: obj.content,
-                });
-            }
-            if (obj.type === "ChatMessageChunk") {
-                return new messages_1.ChatMessageChunk({
-                    content: obj.content,
-                    role: obj.role,
-                });
-            }
-            if (obj.type === "FunctionMessageChunk") {
-                return new messages_1.FunctionMessageChunk({
-                    content: obj.content,
-                    name: obj.name,
-                });
-            }
-            if (obj.type === "ToolMessageChunk") {
-                return new messages_1.ToolMessageChunk({
-                    content: obj.content,
-                    tool_call_id: obj.tool_call_id,
-                });
-            }
-            if (obj.type === "AIMessageChunk") {
-                return new messages_1.AIMessageChunk({
-                    content: obj.content,
-                });
-            }
-        }
-        if (isSuperset(keys, new Set(["text", "generation_info", "type"]))) {
-            if (obj.type === "ChatGenerationChunk") {
-                return new outputs_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_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_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_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_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;
-}
-class RemoteRunnable extends runnables_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",
-                ...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 = (0, event_source_parse_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_1.getBytes)(body, (0, event_source_parse_1.getLines)(onLine));
-            },
-        });
-        return stream_1.IterableReadableStream.fromReadableStream(stream);
-    }
-    async *streamLog(input, options, streamOptions) {
-        const [config, kwargs] = this._separateRunnableConfigFromCallOptions(options);
-        const stream = new log_stream_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,
-            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_1.convertEventStreamToIterableReadableDataStream)(body);
-        for await (const log of runnableStream) {
-            yield revive(JSON.parse(log));
-        }
-    }
-}
-exports.RemoteRunnable = RemoteRunnable;
+__exportStar(require("@langchain/core/runnables/remote"), exports);

package/dist/runnables/remote.d.ts

@@ -1,30 +1 @@
-import { Runnable, RunnableBatchOptions, RunnableConfig } from "@langchain/core/runnables";
-import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
-import { type LogStreamCallbackHandlerInput, type RunLogPatch } from "@langchain/core/tracers/log_stream";
-import { IterableReadableStream } from "@langchain/core/utils/stream";
-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 {};
+export * from "@langchain/core/runnables/remote";