@librechat/agents 3.6.16 → 3.7.0

package/src/llm/init.ts

@@ -1,9 +1,7 @@
-import { ChatVertexAI } from '@langchain/google-vertexai';
 import type { Runnable } from '@langchain/core/runnables';
 import type * as t from '@/types';
-import { ChatOpenAI, AzureChatOpenAI } from '@/llm/openai';
 import { getChatModelClass } from '@/llm/providers';
-import { isOpenAILike } from '@/utils';
+import { isOpenAILike, isLibreChatOpenAIModel, constructorChainHasLcName } from '@/utils';
 import { Providers } from '@/common';
 
 type InitializeModelParams<P extends t.ProviderName> = {
@@ -30,6 +28,18 @@ type InitializeModelParams<P extends t.ProviderName> = {
           })
 );
 
+const VERTEX_LC_NAMES: ReadonlySet<string> = new Set(['ChatVertexAI']);
+
+/** Structural stand-in for `instanceof ChatVertexAI`: matches both builds of
+ *  `@langchain/google-vertexai`, while this package's own vertex class reports
+ *  `LibreChatVertexAI` and keeps failing this guard exactly as it did under
+ *  `instanceof`. */
+function isLangchainVertexModel(
+  model: unknown
+): model is import('@langchain/google-vertexai').ChatVertexAI {
+  return constructorChainHasLcName(model, VERTEX_LC_NAMES);
+}
+
 /**
  * Creates a chat model instance for a given built-in or host-registered
  * provider, applies provider-specific field assignments, and optionally binds
@@ -47,10 +57,7 @@ export function initializeModel<P extends t.ProviderName>({
       (clientOptions ?? {}) as t.ProviderOptionsFor<P>
     );
 
-  if (
-    isOpenAILike(provider) &&
-    (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)
-  ) {
+  if (isOpenAILike(provider) && isLibreChatOpenAIModel(model)) {
     const opts = clientOptions as t.OpenAIClientOptions | undefined;
     if (opts) {
       model.temperature = opts.temperature as number;
@@ -59,7 +66,7 @@ export function initializeModel<P extends t.ProviderName>({
       model.presencePenalty = opts.presencePenalty as number;
       model.n = opts.n as number;
     }
-  } else if (provider === Providers.VERTEXAI && model instanceof ChatVertexAI) {
+  } else if (provider === Providers.VERTEXAI && isLangchainVertexModel(model)) {
     const opts = clientOptions as t.VertexAIClientOptions | undefined;
     if (opts) {
       model.temperature = opts.temperature as number;

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/providerRegistry.ts

@@ -5,8 +5,13 @@ import type {
 } from '../provider-registration';
 import type { ProviderModelConstructor, ProviderName } from '@/types';
 
+type ProviderModelClass = new (config: never) => BaseChatModel;
+
 interface StoredProviderRegistration {
-  model: new (config: never) => BaseChatModel;
+  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;
@@ -107,6 +112,31 @@ export function registerBuiltInProvider<
   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> {
@@ -114,6 +144,16 @@ export function getRegisteredChatModelClass<P extends ProviderName>(
   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>;
 }
 

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,81 +1,95 @@
-import type {
-  ChatModelConstructorMap,
-  ProviderModelConstructor,
-  ProviderName,
-} from '@/types';
+import type { ProviderModelConstructor, ProviderName } from '@/types';
+import { requireInternalModule } from '@/lazyRequire';
 import type { ProviderFamily } from '../provider-registration';
-import {
-  AzureChatOpenAI,
-  ChatDeepSeek,
-  ChatMoonshot,
-  ChatOpenAI,
-  ChatXAI,
-} from '@/llm/openai';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import {
   getRegisteredChatModelClass,
-  registerBuiltInProvider,
+  registerBuiltInProviderLoader,
 } 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';
 
+/**
+ * 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;
 };
 
-function initializeBuiltInProvider<P extends Providers>(
-  provider: P,
-  model: ChatModelConstructorMap[P],
+function initializeBuiltInProvider(
+  provider: Providers,
+  loadModel: () => ProviderModelClass,
   traits: BuiltInProviderTraits
 ): void {
-  registerBuiltInProvider({
+  registerBuiltInProviderLoader({
     provider,
-    model,
+    loadModel,
     ...traits,
   });
 }
 
-initializeBuiltInProvider(Providers.XAI, ChatXAI, { family: 'openai' });
-initializeBuiltInProvider(Providers.OPENAI, ChatOpenAI, { family: 'openai' });
-initializeBuiltInProvider(Providers.AZURE, AzureChatOpenAI, {
+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, ChatVertexAI, {
-  family: 'google',
-});
-initializeBuiltInProvider(Providers.DEEPSEEK, ChatDeepSeek, {
+initializeBuiltInProvider(
+  Providers.VERTEXAI,
+  () => (requireInternalModule<typeof import('@/llm/vertexai')>('llm/vertexai/index')).ChatVertexAI,
+  { family: 'google' }
+);
+initializeBuiltInProvider(Providers.DEEPSEEK, fromOpenAI('ChatDeepSeek'), {
   family: 'openai',
 });
-initializeBuiltInProvider(Providers.MISTRALAI, CustomChatMistralAI, {
+const loadMistral = (): ProviderModelClass =>
+  (requireInternalModule<typeof import('@/llm/mistral')>('llm/mistral/index')).CustomChatMistralAI;
+initializeBuiltInProvider(Providers.MISTRALAI, loadMistral, {
   family: 'mistral',
   strictAlternation: true,
 });
-initializeBuiltInProvider(Providers.MISTRAL, CustomChatMistralAI, {
+initializeBuiltInProvider(Providers.MISTRAL, loadMistral, {
   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, {
+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',
 });
 

package/src/messages/core.ts

@@ -980,6 +980,19 @@ function isCompleteToolStreamContentBlock(block: unknown): boolean {
   }
 }
 
+/** Drops incomplete streamed text blocks before provider-facing tool shaping. */
+export function dropIncompleteToolStreamContent(
+  content: AIMessage['content']
+): AIMessage['content'] {
+  if (!Array.isArray(content)) {
+    return content;
+  }
+  const completeContent = content.filter(isCompleteToolStreamContentBlock);
+  return completeContent.length === content.length
+    ? content
+    : toLangChainContent(completeContent);
+}
+
 function projectPreemptedResponsesV1Content(
   content: AIMessage['content'],
   reasoning: unknown,
@@ -2026,20 +2039,12 @@ export function projectToolStreamContentForProvider(
       }
       continue;
     }
