langchain 0.0.74 → 0.0.76

package/dist/chat_models/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 { BaseChatModel } from "./base.js";
 import { AIChatMessage, ChatMessage, HumanChatMessage, SystemChatMessage, } from "../schema/index.js";
@@ -47,6 +47,9 @@ function openAIResponseToChatMessage(role, text) {
  * if not explicitly available on this class.
  */
 export class ChatOpenAI extends BaseChatModel {
+    get callKeys() {
+        return ["stop", "signal", "timeout", "options"];
+    }
     constructor(fields, configuration) {
         super(fields ?? {});
         Object.defineProperty(this, "temperature", {
@@ -253,19 +256,13 @@ export class ChatOpenAI extends BaseChatModel {
         return this._identifyingParams();
     }
     /** @ignore */
-    async _generate(messages, stopOrOptions, runManager) {
-        const stop = Array.isArray(stopOrOptions)
-            ? stopOrOptions
-            : stopOrOptions?.stop;
-        const options = Array.isArray(stopOrOptions)
-            ? {}
-            : stopOrOptions?.options ?? {};
+    async _generate(messages, options, runManager) {
         const tokenUsage = {};
-        if (this.stop && stop) {
+        if (this.stop && options?.stop) {
             throw new Error("Stop found in input and default params");
         }
         const params = this.invocationParams();
-        params.stop = stop ?? params.stop;
+        params.stop = options?.stop ?? params.stop;
         const messagesMapped = messages.map((message) => ({
             role: messageTypeToOpenAIRole(message._getType()),
             content: message.text,
@@ -280,7 +277,8 @@ export class ChatOpenAI extends BaseChatModel {
                     ...params,
                     messages: messagesMapped,
                 }, {
-                    ...options,
+                    signal: options?.signal,
+                    ...options?.options,
                     adapter: fetchAdapter,
                     responseType: "stream",
                     onmessage: (event) => {
@@ -346,7 +344,10 @@ export class ChatOpenAI extends BaseChatModel {
             : await this.completionWithRetry({
                 ...params,
                 messages: messagesMapped,
-            }, options);
+            }, {
+                signal: options?.signal,
+                ...options?.options,
+            });
         const { completion_tokens: completionTokens, prompt_tokens: promptTokens, total_tokens: totalTokens, } = data.usage ?? {};
         if (completionTokens) {
             tokenUsage.completionTokens =
@@ -387,10 +388,15 @@ export class ChatOpenAI extends BaseChatModel {
         }
         const countPerMessage = await Promise.all(messages.map(async (message) => {
             const textCount = await this.getNumTokens(message.text);
-            const count = textCount + tokensPerMessage + (message.name ? tokensPerName : 0);
+            const roleCount = await this.getNumTokens(messageTypeToOpenAIRole(message._getType()));
+            const nameCount = message.name !== undefined
+                ? tokensPerName + (await this.getNumTokens(message.name))
+                : 0;
+            const count = textCount + tokensPerMessage + roleCount + nameCount;
             totalCount += count;
             return count;
         }));
+        totalCount += 3; // every reply is primed with <|start|>assistant<|message|>
         return { totalCount, countPerMessage };
     }
     /** @ignore */
@@ -410,7 +416,7 @@ export class ChatOpenAI extends BaseChatModel {
             this.client = new OpenAIApi(clientConfig);
         }
         const axiosOptions = {
-            adapter: isNode ? undefined : fetchAdapter,
+            adapter: isNode() ? undefined : fetchAdapter,
             ...this.clientConfig.baseOptions,
             ...options,
         };

package/dist/client/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainPlusClient = void 0;
+var langchainplus_js_1 = require("./langchainplus.cjs");
+Object.defineProperty(exports, "LangChainPlusClient", { enumerable: true, get: function () { return langchainplus_js_1.LangChainPlusClient; } });

package/dist/client/index.d.ts

@@ -0,0 +1 @@
+export { LangChainPlusClient, Dataset, Example, DatasetRunResults, } from "./langchainplus.js";

package/dist/client/index.js

@@ -0,0 +1 @@
+export { LangChainPlusClient, } from "./langchainplus.js";

package/dist/client/langchainplus.cjs

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangChainPlusClient = exports.isChain = exports.isChatModel = exports.isLLM = void 0;
+const tracer_langchain_js_1 = require("../callbacks/handlers/tracer_langchain.cjs");
+const utils_js_1 = require("../stores/message/utils.cjs");
+// 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;
+};
+function isLLM(llm) {
+    const blm = llm;
+    return (typeof blm?._modelType === "function" && blm?._modelType() === "base_llm");
+}
+exports.isLLM = isLLM;
+function isChatModel(llm) {
+    const blm = llm;
+    return (typeof blm?._modelType === "function" &&
+        blm?._modelType() === "base_chat_model");
+}
+exports.isChatModel = isChatModel;
+async function isChain(llm) {
+    if (isLLM(llm)) {
+        return false;
+    }
+    const bchFactory = llm;
+    const bch = await bchFactory();
+    return (typeof bch?._chainType === "function" && bch?._chainType() !== undefined);
+}
+exports.isChain = isChain;
+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");
+}
+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([(0, utils_js_1.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 tracer_langchain_js_1.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;
+    }
+}
+exports.LangChainPlusClient = LangChainPlusClient;

package/dist/client/langchainplus.d.ts

@@ -0,0 +1,65 @@
+import { BaseRun } from "../callbacks/handlers/tracer.js";
+import { LangChainTracer } from "../callbacks/handlers/tracer_langchain.js";
+import { ChainValues, LLMResult, RunInputs, RunOutputs } from "../schema/index.js";
+import { BaseLanguageModel } from "../base_language/index.js";
+import { BaseChain } from "../chains/base.js";
+import { BaseLLM } from "../llms/base.js";
+import { BaseChatModel } from "../chat_models/base.js";
+export interface RunResult extends BaseRun {
+    name: string;
+    session_id: string;
+    parent_run_id?: string;
+}
+export interface BaseDataset {
+    name: string;
+    description: string;
+    tenant_id: string;
+}
+export interface Dataset extends BaseDataset {
+    id: string;
+    created_at: string;
+    modified_at: string;
+}
+export interface BaseExample {
+    dataset_id: string;
+    inputs: RunInputs;
+    outputs: RunOutputs;
+}
+export interface ExampleCreate extends BaseExample {
+    id?: string;
+    created_at: string;
+}
+export interface Example extends BaseExample {
+    id: string;
+    created_at: string;
+    modified_at: string;
+    runs: RunResult[];
+}
+export type DatasetRunResults = Record<string, (string | LLMResult | ChainValues)[]>;
+export declare function isLLM(llm: BaseLanguageModel | (() => Promise<BaseChain>)): llm is BaseLLM;
+export declare function isChatModel(llm: BaseLanguageModel | (() => Promise<BaseChain>)): llm is BaseChatModel;
+export declare function isChain(llm: BaseLanguageModel | (() => Promise<BaseChain>)): Promise<boolean>;
+export declare class LangChainPlusClient {
+    private apiKey?;
+    private apiUrl;
+    private tenantId;
+    constructor(apiUrl: string, tenantId: string, apiKey?: string);
+    static create(apiUrl: string, apiKey?: string | undefined, tenantId?: string | undefined): Promise<LangChainPlusClient>;
+    private validateApiKeyIfHosted;
+    private get headers();
+    private get queryParams();
+    private _get;
+    uploadCsv(csvFile: Blob, fileName: string, description: string, inputKeys: string[], outputKeys: string[]): Promise<Dataset>;
+    createDataset(name: string, description: string): Promise<Dataset>;
+    readDataset(datasetId: string | undefined, datasetName: string | undefined): Promise<Dataset>;
+    listDatasets(limit?: number): Promise<Dataset[]>;
+    deleteDataset(datasetId: string | undefined, datasetName: string | undefined): Promise<Dataset>;
+    createExample(inputs: RunInputs, outputs?: RunOutputs, datasetId?: string | undefined, datasetName?: string | undefined, createdAt?: Date | undefined): Promise<Example>;
+    readExample(exampleId: string): Promise<Example>;
+    listExamples(datasetId?: string | undefined, datasetName?: string | undefined): Promise<Example[]>;
+    deleteExample(exampleId: string): Promise<Example>;
+    protected runLLM(example: Example, tracer: LangChainTracer, llm: BaseLLM, numRepetitions?: number): Promise<(LLMResult | string)[]>;
+    protected runChain(example: Example, tracer: LangChainTracer, chainFactory: () => Promise<BaseChain>, numRepetitions?: number): Promise<(ChainValues | string)[]>;
+    protected runChatModel(example: Example, tracer: LangChainTracer, chatModel: BaseChatModel, numRepetitions?: number): Promise<(LLMResult | string)[]>;
+    runOnDataset(datasetName: string, llmOrChainFactory: BaseLanguageModel | (() => Promise<BaseChain>), numRepetitions?: number, sessionName?: string | undefined): Promise<DatasetRunResults>;
+}