@librechat/agents 3.6.15 → 3.6.16

package/dist/types/llm/invoke.d.ts

@@ -3,11 +3,10 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type { PreparedProviderRequest } from '@/llm/prepareProviderRequest';
-import type { StreamLimitState } from '@/llm/streamLimits';
 import type { ContextOverflowContext } from '@/utils/errors';
+import type { StreamLimitState } from '@/llm/streamLimits';
 import type * as t from '@/types';
 import { ChatModelStreamHandler } from '@/stream';
-import { Providers } from '@/common';
 export { projectMessagesForProvider, resolveServingModelId, usesNativeOpenAIResponses, } from '@/llm/prepareProviderRequest';
 export type { PreparedProviderRequest, PrepareProviderRequestParams, ProviderMessageProjectionMode, ProviderPayloadMeasurement, ProviderRequestContext, } from '@/llm/prepareProviderRequest';
 /**
@@ -75,7 +74,7 @@ type AttemptInvokeParams = AttemptInvokeCommonParams & ({
     request?: never;
     model: t.ChatModel;
     messages: BaseMessage[];
-    provider: Providers;
+    provider: t.ProviderName;
 });
 /**
  * One model attempt. Stamps the attempt identity into callback metadata
@@ -92,7 +91,7 @@ export declare function attemptInvoke(params: AttemptInvokeParams, config?: Runn
  * differ, which is the whole reason a fallback exists.
  */
 export interface FallbackErrorContext {
-    provider: Providers;
+    provider: t.ProviderName;
     clientOptions?: t.ClientOptions;
     maxContextTokens?: number;
 }
