langchain 0.0.74 → 0.0.76

package/dist/client/langchainplus.js

@@ -0,0 +1,398 @@
+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://", "");
+    const hostname = strippedUrl.split("/")[0].split(":")[0];
+    return (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1");
+};
+const getSeededTenantId = async (apiUrl, apiKey) => {
+    // Get the tenant ID from the seeded tenant
+    const url = `${apiUrl}/tenants`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "GET",
+            headers: apiKey ? { authorization: `Bearer ${apiKey}` } : undefined,
+        });
+    }
+    catch (err) {
+        throw new Error("Unable to get seeded tenant ID. Please manually provide.");
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to fetch seeded tenant ID: ${response.status} ${response.statusText}`);
+    }
+    const tenants = await response.json();
+    if (!Array.isArray(tenants)) {
+        throw new Error(`Expected tenants GET request to return an array, but got ${tenants}`);
+    }
+    if (tenants.length === 0) {
+        throw new Error("No seeded tenant found");
+    }
+    return tenants[0].id;
+};
+const stringifyError = (err) => {
+    let result;
+    if (err == null) {
+        result = "Error null or undefined";
+    }
+    else {
+        const error = err;
+        result = `Error: ${error?.name}: ${error?.message}`;
+    }
+    return result;
+};
+export function isLLM(llm) {
+    const blm = llm;
+    return (typeof blm?._modelType === "function" && blm?._modelType() === "base_llm");
+}
+export function isChatModel(llm) {
+    const blm = llm;
+    return (typeof blm?._modelType === "function" &&
+        blm?._modelType() === "base_chat_model");
+}
+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", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "apiUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tenantId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.apiUrl = apiUrl;
+        this.apiKey = apiKey;
+        this.tenantId = tenantId;
+        this.validateApiKeyIfHosted();
+    }
+    static async create(apiUrl, apiKey = undefined, tenantId = undefined) {
+        let tenantId_ = tenantId;
+        if (!tenantId_) {
+            tenantId_ = await getSeededTenantId(apiUrl, apiKey);
+        }
+        return new LangChainPlusClient(apiUrl, tenantId_, apiKey);
+    }
+    validateApiKeyIfHosted() {
+        const isLocal = isLocalhost(this.apiUrl);
+        if (!isLocal && !this.apiKey) {
+            throw new Error("API key must be provided when using hosted LangChain+ API");
+        }
+    }
+    get headers() {
+        const headers = {};
+        if (this.apiKey) {
+            headers.authorization = `Bearer ${this.apiKey}`;
+        }
+        return headers;
+    }
+    get queryParams() {
+        return { tenant_id: this.tenantId };
+    }
+    async _get(path, queryParams = {}) {
+        const params = { ...this.queryParams, ...queryParams };
+        let queryString = "";
+        for (const key in params) {
+            if (Object.prototype.hasOwnProperty.call(params, key)) {
+                queryString = queryString
+                    ? `${queryString}&${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`
+                    : `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`;
+            }
+        }
+        const url = `${this.apiUrl}${path}${queryString ? `?${queryString}` : ""}`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async uploadCsv(csvFile, fileName, description, inputKeys, outputKeys) {
+        const url = `${this.apiUrl}/datasets/upload`;
+        const formData = new FormData();
+        formData.append("file", csvFile, fileName);
+        formData.append("input_keys", inputKeys.join(","));
+        formData.append("output_keys", outputKeys.join(","));
+        formData.append("description", description);
+        formData.append("tenant_id", this.tenantId);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: this.headers,
+            body: formData,
+        });
+        if (!response.ok) {
+            const result = await response.json();
+            if (result.detail && result.detail.includes("already exists")) {
+                throw new Error(`Dataset ${fileName} already exists`);
+            }
+            throw new Error(`Failed to upload CSV: ${response.status} ${response.statusText}`);
+        }
+        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
+        const params = { limit: 1 };
+        if (datasetId !== undefined && datasetName !== undefined) {
+            throw new Error("Must provide either datasetName or datasetId, not both");
+        }
+        else if (datasetId !== undefined) {
+            path += `/${datasetId}`;
+        }
+        else if (datasetName !== undefined) {
+            params.name = datasetName;
+        }
+        else {
+            throw new Error("Must provide datasetName or datasetId");
+        }
+        const response = await this._get(path, params);
+        let result;
+        if (Array.isArray(response)) {
+            if (response.length === 0) {
+                throw new Error(`Dataset[id=${datasetId}, name=${datasetName}] not found`);
+            }
+            result = response[0];
+        }
+        else {
+            result = response;
+        }
+        return result;
+    }
+    async listDatasets(limit = 100) {
+        const path = "/datasets";
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const params = { limit };
+        const response = await this._get(path, params);
+        if (!Array.isArray(response)) {
+            throw new Error(`Expected ${path} to return an array, but got ${response}`);
+        }
+        return response;
+    }
+    async deleteDataset(datasetId, datasetName) {
+        let path = "/datasets";
+        let datasetId_ = datasetId;
+        if (datasetId !== undefined && datasetName !== undefined) {
+            throw new Error("Must provide either datasetName or datasetId, not both");
+        }
+        else if (datasetName !== undefined) {
+            const dataset = await this.readDataset(undefined, datasetName);
+            datasetId_ = dataset.id;
+        }
+        if (datasetId_ !== undefined) {
+            path += `/${datasetId_}`;
+        }
+        else {
+            throw new Error("Must provide datasetName or datasetId");
+        }
+        const response = await fetch(this.apiUrl + path, {
+            method: "DELETE",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to delete ${path}: ${response.status} ${response.statusText}`);
+        }
+        const results = await response.json();
+        return results;
+    }
+    async createExample(inputs, outputs = {}, datasetId = undefined, datasetName = undefined, createdAt = undefined) {
+        let datasetId_ = datasetId;
+        if (datasetId_ === undefined && datasetName === undefined) {
+            throw new Error("Must provide either datasetName or datasetId");
+        }
+        else if (datasetId_ !== undefined && datasetName !== undefined) {
+            throw new Error("Must provide either datasetName or datasetId, not both");
+        }
+        else if (datasetId_ === undefined) {
+            const dataset = await this.readDataset(undefined, datasetName);
+            datasetId_ = dataset.id;
+        }
+        const createdAt_ = createdAt || new Date();
+        const data = {
+            dataset_id: datasetId_,
+            inputs,
+            outputs,
+            created_at: createdAt_.toISOString(),
+        };
+        const response = await fetch(`${this.apiUrl}/examples`, {
+            method: "POST",
+            headers: { ...this.headers, "Content-Type": "application/json" },
+            body: JSON.stringify(data),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to create example: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        return result;
+    }
+    async readExample(exampleId) {
+        const path = `/examples/${exampleId}`;
+        return await this._get(path);
+    }
+    async listExamples(datasetId = undefined, datasetName = undefined) {
+        let datasetId_;
+        if (datasetId !== undefined && datasetName !== undefined) {
+            throw new Error("Must provide either datasetName or datasetId, not both");
+        }
+        else if (datasetId !== undefined) {
+            datasetId_ = datasetId;
+        }
+        else if (datasetName !== undefined) {
+            const dataset = await this.readDataset(undefined, datasetName);
+            datasetId_ = dataset.id;
+        }
+        else {
+            throw new Error("Must provide a datasetName or datasetId");
+        }
+        const response = await this._get("/examples", {
+            dataset: datasetId_,
+        });
+        if (!Array.isArray(response)) {
+            throw new Error(`Expected /examples to return an array, but got ${response}`);
+        }
+        return response;
+    }
+    async deleteExample(exampleId) {
+        const path = `/examples/${exampleId}`;
+        const response = await fetch(this.apiUrl + path, {
+            method: "DELETE",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to delete ${path}: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        return result;
+    }
+    async runLLM(example, tracer, llm, numRepetitions = 1) {
+        const results = await Promise.all(Array.from({ length: numRepetitions }).map(async () => {
+            try {
+                const prompt = example.inputs.prompt;
+                return llm.generate([prompt], undefined, [tracer]);
+            }
+            catch (e) {
+                console.error(e);
+                return stringifyError(e);
+            }
+        }));
+        return results;
+    }
+    async runChain(example, tracer, chainFactory, numRepetitions = 1) {
+        const results = await Promise.all(Array.from({ length: numRepetitions }).map(async () => {
+            try {
+                const chain = await chainFactory();
+                return chain.call(example.inputs, [tracer]);
+            }
+            catch (e) {
+                console.error(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, llmOrChainFactory, numRepetitions = 1, sessionName = undefined) {
+        const examples = await this.listExamples(undefined, datasetName);
+        let sessionName_;
+        if (sessionName === undefined) {
+            const currentTime = new Date().toISOString();
+            sessionName_ = `${datasetName}-${llmOrChainFactory.constructor.name}-${currentTime}`;
+        }
+        else {
+            sessionName_ = sessionName;
+        }
+        const results = {};
+        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 (modelOrFactoryType === "chainFactory") {
+                const chainFactory = llmOrChainFactory;
+                const chainResult = await this.runChain(example, tracer, chainFactory, numRepetitions);
+                results[example.id] = chainResult;
+            }
+            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: ${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,
                 },
             });