langchain 0.0.75 → 0.0.76

package/dist/client/langchainplus.js

@@ -1,4 +1,5 @@
 import { LangChainTracer } from "../callbacks/handlers/tracer_langchain.js";
+import { mapStoredMessagesToChatMessages } from "../stores/message/utils.js";
 // utility functions
 const isLocalhost = (url) => {
     const strippedUrl = url.replace("http://", "").replace("https://", "");
@@ -50,10 +51,28 @@ export function isChatModel(llm) {
     return (typeof blm?._modelType === "function" &&
         blm?._modelType() === "base_chat_model");
 }
-export function isChain(llm) {
-    const bch = llm;
+export async function isChain(llm) {
+    if (isLLM(llm)) {
+        return false;
+    }
+    const bchFactory = llm;
+    const bch = await bchFactory();
     return (typeof bch?._chainType === "function" && bch?._chainType() !== undefined);
 }
+async function getModelOrFactoryType(llm) {
+    if (isLLM(llm)) {
+        return "llm";
+    }
+    if (isChatModel(llm)) {
+        return "chatModel";
+    }
+    const bchFactory = llm;
+    const bch = await bchFactory();
+    if (typeof bch?._chainType === "function") {
+        return "chainFactory";
+    }
+    throw new Error("Unknown model or factory type");
+}
 export class LangChainPlusClient {
     constructor(apiUrl, tenantId, apiKey) {
         Object.defineProperty(this, "apiKey", {
@@ -145,6 +164,26 @@ export class LangChainPlusClient {
         const result = await response.json();
         return result;
     }
+    async createDataset(name, description) {
+        const response = await fetch(`${this.apiUrl}/datasets`, {
+            method: "POST",
+            headers: { ...this.headers, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                name,
+                description,
+                tenant_id: this.tenantId,
+            }),
+        });
+        if (!response.ok) {
+            const result = await response.json();
+            if (result.detail && result.detail.includes("already exists")) {
+                throw new Error(`Dataset ${name} already exists`);
+            }
+            throw new Error(`Failed to create dataset ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        return result;
+    }
     async readDataset(datasetId, datasetName) {
         let path = "/datasets";
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -280,58 +319,80 @@ export class LangChainPlusClient {
         return result;
     }
     async runLLM(example, tracer, llm, numRepetitions = 1) {
-        const results = [];
-        for (let i = 0; i < numRepetitions; i += 1) {
+        const results = await Promise.all(Array.from({ length: numRepetitions }).map(async () => {
             try {
-                const prompts = example.inputs.prompts;
-                results.push(await llm.generate(prompts, undefined, [tracer]));
+                const prompt = example.inputs.prompt;
+                return llm.generate([prompt], undefined, [tracer]);
             }
             catch (e) {
                 console.error(e);
-                results.push(stringifyError(e));
+                return stringifyError(e);
             }
-        }
+        }));
         return results;
     }
-    async runChain(example, tracer, chain, numRepetitions = 1) {
-        const results = [];
-        for (let i = 0; i < numRepetitions; i += 1) {
+    async runChain(example, tracer, chainFactory, numRepetitions = 1) {
+        const results = await Promise.all(Array.from({ length: numRepetitions }).map(async () => {
             try {
-                results.push(await chain.call(example.inputs, [tracer]));
+                const chain = await chainFactory();
+                return chain.call(example.inputs, [tracer]);
             }
             catch (e) {
                 console.error(e);
-                results.push(stringifyError(e));
+                return stringifyError(e);
             }
-        }
+        }));
+        return results;
+    }
+    async runChatModel(example, tracer, chatModel, numRepetitions = 1) {
+        const results = await Promise.all(Array.from({ length: numRepetitions }).map(async () => {
+            try {
+                const messages = example.inputs.messages;
+                return chatModel.generate([mapStoredMessagesToChatMessages(messages)], undefined, [tracer]);
+            }
+            catch (e) {
+                console.error(e);
+                return stringifyError(e);
+            }
+        }));
         return results;
     }
-    async runOnDataset(datasetName, llmOrChain, numRepetitions = 1, sessionName = undefined) {
+    async runOnDataset(datasetName, llmOrChainFactory, numRepetitions = 1, sessionName = undefined) {
         const examples = await this.listExamples(undefined, datasetName);
-        let sessionName_ = sessionName;
+        let sessionName_;
         if (sessionName === undefined) {
             const currentTime = new Date().toISOString();
-            sessionName_ = `${datasetName}-${llmOrChain.constructor.name}-${currentTime}`;
+            sessionName_ = `${datasetName}-${llmOrChainFactory.constructor.name}-${currentTime}`;
+        }
+        else {
+            sessionName_ = sessionName;
         }
         const results = {};
-        const tracer = new LangChainTracer();
-        await tracer.newSession(sessionName_);
-        for (const example of examples) {
-            if (isLLM(llmOrChain)) {
-                const llmResult = await this.runLLM(example, tracer, llmOrChain, numRepetitions);
+        const modelOrFactoryType = await getModelOrFactoryType(llmOrChainFactory);
+        await Promise.all(examples.map(async (example) => {
+            const tracer = new LangChainTracer({
+                exampleId: example.id,
+                sessionName: sessionName_,
+            });
+            if (modelOrFactoryType === "llm") {
+                const llm = llmOrChainFactory;
+                const llmResult = await this.runLLM(example, tracer, llm, numRepetitions);
                 results[example.id] = llmResult;
             }
-            else if (isChain(llmOrChain)) {
-                const ChainResult = await this.runChain(example, tracer, llmOrChain, numRepetitions);
-                results[example.id] = ChainResult;
+            else if (modelOrFactoryType === "chainFactory") {
+                const chainFactory = llmOrChainFactory;
+                const chainResult = await this.runChain(example, tracer, chainFactory, numRepetitions);
+                results[example.id] = chainResult;
             }
-            else if (isChatModel(llmOrChain)) {
-                throw new Error("Chat models not yet supported");
+            else if (modelOrFactoryType === "chatModel") {
+                const chatModel = llmOrChainFactory;
+                const chatModelResult = await this.runChatModel(example, tracer, chatModel, numRepetitions);
+                results[example.id] = chatModelResult;
             }
             else {
-                throw new Error(` llm or chain type: ${llmOrChain}`);
+                throw new Error(` llm or chain type: ${llmOrChainFactory}`);
             }
-        }
+        }));
         return results;
     }
 }

package/dist/document_loaders/fs/unstructured.cjs

@@ -42,6 +42,12 @@ class UnstructuredLoader extends base_js_1.BaseDocumentLoader {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "strategy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         // Temporary shim to avoid breaking existing users
         // Remove when API keys are enforced by Unstructured and existing code will break anyway
         const isLegacySyntax = typeof optionsOrLegacyFilePath === "string";
@@ -53,6 +59,7 @@ class UnstructuredLoader extends base_js_1.BaseDocumentLoader {
             this.filePath = filePathOrLegacyApiUrl;
             this.apiKey = optionsOrLegacyFilePath.apiKey;
             this.apiUrl = optionsOrLegacyFilePath.apiUrl ?? this.apiUrl;
+            this.strategy = optionsOrLegacyFilePath.strategy ?? "hi_res";
         }
     }
     async _partition() {
@@ -66,6 +73,7 @@ class UnstructuredLoader extends base_js_1.BaseDocumentLoader {
         formData.append("files", new Blob([buffer]), fileName);
         const headers = {
             "UNSTRUCTURED-API-KEY": this.apiKey ?? "",
+            strategy: this.strategy,
         };
         const response = await fetch(this.apiUrl, {
             method: "POST",

package/dist/document_loaders/fs/unstructured.d.ts

@@ -15,15 +15,18 @@ type Element = {
 type UnstructuredLoaderOptions = {
     apiKey?: string;
     apiUrl?: string;
+    strategy?: string;
 };
 type UnstructuredDirectoryLoaderOptions = UnstructuredLoaderOptions & {
     recursive?: boolean;
     unknown?: UnknownHandling;
+    strategy?: string;
 };
 export declare class UnstructuredLoader extends BaseDocumentLoader {
     filePath: string;
     private apiUrl;
     private apiKey?;
+    private strategy;
     constructor(filePathOrLegacyApiUrl: string, optionsOrLegacyFilePath?: UnstructuredLoaderOptions | string);
     _partition(): Promise<Element[]>;
     load(): Promise<Document[]>;

package/dist/document_loaders/fs/unstructured.js

@@ -38,6 +38,12 @@ export class UnstructuredLoader extends BaseDocumentLoader {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "strategy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         // Temporary shim to avoid breaking existing users
         // Remove when API keys are enforced by Unstructured and existing code will break anyway
         const isLegacySyntax = typeof optionsOrLegacyFilePath === "string";
@@ -49,6 +55,7 @@ export class UnstructuredLoader extends BaseDocumentLoader {
             this.filePath = filePathOrLegacyApiUrl;
             this.apiKey = optionsOrLegacyFilePath.apiKey;
             this.apiUrl = optionsOrLegacyFilePath.apiUrl ?? this.apiUrl;
+            this.strategy = optionsOrLegacyFilePath.strategy ?? "hi_res";
         }
     }
     async _partition() {
@@ -62,6 +69,7 @@ export class UnstructuredLoader extends BaseDocumentLoader {
         formData.append("files", new Blob([buffer]), fileName);
         const headers = {
             "UNSTRUCTURED-API-KEY": this.apiKey ?? "",
+            strategy: this.strategy,
         };
         const response = await fetch(this.apiUrl, {
             method: "POST",

package/dist/document_loaders/web/apify_dataset.cjs

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApifyDatasetLoader = void 0;
+const apify_client_1 = require("apify-client");
+const base_js_1 = require("../base.cjs");
+class ApifyDatasetLoader extends base_js_1.BaseDocumentLoader {
+    constructor(datasetId, config) {
+        super();
+        Object.defineProperty(this, "apifyClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "datasetId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "datasetMappingFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const apifyApiToken = ApifyDatasetLoader._getApifyApiToken(config.clientOptions);
+        this.apifyClient = new apify_client_1.ApifyClient({
+            ...config.clientOptions,
+            token: apifyApiToken,
+        });
+        this.datasetId = datasetId;
+        this.datasetMappingFunction = config.datasetMappingFunction;
+    }
+    static _getApifyApiToken(config) {
+        return (config?.token ??
+            // eslint-disable-next-line no-process-env
+            (typeof process !== "undefined" ? process.env.APIFY_API_TOKEN : undefined));
+    }
+    async load() {
+        const datasetItems = (await this.apifyClient.dataset(this.datasetId).listItems({ clean: true })).items;
+        return datasetItems.map(this.datasetMappingFunction);
+    }
+    /**
+     * Create an ApifyDatasetLoader by calling an Actor on the Apify platform and waiting for its results to be ready.
+     * @param actorId The ID or name of the Actor on the Apify platform.
+     * @param input The input object of the Actor that you're trying to run.
+     * @param options Options specifying settings for the Actor run.
+     * @param options.datasetMappingFunction A function that takes a single object (an Apify dataset item) and converts it to an instance of the Document class.
+     * @returns An instance of `ApifyDatasetLoader` with the results from the Actor run.
+     */
+    static async fromActorCall(actorId, input, config) {
+        const apifyApiToken = ApifyDatasetLoader._getApifyApiToken(config.clientOptions);
+        const apifyClient = new apify_client_1.ApifyClient({ token: apifyApiToken });
+        const actorCall = await apifyClient
+            .actor(actorId)
+            .call(input, config.callOptions ?? {});
+        return new ApifyDatasetLoader(actorCall.defaultDatasetId, {
+            datasetMappingFunction: config.datasetMappingFunction,
+            clientOptions: { ...config.clientOptions, token: apifyApiToken },
+        });
+    }
+}
+exports.ApifyDatasetLoader = ApifyDatasetLoader;

package/dist/document_loaders/web/apify_dataset.d.ts

@@ -0,0 +1,28 @@
+import { ApifyClient, ApifyClientOptions, ActorCallOptions } from "apify-client";
+import { Document } from "../../document.js";
+import { BaseDocumentLoader, DocumentLoader } from "../base.js";
+export type ApifyDatasetMappingFunction = (item: Record<string | number, unknown>) => Document;
+export declare class ApifyDatasetLoader extends BaseDocumentLoader implements DocumentLoader {
+    protected apifyClient: ApifyClient;
+    protected datasetId: string;
+    protected datasetMappingFunction: (item: Record<string | number, unknown>) => Document;
+    constructor(datasetId: string, config: {
+        datasetMappingFunction: ApifyDatasetMappingFunction;
+        clientOptions?: ApifyClientOptions;
+    });
+    private static _getApifyApiToken;
+    load(): Promise<Document[]>;
+    /**
+     * Create an ApifyDatasetLoader by calling an Actor on the Apify platform and waiting for its results to be ready.
+     * @param actorId The ID or name of the Actor on the Apify platform.
+     * @param input The input object of the Actor that you're trying to run.
+     * @param options Options specifying settings for the Actor run.
+     * @param options.datasetMappingFunction A function that takes a single object (an Apify dataset item) and converts it to an instance of the Document class.
+     * @returns An instance of `ApifyDatasetLoader` with the results from the Actor run.
+     */
+    static fromActorCall(actorId: string, input: Record<string | number, unknown>, config: {
+        callOptions?: ActorCallOptions;
+        clientOptions?: ApifyClientOptions;
+        datasetMappingFunction: ApifyDatasetMappingFunction;
+    }): Promise<ApifyDatasetLoader>;
+}

package/dist/document_loaders/web/apify_dataset.js

@@ -0,0 +1,60 @@
+import { ApifyClient, } from "apify-client";
+import { BaseDocumentLoader } from "../base.js";
+export class ApifyDatasetLoader extends BaseDocumentLoader {
+    constructor(datasetId, config) {
+        super();
+        Object.defineProperty(this, "apifyClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "datasetId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "datasetMappingFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const apifyApiToken = ApifyDatasetLoader._getApifyApiToken(config.clientOptions);
+        this.apifyClient = new ApifyClient({
+            ...config.clientOptions,
+            token: apifyApiToken,
+        });
+        this.datasetId = datasetId;
+        this.datasetMappingFunction = config.datasetMappingFunction;
+    }
+    static _getApifyApiToken(config) {
+        return (config?.token ??
+            // eslint-disable-next-line no-process-env
+            (typeof process !== "undefined" ? process.env.APIFY_API_TOKEN : undefined));
+    }
+    async load() {
+        const datasetItems = (await this.apifyClient.dataset(this.datasetId).listItems({ clean: true })).items;
+        return datasetItems.map(this.datasetMappingFunction);
+    }
+    /**
+     * Create an ApifyDatasetLoader by calling an Actor on the Apify platform and waiting for its results to be ready.
+     * @param actorId The ID or name of the Actor on the Apify platform.
+     * @param input The input object of the Actor that you're trying to run.
+     * @param options Options specifying settings for the Actor run.
+     * @param options.datasetMappingFunction A function that takes a single object (an Apify dataset item) and converts it to an instance of the Document class.
+     * @returns An instance of `ApifyDatasetLoader` with the results from the Actor run.
+     */
+    static async fromActorCall(actorId, input, config) {
+        const apifyApiToken = ApifyDatasetLoader._getApifyApiToken(config.clientOptions);
+        const apifyClient = new ApifyClient({ token: apifyApiToken });
+        const actorCall = await apifyClient
+            .actor(actorId)
+            .call(input, config.callOptions ?? {});
+        return new ApifyDatasetLoader(actorCall.defaultDatasetId, {
+            datasetMappingFunction: config.datasetMappingFunction,
+            clientOptions: { ...config.clientOptions, token: apifyApiToken },
+        });
+    }
+}

package/dist/embeddings/openai.cjs

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIEmbeddings = void 0;
 const openai_1 = require("openai");
-const browser_or_node_1 = require("browser-or-node");
+const env_js_1 = require("../util/env.cjs");
 const axios_fetch_adapter_js_1 = __importDefault(require("../util/axios-fetch-adapter.cjs"));
 const chunk_js_1 = require("../util/chunk.cjs");
 const base_js_1 = require("./base.cjs");
@@ -159,7 +159,7 @@ class OpenAIEmbeddings extends base_js_1.Embeddings {
                 basePath: endpoint,
                 baseOptions: {
                     timeout: this.timeout,
-                    adapter: browser_or_node_1.isNode ? undefined : axios_fetch_adapter_js_1.default,
+                    adapter: (0, env_js_1.isNode)() ? undefined : axios_fetch_adapter_js_1.default,
                     ...this.clientConfig.baseOptions,
                 },
             });

package/dist/embeddings/openai.js

@@ -1,5 +1,5 @@
 import { Configuration, OpenAIApi, } from "openai";
-import { isNode } from "browser-or-node";
+import { isNode } from "../util/env.js";
 import fetchAdapter from "../util/axios-fetch-adapter.js";
 import { chunkArray } from "../util/chunk.js";
 import { Embeddings } from "./base.js";
@@ -153,7 +153,7 @@ export class OpenAIEmbeddings extends Embeddings {
                 basePath: endpoint,
                 baseOptions: {
                     timeout: this.timeout,
-                    adapter: isNode ? undefined : fetchAdapter,
+                    adapter: isNode() ? undefined : fetchAdapter,
                     ...this.clientConfig.baseOptions,
                 },
             });

package/dist/llms/base.cjs

@@ -5,6 +5,7 @@ const index_js_1 = require("../cache/index.cjs");
 const index_js_2 = require("../schema/index.cjs");
 const index_js_3 = require("../base_language/index.cjs");
 const manager_js_1 = require("../callbacks/manager.cjs");
+const base_js_1 = require("../memory/base.cjs");
 /**
  * LLM Wrapper. Provides an {@link call} (an {@link generate}) function that takes in a prompt (or prompts) and returns a string.
  */
@@ -31,10 +32,18 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
         const prompts = promptValues.map((promptValue) => promptValue.toString());
         return this.generate(prompts, options, callbacks);
     }
+    /**
+     * Get the parameters used to invoke the model
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    invocationParams() {
+        return {};
+    }
     /** @ignore */
     async _generateUncached(prompts, options, callbacks) {
         const callbackManager_ = await manager_js_1.CallbackManager.configure(callbacks, this.callbacks, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleLLMStart({ name: this._llmType() }, prompts);
+        const invocationParams = { invocation_params: this?.invocationParams() };
+        const runManager = await callbackManager_?.handleLLMStart({ name: this._llmType() }, prompts, undefined, undefined, invocationParams);
         let output;
         try {
             output = await this._generate(prompts, options, runManager);
@@ -107,6 +116,14 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
         const { generations } = await this.generate([prompt], options ?? {}, callbacks);
         return generations[0][0].text;
     }
+    async predict(text, options, callbacks) {
+        return this.call(text, options, callbacks);
+    }
+    async predictMessages(messages, options, callbacks) {
+        const text = (0, base_js_1.getBufferString)(messages);
+        const prediction = await this.call(text, options, callbacks);
+        return new index_js_2.AIChatMessage(prediction);
+    }
     /**
      * Get the identifying parameters of the LLM.
      */

package/dist/llms/base.d.ts

@@ -1,4 +1,4 @@
-import { BaseCache, BasePromptValue, LLMResult } from "../schema/index.js";
+import { BaseCache, BaseChatMessage, BasePromptValue, LLMResult } from "../schema/index.js";
 import { BaseLanguageModel, BaseLanguageModelCallOptions, BaseLanguageModelParams } from "../base_language/index.js";
 import { CallbackManagerForLLMRun, Callbacks } from "../callbacks/manager.js";
 export type SerializedLLM = {
@@ -27,6 +27,10 @@ export declare abstract class BaseLLM extends BaseLanguageModel {
      * Run the LLM on the given prompts and input.
      */
     abstract _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams(): any;
     /** @ignore */
     _generateUncached(prompts: string[], options: this["CallOptions"], callbacks?: Callbacks): Promise<LLMResult>;
     /**
@@ -37,6 +41,8 @@ export declare abstract class BaseLLM extends BaseLanguageModel {
      * Convenience wrapper for {@link generate} that takes in a single string prompt and returns a single string output.
      */
     call(prompt: string, options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<string>;
+    predict(text: string, options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<string>;
+    predictMessages(messages: BaseChatMessage[], options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<BaseChatMessage>;
     /**
      * Get the identifying parameters of the LLM.
      */

package/dist/llms/base.js

@@ -1,7 +1,8 @@
 import { InMemoryCache } from "../cache/index.js";
-import { RUN_KEY, } from "../schema/index.js";
+import { AIChatMessage, RUN_KEY, } from "../schema/index.js";
 import { BaseLanguageModel, } from "../base_language/index.js";
 import { CallbackManager, } from "../callbacks/manager.js";
+import { getBufferString } from "../memory/base.js";
 /**
  * LLM Wrapper. Provides an {@link call} (an {@link generate}) function that takes in a prompt (or prompts) and returns a string.
  */
@@ -28,10 +29,18 @@ export class BaseLLM extends BaseLanguageModel {
         const prompts = promptValues.map((promptValue) => promptValue.toString());
         return this.generate(prompts, options, callbacks);
     }
+    /**
+     * Get the parameters used to invoke the model
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    invocationParams() {
+        return {};
+    }
     /** @ignore */
     async _generateUncached(prompts, options, callbacks) {
         const callbackManager_ = await CallbackManager.configure(callbacks, this.callbacks, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleLLMStart({ name: this._llmType() }, prompts);
+        const invocationParams = { invocation_params: this?.invocationParams() };
+        const runManager = await callbackManager_?.handleLLMStart({ name: this._llmType() }, prompts, undefined, undefined, invocationParams);
         let output;
         try {
             output = await this._generate(prompts, options, runManager);
@@ -104,6 +113,14 @@ export class BaseLLM extends BaseLanguageModel {
         const { generations } = await this.generate([prompt], options ?? {}, callbacks);
         return generations[0][0].text;
     }
+    async predict(text, options, callbacks) {
+        return this.call(text, options, callbacks);
+    }
+    async predictMessages(messages, options, callbacks) {
+        const text = getBufferString(messages);
+        const prediction = await this.call(text, options, callbacks);
+        return new AIChatMessage(prediction);
+    }
     /**
      * Get the identifying parameters of the LLM.
      */

package/dist/llms/openai-chat.cjs

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptLayerOpenAIChat = exports.OpenAIChat = void 0;
-const browser_or_node_1 = require("browser-or-node");
 const openai_1 = require("openai");
+const env_js_1 = require("../util/env.cjs");
 const axios_fetch_adapter_js_1 = __importDefault(require("../util/axios-fetch-adapter.cjs"));
 const base_js_1 = require("./base.cjs");
 /**
@@ -359,7 +359,7 @@ class OpenAIChat extends base_js_1.LLM {
             this.client = new openai_1.OpenAIApi(clientConfig);
         }
         const axiosOptions = {
-            adapter: browser_or_node_1.isNode ? undefined : axios_fetch_adapter_js_1.default,
+            adapter: (0, env_js_1.isNode)() ? undefined : axios_fetch_adapter_js_1.default,
             ...this.clientConfig.baseOptions,
             ...options,
         };

package/dist/llms/openai-chat.js

@@ -1,5 +1,5 @@
-import { isNode } from "browser-or-node";
 import { Configuration, OpenAIApi, } from "openai";
+import { isNode } from "../util/env.js";
 import fetchAdapter from "../util/axios-fetch-adapter.js";
 import { LLM } from "./base.js";
 /**
@@ -353,7 +353,7 @@ export class OpenAIChat extends LLM {
             this.client = new OpenAIApi(clientConfig);
         }
         const axiosOptions = {
-            adapter: isNode ? undefined : fetchAdapter,
+            adapter: isNode() ? undefined : fetchAdapter,
             ...this.clientConfig.baseOptions,
             ...options,
         };

package/dist/llms/openai.cjs

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptLayerOpenAIChat = exports.OpenAIChat = exports.PromptLayerOpenAI = exports.OpenAI = void 0;
-const browser_or_node_1 = require("browser-or-node");
 const openai_1 = require("openai");
+const env_js_1 = require("../util/env.cjs");
 const axios_fetch_adapter_js_1 = __importDefault(require("../util/axios-fetch-adapter.cjs"));
 const chunk_js_1 = require("../util/chunk.cjs");
 const base_js_1 = require("./base.cjs");
@@ -419,7 +419,7 @@ class OpenAI extends base_js_1.BaseLLM {
             this.client = new openai_1.OpenAIApi(clientConfig);
         }
         const axiosOptions = {
-            adapter: browser_or_node_1.isNode ? undefined : axios_fetch_adapter_js_1.default,
+            adapter: (0, env_js_1.isNode)() ? undefined : axios_fetch_adapter_js_1.default,
             ...this.clientConfig.baseOptions,
             ...options,
         };

package/dist/llms/openai.js

@@ -1,5 +1,5 @@
-import { isNode } from "browser-or-node";
 import { Configuration, OpenAIApi, } from "openai";
+import { isNode } from "../util/env.js";
 import fetchAdapter from "../util/axios-fetch-adapter.js";
 import { chunkArray } from "../util/chunk.js";
 import { BaseLLM } from "./base.js";
@@ -413,7 +413,7 @@ export class OpenAI extends BaseLLM {
             this.client = new OpenAIApi(clientConfig);
         }
         const axiosOptions = {
-            adapter: isNode ? undefined : fetchAdapter,
+            adapter: isNode() ? undefined : fetchAdapter,
             ...this.clientConfig.baseOptions,
             ...options,
         };

package/dist/memory/base.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBufferString = exports.getInputValue = exports.BaseMemory = void 0;
+exports.getPromptInputKey = exports.getBufferString = exports.getInputValue = exports.BaseMemory = void 0;
 class BaseMemory {
 }
 exports.BaseMemory = BaseMemory;
@@ -48,3 +48,11 @@ function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
     return string_messages.join("\n");
 }
 exports.getBufferString = getBufferString;
+function getPromptInputKey(inputs, memoryVariables) {
+    const promptInputKeys = Object.keys(inputs).filter((key) => !memoryVariables.includes(key) && key !== "stop");
+    if (promptInputKeys.length !== 1) {
+        throw new Error(`One input key expected, but got ${promptInputKeys.length}`);
+    }
+    return promptInputKeys[0];
+}
+exports.getPromptInputKey = getPromptInputKey;

package/dist/memory/base.d.ts

@@ -18,3 +18,4 @@ export declare const getInputValue: (inputValues: InputValues, inputKey?: string
  * of the chat message history, based on the message content and role.
  */
 export declare function getBufferString(messages: BaseChatMessage[], humanPrefix?: string, aiPrefix?: string): string;
+export declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;