@langchain/core 1.1.4 → 1.1.5-dev-1765432861398

package/dist/language_models/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["TiktokenModel","ZodType","ZodTypeV3","$ZodType","ZodTypeV4","BaseCache","BasePromptValueInterface","BaseMessage","BaseMessageLike","MessageContent","LLMResult","CallbackManager","Callbacks","AsyncCaller","AsyncCallerParams","Runnable","RunnableInterface","RunnableConfig","JSONSchema","InferInteropZodOutput","InteropZodObject","InteropZodType","ModelProfile","getModelNameForTiktoken","getEmbeddingContextSize","getModelContextSize","isOpenAITool","ToolDefinition","CalculateMaxTokenProps","calculateMaxTokens","prompt","modelName","Promise","SerializedLLM","Record","BaseLangChainParams","BaseLangChain","RunInput","RunOutput","CallOptions","BaseLanguageModelParams","BaseLanguageModelTracingCallOptions","BaseLanguageModelCallOptions","FunctionDefinition","FunctionCallOption","BaseFunctionCallOptions","BaseLanguageModelInput","StructuredOutputType","StructuredOutputMethodOptions","IncludeRaw","StructuredOutputMethodParams","BaseLanguageModelInterface","LanguageModelOutput","LanguageModelLike","BaseLanguageModel","callbacks","callbackManager","config","TokenUsage"],"sources":["../../src/language_models/base.d.ts"],"sourcesContent":["import type { TiktokenModel } from \"js-tiktoken/lite\";\nimport type { ZodType as ZodTypeV3 } from \"zod/v3\";\nimport type { $ZodType as ZodTypeV4 } from \"zod/v4/core\";\nimport { type BaseCache } from \"../caches/index.js\";\nimport { type BasePromptValueInterface } from \"../prompt_values.js\";\nimport { type BaseMessage, type BaseMessageLike, type MessageContent } from \"../messages/base.js\";\nimport { type LLMResult } from \"../outputs.js\";\nimport { CallbackManager, Callbacks } from \"../callbacks/manager.js\";\nimport { AsyncCaller, AsyncCallerParams } from \"../utils/async_caller.js\";\nimport { Runnable, type RunnableInterface } from \"../runnables/base.js\";\nimport { RunnableConfig } from \"../runnables/config.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport { InferInteropZodOutput, InteropZodObject, InteropZodType } from \"../utils/types/zod.js\";\nimport { ModelProfile } from \"./profile.js\";\nexport declare const getModelNameForTiktoken: (modelName: string) => TiktokenModel;\nexport declare const getEmbeddingContextSize: (modelName?: string | undefined) => number;\n/**\n * Get the context window size (max input tokens) for a given model.\n *\n * Context window sizes are sourced from official model documentation:\n * - OpenAI: https://platform.openai.com/docs/models\n * - Anthropic: https://docs.anthropic.com/claude/docs/models-overview\n * - Google: https://ai.google.dev/gemini/docs/models/gemini\n *\n * @param modelName - The name of the model\n * @returns The context window size in tokens\n */\nexport declare const getModelContextSize: (modelName: string) => number;\n/**\n * Whether or not the input matches the OpenAI tool definition.\n * @param {unknown} tool The input to check.\n * @returns {boolean} Whether the input is an OpenAI tool definition.\n */\nexport declare function isOpenAITool(tool: unknown): tool is ToolDefinition;\ninterface CalculateMaxTokenProps {\n    prompt: string;\n    modelName: TiktokenModel;\n}\nexport declare const calculateMaxTokens: ({ prompt, modelName, }: CalculateMaxTokenProps) => Promise<number>;\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\nexport interface BaseLangChainParams {\n    verbose?: boolean;\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n}\n/**\n * Base class for language models, chains, tools.\n */\nexport declare abstract class BaseLangChain<RunInput, RunOutput, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> implements BaseLangChainParams {\n    /**\n     * Whether to print out response text.\n     */\n    verbose: boolean;\n    callbacks?: Callbacks;\n    tags?: string[];\n    metadata?: Record<string, unknown>;\n    get lc_attributes(): {\n        [key: string]: undefined;\n    } | undefined;\n    constructor(params: BaseLangChainParams);\n}\n/**\n * Base interface for language model parameters.\n * A subclass of {@link BaseLanguageModel} should have a constructor that\n * takes in a parameter that extends this interface.\n */\nexport interface BaseLanguageModelParams extends AsyncCallerParams, BaseLangChainParams {\n    /**\n     * @deprecated Use `callbacks` instead\n     */\n    callbackManager?: CallbackManager;\n    cache?: BaseCache | boolean;\n}\nexport interface BaseLanguageModelTracingCallOptions {\n    /**\n     * Describes the format of structured outputs.\n     * This should be provided if an output is considered to be structured\n     */\n    ls_structured_output_format?: {\n        /**\n         * An object containing the method used for structured output (e.g., \"jsonMode\").\n         */\n        kwargs: {\n            method: string;\n        };\n        /**\n         * The JSON schema describing the expected output structure.\n         */\n        schema?: JSONSchema;\n    };\n}\nexport interface BaseLanguageModelCallOptions extends RunnableConfig, BaseLanguageModelTracingCallOptions {\n    /**\n     * Stop tokens to use for this call.\n     * If not provided, the default stop tokens for the model will be used.\n     */\n    stop?: string[];\n}\nexport interface FunctionDefinition {\n    /**\n     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain\n     * underscores and dashes, with a maximum length of 64.\n     */\n    name: string;\n    /**\n     * The parameters the functions accepts, described as a JSON Schema object. See the\n     * [guide](https://platform.openai.com/docs/guides/gpt/function-calling) for\n     * examples, and the\n     * [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for\n     * documentation about the format.\n     *\n     * To describe a function that accepts no parameters, provide the value\n     * `{\"type\": \"object\", \"properties\": {}}`.\n     */\n    parameters: Record<string, unknown> | JSONSchema;\n    /**\n     * A description of what the function does, used by the model to choose when and\n     * how to call the function.\n     */\n    description?: string;\n}\nexport interface ToolDefinition {\n    type: \"function\";\n    function: FunctionDefinition;\n}\nexport type FunctionCallOption = {\n    name: string;\n};\nexport interface BaseFunctionCallOptions extends BaseLanguageModelCallOptions {\n    function_call?: FunctionCallOption;\n    functions?: FunctionDefinition[];\n}\nexport type BaseLanguageModelInput = BasePromptValueInterface | string | BaseMessageLike[];\nexport type StructuredOutputType = InferInteropZodOutput<InteropZodObject>;\nexport type StructuredOutputMethodOptions<IncludeRaw extends boolean = false> = {\n    name?: string;\n    method?: \"functionCalling\" | \"jsonMode\" | \"jsonSchema\" | string;\n    includeRaw?: IncludeRaw;\n    /** Whether to use strict mode. Currently only supported by OpenAI models. */\n    strict?: boolean;\n};\n/** @deprecated Use StructuredOutputMethodOptions instead */\nexport type StructuredOutputMethodParams<RunOutput, IncludeRaw extends boolean = false> = {\n    /** @deprecated Pass schema in as the first argument */\n    schema: InteropZodType<RunOutput> | Record<string, any>;\n    name?: string;\n    method?: \"functionCalling\" | \"jsonMode\";\n    includeRaw?: IncludeRaw;\n};\nexport interface BaseLanguageModelInterface<RunOutput = any, CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends RunnableInterface<BaseLanguageModelInput, RunOutput, CallOptions> {\n    get callKeys(): string[];\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    _modelType(): string;\n    _llmType(): string;\n    getNumTokens(content: MessageContent): Promise<number>;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    _identifyingParams(): Record<string, any>;\n    serialize(): SerializedLLM;\n}\nexport type LanguageModelOutput = BaseMessage | string;\nexport type LanguageModelLike = Runnable<BaseLanguageModelInput, LanguageModelOutput>;\n/**\n * Base class for language models.\n */\nexport declare abstract class BaseLanguageModel<RunOutput = any, CallOptions extends BaseLanguageModelCallOptions = BaseLanguageModelCallOptions> extends BaseLangChain<BaseLanguageModelInput, RunOutput, CallOptions> implements BaseLanguageModelParams, BaseLanguageModelInterface<RunOutput, CallOptions> {\n    /**\n     * Keys that the language model accepts as call options.\n     */\n    get callKeys(): string[];\n    /**\n     * The async caller should be used by subclasses to make any async calls,\n     * which will thus benefit from the concurrency and retry logic.\n     */\n    caller: AsyncCaller;\n    cache?: BaseCache;\n    constructor({ callbacks, callbackManager, ...params }: BaseLanguageModelParams);\n    abstract generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    abstract _modelType(): string;\n    abstract _llmType(): string;\n    private _encoding?;\n    /**\n     * Get the number of tokens in the content.\n     * @param content The content to get the number of tokens for.\n     * @returns The number of tokens in the content.\n     */\n    getNumTokens(content: MessageContent): Promise<number>;\n    protected static _convertInputToPromptValue(input: BaseLanguageModelInput): BasePromptValueInterface;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    _identifyingParams(): Record<string, any>;\n    /**\n     * Create a unique cache key for a specific call to a specific language model.\n     * @param callOptions Call options for the model\n     * @returns A unique cache key.\n     */\n    _getSerializedCacheKeyParametersForCall({ config, ...callOptions }: CallOptions & {\n        config?: RunnableConfig;\n    }): string;\n    /**\n     * @deprecated\n     * Return a json-like object representing this LLM.\n     */\n    serialize(): SerializedLLM;\n    /**\n     * @deprecated\n     * Load an LLM from a json-like object describing it.\n     */\n    static deserialize(_data: SerializedLLM): Promise<BaseLanguageModel>;\n    /**\n     * Return profiling information for the model.\n     *\n     * @returns {ModelProfile} An object describing the model's capabilities and constraints\n     */\n    get profile(): ModelProfile;\n    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    /**\n     * Model wrapper that returns outputs formatted to match the given schema.\n     *\n     * @template {BaseLanguageModelInput} RunInput The input type for the Runnable, expected to be the same input for the LLM.\n     * @template {Record<string, any>} RunOutput The output type for the Runnable, expected to be a Zod schema object for structured output validation.\n     *\n     * @param {InteropZodType<RunOutput>} schema The schema for the structured output. Either as a Zod schema or a valid JSON schema object.\n     *   If a Zod schema is passed, the returned attributes will be validated, whereas with JSON schema they will not be.\n     * @param {string} name The name of the function to call.\n     * @param {\"functionCalling\" | \"jsonMode\"} [method=functionCalling] The method to use for getting the structured output. Defaults to \"functionCalling\".\n     * @param {boolean | undefined} [includeRaw=false] Whether to include the raw output in the result. Defaults to false.\n     * @returns {Runnable<RunInput, RunOutput> | Runnable<RunInput, { raw: BaseMessage; parsed: RunOutput }>} A new runnable that calls the LLM with structured output.\n     */\n    withStructuredOutput?<RunOutput extends Record<string, any> = Record<string, any>>(schema: InteropZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n}\n/**\n * Shared interface for token usage\n * return type from LLM calls.\n */\nexport interface TokenUsage {\n    completionTokens?: number;\n    promptTokens?: number;\n    totalTokens?: number;\n}\nexport {};\n//# sourceMappingURL=base.d.ts.map"],"mappings":"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"}

