@librechat/agents 3.6.15 → 3.7.0

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/openrouter/toolCache.ts

@@ -5,7 +5,13 @@ import {
   buildAnthropicCacheControl,
   type PromptCacheTtl,
 } from '@/messages/cache';
-import { _convertToOpenAITool } from '@/llm/openai';
+import { requireInternalModule } from '@/lazyRequire';
+
+/** Loads with the first OpenRouter request rather than alongside every graph. */
+const convertToOpenAITool = (
+  tool: BindToolsInput
+): OpenAIClient.ChatCompletionTool =>
+  requireInternalModule<typeof import('@/llm/openai')>('llm/openai/index')._convertToOpenAITool(tool);
 
 type OpenRouterCacheControl = { type: 'ephemeral'; ttl?: '1h' };
 
@@ -38,7 +44,7 @@ function hasDeferredMarker(tool: unknown): boolean {
 }
 
 function toOpenRouterTool(tool: unknown): OpenRouterToolWithCacheControl {
-  const converted = _convertToOpenAITool(
+  const converted = convertToOpenAITool(
     tool as BindToolsInput
   ) as OpenRouterToolWithCacheControl;
 

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,174 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type {
+  ProviderFamily,
+  ProviderRegistrationOptions,
+} from '../provider-registration';
+import type { ProviderModelConstructor, ProviderName } from '@/types';
+
+type ProviderModelClass = new (config: never) => BaseChatModel;
+
+interface StoredProviderRegistration {
+  model?: ProviderModelClass;
+  /** Built-ins defer their provider SDK import until the first model request;
+   *  the resolved class is validated once and memoized into `model`. */
+  loadModel?: () => ProviderModelClass;
+  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));
+}
+
+interface BuiltInProviderLoaderOptions {
+  provider: ProviderName;
+  loadModel: () => ProviderModelClass;
+  family?: ProviderFamily;
+  manualToolStream?: boolean;
+  strictAlternation?: boolean;
+}
+
+/** Registers a built-in whose provider SDK loads on first use, not at import time. */
+export function registerBuiltInProviderLoader(
+  options: BuiltInProviderLoaderOptions
+): void {
+  const provider = normalizeProvider(options.provider);
+  if (builtInProviders.has(provider)) {
+    throw new Error(`LLM provider already registered: ${provider}`);
+  }
+  builtInProviders.set(provider, {
+    loadModel: options.loadModel,
+    family: options.family ?? 'generic',
+    manualToolStream: options.manualToolStream ?? false,
+    strictAlternation: options.strictAlternation ?? false,
+    owner: Symbol(provider),
+  });
+}
+
+export function getRegisteredChatModelClass<P extends ProviderName>(
+  provider: P
+): ProviderModelConstructor<P> {
+  const registration = getRegistration(provider);
+  if (!registration) {
+    throw new Error(`Unsupported LLM provider: ${provider}`);
+  }
+  if (registration.model == null && registration.loadModel != null) {
+    const loaded = registration.loadModel();
+    if (typeof loaded !== 'function' || !isConstructible(loaded)) {
+      throw new TypeError(`LLM provider constructor is invalid: ${provider}`);
+    }
+    registration.model = loaded;
+  }
+  if (registration.model == null) {
+    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.eager.ts

@@ -0,0 +1,24 @@
+import * as openai from '@/llm/openai';
+import * as google from '@/llm/google';
+import * as bedrock from '@/llm/bedrock';
+import * as mistral from '@/llm/mistral';
+import * as vertexai from '@/llm/vertexai';
+import * as anthropic from '@/llm/anthropic';
+import * as openrouter from '@/llm/openrouter';
+import { registerSourceModeModules } from '@/lazyRequire';
+
+/**
+ * Source-mode counterpart of the lazy provider loading the built package uses: commands
+ * that run the TypeScript directly import this module first, so every lazily loadable
+ * provider module is loaded through the active ESM loader — one module graph, one set of
+ * class identities — and registered with the lazy-require seam.
+ */
+registerSourceModeModules({
+  'llm/openai/index': openai,
+  'llm/google/index': google,
+  'llm/bedrock/index': bedrock,
+  'llm/mistral/index': mistral,
+  'llm/vertexai/index': vertexai,
+  'llm/anthropic/index': anthropic,
+  'llm/openrouter/index': openrouter,
+});

package/src/llm/providers.ts

@@ -1,52 +1,109 @@
-// src/llm/providers.ts
-import { CustomChatMistralAI } from '@/llm/mistral';
-import type {
-  ChatModelConstructorMap,
-  ProviderOptionsMap,
-  ChatModelMap,
-} from '@/types';
+import type { ProviderModelConstructor, ProviderName } from '@/types';
+import { requireInternalModule } from '@/lazyRequire';
+import type { ProviderFamily } from '../provider-registration';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import {
-  AzureChatOpenAI,
-  ChatDeepSeek,
-  ChatMoonshot,
-  ChatOpenAI,
-  ChatXAI,
-} from '@/llm/openai';
-import { CustomChatGoogleGenerativeAI } from '@/llm/google';
-import { CustomChatBedrockConverse } from '@/llm/bedrock';
-import { CustomAnthropic } from '@/llm/anthropic';
-import { ChatOpenRouter } from '@/llm/openrouter';
-import { ChatVertexAI } from '@/llm/vertexai';
+  getRegisteredChatModelClass,
+  registerBuiltInProviderLoader,
+} from '@/llm/providerRegistry';
 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,
+/**
+ * Built-in provider SDKs load on first model request, not at import time: eagerly
+ * importing every provider cost hundreds of milliseconds of boot in hosts that
+ * configure one or two of them. `createRequire` keeps resolution synchronous and
+ * correct from both the CJS and ESM builds.
+ */
+
+type ProviderModelClass = new (config: never) => BaseChatModel;
+
+type BuiltInProviderTraits = {
+  family: ProviderFamily;
+  manualToolStream?: boolean;
+  strictAlternation?: boolean;
 };
 
-export const manualToolStreamProviders = new Set<Providers | string>([
+function initializeBuiltInProvider(
+  provider: Providers,
+  loadModel: () => ProviderModelClass,
+  traits: BuiltInProviderTraits
+): void {
+  registerBuiltInProviderLoader({
+    provider,
+    loadModel,
+    ...traits,
+  });
+}
+
+const fromOpenAI =
+  (name: string) => (): ProviderModelClass =>
+    (requireInternalModule<Record<string, ProviderModelClass>>('llm/openai/index'))[
+      name
+    ];
+
+initializeBuiltInProvider(Providers.XAI, fromOpenAI('ChatXAI'), { family: 'openai' });
+initializeBuiltInProvider(Providers.OPENAI, fromOpenAI('ChatOpenAI'), { family: 'openai' });
+initializeBuiltInProvider(Providers.AZURE, fromOpenAI('AzureChatOpenAI'), {
+  family: 'openai',
+});
+initializeBuiltInProvider(
+  Providers.VERTEXAI,
+  () => (requireInternalModule<typeof import('@/llm/vertexai')>('llm/vertexai/index')).ChatVertexAI,
+  { family: 'google' }
+);
+initializeBuiltInProvider(Providers.DEEPSEEK, fromOpenAI('ChatDeepSeek'), {
+  family: 'openai',
+});
+const loadMistral = (): ProviderModelClass =>
+  (requireInternalModule<typeof import('@/llm/mistral')>('llm/mistral/index')).CustomChatMistralAI;
+initializeBuiltInProvider(Providers.MISTRALAI, loadMistral, {
+  family: 'mistral',
+  strictAlternation: true,
+});
+initializeBuiltInProvider(Providers.MISTRAL, loadMistral, {
+  family: 'mistral',
+  strictAlternation: true,
+});
+initializeBuiltInProvider(
   Providers.ANTHROPIC,
+  () => (requireInternalModule<typeof import('@/llm/anthropic')>('llm/anthropic/index')).CustomAnthropic,
+  { family: 'anthropic', manualToolStream: true }
+);
+initializeBuiltInProvider(
+  Providers.OPENROUTER,
+  () =>
+    (requireInternalModule<typeof import('@/llm/openrouter')>('llm/openrouter/index')).ChatOpenRouter,
+  { family: 'openai' }
+);
+initializeBuiltInProvider(
   Providers.BEDROCK,
-]);
+  () =>
+    (requireInternalModule<typeof import('@/llm/bedrock')>('llm/bedrock/index'))
+      .CustomChatBedrockConverse,
+  { family: 'bedrock', manualToolStream: true, strictAlternation: true }
+);
+initializeBuiltInProvider(
+  Providers.GOOGLE,
+  () =>
+    (requireInternalModule<typeof import('@/llm/google')>('llm/google/index'))
+      .CustomChatGoogleGenerativeAI,
+  { family: 'google' }
+);
+initializeBuiltInProvider(Providers.MOONSHOT, fromOpenAI('ChatMoonshot'), {
+  family: 'generic',
+});
 
-export const getChatModelClass = <P extends Providers>(
+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';