langchain 0.0.165 → 0.0.166

package/dist/schema/runnable/remote.cjs

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteRunnable = void 0;
+const base_js_1 = require("./base.cjs");
+const stream_js_1 = require("../../util/stream.cjs");
+const event_source_parse_js_1 = require("../../util/event-source-parse.cjs");
+const document_js_1 = require("../../document.cjs");
+const index_js_1 = require("../index.cjs");
+const base_js_2 = require("../../prompts/base.cjs");
+const chat_js_1 = require("../../prompts/chat.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_1.HumanMessage({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "system") {
+                    return new index_js_1.SystemMessage({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "chat") {
+                    return new index_js_1.ChatMessage({
+                        content: obj.content,
+                        role: obj.role,
+                    });
+                }
+                if (obj.type === "function") {
+                    return new index_js_1.FunctionMessage({
+                        content: obj.content,
+                        name: obj.name,
+                    });
+                }
+                if (obj.type === "ai") {
+                    return new index_js_1.AIMessage({
+                        content: obj.content,
+                    });
+                }
+            }
+            else {
+                if (obj.type === "human") {
+                    return new index_js_1.HumanMessageChunk({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "system") {
+                    return new index_js_1.SystemMessageChunk({
+                        content: obj.content,
+                    });
+                }
+                if (obj.type === "chat") {
+                    return new index_js_1.ChatMessageChunk({
+                        content: obj.content,
+                        role: obj.role,
+                    });
+                }
+                if (obj.type === "function") {
+                    return new index_js_1.FunctionMessageChunk({
+                        content: obj.content,
+                        name: obj.name,
+                    });
+                }
+                if (obj.type === "ai") {
+                    return new index_js_1.AIMessageChunk({
+                        content: obj.content,
+                    });
+                }
+            }
+        }
+        if (isSuperset(keys, new Set(["text"]))) {
+            return new base_js_2.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 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 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],
+        ], [[], []]) ?? [[], []];
+        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/schema/runnable/remote.d.ts

@@ -0,0 +1,28 @@
+import { Runnable, RunnableBatchOptions } from "./base.js";
+import { RunnableConfig } from "./config.js";
+import { IterableReadableStream } from "../../util/stream.js";
+import { CallbackManagerForChainRun } from "../../callbacks/manager.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/schema/runnable/remote.js

@@ -0,0 +1,221 @@
+import { Runnable } from "./base.js";
+import { IterableReadableStream } from "../../util/stream.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 "../index.js";
+import { StringPromptValue } from "../../prompts/base.js";
+import { ChatPromptValue } from "../../prompts/chat.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],
+        ], [[], []]) ?? [[], []];
+        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/stores/message/momento.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MomentoChatMessageHistory = void 0;
 /* eslint-disable no-instanceof/no-instanceof */
-const sdk_1 = require("@gomomento/sdk");
+const sdk_core_1 = require("@gomomento/sdk-core");
 const index_js_1 = require("../../schema/index.cjs");
 const utils_js_1 = require("./utils.cjs");
 const momento_js_1 = require("../../util/momento.cjs");
@@ -50,8 +50,8 @@ class MomentoChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
         this.validateTtlSeconds(props.sessionTtl);
         this.sessionTtl =
             props.sessionTtl !== undefined
