@librechat/agents 3.6.15 → 3.7.0

package/src/tools/Calculator.ts

@@ -1,5 +1,12 @@
-import * as math from 'mathjs';
 import { Tool } from '@langchain/core/tools';
+import { requireLazyModule } from '@/lazyRequire';
+
+/** mathjs costs ~150ms of module init; a calculator that is never invoked never pays it. */
+let math: typeof import('mathjs') | undefined;
+const evaluateExpression = (input: string): string => {
+  math ??= requireLazyModule<typeof import('mathjs')>('mathjs');
+  return math.evaluate(input).toString();
+};
 
 export const CalculatorToolName = 'calculator';
 
@@ -36,7 +43,7 @@ export class Calculator extends Tool {
 
   async _call(input: string): Promise<string> {
     try {
-      return math.evaluate(input).toString();
+      return evaluateExpression(input);
     } catch {
       return 'I don\'t know how to do that.';
     }

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,83 @@
 // 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 {
+const OPENAI_FAMILY_LC_NAMES: ReadonlySet<string> = new Set([
+  'LibreChatOpenAI',
+  'LibreChatAzureOpenAI',
+]);
+
+/** Walks the constructor chain for LangChain's `lc_name` serialization ids.
+ *  Constructor identity is unusable across lazily loaded module formats — the
+ *  CJS and ESM builds carry distinct classes — so guards match on the ids the
+ *  relevant classes declare instead of on `instanceof`. */
+export function constructorChainHasLcName(
+  model: unknown,
+  names: ReadonlySet<string>
+): boolean {
+  if (typeof model !== 'object' || model == null) {
+    return false;
+  }
+  let ctor: unknown = model.constructor;
+  while (typeof ctor === 'function') {
+    const lcName = (ctor as { lc_name?: () => string }).lc_name?.();
+    if (lcName != null && names.has(lcName)) {
+      return true;
+    }
+    ctor = Object.getPrototypeOf(ctor);
+  }
+  return false;
+}
+
+/** Matches exactly the instances that were `instanceof` this package's
+ *  `ChatOpenAI`/`AzureChatOpenAI`: only those classes declare the
+ *  `LibreChatOpenAI`/`LibreChatAzureOpenAI` ids, their subclasses keep them in
+ *  the chain, and upstream `@langchain/openai` classes never carry them. */
+export function isLibreChatOpenAIModel(
+  model: unknown
+): model is
+  | import('@/llm/openai').ChatOpenAI
+  | import('@/llm/openai').AzureChatOpenAI {
+  return constructorChainHasLcName(model, OPENAI_FAMILY_LC_NAMES);
+}
+
+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}`);