package/dist/language_models/chat_models.d.cts

@@ -13,7 +13,6 @@ import { ZodType } from "zod/v3";
 import { $ZodType } from "zod/v4/core";
 
 //#region src/language_models/chat_models.d.ts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type ToolChoice = string | Record<string, any> | "auto" | "any";
 /**
  * Represents a serialized chat model.
@@ -22,7 +21,6 @@ type SerializedChatModel = {
   _model: string;
   _type: string;
 } & Record<string, any>;
-// todo?
 /**
  * Represents a serialized large language model.
  */
@@ -105,19 +103,13 @@ type LangSmithParams = {
   ls_max_tokens?: number;
   ls_stop?: Array<string>;
 };
-type BindToolsInput = StructuredToolInterface
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-| Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;
+type BindToolsInput = StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;
 /**
  * Base class for chat models. It extends the BaseLanguageModel class and
  * provides methods for generating chat based on input messages.
  */
-declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions,
-// TODO: Fix the parameter order on the next minor version.
-OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {
-  // Backwards compatibility since fields have been moved to RunnableConfig
+declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {
   ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, "signal" | "timeout" | "maxConcurrency">>;
-  // Only ever instantiated in main LangChain
   lc_namespace: string[];
   disableStreaming: boolean;
   outputVersion?: MessageOutputVersion;
@@ -141,7 +133,6 @@ OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguag
    * @returns A Promise that resolves to a BaseMessageChunk.
    */
   invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;
-  // eslint-disable-next-line require-yield
   _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
   _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;
   getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
@@ -157,7 +148,6 @@ OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguag
     messages: BaseMessageLike[][];
     cache: BaseCache<Generation[]>;
     llmStringKey: string;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     parsedOptions: any;
     handledOptions: RunnableConfig;
   }): Promise<LLMResult & {
@@ -175,7 +165,6 @@ OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguag
   /**
    * Get the parameters used to invoke the model
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   invocationParams(_options?: this["ParsedCallOptions"]): any;
   _modelType(): string;
   abstract _llmType(): string;
@@ -188,29 +177,13 @@ OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguag
    */
   generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
   abstract _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-  withStructuredOutput<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-  withStructuredOutput<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
     raw: BaseMessage;
     parsed: RunOutput;
   }>;
-  withStructuredOutput<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-  withStructuredOutput<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
     raw: BaseMessage;
     parsed: RunOutput;
   }>;