-                ? sdk_1.CollectionTtl.of(props.sessionTtl)
-                : sdk_1.CollectionTtl.fromCacheTtl();
+                ? sdk_core_1.CollectionTtl.of(props.sessionTtl)
+                : sdk_core_1.CollectionTtl.fromCacheTtl();
     }
     /**
      * Create a new chat message history backed by Momento.
@@ -80,7 +80,7 @@ class MomentoChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
      */
     validateTtlSeconds(ttlSeconds) {
         if (ttlSeconds !== undefined && ttlSeconds <= 0) {
-            throw new sdk_1.InvalidArgumentError("ttlSeconds must be positive.");
+            throw new sdk_core_1.InvalidArgumentError("ttlSeconds must be positive.");
         }
     }
     /**
@@ -90,15 +90,15 @@ class MomentoChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
     async getMessages() {
         const fetchResponse = await this.client.listFetch(this.cacheName, this.sessionId);
         let messages = [];
-        if (fetchResponse instanceof sdk_1.CacheListFetch.Hit) {
+        if (fetchResponse instanceof sdk_core_1.CacheListFetch.Hit) {
             messages = fetchResponse
                 .valueList()
                 .map((serializedStoredMessage) => JSON.parse(serializedStoredMessage));
         }
-        else if (fetchResponse instanceof sdk_1.CacheListFetch.Miss) {
+        else if (fetchResponse instanceof sdk_core_1.CacheListFetch.Miss) {
             // pass
         }
-        else if (fetchResponse instanceof sdk_1.CacheListFetch.Error) {
+        else if (fetchResponse instanceof sdk_core_1.CacheListFetch.Error) {
             throw fetchResponse.innerException();
         }
         else {
@@ -114,10 +114,10 @@ class MomentoChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
     async addMessage(message) {
         const messageToAdd = JSON.stringify((0, utils_js_1.mapChatMessagesToStoredMessages)([message])[0]);
         const pushResponse = await this.client.listPushBack(this.cacheName, this.sessionId, messageToAdd, { ttl: this.sessionTtl });
-        if (pushResponse instanceof sdk_1.CacheListPushBack.Success) {
+        if (pushResponse instanceof sdk_core_1.CacheListPushBack.Success) {
             // pass
         }
-        else if (pushResponse instanceof sdk_1.CacheListPushBack.Error) {
+        else if (pushResponse instanceof sdk_core_1.CacheListPushBack.Error) {
             throw pushResponse.innerException();
         }
         else {
@@ -130,10 +130,10 @@ class MomentoChatMessageHistory extends index_js_1.BaseListChatMessageHistory {
      */
     async clear() {
         const deleteResponse = await this.client.delete(this.cacheName, this.sessionId);
-        if (deleteResponse instanceof sdk_1.CacheDelete.Success) {
+        if (deleteResponse instanceof sdk_core_1.CacheDelete.Success) {
             // pass
         }
-        else if (deleteResponse instanceof sdk_1.CacheDelete.Error) {
+        else if (deleteResponse instanceof sdk_core_1.CacheDelete.Error) {
             throw deleteResponse.innerException();
         }
         else {

package/dist/stores/message/momento.d.ts

@@ -1,4 +1,4 @@
-import { ICacheClient } from "@gomomento/sdk";
+import { ICacheClient } from "@gomomento/sdk-core";
 import { BaseMessage, BaseListChatMessageHistory } from "../../schema/index.js";
 /**
  * The settings to instantiate the Momento chat message history.

package/dist/stores/message/momento.js

@@ -1,5 +1,5 @@
 /* eslint-disable no-instanceof/no-instanceof */
-import { CacheDelete, CacheListFetch, CacheListPushBack, InvalidArgumentError, CollectionTtl, } from "@gomomento/sdk";
+import { CacheDelete, CacheListFetch, CacheListPushBack, InvalidArgumentError, CollectionTtl, } from "@gomomento/sdk-core";
 import { BaseListChatMessageHistory, } from "../../schema/index.js";
 import { mapChatMessagesToStoredMessages, mapStoredMessagesToChatMessages, } from "./utils.js";
 import { ensureCacheExists } from "../../util/momento.js";

package/dist/util/time.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+/**
+ * Sleep for a given amount of time.
+ * @param ms - The number of milliseconds to sleep for. Defaults to 1000.
+ * @returns A promise that resolves when the sleep is complete.
+ */
+async function sleep(ms = 1000) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+exports.sleep = sleep;

package/dist/util/time.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sleep for a given amount of time.
+ * @param ms - The number of milliseconds to sleep for. Defaults to 1000.
+ * @returns A promise that resolves when the sleep is complete.
+ */
+export declare function sleep(ms?: number): Promise<void>;

package/dist/util/time.js

@@ -0,0 +1,10 @@
+/**
+ * Sleep for a given amount of time.
+ * @param ms - The number of milliseconds to sleep for. Defaults to 1000.
+ * @returns A promise that resolves when the sleep is complete.
+ */
+export async function sleep(ms = 1000) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}