@@ -138,7 +137,7 @@ export declare function tryFallbackProviders({ fallbacks, tools, messages, confi
     prepareProviderRequest?: (input: {
         model: t.ChatModel;
         messages: BaseMessage[];
-        provider: Providers;
+        provider: t.ProviderName;
         clientOptions?: t.ClientOptions;
         maxContextTokens?: number;
         config?: RunnableConfig;
@@ -147,7 +146,7 @@ export declare function tryFallbackProviders({ fallbacks, tools, messages, confi
     prepareProviderMessages?: (input: {
         model: t.ChatModel;
         messages: BaseMessage[];
-        provider: Providers;
+        provider: t.ProviderName;
         clientOptions?: t.ClientOptions;
         maxContextTokens?: number;
         config?: RunnableConfig;

package/dist/types/llm/prepareProviderRequest.d.ts

@@ -2,7 +2,6 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
-import { Providers } from '@/common';
 declare const preparedProviderRequestBrand: unique symbol;
 export type ProviderMessageProjectionMode = 'chat-messages' | 'openai-responses';
 export interface ProviderPayloadMeasurement {
@@ -15,7 +14,7 @@ export interface ProviderPayloadMeasurement {
 export interface PreparedProviderRequest {
     readonly model: t.ChatModel;
     readonly modelId?: string;
-    readonly provider: Providers;
+    readonly provider: t.ProviderName;
     readonly projectionMode: ProviderMessageProjectionMode;
     readonly messages: BaseMessage[];
     readonly measurement?: ProviderPayloadMeasurement;
@@ -28,17 +27,17 @@ export interface ProviderRequestContext {
 export interface PrepareProviderRequestParams {
     model: t.ChatModel;
     messages: BaseMessage[];
-    provider: Providers;
+    provider: t.ProviderName;
     context?: ProviderRequestContext;
     config?: RunnableConfig;
     maxToolResultChars?: number;
     measure?: (messages: BaseMessage[]) => ProviderPayloadMeasurement;
 }
-export declare function usesNativeOpenAIResponses(model: t.ChatModel, provider: Providers, callOptions?: unknown): boolean;
+export declare function usesNativeOpenAIResponses(model: t.ChatModel, provider: t.ProviderName, callOptions?: unknown): boolean;
 interface ProjectMessagesForProviderParams {
     model: t.ChatModel;
     messages: BaseMessage[];
-    provider: Providers;
+    provider: t.ProviderName;
     maxToolResultChars?: number;
     callOptions?: unknown;
 }
@@ -51,5 +50,5 @@ export declare function resolveServingModelId(model: unknown): string | undefine
  * will be passed to LangChain. Source messages remain untouched.
  */
 export declare function prepareProviderRequest({ model, messages, provider, context, config, maxToolResultChars, measure, }: PrepareProviderRequestParams): PreparedProviderRequest;
-export declare function assertPreparedProviderRequestFor(request: PreparedProviderRequest, model: t.ChatModel, provider: Providers, config?: RunnableConfig): void;
+export declare function assertPreparedProviderRequestFor(request: PreparedProviderRequest, model: t.ChatModel, provider: t.ProviderName, config?: RunnableConfig): void;
 export {};

package/dist/types/llm/providerRegistry.d.ts

@@ -0,0 +1,11 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { ProviderFamily, ProviderRegistrationOptions } from '../provider-registration';
+import type { ProviderModelConstructor, ProviderName } from '@/types';
+/** Registers one host provider until the returned disposer is called. */
+export declare function registerProvider<TOptions extends object, TModel extends BaseChatModel>(options: ProviderRegistrationOptions<TOptions, TModel>): () => void;
+/** Initializes one built-in for the current package module graph. */
+export declare function registerBuiltInProvider<TOptions extends object, TModel extends BaseChatModel>(options: ProviderRegistrationOptions<TOptions, TModel>): void;
+export declare function getRegisteredChatModelClass<P extends ProviderName>(provider: P): ProviderModelConstructor<P>;
+export declare function getProviderFamily(provider: ProviderName): ProviderFamily | undefined;
+export declare function providerUsesManualToolStream(provider: ProviderName): boolean;
+export declare function providerRequiresStrictAlternation(provider: ProviderName): boolean;

package/dist/types/llm/providers.d.ts

@@ -1,5 +1,4 @@
-import type { ChatModelConstructorMap, ProviderOptionsMap, ChatModelMap } from '@/types';
-import { Providers } from '@/common';
-export declare const llmProviders: Partial<ChatModelConstructorMap>;
-export declare const manualToolStreamProviders: Set<string>;
-export declare const getChatModelClass: <P extends Providers>(provider: P) => new (config: ProviderOptionsMap[P]) => ChatModelMap[P];
+import type { ProviderModelConstructor, ProviderName } from '@/types';
+export declare const getChatModelClass: <P extends ProviderName>(provider: P) => ProviderModelConstructor<P>;
+export { getProviderFamily, providerRequiresStrictAlternation, providerUsesManualToolStream, registerProvider, } from '@/llm/providerRegistry';
+export type { ProviderFamily, ProviderRegistrationOptions, } from '../provider-registration';

package/dist/types/llm/request.d.ts

@@ -1,14 +1,13 @@
 import type * as t from '@/types';
-import { Providers } from '@/common';
 /**
  * Returns true when the provider + clientOptions indicate extended thinking
  * is enabled.  Works across Anthropic (direct), Bedrock (additionalModelRequestFields),
  * and OpenAI-compat (modelKwargs.thinking).
  */
-export declare function isThinkingEnabled(provider: Providers, clientOptions?: t.ClientOptions): boolean;
+export declare function isThinkingEnabled(provider: t.ProviderName, clientOptions?: t.ClientOptions): boolean;
 /**
  * Returns the correct key for setting max output tokens on the model
  * constructor options.  Google/Vertex use `maxOutputTokens`, all others
  * use `maxTokens`.
  */
-export declare function getMaxOutputTokensKey(provider: Providers | string): 'maxOutputTokens' | 'maxTokens';
+export declare function getMaxOutputTokensKey(provider: t.ProviderName): 'maxOutputTokens' | 'maxTokens';

package/dist/types/llm/truncation.d.ts

@@ -1,5 +1,5 @@
 import type { AIMessageChunk, BaseMessage } from '@langchain/core/messages';
-import { Providers } from '@/common';
+import type { ProviderName } from '@/types';
 /**
  * Normalized truncation reasons across providers. Providers disagree on the
  * key and the value: Anthropic/Bedrock use `max_tokens`, OpenAI uses `length`,
@@ -42,4 +42,4 @@ export declare class OutputTruncationError extends Error {
  * providers that deliver complete tool calls atomically (Google/Vertex), where
  * `MAX_TOKENS` does not imply the arguments were cut off.
  */
-export declare function assertNotTruncatedToolCall(message: AIMessageChunk | BaseMessage | undefined | null, provider?: Providers): void;
+export declare function assertNotTruncatedToolCall(message: AIMessageChunk | BaseMessage | undefined | null, provider?: ProviderName): void;

package/dist/types/messages/core.d.ts

@@ -1,12 +1,11 @@
 import { AIMessage, BaseMessage, ToolMessage, HumanMessage, AIMessageChunk } from '@langchain/core/messages';
 import type * as t from '@/types';
-import { Providers } from '@/common';
 export declare function getConverseOverrideMessage({ userMessage, lastMessageX, lastMessageY, }: {
     userMessage: string[];
     lastMessageX: AIMessageChunk | null;
     lastMessageY: ToolMessage;
 }): HumanMessage;
-export declare function modifyDeltaProperties(provider: Providers, obj?: AIMessageChunk): AIMessageChunk | undefined;
+export declare function modifyDeltaProperties(provider: t.ProviderName, obj?: AIMessageChunk): AIMessageChunk | undefined;
 export declare function formatAnthropicMessage(message: AIMessageChunk): AIMessage;
 export declare function convertMessagesToContent(messages: BaseMessage[]): t.MessageContentComplex[];
 type ResponsesReplayProjection = 'fallback' | 'native';

package/dist/types/messages/format.d.ts

@@ -1,7 +1,7 @@
 import { AIMessage, ToolMessage, BaseMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
 import type { MessageContentImageUrl } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
-import type { MessageContentComplex, TPayload } from '@/types';
+import type { MessageContentComplex, TPayload, ProviderName } from '@/types';
 import { Providers } from '@/common';
 interface MediaMessageParams {
     message: {
@@ -90,7 +90,7 @@ interface LangChainMessage {
  */
 export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
 interface FormatAgentMessagesOptions {
-    provider?: Providers;
+    provider?: ProviderName;
     /** Reconstruct hidden `reasoning_content` from `THINK` parts onto prior
      *  tool-call messages. Explicit opt-in for OpenAI-compatible endpoints that
      *  replay reasoning across turns; defaults to on for DeepSeek thinking-mode. */
@@ -189,7 +189,7 @@ export declare function compactSyntheticProviderContextMessage(message: HumanMes
  *   compatibility for callers that don't yet pass the boundary.
  * @returns The messages array with tool sequences converted to buffer strings if necessary
  */
-export declare function ensureThinkingBlockInMessages(messages: BaseMessage[], _provider: Providers, config?: RunnableConfig, runStartIndex?: number): BaseMessage[];
+export declare function ensureThinkingBlockInMessages(messages: BaseMessage[], _provider: ProviderName, config?: RunnableConfig, runStartIndex?: number): BaseMessage[];
 /**
  * Folds tool_use / tool_result content into plain text for an agent that binds
  * no tools.

package/dist/types/messages/prune.d.ts

@@ -1,7 +1,8 @@
 import { BaseMessage, UsageMetadata } from '@langchain/core/messages';
 import type { ContextPruningConfig } from '@/types/graph';
 import type { TokenCounter } from '@/types/run';
-import { ContentTypes, Providers } from '@/common';
+import type { ProviderName } from '@/types';
+import { ContentTypes } from '@/common';
 /** Default fraction of the token budget reserved as headroom (5 %). */
 export declare const DEFAULT_RESERVE_RATIO = 0.05;
 /** Provider framing reserved for the assistant reply label. */
@@ -25,7 +26,7 @@ export declare const CALIBRATION_RATIO_MAX = 5;
 /** Keeps provider/local token calibration within the shared safe range. */
 export declare function clampCalibrationRatio(ratio: number): number;
 export type PruneMessagesFactoryParams = {
-    provider?: Providers;
+    provider?: ProviderName;
     maxTokens: number;
     /** Per-tool-result character cap applied while reconciling cached counts. */
     maxToolResultChars?: number;

package/dist/types/provider-registration.d.ts

@@ -0,0 +1,15 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+declare const CUSTOM_PROVIDER_OPTIONS_TYPE: unique symbol;
+/** Declaration-merge this map to type host-registered provider options. */
+export interface CustomProviderOptionsMap {
+    readonly [CUSTOM_PROVIDER_OPTIONS_TYPE]?: never;
+}
+export type ProviderFamily = 'openai' | 'anthropic' | 'bedrock' | 'google' | 'mistral' | 'generic';
+export interface ProviderRegistrationOptions<TOptions extends object, TModel extends BaseChatModel> {
+    provider: string;
+    model: new (config: TOptions) => TModel;
+    family?: ProviderFamily;
+    manualToolStream?: boolean;
+    strictAlternation?: boolean;
+}
+export { registerProvider } from './llm/providers';

package/dist/types/stream.d.ts

@@ -2,10 +2,9 @@ import type { AIMessageChunk } from '@langchain/core/messages';
 import type { AgentContext } from '@/agents/AgentContext';
 import type { StandardGraph } from '@/graphs';
 import type * as t from '@/types';
-import { Providers } from '@/common';
 export declare function getChunkContent({ chunk, provider, reasoningKey, }: {
     chunk?: Partial<AIMessageChunk>;
-    provider?: Providers;
+    provider?: t.ProviderName;
     reasoningKey: 'reasoning_content' | 'reasoning';
 }): string | t.MessageContentComplex[] | undefined;
 /**

package/dist/types/summarization/node.d.ts

@@ -5,7 +5,6 @@ import type { AgentContext } from '@/agents/AgentContext';
 import type { HookRegistry } from '@/hooks';
 import type { OnChunk } from '@/llm/invoke';
 import type * as t from '@/types';
-import { Providers } from '@/common';
 /** Structured checkpoint prompt for fresh summarization (no prior summary). */
 export declare const DEFAULT_SUMMARIZATION_PROMPT = "Hold on, before you continue I need you to write me a checkpoint of everything so far. Your context window is filling up and this checkpoint replaces the messages above, so capture everything you need to pick right back up.\n\nDon't second-guess or fact-check anything you did, your tool results reflect exactly what happened. If a tool result appears truncated, that's just a display artifact from context management: the tool executed fully. Just record what you did and what you observed. Only the checkpoint, don't respond to me or continue the conversation.\n\n## Checkpoint\n\n## Goal\nWhat I asked you to do and any sub-goals you identified.\n\n## Constraints & Preferences\nAny rules, preferences, or configuration I established.\n\n## Progress\n### Done\n- What you completed and the outcomes\n\n### In Progress\n- What you're currently working on\n\n## Key Decisions\nDecisions you made and why.\n\n## Next Steps\nConcrete task actions remaining, in priority order.\n\n## Critical Context\nExact identifiers, names, error messages, URLs, and details you need to preserve verbatim.\n\nRules:\n- Record what you did and observed, don't judge or re-evaluate it\n- For each tool call: the tool name, key inputs, and the outcome\n- Preserve exact identifiers, names, errors, and references verbatim\n- Short declarative sentences\n- Skip empty sections";
 /** Prompt for re-compaction when a prior summary exists. */
@@ -53,7 +52,7 @@ export declare function createSummarizeNode({ agentContext, graph: adapterGraph,
 export declare function createSummarizationChunkHandler({ stepId, config, provider, reasoningKey, graph, }: {
     stepId?: string;
     config?: RunnableConfig;
-    provider?: Providers;
+    provider?: t.ProviderName;
     reasoningKey?: 'reasoning_content' | 'reasoning';
     graph?: StreamLimitState & {
         getBreakerController?: () => AbortController;

package/dist/types/types/activityLabel.d.ts

@@ -1,7 +1,6 @@
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { AssistantTextPhase } from '@/types/assistantPhase';
-import type { ClientOptions } from '@/types/llm';
-import type { Providers } from '@/common';
+import type { ClientOptions, ProviderName } from '@/types/llm';
 /** One tool call's contribution to the label payload (host-assembled). */
 export type ActivityLabelToolEntry = {
     toolName: string;
@@ -23,7 +22,7 @@ export type ActivityLabelToolEntry = {
  * `activity_label` content type's formatter exclusions.
  */
 export type RunActivityLabelOptions = {
-    provider: Providers;
+    provider: ProviderName;
     clientOptions?: ClientOptions;
     /**
      * Agent that executed the labeled batch. Selects that agent's Langfuse
@@ -81,7 +80,7 @@ export type ActivityPhaseEntry = {
 };
 /** Options for `Run.generateActivityPhaseLabel`. */
 export type RunActivityPhaseLabelOptions = {
-    provider: Providers;
+    provider: ProviderName;
     clientOptions?: ClientOptions;
     /**
      * Logical activities in run order. The SDK requires at least two so hosts

package/dist/types/types/graph.d.ts

@@ -8,10 +8,10 @@ import type { SummarizationNodeInput, SummarizeCompleteEvent, SummarizationConfi
 import type { RunStep, RunStepDeltaEvent, RunStepResumeState, RunStepClosedEvent, MessageDeltaEvent, ReasoningDeltaEvent } from '@/types/stream';
 import type { ToolMap, ToolSessionMap, ToolEndEvent, GenericTool, LCTool, ToolExecutionConfig, ToolExecuteBatchRequest } from '@/types/tools';
 import type { TokenCounter, StreamLimits, StreamPreemption, TokenBudgetBreakdown } from '@/types/run';
-import type { Providers, Callback, GraphNodeKeys } from '@/common';
 import type { SubagentTaskConfig } from '@/types/subagentTasks';
 import type { StandardGraph, MultiAgentGraph } from '@/graphs';
-import type { ClientOptions } from '@/types/llm';
+import type { ProviderClientOptionsConfig } from '@/types/llm';
+import type { Callback, GraphNodeKeys } from '@/common';
 /** Interface for bound model with stream and invoke methods */
 export interface ChatModel {
     stream?: (messages: BaseMessage[], config?: RunnableConfig) => Promise<AsyncIterable<AIMessageChunk>>;
@@ -647,7 +647,7 @@ export interface LangfuseConfig {
      */
     deterministicTraceId?: boolean;
 }
-export interface AgentInputs {
+interface AgentInputFields {
     agentId: string;
     /**
      * Partition key for transient code-session ids and file refs. Agents with
@@ -662,12 +662,10 @@ export interface AgentInputs {
     toolEnd?: boolean;
     toolMap?: ToolMap;
     tools?: GraphTools;
-    provider: Providers;
     /** Stable/cacheable system instructions. */
     instructions?: string;
     streamBuffer?: number;
     maxContextTokens?: number;
-    clientOptions?: ClientOptions;
     /** Per-agent Langfuse tracing configuration. */
     langfuse?: LangfuseConfig;
     /** Dynamic system tail appended after stable instructions without provider cache markers. */
@@ -739,6 +737,7 @@ export interface AgentInputs {
      */
     graphTools?: GenericTool[];
 }
+export type AgentInputs = AgentInputFields & ProviderClientOptionsConfig;
 export interface ContextPruningConfig {
     enabled?: boolean;
     keepLastAssistants?: number;

package/dist/types/types/llm.d.ts

@@ -1,6 +1,6 @@
 import { ChatMistralAI } from '@langchain/mistralai';
 import type { OpenAIChatInput, ChatOpenAIFields, AzureOpenAIInput, ClientOptions as OAIClientOptions } from '@langchain/openai';
-import type { BindToolsInput, BaseChatModelParams } from '@langchain/core/language_models/chat_models';
+import type { BindToolsInput, BaseChatModel, BaseChatModelParams } from '@langchain/core/language_models/chat_models';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
@@ -12,6 +12,7 @@ import type { AnthropicInput } from '@langchain/anthropic';
 import type { Runnable } from '@langchain/core/runnables';
 import type { OpenAI as OpenAIClient } from 'openai';
 import type { ChatXAIInput } from '@langchain/xai';
+import type { CustomProviderOptionsMap } from '../provider-registration';
 import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import type { PromptCacheTtl } from '@/messages/cache';
 import { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI } from '@/llm/openai';
@@ -105,21 +106,57 @@ export type GoogleClientOptions = GoogleGenerativeAIChatInput & StreamSmoothingO
 };
 export type DeepSeekClientOptions = Partial<ChatDeepSeekInput> & StreamSmoothingOptions;
 export type XAIClientOptions = ChatXAIInput & StreamSmoothingOptions;
-export type ClientOptions = OpenAIClientOptions | AzureClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions | XAIClientOptions;
-export type SharedLLMConfig = {
-    provider: Providers;
+export type BuiltInClientOptions = OpenAIClientOptions | AzureClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions | XAIClientOptions;
+type CustomProviderName = Extract<keyof CustomProviderOptionsMap, string>;
+type LooseRuntimeProviderName = string & {
+    readonly __runtimeProviderName?: never;
+};
+export type ProviderName = keyof ProviderOptionsMap | CustomProviderName | LooseRuntimeProviderName;
+declare const RUNTIME_PROVIDER_NAME: unique symbol;
+/** A runtime provider without declaration-merged option types. */
+export type RuntimeProviderName = string & {
+    readonly [RUNTIME_PROVIDER_NAME]: true;
+};
+export type ClientOptions = BuiltInClientOptions | CustomProviderOptionsMap[CustomProviderName];
+export type SharedLLMConfig<P extends keyof ProviderOptionsMap | CustomProviderName | RuntimeProviderName = keyof ProviderOptionsMap> = {
+    provider: P;
+    model?: string;
     _lc_stream_delay?: number;
 };
-export interface FallbackConfig {
-    provider: Providers;
-    clientOptions?: ClientOptions;
+type CustomProviderClientOptionsConfig<P extends CustomProviderName> = {
+    provider: P;
+} & (object extends CustomProviderOptionsMap[P] ? {
+    clientOptions?: CustomProviderOptionsMap[P];
+} : {
+    clientOptions: CustomProviderOptionsMap[P];
+});
+export type ProviderClientOptionsConfig = {
+    provider: keyof ProviderOptionsMap;
+    clientOptions?: BuiltInClientOptions;
+} | {
+    [P in CustomProviderName]: CustomProviderClientOptionsConfig<P>;
+}[CustomProviderName] | {
+    provider: RuntimeProviderName;
+    clientOptions: ClientOptions;
+};
+export type FallbackConfig = ProviderClientOptionsConfig & {
     /** Context window used to corroborate ambiguous fallback overflow errors. */
     maxContextTokens?: number;
-}
-export type LLMConfig = SharedLLMConfig & ClientOptions & {
+};
+type LLMConfigFor<P extends CustomProviderName> = SharedLLMConfig<P> & CustomProviderOptionsMap[P] & {
+    /** Optional provider fallbacks in order of attempt */
+    fallbacks?: FallbackConfig[];
+};
+export type BuiltInLLMConfig = SharedLLMConfig & BuiltInClientOptions & {
     /** Optional provider fallbacks in order of attempt */
     fallbacks?: FallbackConfig[];
 };
+export type LLMConfig = BuiltInLLMConfig | {
+    [P in CustomProviderName]: LLMConfigFor<P>;
+}[CustomProviderName] | (SharedLLMConfig<RuntimeProviderName> & ClientOptions & {
+    /** Optional provider fallbacks in order of attempt */
+    fallbacks?: FallbackConfig[];
+});
 export type ProviderOptionsMap = {
     [Providers.AZURE]: AzureClientOptions;
     [Providers.OPENAI]: OpenAIClientOptions;
@@ -134,7 +171,7 @@ export type ProviderOptionsMap = {
     [Providers.XAI]: XAIClientOptions;
     [Providers.MOONSHOT]: OpenAIClientOptions;
 };
-export type ChatModelMap = {
+export interface ChatModelMap {
     [Providers.XAI]: ChatXAI;
     [Providers.OPENAI]: ChatOpenAI;
     [Providers.AZURE]: AzureChatOpenAI;
@@ -147,11 +184,15 @@ export type ChatModelMap = {
     [Providers.BEDROCK]: CustomChatBedrockConverse;
     [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
     [Providers.MOONSHOT]: ChatMoonshot;
-};
+}
+export type ProviderOptionsFor<P extends ProviderName> = P extends keyof ProviderOptionsMap ? ProviderOptionsMap[P] : P extends CustomProviderName ? CustomProviderOptionsMap[P] : BuiltInClientOptions;
+export type ProviderModelFor<P extends ProviderName> = P extends keyof ChatModelMap ? ChatModelMap[P] & BaseChatModel : BaseChatModel;
+export type ProviderModelConstructor<P extends ProviderName> = new (config: ProviderOptionsFor<P>) => ProviderModelFor<P>;
 export type ChatModelConstructorMap = {
     [P in Providers]: new (config: ProviderOptionsMap[P]) => ChatModelMap[P];
 };
-export type ChatModelInstance = ChatModelMap[Providers];
-export type ModelWithTools = ChatModelInstance & {
+export type ChatModelInstance = BaseChatModel;
+export type ModelWithTools = BaseChatModel & {
     bindTools(tools: CommonToolType[]): Runnable;
 };
+export type { CustomProviderOptionsMap } from '../provider-registration';

package/dist/types/types/reasoningLabel.d.ts

@@ -1,7 +1,6 @@
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { UsageMetadata } from '@langchain/core/messages';
-import type { ClientOptions } from '@/types/llm';
-import type { Providers } from '@/common';
+import type { ClientOptions, ProviderName } from '@/types/llm';
 /** Lifecycle state of the visible reasoning snapshot being labeled. */
 export type ReasoningLabelStatus = 'streaming' | 'complete';
 /** Result of one reasoning-label revision. */
@@ -12,7 +11,7 @@ export type ReasoningLabelResult = {
 };
 /** Options for `Run.generateReasoningLabel`. */
 export type RunReasoningLabelOptions = {
-    provider: Providers;
+    provider: ProviderName;
     clientOptions?: ClientOptions;
     /**
      * Complete user-visible reasoning accumulated for this step so far. Hidden

package/dist/types/types/run.d.ts

@@ -14,7 +14,7 @@ import type * as l from '@/types/llm';
 export type ZodObjectAny = z.ZodObject<any, any, any, any>;
 export type BaseGraphConfig = {
     llmConfig: l.LLMConfig;
-    provider?: e.Providers;
+    provider?: l.ProviderName;
     clientOptions?: l.ClientOptions;
     /** Optional compile options for workflow.compile() */
     compileOptions?: g.CompileOptions;
@@ -34,7 +34,7 @@ export type SupervisedGraphConfig = BaseGraphConfig & {
     routingPolicies?: Array<{
         stage: string;
         agents?: string[];
-        model?: e.Providers;
+        model?: l.ProviderName;
         parallel?: boolean;
         /** Optional simple condition on content/tools */
         when?: 'always' | 'has_tools' | 'no_tools' | {
@@ -55,7 +55,7 @@ export type SupervisedGraphConfig = BaseGraphConfig & {
 } & Omit<g.StandardGraphInput, 'provider' | 'clientOptions'>;
 export type RunTitleOptions = {
     inputText: string;
-    provider: e.Providers;
+    provider: l.ProviderName;
     contentParts: (s.MessageContentComplex | undefined)[];
     titlePrompt?: string;
     skipLanguage?: boolean;

package/dist/types/types/summarize.d.ts

@@ -1,5 +1,5 @@
 import type { SummaryContentBlock } from '@/types/stream';
-import type { Providers } from '@/common';
+import type { ProviderName } from '@/types/llm';
 export type SummarizationTrigger = {
     type: 'token_ratio' | 'remaining_tokens' | 'messages_to_refine' | (string & {});
     value: number;
@@ -28,7 +28,7 @@ export type RetainRecentConfig = {
     tokens?: number;
 };
 export type SummarizationConfig = {
-    provider?: Providers;
+    provider?: ProviderName;
     model?: string;
     parameters?: Record<string, unknown>;
     prompt?: string;

package/dist/types/utils/errors.d.ts

@@ -1,4 +1,4 @@
-import type { Providers } from '@/common';
+import type { ProviderName } from '@/types';
 /**
  * Why the request was rejected. Both kinds are fixed by shrinking the
  * prompt, which is what makes them recoverable; they are distinguished
@@ -33,10 +33,10 @@ export interface ContextOverflowInfo {
     promptTokens?: number;
     /** Which layer produced the verdict. Surfaced in logs and asserted in tests. */
     source: 'langchain' | 'pattern';
-    provider?: Providers;
+    provider?: ProviderName;
 }
 export interface ContextOverflowContext {
-    provider?: Providers;
+    provider?: ProviderName;
     /** Our own estimate of the prompt size for the call that failed. */
     estimatedPromptTokens?: number;
     /** The budget we believed applied when we built that prompt. */

package/dist/types/utils/llm.d.ts

@@ -1,7 +1,7 @@
-import { Providers } from '@/common';
-export declare function isOpenAILike(provider?: string | Providers): boolean;
-export declare function isGoogleLike(provider?: string | Providers): boolean;
+import type { ProviderName } from '@/types';
+export declare function isOpenAILike(provider?: ProviderName): boolean;
+export declare function isGoogleLike(provider?: ProviderName): boolean;
 /** Returns true for native Anthropic or Bedrock running a Claude model. */
-export declare function isAnthropicLike(provider?: string | Providers, clientOptions?: {
+export declare function isAnthropicLike(provider?: ProviderName, clientOptions?: {
     model?: string;
 }): boolean;

package/dist/types/utils/llmConfig.d.ts

@@ -1,3 +1,3 @@
 import type * as t from '@/types';
-export declare const llmConfigs: Record<string, t.LLMConfig | undefined>;
-export declare function getLLMConfig(provider: string): t.LLMConfig;
+export declare const llmConfigs: Record<string, t.BuiltInLLMConfig | undefined>;
+export declare function getLLMConfig(provider: string): t.BuiltInLLMConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.6.15",
+  "version": "3.6.16",
   "reova": {
     "enabled": true,
     "endpoint": "https://telemetry.reo.dev/data"
@@ -14,6 +14,11 @@
       "import": "./dist/esm/main.mjs",
       "require": "./dist/cjs/main.cjs"
     },
+    "./provider-registration": {
+      "types": "./dist/types/provider-registration.d.ts",
+      "import": "./dist/esm/provider-registration.mjs",
+      "require": "./dist/cjs/provider-registration.cjs"
+    },
     "./openai": {
       "types": "./dist/types/openai/index.d.ts",
       "import": "./dist/esm/openai/index.mjs",
@@ -77,6 +82,9 @@
   },
   "typesVersions": {
     "*": {
+      "provider-registration": [
+        "dist/types/provider-registration.d.ts"
+      ],
       "langchain": [
         "dist/types/langchain/index.d.ts"
       ],