package/dist/language_models/chat_models.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_models.d.cts","names":["ZodType","ZodTypeV3","$ZodType","ZodTypeV4","BaseMessage","BaseMessageChunk","BaseMessageLike","AIMessageChunk","MessageOutputVersion","BasePromptValueInterface","LLMResult","ChatGenerationChunk","ChatResult","Generation","BaseLanguageModel","StructuredOutputMethodOptions","ToolDefinition","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","CallbackManagerForLLMRun","Callbacks","RunnableConfig","BaseCache","StructuredToolInterface","StructuredToolParams","Runnable","RunnableToolLike","ToolChoice","Record","SerializedChatModel","SerializedLLM","BaseChatModelParams","BaseChatModelCallOptions","LangSmithParams","Array","BindToolsInput","BaseChatModel","RunOutput","CallOptions","OutputMessageType","Exclude","Omit","Partial","Promise","AsyncGenerator","messages","cache","llmStringKey","parsedOptions","handledOptions","SimpleChatModel"],"sources":["../../src/language_models/chat_models.d.ts"],"sourcesContent":["import type { ZodType as ZodTypeV3 } from \"zod/v3\";\nimport type { $ZodType as ZodTypeV4 } from \"zod/v4/core\";\nimport { type BaseMessage, BaseMessageChunk, type BaseMessageLike, AIMessageChunk, MessageOutputVersion } from \"../messages/index.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { LLMResult, ChatGenerationChunk, type ChatResult, type Generation } from \"../outputs.js\";\nimport { BaseLanguageModel, type StructuredOutputMethodOptions, type ToolDefinition, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport { type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/index.js\";\nimport { StructuredToolInterface, StructuredToolParams } from \"../tools/index.js\";\nimport { Runnable, RunnableToolLike } from \"../runnables/base.js\";\nexport type ToolChoice = string | Record<string, any> | \"auto\" | \"any\";\n/**\n * Represents a serialized chat model.\n */\nexport type SerializedChatModel = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n/**\n * Represents a serialized large language model.\n */\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n/**\n * Represents the parameters for a base chat model.\n */\nexport type BaseChatModelParams = BaseLanguageModelParams & {\n    /**\n     * Whether to disable streaming.\n     *\n     * If streaming is bypassed, then `stream()` will defer to\n     * `invoke()`.\n     *\n     * - If true, will always bypass streaming case.\n     * - If false (default), will always use streaming case if available.\n     */\n    disableStreaming?: boolean;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\n/**\n * Represents the call options for a base chat model.\n */\nexport type BaseChatModelCallOptions = BaseLanguageModelCallOptions & {\n    /**\n     * Specifies how the chat model should use tools.\n     * @default undefined\n     *\n     * Possible values:\n     * - \"auto\": The model may choose to use any of the provided tools, or none.\n     * - \"any\": The model must use one of the provided tools.\n     * - \"none\": The model must not use any tools.\n     * - A string (not \"auto\", \"any\", or \"none\"): The name of a specific tool the model must use.\n     * - An object: A custom schema specifying tool choice parameters. Specific to the provider.\n     *\n     * Note: Not all providers support tool_choice. An error will be thrown\n     * if used with an unsupported model.\n     */\n    tool_choice?: ToolChoice;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\nexport type LangSmithParams = {\n    ls_provider?: string;\n    ls_model_name?: string;\n    ls_model_type: \"chat\";\n    ls_temperature?: number;\n    ls_max_tokens?: number;\n    ls_stop?: Array<string>;\n};\nexport type BindToolsInput = StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;\n/**\n * Base class for chat models. It extends the BaseLanguageModel class and\n * provides methods for generating chat based on input messages.\n */\nexport declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    lc_namespace: string[];\n    disableStreaming: boolean;\n    outputVersion?: MessageOutputVersion;\n    get callKeys(): string[];\n    constructor(fields: BaseChatModelParams);\n    _combineLLMOutput?(...llmOutputs: LLMResult[\"llmOutput\"][]): LLMResult[\"llmOutput\"];\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    /**\n     * Bind tool-like objects to this chat model.\n     *\n     * @param tools A list of tool definitions to bind to this chat model.\n     * Can be a structured tool, an OpenAI formatted tool, or an object\n     * matching the provider's specific tool schema.\n     * @param kwargs Any additional parameters to bind.\n     */\n    bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;\n    /**\n     * Invokes the chat model with a single input.\n     * @param input The input for the language model.\n     * @param options The call options.\n     * @returns A Promise that resolves to a BaseMessageChunk.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;\n    _streamResponseChunks(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;\n    getLsParams(options: this[\"ParsedCallOptions\"]): LangSmithParams;\n    /** @ignore */\n    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions }: {\n        messages: BaseMessageLike[][];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Generates chat based on the input messages.\n     * @param messages An array of arrays of BaseMessage instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _modelType(): string;\n    abstract _llmType(): string;\n    /**\n     * Generates a prompt based on the input prompt values.\n     * @param promptValues An array of BasePromptValue instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    abstract _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n}\n/**\n * An abstract class that extends BaseChatModel and provides a simple\n * implementation of _generate.\n */\nexport declare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {\n    abstract _call(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\n//# sourceMappingURL=chat_models.d.ts.map"],"mappings":";;;;;;;;;;;;;;;KAWY4B,UAAAA,YAAsBC;;;;AAAtBD,KAIAE,mBAAAA,GAJsBD;EAItBC,MAAAA,EAAAA,MAAAA;EAOAC,KAAAA,EAAAA,MAAAA;AAOZ,CAAA,GAXIF,MAWQG,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;AA+BZ;;;AA+BoBxB,KArERuB,aAAAA,GAqEQvB;EAAoB,MAAA,EAAA,MAAA;EAE5B0B,KAAAA,EAAAA,MAAAA;AAQZ,CAAA,GA5EIL,MA4EQO,CAAAA,MAAAA,EAAAA,GAAc,CAAA;;;;AAAoET,KAxElFK,mBAAAA,GAAsBb,uBAwE4DQ,GAAAA;EAAmBF;AAAoB;AAKrI;;;;;;;EAC4Bc,gBAAAA,CAAAA,EAAAA,OAAAA;EAA2BjB;;;;;;;;;;;;;;;EAgBqEiB,aAAAA,CAAAA,EApExG/B,oBAoEwG+B;CAApDb;;;;AAONkB,KAtEtDX,wBAAAA,GAA2BhB,4BAsE2B2B,GAAAA;EAC7BxC;;;;;;;;;;;;;;EAKf0C,WAAAA,CAAAA,EA7DJlB,UA6DIkB;EAAUC;;;;;;;;;;;;;;;EAiBsEH,aAAAA,CAAAA,EA9DlFpC,oBA8DkFoC;CAcrEnC;AAAiD8B,KA1EtEL,eAAAA,GA0EsEK;EAAyBlB,WAAAA,CAAAA,EAAAA,MAAAA;EAAoBX,aAAAA,CAAAA,EAAAA,MAAAA;EAARkC,aAAAA,EAAAA,MAAAA;EACtFxC,cAAAA,CAAAA,EAAAA,MAAAA;EAAgEgB,aAAAA,CAAAA,EAAAA,MAAAA;EAAmCR,OAAAA,CAAAA,EArEtHuB,KAqEsHvB,CAAAA,MAAAA,CAAAA;CAARgC;AACjFf,KApE/BO,cAAAA,GAAiBZ,uBAoEcK,GApEYA,MAoEZA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GApEkCb,cAoElCa,GApEmDF,gBAoEnDE,GApEsEJ,oBAoEtEI;;;;;AAA8Gd,uBA/D3HsB,aA+D2HtB,CAAAA,oBA/DzFkB,wBA+DyFlB,GA/D9DkB,wBA+D8DlB,EAAAA,0BA/DVV,gBA+DUU,GA/DSR,cA+DTQ,CAAAA,SA/DiCD,iBA+DjCC,CA/DmDyB,iBA+DnDzB,EA/DsEwB,WA+DtExB,CAAAA,CAAAA;EAAgDG,iBAAAA,EA9DlLwB,IA8DkLxB,CA9D7KqB,WA8D6KrB,EA9DhKuB,OA8DgKvB,CAAAA,MA9DlJI,cA8DkJJ,EAAAA,QAAAA,GAAAA,SAAAA,GAAAA,gBAAAA,CAAAA,CAAAA;EAAwBoB,YAAAA,EAAAA,MAAAA,EAAAA;EAAjCZ,gBAAAA,EAAAA,OAAAA;EACrJG,aAAAA,CAAAA,EA5DvBrB,oBA4DuBqB;EAAsBA,IAAAA,QAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA6CS,WAAAA,CAAAA,MAAAA,EA1DtFN,mBA0DsFM;EAAVnC,iBAAAA,CAAAA,CAAAA,GAAAA,UAAAA,EAzD9DO,SAyD8DP,CAAAA,WAAAA,CAAAA,EAAAA,CAAAA,EAzDnCO,SAyDmCP,CAAAA,WAAAA,CAAAA;EAAuB0B,UAAAA,4CAAAA,CAAAA,OAAAA,CAAAA,EAxDtDc,OAwDsDd,CAxD9CU,WAwD8CV,CAAAA,CAAAA,EAAAA,CAxD9BP,cAwD8BO,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,CAAAA;EAA8Bd;;;;;;;;EAIrDd,SAAAA,CAAAA,CAAAA,KAAAA,EAnD9EmC,cAmD8EnC,EAAAA,EAAAA,MAAAA,CAAAA,EAnDnD0C,OAmDmD1C,CAnD3CsC,WAmD2CtC,CAAAA,CAAAA,EAnD5ByB,QAmD4BzB,CAnDnBiB,sBAmDmBjB,EAnDKuC,iBAmDLvC,EAnDwBsC,WAmDxBtC,CAAAA;EAAuB4B;;;;;;EAC1DA,MAAAA,CAAAA,KAAAA,EA7C/CX,sBA6C+CW,EAAAA,OAAAA,CAAAA,EA7CbU,WA6CaV,CAAAA,EA7CCe,OA6CDf,CA7CSW,iBA6CTX,CAAAA;EAA6CS,qBAAAA,CAAAA,SAAAA,EA5CzElC,WA4CyEkC,EAAAA,EAAAA,QAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,EAAAA,WAAAA,CAAAA,EA5CPlB,wBA4COkB,CAAAA,EA5CoBO,cA4CpBP,CA5CmC3B,mBA4CnC2B,CAAAA;EAAVrC,eAAAA,CAAAA,KAAAA,EA3CzEiB,sBA2CyEjB,EAAAA,OAAAA,CAAAA,EA3CvCsC,WA2CuCtC,CAAAA,EA3CzB4C,cA2CyB5C,CA3CVuC,iBA2CUvC,CAAAA;EAAuB4B,WAAAA,CAAAA,OAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,CAAAA,EA1CtEK,eA0CsEL;EAA8Bd;EAA+CG,iBAAAA,CAAAA,QAAAA,EAxCxKZ,eAwCwKY,EAAAA,EAAAA,EAAAA,aAAAA,EAAAA,IAAAA,CAAAA,mBAAAA,CAAAA,EAAAA,cAAAA,EAxCzFI,cAwCyFJ,EAAAA,kBAAAA,CAAAA,EAxCpDE,wBAwCoDF,EAAAA,CAAAA,EAxCvB0B,OAwCuB1B,CAxCfR,SAwCeQ,CAAAA;EAC3Ld,eAAAA,CAAAA;IAAAA,QAAAA;IAAAA,KAAAA;IAAAA,YAAAA;IAAAA,aAAAA;IAAAA;EAQqD6B,CARrD7B,EAAAA;IACGkC,QAAAA,EAxCEhC,eAwCFgC,EAAAA,EAAAA;IAF+KZ,KAAAA,EArChLH,SAqCgLG,CArCtKb,UAqCsKa,EAAAA,CAAAA;IArELZ,YAAAA,EAAAA,MAAAA;IAAiB,aAAA,EAAA,GAAA;IA8E7KqC,cAAe,EA3CrB7B,cA2CqBiB;EAAqBN,CAAAA,CAAAA,EA1C1DW,OA0C0DX,CA1ClDvB,SA0CkDuB,GAAAA;IAA2BA,oBAAAA,EAAAA,MAAAA,EAAAA;IAAgDM,kBAAAA,CAAAA,EAxChHnB,wBAwCgHmB,EAAAA;EAChHnC,CAAAA,CAAAA;EAAgEgB;;;;;;;EAD+C,QAAA,CAAA,QAAA,EA/BrHd,eA+BqH,EAAA,EAAA,EAAA,OAAA,CAAA,EAAA,MAAA,EAAA,GA/B3EiC,WA+B2E,EAAA,SAAA,CAAA,EA/BlDlB,SA+BkD,CAAA,EA/BtCuB,OA+BsC,CA/B9BlC,SA+B8B,CAAA;;;;;;;;;;;;;;+BAjB3GD,iDAAiD8B,yBAAyBlB,YAAYuB,QAAQlC;+BAC9FN,gEAAgEgB,2BAA2BwB,QAAQhC;yCACzFiB,sBAAsBA,mCAAmC1B,SAAUmC,aAAaT,8BAA8Bd,uCAAuCW,SAASR,wBAAwBoB;yCACtLT,sBAAsBA,mCAAmC1B,SAAUmC,aAAaT,8BAA8Bd,sCAAsCW,SAASR;SAC3Ld;YACGkC;;yCAE2BT,sBAAsBA,mCAAmC5B,QAAUqC,aAAaT,8BAA8Bd,uCAAuCW,SAASR,wBAAwBoB;yCACtLT,sBAAsBA,mCAAmC5B,QAAUqC,aAAaT,8BAA8Bd,sCAAsCW,SAASR;SAC3Ld;YACGkC;;;;;;;uBAOca,oCAAoClB,2BAA2BA,kCAAkCI,cAAcE;2BAChHnC,gEAAgEgB,2BAA2BwB;sBAChGxC,gEAAgEgB,2BAA2BwB,QAAQhC"}

