langchain 0.2.9 → 0.2.11

package/dist/chat_models/universal.js

@@ -0,0 +1,595 @@
+import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
+import { RunnableBinding, ensureConfig, } from "@langchain/core/runnables";
+import { AsyncGeneratorWithSetup, IterableReadableStream, } from "@langchain/core/utils/stream";
+const _SUPPORTED_PROVIDERS = [
+    "openai",
+    "anthropic",
+    "azure_openai",
+    "cohere",
+    "google-vertexai",
+    "google-genai",
+    "ollama",
+    "together",
+    "fireworks",
+    "mistralai",
+    "groq",
+    "bedrock",
+];
+async function _initChatModelHelper(model, modelProvider, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+params = {}) {
+    const modelProviderCopy = modelProvider || _inferModelProvider(model);
+    if (!modelProviderCopy) {
+        throw new Error(`Unable to infer model provider for { model: ${model} }, please specify modelProvider directly.`);
+    }
+    try {
+        switch (modelProviderCopy) {
+            case "openai": {
+                const { ChatOpenAI } = await import("@langchain/openai");
+                return new ChatOpenAI({ model, ...params });
+            }
+            case "anthropic": {
+                const { ChatAnthropic } = await import("@langchain/anthropic");
+                return new ChatAnthropic({ model, ...params });
+            }
+            case "azure_openai": {
+                const { AzureChatOpenAI } = await import("@langchain/openai");
+                return new AzureChatOpenAI({ model, ...params });
+            }
+            case "cohere": {
+                const { ChatCohere } = await import("@langchain/cohere");
+                return new ChatCohere({ model, ...params });
+            }
+            case "google-vertexai": {
+                const { ChatVertexAI } = await import("@langchain/google-vertexai");
+                return new ChatVertexAI({ model, ...params });
+            }
+            case "google-genai": {
+                const { ChatGoogleGenerativeAI } = await import("@langchain/google-genai");
+                return new ChatGoogleGenerativeAI({ model, ...params });
+            }
+            case "ollama": {
+                const { ChatOllama } = await import("@langchain/ollama");
+                return new ChatOllama({ model, ...params });
+            }
+            case "mistralai": {
+                const { ChatMistralAI } = await import("@langchain/mistralai");
+                return new ChatMistralAI({ model, ...params });
+            }
+            case "groq": {
+                const { ChatGroq } = await import("@langchain/groq");
+                return new ChatGroq({ model, ...params });
+            }
+            case "bedrock": {
+                const { ChatBedrockConverse } = await import("@langchain/aws");
+                return new ChatBedrockConverse({ model, ...params });
+            }
+            case "fireworks": {
+                const { ChatFireworks } = await import(
+                // We can not 'expect-error' because if you explicitly build `@langchain/community`
+                // this import will be able to be resolved, thus there will be no error. However
+                // this will never be the case in CI.
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore - Can not install as a proper dependency due to circular dependency
+                "@langchain/community/chat_models/fireworks");
+                return new ChatFireworks({ model, ...params });
+            }
+            case "together": {
+                const { ChatTogetherAI } = await import(
+                // We can not 'expect-error' because if you explicitly build `@langchain/community`
+                // this import will be able to be resolved, thus there will be no error. However
+                // this will never be the case in CI.
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore - Can not install as a proper dependency due to circular dependency
+                "@langchain/community/chat_models/togetherai");
+                return new ChatTogetherAI({ model, ...params });
+            }
+            default: {
+                const supported = _SUPPORTED_PROVIDERS.join(", ");
+                throw new Error(`Unsupported { modelProvider: ${modelProviderCopy} }.\n\nSupported model providers are: ${supported}`);
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (e) {
+        if ("code" in e && e.code.includes("ERR_MODULE_NOT_FOUND")) {
+            const attemptedPackage = new Error(e).message
+                .split("Error: Cannot find package '")[1]
+                .split("'")[0];
+            throw new Error(`Unable to import ${attemptedPackage}. Please install with ` +
+                `\`npm install ${attemptedPackage}\` or \`yarn add ${attemptedPackage}\``);
+        }
+        throw e;
+    }
+}
+/**
+ * Attempts to infer the model provider based on the given model name.
+ *
+ * @param {string} modelName - The name of the model to infer the provider for.
+ * @returns {string | undefined} The inferred model provider name, or undefined if unable to infer.
+ *
+ * @example
+ * _inferModelProvider("gpt-4"); // returns "openai"
+ * _inferModelProvider("claude-2"); // returns "anthropic"
+ * _inferModelProvider("unknown-model"); // returns undefined
+ */
+export function _inferModelProvider(modelName) {
+    if (modelName.startsWith("gpt-3") || modelName.startsWith("gpt-4")) {
+        return "openai";
+    }
+    else if (modelName.startsWith("claude")) {
+        return "anthropic";
+    }
+    else if (modelName.startsWith("command")) {
+        return "cohere";
+    }
+    else if (modelName.startsWith("accounts/fireworks")) {
+        return "fireworks";
+    }
+    else if (modelName.startsWith("gemini")) {
+        return "google-vertexai";
+    }
+    else if (modelName.startsWith("amazon.")) {
+        return "bedrock";
+    }
+    else {
+        return undefined;
+    }
+}
+class _ConfigurableModel extends BaseChatModel {
+    _llmType() {
+        return "chat_model";
+    }
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "chat_models"]
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "_defaultConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        /**
+         * @default "any"
+         */
+        Object.defineProperty(this, "_configurableFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "any"
+        });
+        /**
+         * @default ""
+         */
+        Object.defineProperty(this, "_configPrefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Methods which should be called after the model is initialized.
+         * The key will be the method name, and the value will be the arguments.
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "_queuedMethodOperations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        // Extract the input types from the `BaseModel` class.
+        Object.defineProperty(this, "withStructuredOutput", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (schema, ...args) => {
+                this._queuedMethodOperations.withStructuredOutput = [schema, ...args];
+                return new _ConfigurableModel({
+                    defaultConfig: this._defaultConfig,
+                    configurableFields: this._configurableFields,
+                    configPrefix: this._configPrefix,
+                    queuedMethodOperations: this._queuedMethodOperations,
+                });
+            }
+        });
+        this._defaultConfig = fields.defaultConfig ?? {};
+        if (fields.configurableFields === "any") {
+            this._configurableFields = "any";
+        }
+        else {
+            this._configurableFields = fields.configurableFields ?? "any";
+        }
+        if (fields.configPrefix) {
+            this._configPrefix = fields.configPrefix.endsWith("_")
+                ? fields.configPrefix
+                : `${fields.configPrefix}_`;
+        }
+        else {
+            this._configPrefix = "";
+        }
+        this._queuedMethodOperations =
+            fields.queuedMethodOperations ?? this._queuedMethodOperations;
+    }
+    async _model(config) {
+        const params = { ...this._defaultConfig, ...this._modelParams(config) };
+        let initializedModel = await _initChatModelHelper(params.model, params.modelProvider, params);
+        // Apply queued method operations
+        const queuedMethodOperationsEntries = Object.entries(this._queuedMethodOperations);
+        if (queuedMethodOperationsEntries.length > 0) {
+            for (const [method, args] of queuedMethodOperationsEntries) {
+                if (method in initializedModel &&
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    typeof initializedModel[method] === "function") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    initializedModel = await initializedModel[method](...args);
+                }
+            }
+        }
+        return initializedModel;
+    }
+    async _generate(messages, options, runManager) {
+        const model = await this._model(options);
+        return model._generate(messages, options ?? {}, runManager);
+    }
+    bindTools(tools, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    params) {
+        this._queuedMethodOperations.bindTools = [tools, params];
+        return new _ConfigurableModel({
+            defaultConfig: this._defaultConfig,
+            configurableFields: this._configurableFields,
+            configPrefix: this._configPrefix,
+            queuedMethodOperations: this._queuedMethodOperations,
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _modelParams(config) {
+        const configurable = config?.configurable ?? {};
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let modelParams = {};
+        for (const [key, value] of Object.entries(configurable)) {
+            if (key.startsWith(this._configPrefix)) {
+                const strippedKey = this._removePrefix(key, this._configPrefix);
+                modelParams[strippedKey] = value;
+            }
+        }
+        if (this._configurableFields !== "any") {
+            modelParams = Object.fromEntries(Object.entries(modelParams).filter(([key]) => this._configurableFields.includes(key)));
+        }
+        return modelParams;
+    }
+    _removePrefix(str, prefix) {
+        return str.startsWith(prefix) ? str.slice(prefix.length) : str;
+    }
+    /**
+     * Bind config to a Runnable, returning a new Runnable.
+     * @param {RunnableConfig | undefined} [config] - The config to bind.
+     * @returns {RunnableBinding<RunInput, RunOutput, CallOptions>} A new RunnableBinding with the bound config.
+     */
+    withConfig(config) {
+        const mergedConfig = { ...(config || {}) };
+        const modelParams = this._modelParams(mergedConfig);
+        const remainingConfig = Object.fromEntries(Object.entries(mergedConfig).filter(([k]) => k !== "configurable"));
+        remainingConfig.configurable = Object.fromEntries(Object.entries(mergedConfig.configurable || {}).filter(([k]) => this._configPrefix &&
+            !Object.keys(modelParams).includes(this._removePrefix(k, this._configPrefix))));
+        const newConfigurableModel = new _ConfigurableModel({
+            defaultConfig: { ...this._defaultConfig, ...modelParams },
+            configurableFields: Array.isArray(this._configurableFields)
+                ? [...this._configurableFields]
+                : this._configurableFields,
+            configPrefix: this._configPrefix,
+        });
+        return new RunnableBinding({
+            config: mergedConfig,
+            bound: newConfigurableModel,
+        });
+    }
+    async invoke(input, options) {
+        const model = await this._model(options);
+        const config = ensureConfig(options);
+        return model.invoke(input, config);
+    }
+    async stream(input, options) {
+        const model = await this._model(options);
+        const wrappedGenerator = new AsyncGeneratorWithSetup({
+            generator: await model.stream(input, options),
+            config: options,
+        });
+        await wrappedGenerator.setup;
+        return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
+    }
+    async batch(inputs, options, batchOptions) {
+        // We can super this since the base runnable implementation of
+        // `.batch` will call `.invoke` on each input.
+        return super.batch(inputs, options, batchOptions);
+    }
+    async *transform(generator, options) {
+        const model = await this._model(options);
+        const config = ensureConfig(options);
+        yield* model.transform(generator, config);
+    }
+    async *streamLog(input, options, streamOptions) {
+        const model = await this._model(options);
+        const config = ensureConfig(options);
+        yield* model.streamLog(input, config, {
+            ...streamOptions,
+            _schemaFormat: "original",
+            includeNames: streamOptions?.includeNames,
+            includeTypes: streamOptions?.includeTypes,
+            includeTags: streamOptions?.includeTags,
+            excludeNames: streamOptions?.excludeNames,
+            excludeTypes: streamOptions?.excludeTypes,
+            excludeTags: streamOptions?.excludeTags,
+        });
+    }
+    streamEvents(input, options, streamOptions) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const outerThis = this;
+        async function* wrappedGenerator() {
+            const model = await outerThis._model(options);
+            const config = ensureConfig(options);
+            const eventStream = model.streamEvents(input, config, streamOptions);
+            for await (const chunk of eventStream) {
+                yield chunk;
+            }
+        }
+        return IterableReadableStream.fromAsyncGenerator(wrappedGenerator());
+    }
+}
+// ################################# FOR CONTRIBUTORS #################################
+//
+// If adding support for a new provider, please append the provider
+// name to the supported list in the docstring below.
+//
+// ####################################################################################
+/**
+ * Initialize a ChatModel from the model name and provider.
+ * Must have the integration package corresponding to the model provider installed.
+ *
+ * @template {extends BaseLanguageModelInput = BaseLanguageModelInput} RunInput - The input type for the model.
+ * @template {extends ConfigurableChatModelCallOptions = ConfigurableChatModelCallOptions} CallOptions - Call options for the model.
+ *
+ * @param {string | ChatModelProvider} [model] - The name of the model, e.g. "gpt-4", "claude-3-opus-20240229".
+ * @param {Object} [fields] - Additional configuration options.
+ * @param {string} [fields.modelProvider] - The model provider. Supported values include:
+ *   - openai (@langchain/openai)
+ *   - anthropic (@langchain/anthropic)
+ *   - azure_openai (@langchain/openai)
+ *   - google-vertexai (@langchain/google-vertexai)
+ *   - google-genai (@langchain/google-genai)
+ *   - bedrock (@langchain/aws)
+ *   - cohere (@langchain/cohere)
+ *   - fireworks (@langchain/community/chat_models/fireworks)
+ *   - together (@langchain/community/chat_models/togetherai)
+ *   - mistralai (@langchain/mistralai)
+ *   - groq (@langchain/groq)
+ *   - ollama (@langchain/ollama)
+ * @param {string[] | "any"} [fields.configurableFields] - Which model parameters are configurable:
+ *   - undefined: No configurable fields.
+ *   - "any": All fields are configurable. (See Security Note in description)
+ *   - string[]: Specified fields are configurable.
+ * @param {string} [fields.configPrefix] - Prefix for configurable fields at runtime.
+ * @param {Record<string, any>} [fields.params] - Additional keyword args to pass to the ChatModel constructor.
+ * @returns {Promise<_ConfigurableModel<RunInput, CallOptions>>} A class which extends BaseChatModel.
+ * @throws {Error} If modelProvider cannot be inferred or isn't supported.
+ * @throws {Error} If the model provider integration package is not installed.
+ *
+ * @example Initialize non-configurable models
+ * ```typescript
+ * import { initChatModel } from "langchain/chat_models/universal";
+ *
+ * const gpt4 = await initChatModel("gpt-4", {
+ *   modelProvider: "openai",
+ *   temperature: 0.25,
+ * });
+ * const gpt4Result = await gpt4.invoke("what's your name");
+ *
+ * const claude = await initChatModel("claude-3-opus-20240229", {
+ *   modelProvider: "anthropic",
+ *   temperature: 0.25,
+ * });
+ * const claudeResult = await claude.invoke("what's your name");
+ *
+ * const gemini = await initChatModel("gemini-1.5-pro", {
+ *   modelProvider: "google-vertexai",
+ *   temperature: 0.25,
+ * });
+ * const geminiResult = await gemini.invoke("what's your name");
+ * ```
+ *
+ * @example Create a partially configurable model with no default model
+ * ```typescript
+ * import { initChatModel } from "langchain/chat_models/universal";
+ *
+ * const configurableModel = await initChatModel(undefined, {
+ *   temperature: 0,
+ *   configurableFields: ["model", "apiKey"],
+ * });
+ *
+ * const gpt4Result = await configurableModel.invoke("what's your name", {
+ *   configurable: {
+ *     model: "gpt-4",
+ *   },
+ * });
+ *
+ * const claudeResult = await configurableModel.invoke("what's your name", {
+ *   configurable: {
+ *     model: "claude-3-5-sonnet-20240620",
+ *   },
+ * });
+ * ```
+ *
+ * @example Create a fully configurable model with a default model and a config prefix
+ * ```typescript
+ * import { initChatModel } from "langchain/chat_models/universal";
+ *
+ * const configurableModelWithDefault = await initChatModel("gpt-4", {
+ *   modelProvider: "openai",
+ *   configurableFields: "any",
+ *   configPrefix: "foo",
+ *   temperature: 0,
+ * });
+ *
+ * const openaiResult = await configurableModelWithDefault.invoke(
+ *   "what's your name",
+ *   {
+ *     configurable: {
+ *       foo_apiKey: process.env.OPENAI_API_KEY,
+ *     },
+ *   }
+ * );
+ *
+ * const claudeResult = await configurableModelWithDefault.invoke(
+ *   "what's your name",
+ *   {
+ *     configurable: {
+ *       foo_model: "claude-3-5-sonnet-20240620",
+ *       foo_modelProvider: "anthropic",
+ *       foo_temperature: 0.6,
+ *       foo_apiKey: process.env.ANTHROPIC_API_KEY,
+ *     },
+ *   }
+ * );
+ * ```
+ *
+ * @example Bind tools to a configurable model:
+ * ```typescript
+ * import { initChatModel } from "langchain/chat_models/universal";
+ * import { z } from "zod";
+ * import { tool } from "@langchain/core/tools";
+ *
+ * const getWeatherTool = tool(
+ *   (input) => {
+ *     // Do something with the input
+ *     return JSON.stringify(input);
+ *   },
+ *   {
+ *     schema: z
+ *       .object({
+ *         location: z
+ *           .string()
+ *           .describe("The city and state, e.g. San Francisco, CA"),
+ *       })
+ *       .describe("Get the current weather in a given location"),
+ *     name: "GetWeather",
+ *     description: "Get the current weather in a given location",
+ *   }
+ * );
+ *
+ * const getPopulationTool = tool(
+ *   (input) => {
+ *     // Do something with the input
+ *     return JSON.stringify(input);
+ *   },
+ *   {
+ *     schema: z
+ *       .object({
+ *         location: z
+ *           .string()
+ *           .describe("The city and state, e.g. San Francisco, CA"),
+ *       })
+ *       .describe("Get the current population in a given location"),
+ *     name: "GetPopulation",
+ *     description: "Get the current population in a given location",
+ *   }
+ * );
+ *
+ * const configurableModel = await initChatModel("gpt-4", {
+ *   configurableFields: ["model", "modelProvider", "apiKey"],
+ *   temperature: 0,
+ * });
+ *
+ * const configurableModelWithTools = configurableModel.bind({
+ *   tools: [getWeatherTool, getPopulationTool],
+ * });
+ *
+ * const configurableToolResult = await configurableModelWithTools.invoke(
+ *   "Which city is hotter today and which is bigger: LA or NY?",
+ *   {
+ *     configurable: {
+ *       apiKey: process.env.OPENAI_API_KEY,
+ *     },
+ *   }
+ * );
+ *
+ * const configurableToolResult2 = await configurableModelWithTools.invoke(
+ *   "Which city is hotter today and which is bigger: LA or NY?",
+ *   {
+ *     configurable: {
+ *       model: "claude-3-5-sonnet-20240620",
+ *       apiKey: process.env.ANTHROPIC_API_KEY,
+ *     },
+ *   }
+ * );
+ * ```
+ *
+ * @description
+ * This function initializes a ChatModel based on the provided model name and provider.
+ * It supports various model providers and allows for runtime configuration of model parameters.
+ *
+ * Security Note: Setting `configurableFields` to "any" means fields like api_key, base_url, etc.
+ * can be altered at runtime, potentially redirecting model requests to a different service/user.
+ * Make sure that if you're accepting untrusted configurations, you enumerate the
+ * `configurableFields` explicitly.
+ *
+ * The function will attempt to infer the model provider from the model name if not specified.
+ * Certain model name prefixes are associated with specific providers:
+ * - gpt-3... or gpt-4... -> openai
+ * - claude... -> anthropic
+ * - amazon.... -> bedrock
+ * - gemini... -> google-vertexai
+ * - command... -> cohere
+ * - accounts/fireworks... -> fireworks
+ *
+ * @since 0.2.11
+ * @version 0.2.11
+ */
+export async function initChatModel(model, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+fields) {
+    const { configurableFields, configPrefix, modelProvider, ...params } = {
+        configPrefix: "",
+        ...(fields ?? {}),
+    };
+    let configurableFieldsCopy = configurableFields;
+    if (!model && !configurableFieldsCopy) {
+        configurableFieldsCopy = ["model", "modelProvider"];
+    }
+    if (configPrefix && !configurableFieldsCopy) {
+        console.warn(`{ configPrefix: ${configPrefix} } has been set but no fields are configurable. Set ` +
+            `{ configurableFields: [...] } to specify the model params that are ` +
+            `configurable.`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const paramsCopy = { ...params };
+    if (!configurableFieldsCopy) {
+        return new _ConfigurableModel({
+            defaultConfig: {
+                ...paramsCopy,
+                model,
+                modelProvider,
+            },
+            configPrefix,
+        });
+    }
+    else {
+        if (model) {
+            paramsCopy.model = model;
+        }
+        if (modelProvider) {
+            paramsCopy.modelProvider = modelProvider;
+        }
+        return new _ConfigurableModel({
+            defaultConfig: paramsCopy,
+            configPrefix,
+            configurableFields: configurableFieldsCopy,
+        });
+    }
+}

package/dist/document_loaders/web/assemblyai.cjs

@@ -10,6 +10,11 @@ const entrypoint_deprecation_js_1 = require("../../util/entrypoint_deprecation.c
     oldEntrypointName: "document_loaders/web/assemblyai",
     newPackageName: "@langchain/community",
 });
+const defaultOptions = {
+    userAgent: {
+        integration: { name: "LangChainJS", version: "1.0.1" },
+    },
+};
 /**
  * @deprecated
  * Base class for AssemblyAI loaders.
@@ -38,7 +43,10 @@ class AssemblyAILoader extends base_js_1.BaseDocumentLoader {
         if (!options.apiKey) {
             throw new Error("No AssemblyAI API key provided");
         }
-        this.client = new assemblyai_1.AssemblyAI(options);
+        this.client = new assemblyai_1.AssemblyAI({
+            ...defaultOptions,
+            ...options,
+        });
     }
 }
 /**

package/dist/document_loaders/web/assemblyai.js

@@ -7,6 +7,11 @@ import { logVersion020MigrationWarning } from "../../util/entrypoint_deprecation
     oldEntrypointName: "document_loaders/web/assemblyai",
     newPackageName: "@langchain/community",
 });
+const defaultOptions = {
+    userAgent: {
+        integration: { name: "LangChainJS", version: "1.0.1" },
+    },
+};
 /**
  * @deprecated
  * Base class for AssemblyAI loaders.
@@ -35,7 +40,10 @@ class AssemblyAILoader extends BaseDocumentLoader {
         if (!options.apiKey) {
             throw new Error("No AssemblyAI API key provided");
         }
-        this.client = new AssemblyAI(options);
+        this.client = new AssemblyAI({
+            ...defaultOptions,
+            ...options,
+        });
     }
 }
 /**