-    if (!Array.isArray(assistantMessage.content)) {
-      continue;
-    }
-    const content = assistantMessage.content.filter(
-      isCompleteToolStreamContentBlock
-    );
-    if (content.length === assistantMessage.content.length) {
+    const content = dropIncompleteToolStreamContent(assistantMessage.content);
+    if (content === assistantMessage.content) {
       continue;
     }
     projected ??= [...messages];
-    projected[i] = cloneAIMessageWithContent(
-      assistantMessage,
-      toLangChainContent(content)
-    );
+    projected[i] = cloneAIMessageWithContent(assistantMessage, content);
   }
   return projected ?? messages;
 }

package/src/messages/prune.ts

@@ -31,6 +31,7 @@ import { resolveContextPruningSettings } from './contextPruningSettings';
 import { hasUnsafeStructuredSerialization } from '@/utils/tokens';
 import { ContentTypes, Providers, Constants } from '@/common';
 import { getProviderFamily } from '@/llm/providerRegistry';
+import { dropIncompleteToolStreamContent } from './core';
 import { applyContextPruning } from './contextPruning';
 import { toLangChainContent } from './langchain';
 
@@ -1412,6 +1413,47 @@ function cloneWithProjectedProperties<T extends object>(
   ) as T;
 }
 
+function cloneAIMessageWithProjectedStreamContent(
+  message: AIMessage | AIMessageChunk,
+  changes: Readonly<Record<string, unknown>>,
+  streamContent: AIMessage['content']
+): AIMessage | AIMessageChunk {
+  const descriptors = Object.getOwnPropertyDescriptors(message) as Record<
+    string,
+    PropertyDescriptor | undefined
+  >;
+  for (const [key, projectedValue] of Object.entries(changes)) {
+    const descriptor = descriptors[key];
+    descriptors[key] = {
+      configurable: descriptor?.configurable ?? true,
+      enumerable: descriptor?.enumerable ?? true,
+      value: projectedValue,
+      writable: descriptor?.writable ?? true,
+    };
+  }
+  const lcKwargs = descriptors.lc_kwargs;
+  if (
+    lcKwargs != null &&
+    'value' in lcKwargs &&
+    typeof lcKwargs.value === 'object' &&
+    lcKwargs.value != null
+  ) {
+    descriptors.lc_kwargs = {
+      ...lcKwargs,
+      value: {
+        ...(lcKwargs.value as Record<string, unknown>),
+        ...(message.response_metadata.output_version === 'v1'
+          ? { content: undefined, contentBlocks: streamContent }
+          : { content: streamContent }),
+      },
+    };
+  }
+  return Object.create(
+    Object.getPrototypeOf(message),
+    descriptors as PropertyDescriptorMap
+  ) as AIMessage | AIMessageChunk;
+}
+
 function createBoundedTruncationValue(
   preview: string,
   originalChars: number,
@@ -1875,9 +1917,10 @@ export function calculateMaxToolCallInputChars(
  * Returns the original array when no message changes and otherwise clones only
  * the array and AI messages whose inline input or `tool_calls` args changed.
  */
-export function projectToolCallInputs(
+function projectToolCallInputsInternal(
   messages: BaseMessage[],
-  maxInputChars: number
+  maxInputChars: number,
+  dropIncompleteStreamContent: boolean
 ): BaseMessage[] {
   const normalizedMaxInputChars = normalizeToolInputLimit(maxInputChars);
   let projectedMessages: BaseMessage[] | undefined;
@@ -1889,16 +1932,21 @@ export function projectToolCallInputs(
     }
 
     const aiMessage = message as AIMessage | AIMessageChunk;
-    let projectedContent = aiMessage.content;
-    let contentChanged = false;
-    if (Array.isArray(aiMessage.content)) {
-      const originalContent = aiMessage.content as MessageContentComplex[];
+    const streamContent = dropIncompleteStreamContent
+      ? dropIncompleteToolStreamContent(aiMessage.content)
+      : aiMessage.content;
+    let projectedContent = streamContent;
+    let contentChanged = streamContent !== aiMessage.content;
+    if (Array.isArray(streamContent)) {
+      const originalContent = streamContent as MessageContentComplex[];
       const mappedContent = originalContent.map((block) =>
         projectInlineToolInput(block, normalizedMaxInputChars)
       );
-      contentChanged = mappedContent.some(
-        (block, blockIndex) => block !== originalContent[blockIndex]
-      );
+      contentChanged =
+        contentChanged ||
+        mappedContent.some(
+          (block, blockIndex) => block !== originalContent[blockIndex]
+        );
       projectedContent = toLangChainContent(mappedContent);
     }
 
@@ -2020,18 +2068,45 @@ export function projectToolCallInputs(
       continue;
     }
 
-    const projectedMessage = cloneWithProjectedProperties(aiMessage, {
+    const changes = {
       content: projectedContent,
       tool_calls: projectedToolCalls.length > 0 ? projectedToolCalls : [],
       additional_kwargs: projectedAdditionalKwargs,
       response_metadata: projectedResponseMetadata,
-    });
+    };
+    const projectedMessage =
+      streamContent === aiMessage.content
+        ? cloneWithProjectedProperties(aiMessage, changes)
+        : cloneAIMessageWithProjectedStreamContent(
+          aiMessage,
+          changes,
+          streamContent
+        );
     projectedMessages ??= [...messages];
     projectedMessages[i] = projectedMessage;
   }
   return projectedMessages ?? messages;
 }
 
+/** Projects all historical tool-call input representations to bounded values. */
+export function projectToolCallInputs(
+  messages: BaseMessage[],
+  maxInputChars: number
+): BaseMessage[] {
+  return projectToolCallInputsInternal(messages, maxInputChars, false);
+}
+
+/**
+ * Derives provider-safe tool history in one pass by dropping incomplete stream
+ * content and bounding every provider-consumed tool-call input representation.
+ */
+export function projectToolMessagesForProvider(
+  messages: BaseMessage[],
+  maxInputChars: number
+): BaseMessage[] {
+  return projectToolCallInputsInternal(messages, maxInputChars, true);
+}
+
 export function preFlightTruncateToolCallInputs(params: {
   messages: BaseMessage[];
   maxContextTokens: number;

package/src/run.ts

@@ -2,7 +2,6 @@
 import { nanoid } from 'nanoid';
 import { PromptTemplate } from '@langchain/core/prompts';
 import { RunnableLambda } from '@langchain/core/runnables';
-import { AzureChatOpenAI, ChatOpenAI } from '@langchain/openai';
 import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import {
   Command,
@@ -36,6 +35,7 @@ import {
   ACTIVITY_PHASE_LABEL_RUN_NAME,
   DEFAULT_RECURSION_LIMIT,
 } from '@/common';
+import { isBuiltRuntime } from '@/lazyRequire';
 import {
   requireValidSubagentResumeManifest,
   stripSubagentResumeManifest,
@@ -101,9 +101,19 @@ import { createGraph } from '@/graphs/createGraph';
 import { resolveMaxSeals } from '@/llm/preempt';
 import { initializeModel } from '@/llm/init';
 import { HandlerRegistry } from '@/events';
-import { isOpenAILike } from '@/utils/llm';
+import { isOpenAILike, isLibreChatOpenAIModel } from '@/utils/llm';
 import { executeHooks } from '@/hooks';
 
+/** Source-mode runs have no dist siblings for the lazy-loading seam, so every
+ *  lazily loadable module is imported through the active loader before the
+ *  first model resolves. The built package never enters this branch. */
+async function ensureSourceModeProviders(): Promise<void> {
+  if (isBuiltRuntime()) {
+    return;
+  }
+  await import('@/llm/providers.eager');
+}
+
 export const defaultOmitOptions = new Set([
   'stream',
   'thinking',
@@ -717,6 +727,7 @@ export class Run<_T extends t.BaseGraphState> {
   static async create<T extends t.BaseGraphState>(
     config: t.RunConfig
   ): Promise<Run<T>> {
+    await ensureSourceModeProviders();
     /** Create tokenCounter if indexTokenCountMap is provided but tokenCounter is not */
     if (config.indexTokenCountMap && !config.tokenCounter) {
       const gc = config.graphConfig;
@@ -1974,10 +1985,7 @@ export class Run<_T extends t.BaseGraphState> {
       clientOptions,
     }) as t.ChatModelInstance;
 
-    if (
-      isOpenAILike(provider) &&
-      (model instanceof ChatOpenAI || model instanceof AzureChatOpenAI)
-    ) {
+    if (isOpenAILike(provider) && isLibreChatOpenAIModel(model)) {
       model.temperature = (clientOptions as t.OpenAIClientOptions | undefined)
         ?.temperature as number;
       model.topP = (clientOptions as t.OpenAIClientOptions | undefined)

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/utils/llm.ts

@@ -3,6 +3,45 @@ import type { ProviderName } from '@/types';
 import { getProviderFamily } from '@/llm/providerRegistry';
 import { Providers } from '@/common';
 
+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;