@librechat/agents 3.6.15 → 3.6.16

package/src/summarization/node.ts

@@ -657,7 +657,7 @@ async function executeSummarizationWithFallback(params: {
      * `log('error', ...)` path below rather than bubbling up silently.
      */
     const summarizationModel = initializeModel({
-      provider: clientConfig.provider as Providers,
+      provider: clientConfig.provider,
       clientOptions: clientConfig.clientOptions as t.ClientOptions,
       tools: agentContext.getToolsForBinding(),
     }) as t.ChatModel;
@@ -670,13 +670,13 @@ async function executeSummarizationWithFallback(params: {
       priorSummaryText,
       config: summarizeConfig,
       stepId,
-      provider: clientConfig.provider as Providers,
+      provider: clientConfig.provider,
       reasoningKey: agentContext.reasoningKey,
       graph,
       usePromptCache,
       promptCacheTtl:
-        (clientConfig.provider as Providers) === Providers.ANTHROPIC ||
-        (clientConfig.provider as Providers) === Providers.OPENROUTER
+        clientConfig.provider === Providers.ANTHROPIC ||
+        clientConfig.provider === Providers.OPENROUTER
           ? resolvePromptCacheTtl(
             (
                 clientConfig.clientOptions as {
@@ -737,7 +737,7 @@ async function executeSummarizationWithFallback(params: {
         const onChunk = createSummarizationChunkHandler({
           stepId,
           config: traceConfig(summarizeConfig, 'cache_hit_compaction'),
-          provider: clientConfig.provider as Providers,
+          provider: clientConfig.provider,
           reasoningKey: agentContext.reasoningKey,
           graph,
         });
@@ -1509,7 +1509,7 @@ export function createSummarizationChunkHandler({
 }: {
   stepId?: string;
   config?: RunnableConfig;
-  provider?: Providers;
+  provider?: t.ProviderName;
   reasoningKey?: 'reasoning_content' | 'reasoning';
   graph?: StreamLimitState & { getBreakerController?: () => AbortController };
 }): OnChunk | undefined {
@@ -1622,7 +1622,7 @@ async function summarizeWithCacheHit({
   priorSummaryText: string;
   config?: RunnableConfig;
   stepId?: string;
-  provider: Providers;
+  provider: t.ProviderName;
   reasoningKey?: 'reasoning_content' | 'reasoning';
   graph?: StreamLimitState & { getBreakerSignal?: () => AbortSignal };
   usePromptCache?: boolean;

package/src/types/activityLabel.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 = {
@@ -25,7 +24,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
@@ -85,7 +84,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/src/types/graph.ts

@@ -40,10 +40,10 @@ import type {
   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 {
@@ -824,7 +824,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
@@ -839,12 +839,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. */
@@ -914,6 +912,8 @@ export interface AgentInputs {
   graphTools?: GenericTool[];
 }
 
+export type AgentInputs = AgentInputFields & ProviderClientOptionsConfig;
+
 export interface ContextPruningConfig {
   enabled?: boolean;
   keepLastAssistants?: number;

package/src/types/llm.ts

@@ -8,6 +8,7 @@ import type {
 } from '@langchain/openai';
 import type {
   BindToolsInput,
+  BaseChatModel,
   BaseChatModelParams,
 } from '@langchain/core/language_models/chat_models';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
@@ -21,6 +22,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 {
@@ -138,7 +140,7 @@ export type DeepSeekClientOptions = Partial<ChatDeepSeekInput> &
   StreamSmoothingOptions;
 export type XAIClientOptions = ChatXAIInput & StreamSmoothingOptions;
 
-export type ClientOptions =
+export type BuiltInClientOptions =
   | OpenAIClientOptions
   | AzureClientOptions
   | AnthropicClientOptions
@@ -149,24 +151,86 @@ export type ClientOptions =
   | DeepSeekClientOptions
   | XAIClientOptions;
 
-export type SharedLLMConfig = {
-  provider: Providers;
+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;
-}
+};
+
+type LLMConfigFor<P extends CustomProviderName> = SharedLLMConfig<P> &
+  CustomProviderOptionsMap[P] & {
+    /** Optional provider fallbacks in order of attempt */
+    fallbacks?: FallbackConfig[];
+  };
 
-export type LLMConfig = SharedLLMConfig &
-  ClientOptions & {
+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;
@@ -182,7 +246,7 @@ export type ProviderOptionsMap = {
   [Providers.MOONSHOT]: OpenAIClientOptions;
 };
 
-export type ChatModelMap = {
+export interface ChatModelMap {
   [Providers.XAI]: ChatXAI;
   [Providers.OPENAI]: ChatOpenAI;
   [Providers.AZURE]: AzureChatOpenAI;
@@ -195,14 +259,32 @@ 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 ChatModelInstance = BaseChatModel;
 
-export type ModelWithTools = ChatModelInstance & {
+export type ModelWithTools = BaseChatModel & {
   bindTools(tools: CommonToolType[]): Runnable;
 };
+
+export type { CustomProviderOptionsMap } from '../provider-registration';

package/src/types/reasoningLabel.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';
@@ -15,7 +14,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/src/types/run.ts

@@ -22,7 +22,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;
@@ -47,7 +47,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?:
@@ -70,7 +70,7 @@ export type SupervisedGraphConfig = BaseGraphConfig & {
 
 export type RunTitleOptions = {
   inputText: string;
-  provider: e.Providers;
+  provider: l.ProviderName;
   contentParts: (s.MessageContentComplex | undefined)[];
   titlePrompt?: string;
   skipLanguage?: boolean;

package/src/types/summarize.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:
@@ -35,7 +35,7 @@ export type RetainRecentConfig = {
 };
 
 export type SummarizationConfig = {
-  provider?: Providers;
+  provider?: ProviderName;
   model?: string;
   parameters?: Record<string, unknown>;
   prompt?: string;

package/src/utils/errors.ts

@@ -12,7 +12,7 @@
  * into a forced summarization pass instead of surfacing the error.
  */
 import { ContextOverflowError } from '@langchain/core/errors';
-import type { Providers } from '@/common';
+import type { ProviderName } from '@/types';
 
 /**
  * Why the request was rejected. Both kinds are fixed by shrinking the
@@ -49,7 +49,7 @@ export interface ContextOverflowInfo {
   promptTokens?: number;
   /** Which layer produced the verdict. Surfaced in logs and asserted in tests. */
   source: 'langchain' | 'pattern';
-  provider?: Providers;
+  provider?: ProviderName;
 }
 
 interface OverflowPattern {
@@ -80,7 +80,7 @@ interface OverflowPattern {
 const CONTEXT_PRESSURE_RATIO = 0.8;
 
 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/src/utils/llm.ts

@@ -1,37 +1,44 @@
 // src/utils/llm.ts
+import type { ProviderName } from '@/types';
+import { getProviderFamily } from '@/llm/providerRegistry';
 import { Providers } from '@/common';
 
-export function isOpenAILike(provider?: string | Providers): boolean {
+export function isOpenAILike(provider?: ProviderName): boolean {
   if (provider == null) {
     return false;
   }
   return (
-    [
-      Providers.OPENAI,
-      Providers.AZURE,
-      Providers.OPENROUTER,
-      Providers.XAI,
-      Providers.DEEPSEEK,
-    ] as string[]
-  ).includes(provider);
+    getProviderFamily(provider) === 'openai' ||
+    (
+      [
+        Providers.OPENAI,
+        Providers.AZURE,
+        Providers.OPENROUTER,
+        Providers.XAI,
+        Providers.DEEPSEEK,
+      ] as string[]
+    ).includes(provider)
+  );
 }
 
-export function isGoogleLike(provider?: string | Providers): boolean {
+export function isGoogleLike(provider?: ProviderName): boolean {
   if (provider == null) {
     return false;
   }
-  return ([Providers.GOOGLE, Providers.VERTEXAI] as string[]).includes(
-    provider
+  return (
+    getProviderFamily(provider) === 'google' ||
+    ([Providers.GOOGLE, Providers.VERTEXAI] as string[]).includes(provider)
   );
 }
 
 /** Returns true for native Anthropic or Bedrock running a Claude model. */
 export function isAnthropicLike(
-  provider?: string | Providers,
+  provider?: ProviderName,
   clientOptions?: { model?: string }
 ): boolean {
-  if (provider === Providers.ANTHROPIC) return true;
-  if (provider === Providers.BEDROCK) {
+  const family = provider == null ? undefined : getProviderFamily(provider);
+  if (provider === Providers.ANTHROPIC || family === 'anthropic') return true;
+  if (provider === Providers.BEDROCK || family === 'bedrock') {
     return (
       clientOptions?.model == null ||
       /claude/i.test(String(clientOptions.model))

package/src/utils/llmConfig.ts

@@ -3,7 +3,7 @@ import type * as or from '@/llm/openrouter';
 import type * as t from '@/types';
 import { Providers } from '@/common';
 
-export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
+export const llmConfigs: Record<string, t.BuiltInLLMConfig | undefined> = {
   [Providers.OPENAI]: {
     provider: Providers.OPENAI,
     model: 'gpt-4.1',
@@ -68,7 +68,7 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     modelKwargs: {
       max_tokens: 10000,
     },
-  } as or.ChatOpenRouterCallOptions & t.LLMConfig,
+  } as or.ChatOpenRouterCallOptions & t.BuiltInLLMConfig,
   [Providers.AZURE]: {
     provider: Providers.AZURE,
     temperature: 0.7,
@@ -159,7 +159,7 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     // location: 'global',
     // thinkingBudget: -1,
     // includeThoughts: true,
-  } as t.VertexAIClientOptions & t.LLMConfig,
+  } as t.VertexAIClientOptions & t.BuiltInLLMConfig,
   [Providers.GOOGLE]: {
     provider: Providers.GOOGLE,
     model: 'gemini-2.5-flash',
@@ -194,7 +194,7 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   },
 };
 
-export function getLLMConfig(provider: string): t.LLMConfig {
+export function getLLMConfig(provider: string): t.BuiltInLLMConfig {
   const config = llmConfigs[provider];
   if (config === undefined) {
     throw new Error(`Unsupported provider: ${provider}`);