@librechat/agents 3.6.15 → 3.7.0

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;
@@ -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/format.ts

@@ -27,6 +27,7 @@ import type {
   ToolCallPart,
   TPayload,
   TMessage,
+  ProviderName,
 } from '@/types';
 import type {
   ProviderMessageAttribution,
@@ -366,7 +367,7 @@ export const formatFromLangChain = (
 interface FormatAssistantMessageOptions {
   preserveUnpairedServerToolUses?: boolean;
   preserveReasoningContent?: boolean;
-  provider?: Providers;
+  provider?: ProviderName;
   sourceMessageId?: string;
   sourceContentPartOffset?: number;
   sourceContentPartIndices?: readonly SourceContentPartIndices[];
@@ -376,7 +377,7 @@ interface FormatAssistantMessageOptions {
 type SourceContentPartIndices = number | readonly number[];
 
 interface FormatAgentMessagesOptions {
-  provider?: Providers;
+  provider?: ProviderName;
   /** Reconstruct hidden `reasoning_content` from `THINK` parts onto prior
    *  tool-call messages. Explicit opt-in for OpenAI-compatible endpoints that
    *  replay reasoning across turns; defaults to on for DeepSeek thinking-mode. */
@@ -478,10 +479,7 @@ function collectTrustedToolResultSourceContentPartIndices(
   let trusted: Set<number> | undefined;
   let previousPart: MessageContentComplex | null | undefined;
   for (let index = 0; index < content.length; index++) {
-    const part = content[index] as
-      | MessageContentComplex
-      | null
-      | undefined;
+    const part = content[index] as MessageContentComplex | null | undefined;
     if (part == null) {
       previousPart = part;
       continue;
@@ -509,13 +507,18 @@ function sourceContentPartIndicesAreTrustedToolResult(
   trustedToolSourceContentPartIndices: ReadonlySet<number> | undefined
 ): boolean {
   if (typeof sourceContentPartIndices === 'number') {
-    return trustedToolSourceContentPartIndices?.has(sourceContentPartIndices) === true;
+    return (
+      trustedToolSourceContentPartIndices?.has(sourceContentPartIndices) ===
+      true
+    );
   }
   if (sourceContentPartIndices.length === 0) {
     return false;
   }
   for (const sourceContentPartIndex of sourceContentPartIndices) {
-    if (trustedToolSourceContentPartIndices?.has(sourceContentPartIndex) !== true) {
+    if (
+      trustedToolSourceContentPartIndices?.has(sourceContentPartIndex) !== true
+    ) {
       return false;
     }
   }
@@ -1377,10 +1380,7 @@ function stampSourceMessageIdentity(
       },
     ];
   }
-  setProviderMessageProvenance(
-    message,
-    partsToStamp
-  );
+  setProviderMessageProvenance(message, partsToStamp);
   if (sourceMessageId == null || derivedIndex !== 0) {
     return;
   }
@@ -2759,9 +2759,7 @@ function getSyntheticProviderContextProvenanceParts(
 ): ProviderMessageProvenancePart[] | null {
   /** Fold labels are generated context, while retained source bytes keep their
    * original attribution so downstream policy can still route them exactly. */
-  const parts: ProviderMessageProvenancePart[] = [
-    { attribution: 'synthetic' },
-  ];
+  const parts: ProviderMessageProvenancePart[] = [{ attribution: 'synthetic' }];
   for (const source of sourceMessages) {
     const {
       message: sourceMessage,
@@ -3311,7 +3309,7 @@ function appendToolCalls(
  */
 export function ensureThinkingBlockInMessages(
   messages: BaseMessage[],
-  _provider: Providers,
+  _provider: ProviderName,
   config?: RunnableConfig,
   runStartIndex?: number
 ): BaseMessage[] {

package/src/messages/prune.ts

@@ -13,6 +13,7 @@ import type {
 } from '@/types/stream';
 import type { ContextPruningConfig } from '@/types/graph';
 import type { TokenCounter } from '@/types/run';
+import type { ProviderName } from '@/types';
 import {
   cloneToolMessageWithContent,
   compactToolContent,
@@ -29,6 +30,8 @@ import {
 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';
 
@@ -130,7 +133,7 @@ export function clampCalibrationRatio(ratio: number): number {
 }
 
 export type PruneMessagesFactoryParams = {
-  provider?: Providers;
+  provider?: ProviderName;
   maxTokens: number;
   /** Per-tool-result character cap applied while reconciling cached counts. */
   maxToolResultChars?: number;
@@ -1410,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,
@@ -1873,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;
@@ -1887,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);
     }
 
@@ -2018,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;
@@ -2065,6 +2142,15 @@ type ThinkingBlocks = {
 };
 
 export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
+  const providerFamily =
+    factoryParams.provider == null
+      ? undefined
+      : getProviderFamily(factoryParams.provider);
+  const usesBedrockThinking =
+    factoryParams.provider === Providers.BEDROCK ||
+    providerFamily === 'bedrock';
+  const usesOpenAIThinking =
+    factoryParams.provider === Providers.OPENAI || providerFamily === 'openai';
   const indexTokenCountMap = { ...factoryParams.indexTokenCountMap };
   let lastTurnStartIndex = factoryParams.startIndex;
   let lastCutOffIndex = 0;
@@ -2152,10 +2238,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
       };
     }
 
-    if (
-      factoryParams.provider === Providers.OPENAI &&
-      factoryParams.thinkingEnabled === true
-    ) {
+    if (usesOpenAIThinking && factoryParams.thinkingEnabled === true) {
       for (let i = lastTurnStartIndex; i < params.messages.length; i++) {
         const m = params.messages[i];
         if (
@@ -2729,10 +2812,9 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
       thinkingEnabled: factoryParams.thinkingEnabled,
       tokenCounter: factoryParams.tokenCounter,
       instructionTokens: rawSpaceInstructionTokens,
-      reasoningType:
-        factoryParams.provider === Providers.BEDROCK
-          ? ContentTypes.REASONING_CONTENT
-          : ContentTypes.THINKING,
+      reasoningType: usesBedrockThinking
+        ? ContentTypes.REASONING_CONTENT
+        : ContentTypes.THINKING,
       thinkingStartIndex:
         factoryParams.thinkingEnabled === true
           ? runThinkingStartIndex
@@ -2826,10 +2908,9 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
         thinkingEnabled: factoryParams.thinkingEnabled,
         tokenCounter: factoryParams.tokenCounter,
         instructionTokens: currentInstructionTokens,
-        reasoningType:
-          factoryParams.provider === Providers.BEDROCK
-            ? ContentTypes.REASONING_CONTENT
-            : ContentTypes.THINKING,
+        reasoningType: usesBedrockThinking
+          ? ContentTypes.REASONING_CONTENT
+          : ContentTypes.THINKING,
         thinkingStartIndex:
           factoryParams.thinkingEnabled === true
             ? runThinkingStartIndex
@@ -2963,10 +3044,9 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
           thinkingEnabled: factoryParams.thinkingEnabled,
           tokenCounter: factoryParams.tokenCounter,
           instructionTokens: currentInstructionTokens,
-          reasoningType:
-            factoryParams.provider === Providers.BEDROCK
-              ? ContentTypes.REASONING_CONTENT
-              : ContentTypes.THINKING,
+          reasoningType: usesBedrockThinking
+            ? ContentTypes.REASONING_CONTENT
+            : ContentTypes.THINKING,
           thinkingStartIndex:
             factoryParams.thinkingEnabled === true
               ? runThinkingStartIndex

package/src/provider-registration.ts

@@ -0,0 +1,29 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+
+declare const CUSTOM_PROVIDER_OPTIONS_TYPE: unique symbol;
+
+/** Declaration-merge this map to type host-registered provider options. */
+export interface CustomProviderOptionsMap {
+  readonly [CUSTOM_PROVIDER_OPTIONS_TYPE]?: never;
+}
+
+export type ProviderFamily =
+  | 'openai'
+  | 'anthropic'
+  | 'bedrock'
+  | 'google'
+  | 'mistral'
+  | 'generic';
+
+export interface ProviderRegistrationOptions<
+  TOptions extends object,
+  TModel extends BaseChatModel,
+> {
+  provider: string;
+  model: new (config: TOptions) => TModel;
+  family?: ProviderFamily;
+  manualToolStream?: boolean;
+  strictAlternation?: boolean;
+}
+
+export { registerProvider } from './llm/providers';

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',
@@ -452,7 +462,7 @@ export class Run<_T extends t.BaseGraphState> {
         provider,
         clientOptions,
         agentId: 'default',
-      };
+      } as t.AgentInputs;
       signal = legacySignal;
     }
 
@@ -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/session/AgentSession.ts

@@ -588,7 +588,7 @@ function createAgentInputFromGraphConfig(
       provider,
       clientOptions,
       agentId: 'default',
-    };
+    } as t.AgentInputs;
   }
   const summarizationConfig: t.SummarizationConfig = {
     ...(agent.summarizationConfig ?? {}),

package/src/stream.ts

@@ -820,12 +820,11 @@ function startEagerToolExecutions(args: {
       toolCalls: entries.map((entry) => entry.request),
       userId: graph.config?.configurable?.user_id as string | undefined,
       agentId: agentContext?.agentId,
-      callerCapabilityProjection:
-        (
-          agentContext as
-            | Partial<Pick<AgentContext, 'getCallerCapabilityProjectionSnapshot'>>
-            | undefined
-        )?.getCallerCapabilityProjectionSnapshot?.(),
+      callerCapabilityProjection: (
+        agentContext as
+          | Partial<Pick<AgentContext, 'getCallerCapabilityProjectionSnapshot'>>
+          | undefined
+      )?.getCallerCapabilityProjectionSnapshot?.(),
       configurable: graph.config?.configurable as
         | Record<string, unknown>
         | undefined,
@@ -1327,7 +1326,7 @@ export function getChunkContent({
   reasoningKey,
 }: {
   chunk?: Partial<AIMessageChunk>;
-  provider?: Providers;
+  provider?: t.ProviderName;
   reasoningKey: 'reasoning_content' | 'reasoning';
 }): string | t.MessageContentComplex[] | undefined {
   if (
@@ -1851,7 +1850,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
 
     if (Array.isArray(content) && content.every(isTextContentPart)) {
       const contentGroups = splitAssistantTextContentByPhase(content);
-      const currentStepId = graph.stepKeyIds?.get(stepKey)?.at(-1);
+      const currentStepId = graph.stepKeyIds.get(stepKey)?.at(-1);
       const currentStep =
         currentStepId == null ? undefined : graph.getRunStep(currentStepId);
       const currentPhase =

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;