package/dist/language_models/chat_models.d.ts

@@ -16,7 +16,6 @@ import { ZodType } from "zod/v3";
 import { $ZodType } from "zod/v4/core";
 
 //#region src/language_models/chat_models.d.ts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type ToolChoice = string | Record<string, any> | "auto" | "any";
 /**
  * Represents a serialized chat model.
@@ -25,7 +24,6 @@ type SerializedChatModel = {
   _model: string;
   _type: string;
 } & Record<string, any>;
-// todo?
 /**
  * Represents a serialized large language model.
  */
@@ -108,19 +106,13 @@ type LangSmithParams = {
   ls_max_tokens?: number;
   ls_stop?: Array<string>;
 };
-type BindToolsInput = StructuredToolInterface
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-| Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;
+type BindToolsInput = StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;
 /**
  * Base class for chat models. It extends the BaseLanguageModel class and
  * provides methods for generating chat based on input messages.
  */
-declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions,
-// TODO: Fix the parameter order on the next minor version.
-OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {
-  // Backwards compatibility since fields have been moved to RunnableConfig
+declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {
   ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, "signal" | "timeout" | "maxConcurrency">>;
-  // Only ever instantiated in main LangChain
   lc_namespace: string[];
   disableStreaming: boolean;
   outputVersion?: MessageOutputVersion;
@@ -144,7 +136,6 @@ OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguag
    * @returns A Promise that resolves to a BaseMessageChunk.
    */
   invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;
-  // eslint-disable-next-line require-yield
   _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
   _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;
   getLsParams(options: this["ParsedCallOptions"]): LangSmithParams;
@@ -160,7 +151,6 @@ OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguag
     messages: BaseMessageLike[][];
     cache: BaseCache<Generation[]>;
     llmStringKey: string;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     parsedOptions: any;
     handledOptions: RunnableConfig;
   }): Promise<LLMResult & {
@@ -178,7 +168,6 @@ OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguag
   /**
    * Get the parameters used to invoke the model
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   invocationParams(_options?: this["ParsedCallOptions"]): any;
   _modelType(): string;
   abstract _llmType(): string;
@@ -191,29 +180,13 @@ OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguag
    */
   generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
   abstract _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-  withStructuredOutput<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-  withStructuredOutput<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: $ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
     raw: BaseMessage;
     parsed: RunOutput;
   }>;
-  withStructuredOutput<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-  withStructuredOutput<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+  withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
     raw: BaseMessage;
     parsed: RunOutput;
   }>;

package/dist/language_models/chat_models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_models.d.ts","names":["ZodType","ZodTypeV3","$ZodType","ZodTypeV4","BaseMessage","BaseMessageChunk","BaseMessageLike","AIMessageChunk","MessageOutputVersion","BasePromptValueInterface","LLMResult","ChatGenerationChunk","ChatResult","Generation","BaseLanguageModel","StructuredOutputMethodOptions","ToolDefinition","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","CallbackManagerForLLMRun","Callbacks","RunnableConfig","BaseCache","StructuredToolInterface","StructuredToolParams","Runnable","RunnableToolLike","ToolChoice","Record","SerializedChatModel","SerializedLLM","BaseChatModelParams","BaseChatModelCallOptions","LangSmithParams","Array","BindToolsInput","BaseChatModel","RunOutput","CallOptions","OutputMessageType","Exclude","Omit","Partial","Promise","AsyncGenerator","messages","cache","llmStringKey","parsedOptions","handledOptions","SimpleChatModel"],"sources":["../../src/language_models/chat_models.d.ts"],"sourcesContent":["import type { ZodType as ZodTypeV3 } from \"zod/v3\";\nimport type { $ZodType as ZodTypeV4 } from \"zod/v4/core\";\nimport { type BaseMessage, BaseMessageChunk, type BaseMessageLike, AIMessageChunk, MessageOutputVersion } from \"../messages/index.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { LLMResult, ChatGenerationChunk, type ChatResult, type Generation } from \"../outputs.js\";\nimport { BaseLanguageModel, type StructuredOutputMethodOptions, type ToolDefinition, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport { type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/index.js\";\nimport { StructuredToolInterface, StructuredToolParams } from \"../tools/index.js\";\nimport { Runnable, RunnableToolLike } from \"../runnables/base.js\";\nexport type ToolChoice = string | Record<string, any> | \"auto\" | \"any\";\n/**\n * Represents a serialized chat model.\n */\nexport type SerializedChatModel = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n/**\n * Represents a serialized large language model.\n */\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\n/**\n * Represents the parameters for a base chat model.\n */\nexport type BaseChatModelParams = BaseLanguageModelParams & {\n    /**\n     * Whether to disable streaming.\n     *\n     * If streaming is bypassed, then `stream()` will defer to\n     * `invoke()`.\n     *\n     * - If true, will always bypass streaming case.\n     * - If false (default), will always use streaming case if available.\n     */\n    disableStreaming?: boolean;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\n/**\n * Represents the call options for a base chat model.\n */\nexport type BaseChatModelCallOptions = BaseLanguageModelCallOptions & {\n    /**\n     * Specifies how the chat model should use tools.\n     * @default undefined\n     *\n     * Possible values:\n     * - \"auto\": The model may choose to use any of the provided tools, or none.\n     * - \"any\": The model must use one of the provided tools.\n     * - \"none\": The model must not use any tools.\n     * - A string (not \"auto\", \"any\", or \"none\"): The name of a specific tool the model must use.\n     * - An object: A custom schema specifying tool choice parameters. Specific to the provider.\n     *\n     * Note: Not all providers support tool_choice. An error will be thrown\n     * if used with an unsupported model.\n     */\n    tool_choice?: ToolChoice;\n    /**\n     * Version of `AIMessage` output format to store in message content.\n     *\n     * `AIMessage.contentBlocks` will lazily parse the contents of `content` into a\n     * standard format. This flag can be used to additionally store the standard format\n     * as the message content, e.g., for serialization purposes.\n     *\n     * - \"v0\": provider-specific format in content (can lazily parse with `.contentBlocks`)\n     * - \"v1\": standardized format in content (consistent with `.contentBlocks`)\n     *\n     * You can also set `LC_OUTPUT_VERSION` as an environment variable to \"v1\" to\n     * enable this by default.\n     *\n     * @default \"v0\"\n     */\n    outputVersion?: MessageOutputVersion;\n};\nexport type LangSmithParams = {\n    ls_provider?: string;\n    ls_model_name?: string;\n    ls_model_type: \"chat\";\n    ls_temperature?: number;\n    ls_max_tokens?: number;\n    ls_stop?: Array<string>;\n};\nexport type BindToolsInput = StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike | StructuredToolParams;\n/**\n * Base class for chat models. It extends the BaseLanguageModel class and\n * provides methods for generating chat based on input messages.\n */\nexport declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions, OutputMessageType extends BaseMessageChunk = AIMessageChunk> extends BaseLanguageModel<OutputMessageType, CallOptions> {\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    lc_namespace: string[];\n    disableStreaming: boolean;\n    outputVersion?: MessageOutputVersion;\n    get callKeys(): string[];\n    constructor(fields: BaseChatModelParams);\n    _combineLLMOutput?(...llmOutputs: LLMResult[\"llmOutput\"][]): LLMResult[\"llmOutput\"];\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    /**\n     * Bind tool-like objects to this chat model.\n     *\n     * @param tools A list of tool definitions to bind to this chat model.\n     * Can be a structured tool, an OpenAI formatted tool, or an object\n     * matching the provider's specific tool schema.\n     * @param kwargs Any additional parameters to bind.\n     */\n    bindTools?(tools: BindToolsInput[], kwargs?: Partial<CallOptions>): Runnable<BaseLanguageModelInput, OutputMessageType, CallOptions>;\n    /**\n     * Invokes the chat model with a single input.\n     * @param input The input for the language model.\n     * @param options The call options.\n     * @returns A Promise that resolves to a BaseMessageChunk.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<OutputMessageType>;\n    _streamResponseChunks(_messages: BaseMessage[], _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<OutputMessageType>;\n    getLsParams(options: this[\"ParsedCallOptions\"]): LangSmithParams;\n    /** @ignore */\n    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: RunnableConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ messages, cache, llmStringKey, parsedOptions, handledOptions }: {\n        messages: BaseMessageLike[][];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Generates chat based on the input messages.\n     * @param messages An array of arrays of BaseMessage instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _modelType(): string;\n    abstract _llmType(): string;\n    /**\n     * Generates a prompt based on the input prompt values.\n     * @param promptValues An array of BasePromptValue instances.\n     * @param options The call options or an array of stop sequences.\n     * @param callbacks The callbacks for the language model.\n     * @returns A Promise that resolves to an LLMResult.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    abstract _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV4<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;\n    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: ZodTypeV3<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {\n        raw: BaseMessage;\n        parsed: RunOutput;\n    }>;\n}\n/**\n * An abstract class that extends BaseChatModel and provides a simple\n * implementation of _generate.\n */\nexport declare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {\n    abstract _call(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(messages: BaseMessage[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;\n}\n//# sourceMappingURL=chat_models.d.ts.map"],"mappings":"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"}

