@librechat/agents 3.6.14 → 3.6.16

package/src/llm/invoke.ts

@@ -13,14 +13,9 @@ import type { ToolCall } from '@langchain/core/messages/tool';
 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 {
-  modifyDeltaProperties,
-} from '@/messages';
-import { ChatModelStreamHandler, dispatchesChatModelStream } from '@/stream';
-import { Constants, ContentTypes, GraphEvents, Providers } from '@/common';
 import {
   enforceStreamLimitsForWireChunk,
   registerActiveStreamLimitGeneration,
@@ -35,11 +30,17 @@ import {
   assertPreparedProviderRequestFor,
   prepareProviderRequest,
 } from '@/llm/prepareProviderRequest';
+import {
+  getProviderFamily,
+  providerUsesManualToolStream,
+} from '@/llm/providers';
+import { ChatModelStreamHandler, dispatchesChatModelStream } from '@/stream';
+import { Constants, ContentTypes, GraphEvents, Providers } from '@/common';
 import { assertNotTruncatedToolCall } from '@/llm/truncation';
-import { manualToolStreamProviders } from '@/llm/providers';
 import { safeDispatchCustomEvent } from '@/utils/events';
 import { getContextOverflowInfo } from '@/utils/errors';
 import { appendCallbacks } from '@/utils/callbacks';
+import { modifyDeltaProperties } from '@/messages';
 import { canSealPreempt } from '@/llm/preempt';
 import { initializeModel } from '@/llm/init';
 
@@ -105,6 +106,19 @@ export type OnChunk = (
 /** Unique per-model-attempt sequence; see the stamp in `attemptInvoke`. */
 let streamLimitAttemptSeq = 0;
 
+function getManualToolStreamNormalizationProvider(
+  provider: t.ProviderName
+): t.ProviderName {
+  const family = getProviderFamily(provider);
+  if (family === 'anthropic') {
+    return Providers.ANTHROPIC;
+  }
+  if (family === 'bedrock') {
+    return Providers.BEDROCK;
+  }
+  return provider;
+}
+
 /**
  * The registered handler that owns content-part dispatch, if any.
  *
@@ -136,7 +150,7 @@ function removeOpenRouterFinalReasoningReplayContent({
 }: {
   current?: AIMessageChunk;
   next: AIMessageChunk;
-  provider: Providers;
+  provider: t.ProviderName;
 }): AIMessageChunk {
   const content = getOpenRouterFinalReasoningContent({
     current,
@@ -161,7 +175,7 @@ function getOpenRouterFinalReasoningContent({
 }: {
   current?: AIMessageChunk;
   next: AIMessageChunk;
-  provider: Providers;
+  provider: t.ProviderName;
 }): string | undefined {
   if (
     provider !== Providers.OPENROUTER ||
@@ -197,7 +211,7 @@ function getStreamHandlingChunk({
 }: {
   current?: AIMessageChunk;
   next: AIMessageChunk;
-  provider: Providers;
+  provider: t.ProviderName;
 }): AIMessageChunk | undefined {
   const content = getOpenRouterFinalReasoningContent({
     current,
@@ -473,7 +487,7 @@ function appendStreamChunk({
 }: {
   current?: AIMessageChunk;
   next: AIMessageChunk;
-  provider: Providers;
+  provider: t.ProviderName;
 }): AIMessageChunk {
   if (current == null) {
     return next;
@@ -514,11 +528,11 @@ type AttemptInvokeParams = AttemptInvokeCommonParams &
         request?: never;
         model: t.ChatModel;
         messages: BaseMessage[];
-        provider: Providers;
+        provider: t.ProviderName;
       }
   );
 
-function resolveAttemptProvider(params: AttemptInvokeParams): Providers {
+function resolveAttemptProvider(params: AttemptInvokeParams): t.ProviderName {
   if (params.request != null) {
     return params.request.provider;
   }
@@ -586,9 +600,7 @@ export async function attemptInvoke(
       : undefined;
   const generationKey =
     leaseTarget != null
-      ? resolveGenerationKey(
-        stampedConfig.metadata as Record<string, unknown>
-      )
+      ? resolveGenerationKey(stampedConfig.metadata as Record<string, unknown>)
       : undefined;
   if (leaseTarget != null && generationKey != null) {
     registerActiveStreamLimitGeneration(leaseTarget, generationKey);
@@ -809,8 +821,11 @@ async function attemptInvokeBody(
       }
     }
 
-    if (manualToolStreamProviders.has(provider)) {
-      finalChunk = modifyDeltaProperties(provider, finalChunk);
+    if (providerUsesManualToolStream(provider)) {
+      finalChunk = modifyDeltaProperties(
+        getManualToolStreamNormalizationProvider(provider),
+        finalChunk
+      );
     }
 
     if (preempted && finalChunk != null) {
@@ -857,7 +872,7 @@ async function attemptInvokeBody(
  * differ, which is the whole reason a fallback exists.
  */
 export interface FallbackErrorContext {
-  provider: Providers;
+  provider: t.ProviderName;
   clientOptions?: t.ClientOptions;
   maxContextTokens?: number;
 }
@@ -968,7 +983,7 @@ export async function tryFallbackProviders({
   prepareProviderRequest?: (input: {
     model: t.ChatModel;
     messages: BaseMessage[];
-    provider: Providers;
+    provider: t.ProviderName;
     clientOptions?: t.ClientOptions;
     maxContextTokens?: number;
     config?: RunnableConfig;
@@ -977,7 +992,7 @@ export async function tryFallbackProviders({
   prepareProviderMessages?: (input: {
     model: t.ChatModel;
     messages: BaseMessage[];
-    provider: Providers;
+    provider: t.ProviderName;
     clientOptions?: t.ClientOptions;
     maxContextTokens?: number;
     config?: RunnableConfig;

package/src/llm/prepareProviderRequest.ts

@@ -14,7 +14,6 @@ import {
 } from '@/messages/core';
 import {
   coalesceAdjacentUserTurns,
-  strictAlternationProviders,
   appendPredecessorHandoffCue,
   removePredecessorHandoffCue,
 } from '@/messages';
@@ -23,8 +22,10 @@ import {
   stripBedrockCacheControl,
 } from '@/messages/cache';
 import { annotateMessagesForLLM } from '@/tools/toolOutputReferences';
-import { Providers } from '@/common';
+import { providerRequiresStrictAlternation } from '@/llm/providers';
 import { isAnthropicLike, isOpenAILike } from '@/utils/llm';
+import { getProviderFamily } from '@/llm/providerRegistry';
+import { Providers } from '@/common';
 
 const preparedProviderRequestBrand = Symbol('PreparedProviderRequest');
 
@@ -43,7 +44,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;
@@ -63,7 +64,7 @@ export interface ProviderRequestContext {
 export interface PrepareProviderRequestParams {
   model: t.ChatModel;
   messages: BaseMessage[];
-  provider: Providers;
+  provider: t.ProviderName;
   context?: ProviderRequestContext;
   config?: RunnableConfig;
   maxToolResultChars?: number;
@@ -72,7 +73,7 @@ export interface PrepareProviderRequestParams {
 
 export function usesNativeOpenAIResponses(
   model: t.ChatModel,
-  provider: Providers,
+  provider: t.ProviderName,
   callOptions?: unknown
 ): boolean {
   if (!isOpenAILike(provider)) {
@@ -142,7 +143,7 @@ export function usesNativeOpenAIResponses(
 
 function resolveProviderMessageProjectionMode(
   model: t.ChatModel,
-  provider: Providers,
+  provider: t.ProviderName,
   callOptions?: unknown
 ): ProviderMessageProjectionMode {
   return usesNativeOpenAIResponses(model, provider, callOptions)
@@ -153,18 +154,16 @@ function resolveProviderMessageProjectionMode(
 interface ProjectMessagesForProviderParams {
   model: t.ChatModel;
   messages: BaseMessage[];
-  provider: Providers;
+  provider: t.ProviderName;
   maxToolResultChars?: number;
   callOptions?: unknown;
 }
 
-function projectMessagesForProviderMode({
-  messages,
-  provider,
-  maxToolResultChars,
-}: ProjectMessagesForProviderParams,
-projectionMode: ProviderMessageProjectionMode
+function projectMessagesForProviderMode(
+  { messages, provider, maxToolResultChars }: ProjectMessagesForProviderParams,
+  projectionMode: ProviderMessageProjectionMode
 ): BaseMessage[] {
+  const providerFamily = getProviderFamily(provider);
   const nativeOpenAIResponses = projectionMode === 'openai-responses';
   const providerInputMessages = projectToolStreamContentForProvider(
     messages,
@@ -197,7 +196,7 @@ projectionMode: ProviderMessageProjectionMode
       )
     );
   }
-  if (provider === Providers.ANTHROPIC) {
+  if (provider === Providers.ANTHROPIC || providerFamily === 'anthropic') {
     return projectComputerCallOutputsToText(
       projectSingleTextToolOutputsToText(
         stripBedrockCacheControl(providerInputMessages),
@@ -205,7 +204,7 @@ projectionMode: ProviderMessageProjectionMode
       )
     );
   }
-  if (provider === Providers.BEDROCK) {
+  if (provider === Providers.BEDROCK || providerFamily === 'bedrock') {
     return stripAnthropicCacheControl(
       projectComputerCallOutputsToText(
         projectCacheControlledToolOutputsToText(
@@ -310,7 +309,7 @@ export function prepareProviderRequest({
         : (message): boolean => isRunProduced.call(context, message)
     )
     : removePredecessorHandoffCue(annotated);
-  const preparedMessages = strictAlternationProviders.has(provider)
+  const preparedMessages = providerRequiresStrictAlternation(provider)
     ? coalesceAdjacentUserTurns(cued)
     : cued;
 
@@ -332,7 +331,7 @@ export function prepareProviderRequest({
 export function assertPreparedProviderRequestFor(
   request: PreparedProviderRequest,
   model: t.ChatModel,
-  provider: Providers,
+  provider: t.ProviderName,
   config?: RunnableConfig
 ): void {
   if (
@@ -344,7 +343,9 @@ export function assertPreparedProviderRequestFor(
     throw new Error('Prepared provider request does not match serving model');
   }
   if (request.provider !== provider) {
-    throw new Error('Prepared provider request does not match serving provider');
+    throw new Error(
+      'Prepared provider request does not match serving provider'
+    );
   }
   if (
     request.projectionMode !==

package/src/llm/providerRegistry.ts

@@ -0,0 +1,134 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type {
+  ProviderFamily,
+  ProviderRegistrationOptions,
+} from '../provider-registration';
+import type { ProviderModelConstructor, ProviderName } from '@/types';
+
+interface StoredProviderRegistration {
+  model: new (config: never) => BaseChatModel;
+  family: ProviderFamily;
+  manualToolStream: boolean;
+  strictAlternation: boolean;
+  owner: symbol;
+}
+
+interface ProviderRegistryGlobal {
+  [key: symbol]: Map<ProviderName, StoredProviderRegistration> | undefined;
+}
+
+const PROVIDER_REGISTRY_KEY = Symbol.for(
+  '@librechat/agents:providerRegistry:v1'
+);
+const providerRegistryGlobal = globalThis as ProviderRegistryGlobal;
+const registeredProviders =
+  providerRegistryGlobal[PROVIDER_REGISTRY_KEY] ??
+  new Map<ProviderName, StoredProviderRegistration>();
+providerRegistryGlobal[PROVIDER_REGISTRY_KEY] = registeredProviders;
+const builtInProviders = new Map<ProviderName, StoredProviderRegistration>();
+
+function normalizeProvider(provider: ProviderName): ProviderName {
+  if (typeof provider !== 'string' || provider.trim() === '') {
+    throw new TypeError('LLM provider name must be a non-empty string');
+  }
+  if (provider !== provider.trim()) {
+    throw new TypeError(
+      'LLM provider name must not have surrounding whitespace'
+    );
+  }
+  return provider;
+}
+
+function isConstructible<T extends abstract new (...args: never[]) => object>(
+  value: T
+): boolean {
+  try {
+    Reflect.construct(String, [], value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function createRegistration<
+  TOptions extends object,
+  TModel extends BaseChatModel,
+>(
+  provider: ProviderName,
+  options: ProviderRegistrationOptions<TOptions, TModel>
+): StoredProviderRegistration {
+  if (typeof options.model !== 'function' || !isConstructible(options.model)) {
+    throw new TypeError(`LLM provider constructor is invalid: ${provider}`);
+  }
+  return {
+    model: options.model,
+    family: options.family ?? 'generic',
+    manualToolStream: options.manualToolStream ?? false,
+    strictAlternation: options.strictAlternation ?? false,
+    owner: Symbol(provider),
+  };
+}
+
+function getRegistration(
+  provider: ProviderName
+): StoredProviderRegistration | undefined {
+  return builtInProviders.get(provider) ?? registeredProviders.get(provider);
+}
+
+/** Registers one host provider until the returned disposer is called. */
+export function registerProvider<
+  TOptions extends object,
+  TModel extends BaseChatModel,
+>(options: ProviderRegistrationOptions<TOptions, TModel>): () => void {
+  const provider = normalizeProvider(options.provider);
+  if (getRegistration(provider) != null) {
+    throw new Error(`LLM provider already registered: ${provider}`);
+  }
+
+  const registration = createRegistration(provider, options);
+  registeredProviders.set(provider, registration);
+
+  return (): void => {
+    if (registeredProviders.get(provider)?.owner === registration.owner) {
+      registeredProviders.delete(provider);
+    }
+  };
+}
+
+/** Initializes one built-in for the current package module graph. */
+export function registerBuiltInProvider<
+  TOptions extends object,
+  TModel extends BaseChatModel,
+>(options: ProviderRegistrationOptions<TOptions, TModel>): void {
+  const provider = normalizeProvider(options.provider);
+  if (builtInProviders.has(provider)) {
+    throw new Error(`LLM provider already registered: ${provider}`);
+  }
+  builtInProviders.set(provider, createRegistration(provider, options));
+}
+
+export function getRegisteredChatModelClass<P extends ProviderName>(
+  provider: P
+): ProviderModelConstructor<P> {
+  const registration = getRegistration(provider);
+  if (!registration) {
+    throw new Error(`Unsupported LLM provider: ${provider}`);
+  }
+  return registration.model as ProviderModelConstructor<P>;
+}
+
+export function getProviderFamily(
+  provider: ProviderName
+): ProviderFamily | undefined {
+  return getRegistration(provider)?.family;
+}
+
+export function providerUsesManualToolStream(provider: ProviderName): boolean {
+  return getRegistration(provider)?.manualToolStream ?? false;
+}
+
+export function providerRequiresStrictAlternation(
+  provider: ProviderName
+): boolean {
+  return getRegistration(provider)?.strictAlternation ?? false;
+}

package/src/llm/providers.ts

@@ -1,10 +1,9 @@
-// src/llm/providers.ts
-import { CustomChatMistralAI } from '@/llm/mistral';
 import type {
   ChatModelConstructorMap,
-  ProviderOptionsMap,
-  ChatModelMap,
+  ProviderModelConstructor,
+  ProviderName,
 } from '@/types';
+import type { ProviderFamily } from '../provider-registration';
 import {
   AzureChatOpenAI,
   ChatDeepSeek,
@@ -12,41 +11,85 @@ import {
   ChatOpenAI,
   ChatXAI,
 } from '@/llm/openai';
+import {
+  getRegisteredChatModelClass,
+  registerBuiltInProvider,
+} from '@/llm/providerRegistry';
 import { CustomChatGoogleGenerativeAI } from '@/llm/google';
 import { CustomChatBedrockConverse } from '@/llm/bedrock';
+import { CustomChatMistralAI } from '@/llm/mistral';
 import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import { ChatVertexAI } from '@/llm/vertexai';
 import { Providers } from '@/common';
 
-export const llmProviders: Partial<ChatModelConstructorMap> = {
-  [Providers.XAI]: ChatXAI,
-  [Providers.OPENAI]: ChatOpenAI,
-  [Providers.AZURE]: AzureChatOpenAI,
-  [Providers.VERTEXAI]: ChatVertexAI,
-  [Providers.DEEPSEEK]: ChatDeepSeek,
-  [Providers.MISTRALAI]: CustomChatMistralAI,
-  [Providers.MISTRAL]: CustomChatMistralAI,
-  [Providers.ANTHROPIC]: CustomAnthropic,
-  [Providers.OPENROUTER]: ChatOpenRouter,
-  [Providers.BEDROCK]: CustomChatBedrockConverse,
-  // [Providers.ANTHROPIC]: ChatAnthropic,
-  [Providers.GOOGLE]: CustomChatGoogleGenerativeAI,
-  [Providers.MOONSHOT]: ChatMoonshot,
+type BuiltInProviderTraits = {
+  family: ProviderFamily;
+  manualToolStream?: boolean;
+  strictAlternation?: boolean;
 };
 
-export const manualToolStreamProviders = new Set<Providers | string>([
-  Providers.ANTHROPIC,
-  Providers.BEDROCK,
-]);
+function initializeBuiltInProvider<P extends Providers>(
+  provider: P,
+  model: ChatModelConstructorMap[P],
+  traits: BuiltInProviderTraits
+): void {
+  registerBuiltInProvider({
+    provider,
+    model,
+    ...traits,
+  });
+}
 
-export const getChatModelClass = <P extends Providers>(
+initializeBuiltInProvider(Providers.XAI, ChatXAI, { family: 'openai' });
+initializeBuiltInProvider(Providers.OPENAI, ChatOpenAI, { family: 'openai' });
+initializeBuiltInProvider(Providers.AZURE, AzureChatOpenAI, {
+  family: 'openai',
+});
+initializeBuiltInProvider(Providers.VERTEXAI, ChatVertexAI, {
+  family: 'google',
+});
+initializeBuiltInProvider(Providers.DEEPSEEK, ChatDeepSeek, {
+  family: 'openai',
+});
+initializeBuiltInProvider(Providers.MISTRALAI, CustomChatMistralAI, {
+  family: 'mistral',
+  strictAlternation: true,
+});
+initializeBuiltInProvider(Providers.MISTRAL, CustomChatMistralAI, {
+  family: 'mistral',
+  strictAlternation: true,
+});
+initializeBuiltInProvider(Providers.ANTHROPIC, CustomAnthropic, {
+  family: 'anthropic',
+  manualToolStream: true,
+});
+initializeBuiltInProvider(Providers.OPENROUTER, ChatOpenRouter, {
+  family: 'openai',
+});
+initializeBuiltInProvider(Providers.BEDROCK, CustomChatBedrockConverse, {
+  family: 'bedrock',
+  manualToolStream: true,
+  strictAlternation: true,
+});
+initializeBuiltInProvider(Providers.GOOGLE, CustomChatGoogleGenerativeAI, {
+  family: 'google',
+});
+initializeBuiltInProvider(Providers.MOONSHOT, ChatMoonshot, {
+  family: 'generic',
+});
+
+export const getChatModelClass = <P extends ProviderName>(
   provider: P
-): new (config: ProviderOptionsMap[P]) => ChatModelMap[P] => {
-  const ChatModelClass = llmProviders[provider];
-  if (!ChatModelClass) {
-    throw new Error(`Unsupported LLM provider: ${provider}`);
-  }
+): ProviderModelConstructor<P> => getRegisteredChatModelClass(provider);
 
-  return ChatModelClass;
-};
+export {
+  getProviderFamily,
+  providerRequiresStrictAlternation,
+  providerUsesManualToolStream,
+  registerProvider,
+} from '@/llm/providerRegistry';
+export type {
+  ProviderFamily,
+  ProviderRegistrationOptions,
+} from '../provider-registration';

package/src/llm/request.ts

@@ -1,4 +1,5 @@
 import type * as t from '@/types';
+import { getProviderFamily } from '@/llm/providerRegistry';
 import { Providers } from '@/common';
 
 /**
@@ -7,20 +8,21 @@ import { Providers } from '@/common';
  * and OpenAI-compat (modelKwargs.thinking).
  */
 export function isThinkingEnabled(
-  provider: Providers,
+  provider: t.ProviderName,
   clientOptions?: t.ClientOptions
 ): boolean {
   if (!clientOptions) return false;
+  const family = getProviderFamily(provider);
 
   if (
-    provider === Providers.ANTHROPIC &&
+    (provider === Providers.ANTHROPIC || family === 'anthropic') &&
     (clientOptions as t.AnthropicClientOptions).thinking != null
   ) {
     return true;
   }
 
   if (
-    provider === Providers.BEDROCK &&
+    (provider === Providers.BEDROCK || family === 'bedrock') &&
     (clientOptions as t.BedrockAnthropicInput).additionalModelRequestFields?.[
       'thinking'
     ] != null
@@ -29,7 +31,7 @@ export function isThinkingEnabled(
   }
 
   if (
-    provider === Providers.OPENAI &&
+    (provider === Providers.OPENAI || family === 'openai') &&
     (
       (clientOptions as t.OpenAIClientOptions).modelKwargs
         ?.thinking as t.AnthropicClientOptions['thinking']
@@ -47,9 +49,11 @@ export function isThinkingEnabled(
  * use `maxTokens`.
  */
 export function getMaxOutputTokensKey(
-  provider: Providers | string
+  provider: t.ProviderName
 ): 'maxOutputTokens' | 'maxTokens' {
-  return provider === Providers.GOOGLE || provider === Providers.VERTEXAI
+  return provider === Providers.GOOGLE ||
+    provider === Providers.VERTEXAI ||
+    getProviderFamily(provider) === 'google'
     ? 'maxOutputTokens'
     : 'maxTokens';
 }

package/src/llm/truncation.ts

@@ -1,4 +1,6 @@
 import type { AIMessageChunk, BaseMessage } from '@langchain/core/messages';
+import type { ProviderName } from '@/types';
+import { getProviderFamily } from '@/llm/providerRegistry';
 import { Providers } from '@/common';
 
 /**
@@ -7,7 +9,7 @@ import { Providers } from '@/common';
  * `functionCall` whole and seal it on arrival, so a `MAX_TOKENS` finish does
  * NOT imply the arguments were cut off — the truncation guard must skip them.
  */
-const ATOMIC_TOOL_CALL_ARG_PROVIDERS = new Set<Providers>([
+const ATOMIC_TOOL_CALL_ARG_PROVIDERS = new Set<ProviderName>([
   Providers.GOOGLE,
   Providers.VERTEXAI,
 ]);
@@ -162,12 +164,16 @@ function collectToolCallNames(message: AIMessageChunk | BaseMessage): string[] {
  */
 export function assertNotTruncatedToolCall(
   message: AIMessageChunk | BaseMessage | undefined | null,
-  provider?: Providers
+  provider?: ProviderName
 ): void {
   if (message == null) {
     return;
   }
-  if (provider != null && ATOMIC_TOOL_CALL_ARG_PROVIDERS.has(provider)) {
+  if (
+    provider != null &&
+    (ATOMIC_TOOL_CALL_ARG_PROVIDERS.has(provider) ||
+      getProviderFamily(provider) === 'google')
+  ) {
     return;
   }
   const stopReason = getTruncationStopReason(message);

package/src/messages/core.ts

@@ -90,7 +90,7 @@ const modifyContent = ({
   messageType,
   content,
 }: {
-  provider: Providers;
+  provider: t.ProviderName;
   messageType: string;
   content: t.ExtendedMessageContent[];
 }): (t.ExtendedMessageContent | null)[] => {
@@ -243,7 +243,7 @@ function hasReasoningContent(content: BaseMessage['content']): boolean {
 }
 
 export function modifyDeltaProperties(
-  provider: Providers,
+  provider: t.ProviderName,
   obj?: AIMessageChunk
 ): AIMessageChunk | undefined {
   if (!obj || typeof obj !== 'object') return obj;