package/dist/language_models/llms.d.cts

@@ -16,9 +16,7 @@ interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {}
  * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
  */
 declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLanguageModel<string, CallOptions> {
-  // Backwards compatibility since fields have been moved to RunnableConfig
   ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, "signal" | "timeout" | "maxConcurrency">>;
-  // Only ever instantiated in main LangChain
   lc_namespace: string[];
   /**
    * This method takes an input and options, and returns a string. It
@@ -29,7 +27,6 @@ declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMC
    * @returns A string result based on the prompt.
    */
   invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;
-  // eslint-disable-next-line require-yield
   _streamResponseChunks(_input: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
   protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
   _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;
@@ -49,7 +46,6 @@ declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMC
   /**
    * Get the parameters used to invoke the model
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   invocationParams(_options?: this["ParsedCallOptions"]): any;
   _flattenLLMResult(llmResult: LLMResult): LLMResult[];
   /** @ignore */
@@ -65,7 +61,6 @@ declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMC
     prompts: string[];
     cache: BaseCache<Generation[]>;
     llmStringKey: string;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     parsedOptions: any;
     handledOptions: RunnableConfig;
     runId?: string;
@@ -80,7 +75,6 @@ declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMC
   /**
    * Get the identifying parameters of the LLM.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   _identifyingParams(): Record<string, any>;
   /**
    * Return the string type key uniquely identifying this class of LLM.

package/dist/language_models/llms.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llms.d.cts","names":["BasePromptValueInterface","LLMResult","Generation","GenerationChunk","BaseCallbackConfig","CallbackManagerForLLMRun","Callbacks","BaseLanguageModel","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","RunnableConfig","BaseCache","SerializedLLM","Record","BaseLLMParams","BaseLLMCallOptions","BaseLLM","CallOptions","Exclude","Omit","Promise","AsyncGenerator","Partial","prompts","cache","llmStringKey","parsedOptions","handledOptions","runId","LLM"],"sources":["../../src/language_models/llms.d.ts"],"sourcesContent":["import type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { type LLMResult, type Generation, GenerationChunk } from \"../outputs.js\";\nimport { type BaseCallbackConfig, type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport { BaseLanguageModel, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/index.js\";\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\nexport interface BaseLLMParams extends BaseLanguageModelParams {\n}\nexport interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {\n}\n/**\n * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.\n */\nexport declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLanguageModel<string, CallOptions> {\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    lc_namespace: string[];\n    /**\n     * This method takes an input and options, and returns a string. It\n     * converts the input to a prompt value and generates a result based on\n     * the prompt.\n     * @param input Input for the LLM.\n     * @param options Options for the LLM call.\n     * @returns A string result based on the prompt.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;\n    _streamResponseChunks(_input: string, _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;\n    /**\n     * This method takes prompt values, options, and callbacks, and generates\n     * a result based on the prompts.\n     * @param promptValues Prompt values for the LLM.\n     * @param options Options for the LLM call.\n     * @param callbacks Callbacks for the LLM call.\n     * @returns An LLMResult based on the prompts.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Run the LLM on the given prompts and input.\n     */\n    abstract _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _flattenLLMResult(llmResult: LLMResult): LLMResult[];\n    /** @ignore */\n    _generateUncached(prompts: string[], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: BaseCallbackConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId }: {\n        prompts: string[];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n        runId?: string;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Run the LLM on the given prompts and input, handling caching.\n     */\n    generate(prompts: string[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    _identifyingParams(): Record<string, any>;\n    /**\n     * Return the string type key uniquely identifying this class of LLM.\n     */\n    abstract _llmType(): string;\n    _modelType(): string;\n}\n/**\n * LLM class that provides a simpler interface to subclass than {@link BaseLLM}.\n *\n * Requires only implementing a simpler {@link _call} method instead of {@link _generate}.\n *\n * @augments BaseLLM\n */\nexport declare abstract class LLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLLM<CallOptions> {\n    /**\n     * Run the LLM on the given prompt and input.\n     */\n    abstract _call(prompt: string, options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n}\n//# sourceMappingURL=llms.d.ts.map"],"mappings":"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"}

package/dist/language_models/llms.d.ts

@@ -17,9 +17,7 @@ interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {}
  * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.
  */
 declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLanguageModel<string, CallOptions> {
-  // Backwards compatibility since fields have been moved to RunnableConfig
   ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, "signal" | "timeout" | "maxConcurrency">>;
-  // Only ever instantiated in main LangChain
   lc_namespace: string[];
   /**
    * This method takes an input and options, and returns a string. It
@@ -30,7 +28,6 @@ declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMC
    * @returns A string result based on the prompt.
    */
   invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;
-  // eslint-disable-next-line require-yield
   _streamResponseChunks(_input: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
   protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
   _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;
@@ -50,7 +47,6 @@ declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMC
   /**
    * Get the parameters used to invoke the model
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   invocationParams(_options?: this["ParsedCallOptions"]): any;
   _flattenLLMResult(llmResult: LLMResult): LLMResult[];
   /** @ignore */
@@ -66,7 +62,6 @@ declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMC
     prompts: string[];
     cache: BaseCache<Generation[]>;
     llmStringKey: string;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     parsedOptions: any;
     handledOptions: RunnableConfig;
     runId?: string;
@@ -81,7 +76,6 @@ declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMC
   /**
    * Get the identifying parameters of the LLM.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   _identifyingParams(): Record<string, any>;
   /**
    * Return the string type key uniquely identifying this class of LLM.

package/dist/language_models/llms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llms.d.ts","names":["BasePromptValueInterface","LLMResult","Generation","GenerationChunk","BaseCallbackConfig","CallbackManagerForLLMRun","Callbacks","BaseLanguageModel","BaseLanguageModelCallOptions","BaseLanguageModelInput","BaseLanguageModelParams","RunnableConfig","BaseCache","SerializedLLM","Record","BaseLLMParams","BaseLLMCallOptions","BaseLLM","CallOptions","Exclude","Omit","Promise","AsyncGenerator","Partial","prompts","cache","llmStringKey","parsedOptions","handledOptions","runId","LLM"],"sources":["../../src/language_models/llms.d.ts"],"sourcesContent":["import type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport { type LLMResult, type Generation, GenerationChunk } from \"../outputs.js\";\nimport { type BaseCallbackConfig, type CallbackManagerForLLMRun, type Callbacks } from \"../callbacks/manager.js\";\nimport { BaseLanguageModel, type BaseLanguageModelCallOptions, type BaseLanguageModelInput, type BaseLanguageModelParams } from \"./base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BaseCache } from \"../caches/index.js\";\nexport type SerializedLLM = {\n    _model: string;\n    _type: string;\n} & Record<string, any>;\nexport interface BaseLLMParams extends BaseLanguageModelParams {\n}\nexport interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {\n}\n/**\n * LLM Wrapper. Takes in a prompt (or prompts) and returns a string.\n */\nexport declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLanguageModel<string, CallOptions> {\n    ParsedCallOptions: Omit<CallOptions, Exclude<keyof RunnableConfig, \"signal\" | \"timeout\" | \"maxConcurrency\">>;\n    lc_namespace: string[];\n    /**\n     * This method takes an input and options, and returns a string. It\n     * converts the input to a prompt value and generates a result based on\n     * the prompt.\n     * @param input Input for the LLM.\n     * @param options Options for the LLM call.\n     * @returns A string result based on the prompt.\n     */\n    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;\n    _streamResponseChunks(_input: string, _options: this[\"ParsedCallOptions\"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;\n    protected _separateRunnableConfigFromCallOptionsCompat(options?: Partial<CallOptions>): [RunnableConfig, this[\"ParsedCallOptions\"]];\n    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;\n    /**\n     * This method takes prompt values, options, and callbacks, and generates\n     * a result based on the prompts.\n     * @param promptValues Prompt values for the LLM.\n     * @param options Options for the LLM call.\n     * @param callbacks Callbacks for the LLM call.\n     * @returns An LLMResult based on the prompts.\n     */\n    generatePrompt(promptValues: BasePromptValueInterface[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Run the LLM on the given prompts and input.\n     */\n    abstract _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n    /**\n     * Get the parameters used to invoke the model\n     */\n    invocationParams(_options?: this[\"ParsedCallOptions\"]): any;\n    _flattenLLMResult(llmResult: LLMResult): LLMResult[];\n    /** @ignore */\n    _generateUncached(prompts: string[], parsedOptions: this[\"ParsedCallOptions\"], handledOptions: BaseCallbackConfig, startedRunManagers?: CallbackManagerForLLMRun[]): Promise<LLMResult>;\n    _generateCached({ prompts, cache, llmStringKey, parsedOptions, handledOptions, runId }: {\n        prompts: string[];\n        cache: BaseCache<Generation[]>;\n        llmStringKey: string;\n        parsedOptions: any;\n        handledOptions: RunnableConfig;\n        runId?: string;\n    }): Promise<LLMResult & {\n        missingPromptIndices: number[];\n        startedRunManagers?: CallbackManagerForLLMRun[];\n    }>;\n    /**\n     * Run the LLM on the given prompts and input, handling caching.\n     */\n    generate(prompts: string[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;\n    /**\n     * Get the identifying parameters of the LLM.\n     */\n    _identifyingParams(): Record<string, any>;\n    /**\n     * Return the string type key uniquely identifying this class of LLM.\n     */\n    abstract _llmType(): string;\n    _modelType(): string;\n}\n/**\n * LLM class that provides a simpler interface to subclass than {@link BaseLLM}.\n *\n * Requires only implementing a simpler {@link _call} method instead of {@link _generate}.\n *\n * @augments BaseLLM\n */\nexport declare abstract class LLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLLM<CallOptions> {\n    /**\n     * Run the LLM on the given prompt and input.\n     */\n    abstract _call(prompt: string, options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<string>;\n    _generate(prompts: string[], options: this[\"ParsedCallOptions\"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;\n}\n//# sourceMappingURL=llms.d.ts.map"],"mappings":"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"}

package/dist/language_models/profile.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.cts","names":["ModelProfile"],"sources":["../../src/language_models/profile.d.ts"],"sourcesContent":["/**\n * Represents the capabilities and constraints of a language model.\n *\n * This interface defines the various features and limitations that a model may have,\n * including input/output constraints, multimodal support, and advanced capabilities\n * like tool calling and structured output.\n */\nexport interface ModelProfile {\n    /**\n     * Maximum number of tokens that can be included in the input context window.\n     *\n     * This represents the total token budget for the model's input, including\n     * the prompt, system messages, conversation history, and any other context.\n     *\n     * @example\n     * ```typescript\n     * const profile: ModelProfile = {\n     *   maxInputTokens: 128000 // Model supports up to 128k tokens\n     * };\n     * ```\n     */\n    maxInputTokens?: number;\n    /**\n     * Whether the model supports image inputs.\n     *\n     * When `true`, the model can process images as part of its input, enabling\n     * multimodal interactions where visual content can be analyzed alongside text.\n     *\n     * @see {@link imageUrlInputs} for URL-based image input support\n     */\n    imageInputs?: boolean;\n    /**\n     * Whether the model supports image URL inputs.\n     *\n     * When `true`, the model can accept URLs pointing to images rather than\n     * requiring the image data to be embedded directly in the request. This can\n     * be more efficient for large images or when images are already hosted.\n     *\n     * @see {@link imageInputs} for direct image input support\n     */\n    imageUrlInputs?: boolean;\n    /**\n     * Whether the model supports PDF document inputs.\n     *\n     * When `true`, the model can process PDF files as input, allowing it to\n     * analyze document content, extract information, or answer questions about\n     * PDF documents.\n     */\n    pdfInputs?: boolean;\n    /**\n     * Whether the model supports audio inputs.\n     *\n     * When `true`, the model can process audio data as input, enabling\n     * capabilities like speech recognition, audio analysis, or multimodal\n     * interactions involving sound.\n     */\n    audioInputs?: boolean;\n    /**\n     * Whether the model supports video inputs.\n     *\n     * When `true`, the model can process video data as input, enabling\n     * capabilities like video analysis, scene understanding, or multimodal\n     * interactions involving moving images.\n     */\n    videoInputs?: boolean;\n    /**\n     * Whether the model supports image content in tool messages.\n     *\n     * When `true`, tool responses can include images that the model can process\n     * and reason about. This enables workflows where tools return visual data\n     * that the model needs to interpret.\n     */\n    imageToolMessage?: boolean;\n    /**\n     * Whether the model supports PDF content in tool messages.\n     *\n     * When `true`, tool responses can include PDF documents that the model can\n     * process and reason about. This enables workflows where tools return\n     * document data that the model needs to interpret.\n     */\n    pdfToolMessage?: boolean;\n    /**\n     * Maximum number of tokens the model can generate in its output.\n     *\n     * This represents the upper limit on the length of the model's response.\n     * The actual output may be shorter depending on the completion criteria\n     * (e.g., natural stopping point, stop sequences).\n     *\n     * @example\n     * ```typescript\n     * const profile: ModelProfile = {\n     *   maxOutputTokens: 4096 // Model can generate up to 4k tokens\n     * };\n     * ```\n     */\n    maxOutputTokens?: number;\n    /**\n     * Whether the model supports reasoning or chain-of-thought output.\n     *\n     * When `true`, the model can produce explicit reasoning steps or\n     * chain-of-thought explanations as part of its output. This is useful\n     * for understanding the model's decision-making process and improving\n     * transparency in complex reasoning tasks.\n     */\n    reasoningOutput?: boolean;\n    /**\n     * Whether the model can generate image outputs.\n     *\n     * When `true`, the model can produce images as part of its response,\n     * enabling capabilities like image generation, editing, or visual\n     * content creation.\n     */\n    imageOutputs?: boolean;\n    /**\n     * Whether the model can generate audio outputs.\n     *\n     * When `true`, the model can produce audio data as part of its response,\n     * enabling capabilities like text-to-speech, audio generation, or\n     * sound synthesis.\n     */\n    audioOutputs?: boolean;\n    /**\n     * Whether the model can generate video outputs.\n     *\n     * When `true`, the model can produce video data as part of its response,\n     * enabling capabilities like video generation, editing, or visual\n     * content creation with motion.\n     */\n    videoOutputs?: boolean;\n    /**\n     * Whether the model supports tool calling (function calling).\n     *\n     * When `true`, the model can invoke external tools or functions during\n     * its reasoning process. The model can decide which tools to call,\n     * with what arguments, and can incorporate the tool results into its\n     * final response.\n     *\n     * @see {@link toolChoice} for controlling tool selection behavior\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/models#tool-calling}\n     */\n    toolCalling?: boolean;\n    /**\n     * Whether the model supports tool choice control.\n     *\n     * When `true`, the caller can specify how the model should select tools,\n     * such as forcing the use of a specific tool, allowing any tool, or\n     * preventing tool use entirely. This provides fine-grained control over\n     * the model's tool-calling behavior.\n     *\n     * @see {@link toolCalling} for basic tool calling support\n     */\n    toolChoice?: boolean;\n    /**\n     * Whether the model supports structured output generation.\n     *\n     * When `true`, the model can generate responses that conform to a\n     * specified schema or structure (e.g., JSON with a particular format).\n     * This is useful for ensuring the model's output can be reliably parsed\n     * and processed programmatically.\n     *\n     * @example\n     * ```typescript\n     * // Model can be instructed to return JSON matching a schema\n     * const profile: ModelProfile = {\n     *   structuredOutput: true\n     * };\n     * ```\n     */\n    structuredOutput?: boolean;\n}\n//# sourceMappingURL=profile.d.ts.map"],"mappings":";;AAOA;;;;;;UAAiBA,YAAAA"}

package/dist/language_models/profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile.d.ts","names":["ModelProfile"],"sources":["../../src/language_models/profile.d.ts"],"sourcesContent":["/**\n * Represents the capabilities and constraints of a language model.\n *\n * This interface defines the various features and limitations that a model may have,\n * including input/output constraints, multimodal support, and advanced capabilities\n * like tool calling and structured output.\n */\nexport interface ModelProfile {\n    /**\n     * Maximum number of tokens that can be included in the input context window.\n     *\n     * This represents the total token budget for the model's input, including\n     * the prompt, system messages, conversation history, and any other context.\n     *\n     * @example\n     * ```typescript\n     * const profile: ModelProfile = {\n     *   maxInputTokens: 128000 // Model supports up to 128k tokens\n     * };\n     * ```\n     */\n    maxInputTokens?: number;\n    /**\n     * Whether the model supports image inputs.\n     *\n     * When `true`, the model can process images as part of its input, enabling\n     * multimodal interactions where visual content can be analyzed alongside text.\n     *\n     * @see {@link imageUrlInputs} for URL-based image input support\n     */\n    imageInputs?: boolean;\n    /**\n     * Whether the model supports image URL inputs.\n     *\n     * When `true`, the model can accept URLs pointing to images rather than\n     * requiring the image data to be embedded directly in the request. This can\n     * be more efficient for large images or when images are already hosted.\n     *\n     * @see {@link imageInputs} for direct image input support\n     */\n    imageUrlInputs?: boolean;\n    /**\n     * Whether the model supports PDF document inputs.\n     *\n     * When `true`, the model can process PDF files as input, allowing it to\n     * analyze document content, extract information, or answer questions about\n     * PDF documents.\n     */\n    pdfInputs?: boolean;\n    /**\n     * Whether the model supports audio inputs.\n     *\n     * When `true`, the model can process audio data as input, enabling\n     * capabilities like speech recognition, audio analysis, or multimodal\n     * interactions involving sound.\n     */\n    audioInputs?: boolean;\n    /**\n     * Whether the model supports video inputs.\n     *\n     * When `true`, the model can process video data as input, enabling\n     * capabilities like video analysis, scene understanding, or multimodal\n     * interactions involving moving images.\n     */\n    videoInputs?: boolean;\n    /**\n     * Whether the model supports image content in tool messages.\n     *\n     * When `true`, tool responses can include images that the model can process\n     * and reason about. This enables workflows where tools return visual data\n     * that the model needs to interpret.\n     */\n    imageToolMessage?: boolean;\n    /**\n     * Whether the model supports PDF content in tool messages.\n     *\n     * When `true`, tool responses can include PDF documents that the model can\n     * process and reason about. This enables workflows where tools return\n     * document data that the model needs to interpret.\n     */\n    pdfToolMessage?: boolean;\n    /**\n     * Maximum number of tokens the model can generate in its output.\n     *\n     * This represents the upper limit on the length of the model's response.\n     * The actual output may be shorter depending on the completion criteria\n     * (e.g., natural stopping point, stop sequences).\n     *\n     * @example\n     * ```typescript\n     * const profile: ModelProfile = {\n     *   maxOutputTokens: 4096 // Model can generate up to 4k tokens\n     * };\n     * ```\n     */\n    maxOutputTokens?: number;\n    /**\n     * Whether the model supports reasoning or chain-of-thought output.\n     *\n     * When `true`, the model can produce explicit reasoning steps or\n     * chain-of-thought explanations as part of its output. This is useful\n     * for understanding the model's decision-making process and improving\n     * transparency in complex reasoning tasks.\n     */\n    reasoningOutput?: boolean;\n    /**\n     * Whether the model can generate image outputs.\n     *\n     * When `true`, the model can produce images as part of its response,\n     * enabling capabilities like image generation, editing, or visual\n     * content creation.\n     */\n    imageOutputs?: boolean;\n    /**\n     * Whether the model can generate audio outputs.\n     *\n     * When `true`, the model can produce audio data as part of its response,\n     * enabling capabilities like text-to-speech, audio generation, or\n     * sound synthesis.\n     */\n    audioOutputs?: boolean;\n    /**\n     * Whether the model can generate video outputs.\n     *\n     * When `true`, the model can produce video data as part of its response,\n     * enabling capabilities like video generation, editing, or visual\n     * content creation with motion.\n     */\n    videoOutputs?: boolean;\n    /**\n     * Whether the model supports tool calling (function calling).\n     *\n     * When `true`, the model can invoke external tools or functions during\n     * its reasoning process. The model can decide which tools to call,\n     * with what arguments, and can incorporate the tool results into its\n     * final response.\n     *\n     * @see {@link toolChoice} for controlling tool selection behavior\n     * @see {@link https://docs.langchain.com/oss/javascript/langchain/models#tool-calling}\n     */\n    toolCalling?: boolean;\n    /**\n     * Whether the model supports tool choice control.\n     *\n     * When `true`, the caller can specify how the model should select tools,\n     * such as forcing the use of a specific tool, allowing any tool, or\n     * preventing tool use entirely. This provides fine-grained control over\n     * the model's tool-calling behavior.\n     *\n     * @see {@link toolCalling} for basic tool calling support\n     */\n    toolChoice?: boolean;\n    /**\n     * Whether the model supports structured output generation.\n     *\n     * When `true`, the model can generate responses that conform to a\n     * specified schema or structure (e.g., JSON with a particular format).\n     * This is useful for ensuring the model's output can be reliably parsed\n     * and processed programmatically.\n     *\n     * @example\n     * ```typescript\n     * // Model can be instructed to return JSON matching a schema\n     * const profile: ModelProfile = {\n     *   structuredOutput: true\n     * };\n     * ```\n     */\n    structuredOutput?: boolean;\n}\n//# sourceMappingURL=profile.d.ts.map"],"mappings":";;AAOA;;;;;;UAAiBA,YAAAA"}

package/dist/load/import_type.d.cts

@@ -1,5 +1,4 @@
 //#region src/load/import_type.d.ts
-// Auto-generated by lc-secrets plugin. Do not edit manually.
 interface OptionalImportMap {}
 interface SecretMap {}
 //#endregion

package/dist/load/import_type.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import_type.d.cts","names":["OptionalImportMap","SecretMap"],"sources":["../../src/load/import_type.d.ts"],"sourcesContent":["export interface OptionalImportMap {\n}\nexport interface SecretMap {\n}\n//# sourceMappingURL=import_type.d.ts.map"],"mappings":";UAAiBA,iBAAAA,EAAjB;AAEiBC,UAAAA,SAAAA,CAAS"}

package/dist/load/import_type.d.ts

@@ -1,5 +1,4 @@
 //#region src/load/import_type.d.ts
-// Auto-generated by lc-secrets plugin. Do not edit manually.
 interface OptionalImportMap {}
 interface SecretMap {}
 //#endregion

package/dist/load/import_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import_type.d.ts","names":["OptionalImportMap","SecretMap"],"sources":["../../src/load/import_type.d.ts"],"sourcesContent":["export interface OptionalImportMap {\n}\nexport interface SecretMap {\n}\n//# sourceMappingURL=import_type.d.ts.map"],"mappings":";UAAiBA,iBAAAA,EAAjB;AAEiBC,UAAAA,SAAAA,CAAS"}

package/dist/load/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["OptionalImportMap","SecretMap","load","T","Record","Promise"],"sources":["../../src/load/index.d.ts"],"sourcesContent":["import type { OptionalImportMap, SecretMap } from \"./import_type.js\";\nexport declare function load<T>(text: string, mappings?: {\n    secretsMap?: SecretMap;\n    optionalImportsMap?: OptionalImportMap;\n    optionalImportEntrypoints?: string[];\n    importMap?: Record<string, unknown>;\n}): Promise<T>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;iBACwBE,8BAIRE;eAHCH;EADOC,kBAAIC,CAAAA,EAEHH,iBAFG;EACXC,yBAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EACQD,SAAAA,CAAAA,EAETI,MAFSJ,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;CAETI,CAAAA,EACZC,OADYD,CACJD,CADIC,CAAAA"}

package/dist/load/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["OptionalImportMap","SecretMap","load","T","Record","Promise"],"sources":["../../src/load/index.d.ts"],"sourcesContent":["import type { OptionalImportMap, SecretMap } from \"./import_type.js\";\nexport declare function load<T>(text: string, mappings?: {\n    secretsMap?: SecretMap;\n    optionalImportsMap?: OptionalImportMap;\n    optionalImportEntrypoints?: string[];\n    importMap?: Record<string, unknown>;\n}): Promise<T>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;iBACwBE,8BAIRE;eAHCH;EADOC,kBAAIC,CAAAA,EAEHH,iBAFG;EACXC,yBAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EACQD,SAAAA,CAAAA,EAETI,MAFSJ,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;CAETI,CAAAA,EACZC,OADYD,CACJD,CADIC,CAAAA"}

package/dist/load/map_keys.d.cts

@@ -1,6 +1,5 @@
 //#region src/load/map_keys.d.ts
 interface SerializedFields {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   [key: string]: any;
 }
 //#endregion

package/dist/load/map_keys.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map_keys.d.cts","names":["SerializedFields","SerializedKeyAlias","keyToJson","keyFromJson","mapKeys"],"sources":["../../src/load/map_keys.d.ts"],"sourcesContent":["export interface SerializedFields {\n    [key: string]: any;\n}\nexport interface SerializedKeyAlias {\n    [key: string]: string;\n}\nexport declare function keyToJson(key: string, map?: SerializedKeyAlias): string;\nexport declare function keyFromJson(key: string, map?: SerializedKeyAlias): string;\nexport declare function mapKeys(fields: SerializedFields, mapper: typeof keyToJson, map?: SerializedKeyAlias): SerializedFields;\n//# sourceMappingURL=map_keys.d.ts.map"],"mappings":";UAAiBA,gBAAAA;EAAAA,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,GAAAA"}

package/dist/load/map_keys.d.ts

@@ -1,6 +1,5 @@
 //#region src/load/map_keys.d.ts
 interface SerializedFields {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   [key: string]: any;
 }
 //#endregion

package/dist/load/map_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map_keys.d.ts","names":["SerializedFields","SerializedKeyAlias","keyToJson","keyFromJson","mapKeys"],"sources":["../../src/load/map_keys.d.ts"],"sourcesContent":["export interface SerializedFields {\n    [key: string]: any;\n}\nexport interface SerializedKeyAlias {\n    [key: string]: string;\n}\nexport declare function keyToJson(key: string, map?: SerializedKeyAlias): string;\nexport declare function keyFromJson(key: string, map?: SerializedKeyAlias): string;\nexport declare function mapKeys(fields: SerializedFields, mapper: typeof keyToJson, map?: SerializedKeyAlias): SerializedFields;\n//# sourceMappingURL=map_keys.d.ts.map"],"mappings":";UAAiBA,gBAAAA;EAAAA,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,GAAAA"}

package/dist/load/serializable.d.cts

@@ -6,7 +6,6 @@ interface BaseSerialized<T extends string> {
   type: T;
   id: string[];
   name?: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   graph?: Record<string, any>;
 }
 interface SerializedConstructor extends BaseSerialized<"constructor"> {

package/dist/load/serializable.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializable.d.cts","names":["SerializedFields","BaseSerialized","T","Record","SerializedConstructor","SerializedSecret","SerializedNotImplemented","Serialized","get_lc_unique_name","Serializable","SerializableInterface"],"sources":["../../src/load/serializable.d.ts"],"sourcesContent":["import { type SerializedFields } from \"./map_keys.js\";\nexport interface BaseSerialized<T extends string> {\n    lc: number;\n    type: T;\n    id: string[];\n    name?: string;\n    graph?: Record<string, any>;\n}\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n    kwargs: SerializedFields;\n}\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {\n}\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {\n}\nexport type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport declare function get_lc_unique_name(serializableClass: typeof Serializable): string;\nexport interface SerializableInterface {\n    get lc_id(): string[];\n}\nexport declare abstract class Serializable implements SerializableInterface {\n    lc_serializable: boolean;\n    lc_kwargs: SerializedFields;\n    /**\n     * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n     * Usually should be the same as the entrypoint the class is exported from.\n     */\n    abstract lc_namespace: string[];\n    /**\n     * The name of the serializable. Override to provide an alias or\n     * to preserve the serialized module name in minified environments.\n     *\n     * Implemented as a static method to support loading logic.\n     */\n    static lc_name(): string;\n    /**\n     * The final serialized identifier for the module.\n     */\n    get lc_id(): string[];\n    /**\n     * A map of secrets, which will be omitted from serialization.\n     * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n     * Values are the secret ids, which will be used when deserializing.\n     */\n    get lc_secrets(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A map of additional attributes to merge with constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the attribute values, which will be serialized.\n     * These attributes need to be accepted by the constructor as arguments.\n     */\n    get lc_attributes(): SerializedFields | undefined;\n    /**\n     * A map of aliases for constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the alias that will replace the key in serialization.\n     * This is used to eg. make argument names match Python.\n     */\n    get lc_aliases(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A manual list of keys that should be serialized.\n     * If not overridden, all fields passed into the constructor will be serialized.\n     */\n    get lc_serializable_keys(): string[] | undefined;\n    constructor(kwargs?: SerializedFields, ..._args: never[]);\n    toJSON(): Serialized;\n    toJSONNotImplemented(): SerializedNotImplemented;\n}\n//# sourceMappingURL=serializable.d.ts.map"],"mappings":";;;UACiBC;;EAAAA,IAAAA,EAEPC,CAFOD;EAOAG,EAAAA,EAAAA,MAAAA,EAAAA;EAGAC,IAAAA,CAAAA,EAAAA,MAAAA;EAEAC,KAAAA,CAAAA,EAPLH,MAOKG,CAAAA,MAAAA,EAAAA,GAAAA,CAAwB;AAEzC;AAAyBF,UAPRA,qBAAAA,SAA8BH,cAOtBG,CAAAA,aAAAA,CAAAA,CAAAA;EAAwBC,MAAAA,EANrCL,gBAMqCK;;AAA2C,UAJ3EA,gBAAAA,SAAyBJ,cAIkD,CAAA,QAAA,CAAA,CAAA,CAK5F;AACiBS,UARAJ,wBAAAA,SAAiCL,cAQZ,CAAA,iBAAA,CAAA,CAAA,CAGtC;AAEeD,KAXHO,UAAAA,GAAaH,qBAWVJ,GAXkCK,gBAWlCL,GAXqDM,wBAWrDN;;;;;AAFuCU,iBAJ9BF,kBAAAA,CAI8BE,iBAAAA,EAAAA,OAJeD,YAIfC,CAAAA,EAAAA,MAAAA;AAAqB,UAH1DA,qBAAAA,CAG0D;;;uBAA7CD,YAAAA,YAAwBC;;aAEvCV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA+BUA;;;;;;;;;;;;;;;uBAeAA;YACXO;0BACcD"}

package/dist/load/serializable.d.ts

@@ -6,7 +6,6 @@ interface BaseSerialized<T extends string> {
   type: T;
   id: string[];
   name?: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   graph?: Record<string, any>;
 }
 interface SerializedConstructor extends BaseSerialized<"constructor"> {

package/dist/load/serializable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializable.d.ts","names":["SerializedFields","BaseSerialized","T","Record","SerializedConstructor","SerializedSecret","SerializedNotImplemented","Serialized","get_lc_unique_name","Serializable","SerializableInterface"],"sources":["../../src/load/serializable.d.ts"],"sourcesContent":["import { type SerializedFields } from \"./map_keys.js\";\nexport interface BaseSerialized<T extends string> {\n    lc: number;\n    type: T;\n    id: string[];\n    name?: string;\n    graph?: Record<string, any>;\n}\nexport interface SerializedConstructor extends BaseSerialized<\"constructor\"> {\n    kwargs: SerializedFields;\n}\nexport interface SerializedSecret extends BaseSerialized<\"secret\"> {\n}\nexport interface SerializedNotImplemented extends BaseSerialized<\"not_implemented\"> {\n}\nexport type Serialized = SerializedConstructor | SerializedSecret | SerializedNotImplemented;\n/**\n * Get a unique name for the module, rather than parent class implementations.\n * Should not be subclassed, subclass lc_name above instead.\n */\nexport declare function get_lc_unique_name(serializableClass: typeof Serializable): string;\nexport interface SerializableInterface {\n    get lc_id(): string[];\n}\nexport declare abstract class Serializable implements SerializableInterface {\n    lc_serializable: boolean;\n    lc_kwargs: SerializedFields;\n    /**\n     * A path to the module that contains the class, eg. [\"langchain\", \"llms\"]\n     * Usually should be the same as the entrypoint the class is exported from.\n     */\n    abstract lc_namespace: string[];\n    /**\n     * The name of the serializable. Override to provide an alias or\n     * to preserve the serialized module name in minified environments.\n     *\n     * Implemented as a static method to support loading logic.\n     */\n    static lc_name(): string;\n    /**\n     * The final serialized identifier for the module.\n     */\n    get lc_id(): string[];\n    /**\n     * A map of secrets, which will be omitted from serialization.\n     * Keys are paths to the secret in constructor args, e.g. \"foo.bar.baz\".\n     * Values are the secret ids, which will be used when deserializing.\n     */\n    get lc_secrets(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A map of additional attributes to merge with constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the attribute values, which will be serialized.\n     * These attributes need to be accepted by the constructor as arguments.\n     */\n    get lc_attributes(): SerializedFields | undefined;\n    /**\n     * A map of aliases for constructor args.\n     * Keys are the attribute names, e.g. \"foo\".\n     * Values are the alias that will replace the key in serialization.\n     * This is used to eg. make argument names match Python.\n     */\n    get lc_aliases(): {\n        [key: string]: string;\n    } | undefined;\n    /**\n     * A manual list of keys that should be serialized.\n     * If not overridden, all fields passed into the constructor will be serialized.\n     */\n    get lc_serializable_keys(): string[] | undefined;\n    constructor(kwargs?: SerializedFields, ..._args: never[]);\n    toJSON(): Serialized;\n    toJSONNotImplemented(): SerializedNotImplemented;\n}\n//# sourceMappingURL=serializable.d.ts.map"],"mappings":";;;UACiBC;;EAAAA,IAAAA,EAEPC,CAFOD;EAOAG,EAAAA,EAAAA,MAAAA,EAAAA;EAGAC,IAAAA,CAAAA,EAAAA,MAAAA;EAEAC,KAAAA,CAAAA,EAPLH,MAOKG,CAAAA,MAAAA,EAAAA,GAAAA,CAAwB;AAEzC;AAAyBF,UAPRA,qBAAAA,SAA8BH,cAOtBG,CAAAA,aAAAA,CAAAA,CAAAA;EAAwBC,MAAAA,EANrCL,gBAMqCK;;AAA2C,UAJ3EA,gBAAAA,SAAyBJ,cAIkD,CAAA,QAAA,CAAA,CAAA,CAK5F;AACiBS,UARAJ,wBAAAA,SAAiCL,cAQZ,CAAA,iBAAA,CAAA,CAAA,CAGtC;AAEeD,KAXHO,UAAAA,GAAaH,qBAWVJ,GAXkCK,gBAWlCL,GAXqDM,wBAWrDN;;;;;AAFuCU,iBAJ9BF,kBAAAA,CAI8BE,iBAAAA,EAAAA,OAJeD,YAIfC,CAAAA,EAAAA,MAAAA;AAAqB,UAH1DA,qBAAAA,CAG0D;;;uBAA7CD,YAAAA,YAAwBC;;aAEvCV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA+BUA;;;;;;;;;;;;;;;uBAeAA;YACXO;0BACcD"}

package/dist/memory.d.cts

@@ -3,19 +3,16 @@
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the input values for a Chain.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type InputValues = Record<string, any>;
 /**
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the output values from a Chain.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type OutputValues = Record<string, any>;
 /**
  * Type alias for a record where the keys are strings and the values can
  * be any type. This is used to represent the memory variables in a Chain.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type MemoryVariables = Record<string, any>;
 /**
  * Abstract base class for memory in LangChain's Chains. Memory refers to