@librechat/agents 3.6.14 → 3.6.16

package/dist/types/types/llm.d.ts

@@ -1,6 +1,6 @@
 import { ChatMistralAI } from '@langchain/mistralai';
 import type { OpenAIChatInput, ChatOpenAIFields, AzureOpenAIInput, ClientOptions as OAIClientOptions } from '@langchain/openai';
-import type { BindToolsInput, BaseChatModelParams } from '@langchain/core/language_models/chat_models';
+import type { BindToolsInput, BaseChatModel, BaseChatModelParams } from '@langchain/core/language_models/chat_models';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
@@ -12,6 +12,7 @@ import type { AnthropicInput } from '@langchain/anthropic';
 import type { Runnable } from '@langchain/core/runnables';
 import type { OpenAI as OpenAIClient } from 'openai';
 import type { ChatXAIInput } from '@langchain/xai';
+import type { CustomProviderOptionsMap } from '../provider-registration';
 import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import type { PromptCacheTtl } from '@/messages/cache';
 import { AzureChatOpenAI, ChatDeepSeek, ChatMoonshot, ChatOpenAI, ChatXAI } from '@/llm/openai';
@@ -105,21 +106,57 @@ export type GoogleClientOptions = GoogleGenerativeAIChatInput & StreamSmoothingO
 };
 export type DeepSeekClientOptions = Partial<ChatDeepSeekInput> & StreamSmoothingOptions;
 export type XAIClientOptions = ChatXAIInput & StreamSmoothingOptions;
-export type ClientOptions = OpenAIClientOptions | AzureClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions | XAIClientOptions;
-export type SharedLLMConfig = {
-    provider: Providers;
+export type BuiltInClientOptions = OpenAIClientOptions | AzureClientOptions | AnthropicClientOptions | MistralAIClientOptions | VertexAIClientOptions | BedrockConverseClientOptions | GoogleClientOptions | DeepSeekClientOptions | XAIClientOptions;
+type CustomProviderName = Extract<keyof CustomProviderOptionsMap, string>;
+type LooseRuntimeProviderName = string & {
+    readonly __runtimeProviderName?: never;
+};
+export type ProviderName = keyof ProviderOptionsMap | CustomProviderName | LooseRuntimeProviderName;
+declare const RUNTIME_PROVIDER_NAME: unique symbol;
+/** A runtime provider without declaration-merged option types. */
+export type RuntimeProviderName = string & {
+    readonly [RUNTIME_PROVIDER_NAME]: true;
+};
+export type ClientOptions = BuiltInClientOptions | CustomProviderOptionsMap[CustomProviderName];
+export type SharedLLMConfig<P extends keyof ProviderOptionsMap | CustomProviderName | RuntimeProviderName = keyof ProviderOptionsMap> = {
+    provider: P;
+    model?: string;
     _lc_stream_delay?: number;
 };
-export interface FallbackConfig {
-    provider: Providers;
-    clientOptions?: ClientOptions;
+type CustomProviderClientOptionsConfig<P extends CustomProviderName> = {
+    provider: P;
+} & (object extends CustomProviderOptionsMap[P] ? {
+    clientOptions?: CustomProviderOptionsMap[P];
+} : {
+    clientOptions: CustomProviderOptionsMap[P];
+});
+export type ProviderClientOptionsConfig = {
+    provider: keyof ProviderOptionsMap;
+    clientOptions?: BuiltInClientOptions;
+} | {
+    [P in CustomProviderName]: CustomProviderClientOptionsConfig<P>;
+}[CustomProviderName] | {
+    provider: RuntimeProviderName;
+    clientOptions: ClientOptions;
+};
+export type FallbackConfig = ProviderClientOptionsConfig & {
     /** Context window used to corroborate ambiguous fallback overflow errors. */
     maxContextTokens?: number;
-}
-export type LLMConfig = SharedLLMConfig & ClientOptions & {
+};
+type LLMConfigFor<P extends CustomProviderName> = SharedLLMConfig<P> & CustomProviderOptionsMap[P] & {
+    /** Optional provider fallbacks in order of attempt */
+    fallbacks?: FallbackConfig[];
+};
+export type BuiltInLLMConfig = SharedLLMConfig & BuiltInClientOptions & {
     /** Optional provider fallbacks in order of attempt */
     fallbacks?: FallbackConfig[];
 };
+export type LLMConfig = BuiltInLLMConfig | {
+    [P in CustomProviderName]: LLMConfigFor<P>;
+}[CustomProviderName] | (SharedLLMConfig<RuntimeProviderName> & ClientOptions & {
+    /** Optional provider fallbacks in order of attempt */
+    fallbacks?: FallbackConfig[];
+});
 export type ProviderOptionsMap = {
     [Providers.AZURE]: AzureClientOptions;
     [Providers.OPENAI]: OpenAIClientOptions;
@@ -134,7 +171,7 @@ export type ProviderOptionsMap = {
     [Providers.XAI]: XAIClientOptions;
     [Providers.MOONSHOT]: OpenAIClientOptions;
 };
-export type ChatModelMap = {
+export interface ChatModelMap {
     [Providers.XAI]: ChatXAI;
     [Providers.OPENAI]: ChatOpenAI;
     [Providers.AZURE]: AzureChatOpenAI;
@@ -147,11 +184,15 @@ export type ChatModelMap = {
     [Providers.BEDROCK]: CustomChatBedrockConverse;
     [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
     [Providers.MOONSHOT]: ChatMoonshot;
-};
+}
+export type ProviderOptionsFor<P extends ProviderName> = P extends keyof ProviderOptionsMap ? ProviderOptionsMap[P] : P extends CustomProviderName ? CustomProviderOptionsMap[P] : BuiltInClientOptions;
+export type ProviderModelFor<P extends ProviderName> = P extends keyof ChatModelMap ? ChatModelMap[P] & BaseChatModel : BaseChatModel;
+export type ProviderModelConstructor<P extends ProviderName> = new (config: ProviderOptionsFor<P>) => ProviderModelFor<P>;
 export type ChatModelConstructorMap = {
     [P in Providers]: new (config: ProviderOptionsMap[P]) => ChatModelMap[P];
 };
-export type ChatModelInstance = ChatModelMap[Providers];
-export type ModelWithTools = ChatModelInstance & {
+export type ChatModelInstance = BaseChatModel;
+export type ModelWithTools = BaseChatModel & {
     bindTools(tools: CommonToolType[]): Runnable;
 };
+export type { CustomProviderOptionsMap } from '../provider-registration';

package/dist/types/types/reasoningLabel.d.ts

@@ -1,7 +1,6 @@
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { UsageMetadata } from '@langchain/core/messages';
-import type { ClientOptions } from '@/types/llm';
-import type { Providers } from '@/common';
+import type { ClientOptions, ProviderName } from '@/types/llm';
 /** Lifecycle state of the visible reasoning snapshot being labeled. */
 export type ReasoningLabelStatus = 'streaming' | 'complete';
 /** Result of one reasoning-label revision. */
@@ -12,7 +11,7 @@ export type ReasoningLabelResult = {
 };
 /** Options for `Run.generateReasoningLabel`. */
 export type RunReasoningLabelOptions = {
-    provider: Providers;
+    provider: ProviderName;
     clientOptions?: ClientOptions;
     /**
      * Complete user-visible reasoning accumulated for this step so far. Hidden

package/dist/types/types/run.d.ts

@@ -14,7 +14,7 @@ import type * as l from '@/types/llm';
 export type ZodObjectAny = z.ZodObject<any, any, any, any>;
 export type BaseGraphConfig = {
     llmConfig: l.LLMConfig;
-    provider?: e.Providers;
+    provider?: l.ProviderName;
     clientOptions?: l.ClientOptions;
     /** Optional compile options for workflow.compile() */
     compileOptions?: g.CompileOptions;
@@ -34,7 +34,7 @@ export type SupervisedGraphConfig = BaseGraphConfig & {
     routingPolicies?: Array<{
         stage: string;
         agents?: string[];
-        model?: e.Providers;
+        model?: l.ProviderName;
         parallel?: boolean;
         /** Optional simple condition on content/tools */
         when?: 'always' | 'has_tools' | 'no_tools' | {
@@ -55,7 +55,7 @@ export type SupervisedGraphConfig = BaseGraphConfig & {
 } & Omit<g.StandardGraphInput, 'provider' | 'clientOptions'>;
 export type RunTitleOptions = {
     inputText: string;
-    provider: e.Providers;
+    provider: l.ProviderName;
     contentParts: (s.MessageContentComplex | undefined)[];
     titlePrompt?: string;
     skipLanguage?: boolean;

package/dist/types/types/summarize.d.ts

@@ -1,5 +1,5 @@
 import type { SummaryContentBlock } from '@/types/stream';
-import type { Providers } from '@/common';
+import type { ProviderName } from '@/types/llm';
 export type SummarizationTrigger = {
     type: 'token_ratio' | 'remaining_tokens' | 'messages_to_refine' | (string & {});
     value: number;
@@ -28,7 +28,7 @@ export type RetainRecentConfig = {
     tokens?: number;
 };
 export type SummarizationConfig = {
-    provider?: Providers;
+    provider?: ProviderName;
     model?: string;
     parameters?: Record<string, unknown>;
     prompt?: string;

package/dist/types/utils/errors.d.ts

@@ -1,4 +1,4 @@
-import type { Providers } from '@/common';
+import type { ProviderName } from '@/types';
 /**
  * Why the request was rejected. Both kinds are fixed by shrinking the
  * prompt, which is what makes them recoverable; they are distinguished
@@ -33,10 +33,10 @@ export interface ContextOverflowInfo {
     promptTokens?: number;
     /** Which layer produced the verdict. Surfaced in logs and asserted in tests. */
     source: 'langchain' | 'pattern';
-    provider?: Providers;
+    provider?: ProviderName;
 }
 export interface ContextOverflowContext {
-    provider?: Providers;
+    provider?: ProviderName;
     /** Our own estimate of the prompt size for the call that failed. */
     estimatedPromptTokens?: number;
     /** The budget we believed applied when we built that prompt. */

package/dist/types/utils/llm.d.ts

@@ -1,7 +1,7 @@
-import { Providers } from '@/common';
-export declare function isOpenAILike(provider?: string | Providers): boolean;
-export declare function isGoogleLike(provider?: string | Providers): boolean;
+import type { ProviderName } from '@/types';
+export declare function isOpenAILike(provider?: ProviderName): boolean;
+export declare function isGoogleLike(provider?: ProviderName): boolean;
 /** Returns true for native Anthropic or Bedrock running a Claude model. */
-export declare function isAnthropicLike(provider?: string | Providers, clientOptions?: {
+export declare function isAnthropicLike(provider?: ProviderName, clientOptions?: {
     model?: string;
 }): boolean;

package/dist/types/utils/llmConfig.d.ts

@@ -1,3 +1,3 @@
 import type * as t from '@/types';
-export declare const llmConfigs: Record<string, t.LLMConfig | undefined>;
-export declare function getLLMConfig(provider: string): t.LLMConfig;
+export declare const llmConfigs: Record<string, t.BuiltInLLMConfig | undefined>;
+export declare function getLLMConfig(provider: string): t.BuiltInLLMConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.6.14",
+  "version": "3.6.16",
   "reova": {
     "enabled": true,
     "endpoint": "https://telemetry.reo.dev/data"
@@ -14,6 +14,11 @@
       "import": "./dist/esm/main.mjs",
       "require": "./dist/cjs/main.cjs"
     },
+    "./provider-registration": {
+      "types": "./dist/types/provider-registration.d.ts",
+      "import": "./dist/esm/provider-registration.mjs",
+      "require": "./dist/cjs/provider-registration.cjs"
+    },
     "./openai": {
       "types": "./dist/types/openai/index.d.ts",
       "import": "./dist/esm/openai/index.mjs",
@@ -77,6 +82,9 @@
   },
   "typesVersions": {
     "*": {
+      "provider-registration": [
+        "dist/types/provider-registration.d.ts"
+      ],
       "langchain": [
         "dist/types/langchain/index.d.ts"
       ],

package/src/agents/AgentContext.ts

@@ -7,8 +7,18 @@ import type {
   BaseMessageFields,
 } from '@langchain/core/messages';
 import type { RunnableConfig, Runnable } from '@langchain/core/runnables';
-import type * as t from '@/types';
 import type { ExactTokenCountCache } from '@/llm/contextPressureMeter';
+import type * as t from '@/types';
+import {
+  type CallerCapabilityProjection,
+  allowsToolCaller,
+  applyCallerCapabilityDefinitionOverrides,
+  createCallerCapabilityProjectionSnapshot,
+  isToolDefinitionActive,
+  isProgrammaticControlTool,
+  mergeCallerCapabilityDefinitions,
+  resolveCallerCapabilityProjection,
+} from '@/tools/CallerCapabilities';
 import {
   addTailCacheControl,
   addCacheControlToStablePrefixMessages,
@@ -19,6 +29,12 @@ import {
   cloneMessage,
   type PromptCacheTtl,
 } from '@/messages/cache';
+import {
+  isProgrammaticRunnerAutoBound,
+  isProgrammaticRunnerResolvedDirectly,
+  resolveLocalImplementationNames,
+  resolveLocalToolRegistry,
+} from '@/tools/local/resolveLocalExecutionTools';
 import {
   DEFAULT_RESERVE_RATIO,
   ORIGINAL_CONTENT_MAX_CHARS,
@@ -33,27 +49,11 @@ import {
   Constants,
   Providers,
 } from '@/common';
-import {
-  isProgrammaticRunnerAutoBound,
-  isProgrammaticRunnerResolvedDirectly,
-  resolveLocalImplementationNames,
-  resolveLocalToolRegistry,
-} from '@/tools/local/resolveLocalExecutionTools';
-import {
-  type CallerCapabilityProjection,
-  allowsToolCaller,
-  applyCallerCapabilityDefinitionOverrides,
-  createCallerCapabilityProjectionSnapshot,
-  isToolDefinitionActive,
-  isProgrammaticControlTool,
-  mergeCallerCapabilityDefinitions,
-  resolveCallerCapabilityProjection,
-} from '@/tools/CallerCapabilities';
+import { isTokenCounterCacheCompatible } from '@/llm/tokenCounterCacheCompatibility';
+import { createExactTokenCountCache } from '@/llm/contextPressureMeter';
 import { createSchemaOnlyTools } from '@/tools/schema';
 import { apportionTokenCounts } from '@/utils/tokens';
 import { isThinkingEnabled } from '@/llm/request';
-import { createExactTokenCountCache } from '@/llm/contextPressureMeter';
-import { isTokenCounterCacheCompatible } from '@/llm/tokenCounterCacheCompatibility';
 import { toJsonSchema } from '@/utils/schema';
 
 type AgentSystemTextBlock = {
@@ -201,7 +201,7 @@ export class AgentContext {
   /** Human-readable name for this agent (used in handoff context). Falls back to agentId if not provided. */
   name?: string;
   /** Provider for this specific agent */
-  provider: Providers;
+  provider: t.ProviderName;
   /** Client options for this agent */
   clientOptions?: t.ClientOptions;
   /** Per-agent Langfuse tracing configuration. */
@@ -433,7 +433,7 @@ export class AgentContext {
     agentId: string;
     codeSessionKey?: string;
     name?: string;
-    provider: Providers;
+    provider: t.ProviderName;
     clientOptions?: t.ClientOptions;
     langfuse?: t.LangfuseConfig;
     maxContextTokens?: number;
@@ -570,7 +570,9 @@ export class AgentContext {
       directOnlyToolNames.length > 0
         ? `\nCall these tools directly; never list them in the \`tool_manifest\` or reference them inside ${programmaticRunnerNames}: ${directOnlyToolNames
           .map((name) => `\`${name}\``)
-          .join(', ')}. Every ${programmaticRunnerNames} call must include a \`tool_manifest\` containing the exact registered names used by its code; the manifest is validated before execution starts.`
+          .join(
+            ', '
+          )}. Every ${programmaticRunnerNames} call must include a \`tool_manifest\` containing the exact registered names used by its code; the manifest is validated before execution starts.`
         : '';
     const boundary =
       '\n\n' +
@@ -658,9 +660,8 @@ export class AgentContext {
         this.toolExecution,
         this.toolDefinitions?.some((toolDef) => toolDef.name === name) === true
       ) ||
-      this.graphTools?.some(
-        (tool) => 'name' in tool && tool.name === name
-      ) === true
+      this.graphTools?.some((tool) => 'name' in tool && tool.name === name) ===
+        true
     );
   }
 
@@ -1618,7 +1619,7 @@ export class AgentContext {
 
   /** Applies token calibration only when the observation came from this provider. */
   applyObservedOverflowCalibration(
-    provider: Providers | undefined,
+    provider: t.ProviderName | undefined,
     observedCalibrationRatio: number | undefined
   ): void {
     if (

package/src/graphs/Graph.ts

@@ -72,7 +72,6 @@ import {
   splitAtRecencyBoundary,
   convertInjectedMessages,
   coalesceAdjacentUserTurns,
-  strictAlternationProviders,
   appendPredecessorHandoffCue,
   stampSyntheticProviderMessage,
 } from '@/messages';
@@ -98,14 +97,6 @@ import {
   joinKeys,
   sleep,
 } from '@/utils';
-import {
-  attemptInvoke,
-  tryFallbackProviders,
-  getFallbackErrorContext,
-  getFallbackOverflowCandidates,
-} from '@/llm/invoke';
-import { prepareProviderRequest } from '@/llm/prepareProviderRequest';
-import { createContextPressureMeter } from '@/llm/contextPressureMeter';
 import {
   resolveStreamLimits,
   StreamLimitExceededError,
@@ -130,6 +121,12 @@ import {
   planContextOverflowRecovery,
   translateRecoveryBudget,
 } from '@/llm/contextOverflowRecovery';
+import {
+  attemptInvoke,
+  tryFallbackProviders,
+  getFallbackErrorContext,
+  getFallbackOverflowCandidates,
+} from '@/llm/invoke';
 import {
   hasToolOutputTracingConfig,
   resolveLangfuseConfig,
@@ -159,8 +156,11 @@ import { createLocalCodingToolBundle } from '@/tools/local/LocalCodingTools';
 import { SUBAGENT_REPLAY_CONTROLLER } from '@/tools/subagent/SubagentReplay';
 import { applyGraphRuntimeConfig } from '@/graphs/applyGraphRuntimeConfig';
 import { partitionAndMarkBedrockToolCache } from '@/llm/bedrock/toolCache';
+import { createContextPressureMeter } from '@/llm/contextPressureMeter';
 import { safeDispatchCustomEvent, emitAgentLog } from '@/utils/events';
+import { prepareProviderRequest } from '@/llm/prepareProviderRequest';
 import { createCloudflareCodingToolBundle } from '@/tools/cloudflare';
+import { providerRequiresStrictAlternation } from '@/llm/providers';
 import { buildSubagentToolParams } from '@/tools/SubagentTool';
 import { initializeLangfuseTracing } from '@/instrumentation';
 import { shouldTriggerSummarization } from '@/summarization';
@@ -324,7 +324,7 @@ function isGoogleServerSideToolMessageContentPart(
 }
 
 function hasGoogleServerSideToolDeltaContent(
-  provider: Providers | undefined,
+  provider: t.ProviderName | undefined,
   content: t.MessageDelta['content']
 ): content is t.MessageContentComplex[] {
   return (
@@ -337,7 +337,7 @@ function hasGoogleServerSideToolDeltaContent(
 }
 
 function getMessageDeltaContent(
-  provider: Providers | undefined,
+  provider: t.ProviderName | undefined,
   content: MessageContent | undefined
 ): t.MessageDelta['content'] | undefined {
   if (content == null) {
@@ -550,7 +550,7 @@ async function dispatchTextMessageContent({
 }: {
   graph: Graph<t.BaseGraphState>;
   stepKey: string;
-  provider?: Providers;
+  provider?: t.ProviderName;
   content: t.MessageDelta['content'];
   metadata: Record<string, unknown>;
 }): Promise<boolean> {
@@ -3237,7 +3237,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         info,
       }: {
         projection: ReturnType<typeof measureProviderPayload>;
-        provider?: Providers;
+        provider?: t.ProviderName;
         info: string;
       }): ContextOverflowError => {
         const error = new ContextOverflowError(
@@ -3508,7 +3508,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
        * drop messages, so coalescing has to see its output, and it is the
        * last shaping step before the cache breakpoint is chosen.
        */
-      if (strictAlternationProviders.has(agentContext.provider)) {
+      if (providerRequiresStrictAlternation(agentContext.provider)) {
         /**
          * Wrapped like every other provider transform: the merged message is
          * a NEW object, and without re-attachment the final pre-invoke

package/src/index.ts

@@ -78,6 +78,11 @@ export type {
   ChatOpenRouterCallOptions,
 } from './llm/openrouter';
 export { getChatModelClass } from './llm/providers';
+export { registerProvider } from './provider-registration';
+export type {
+  ProviderFamily,
+  ProviderRegistrationOptions,
+} from './provider-registration';
 export { CustomChatMistralAI } from './llm/mistral';
 export {
   smoothStream,

package/src/llm/contextOverflowRecovery.ts

@@ -18,7 +18,7 @@
  * provider-space budget.
  */
 import type { ContextOverflowInfo } from '@/utils/errors';
-import type { Providers } from '@/common';
+import type { ProviderName } from '@/types';
 import { getContextOverflowInfo } from '@/utils/errors';
 
 /** Fraction of the previous budget used when the provider named no ceiling. */
@@ -66,7 +66,7 @@ export interface OverflowRecoveryPlan {
 
 export interface OverflowRecoveryParams {
   error: unknown;
-  provider: Providers;
+  provider: ProviderName;
   /** Budget in force when the rejected prompt was built. */
   maxContextTokens?: number;
   /** Our own estimate of the prompt we actually sent. */

package/src/llm/contextPressureMeter.ts

@@ -35,7 +35,9 @@ interface ProviderPayloadMeasureOptions {
 }
 
 interface ProviderMessageBaseline {
-  rawTokens: number;
+  message: BaseMessage;
+  /** Lazily tokenized: reading it costs a full count, so only read it on a changed projection. */
+  readonly rawTokens: number;
   accountingWeight: number;
 }
 
@@ -264,20 +266,27 @@ export function createContextPressureMeter({
       sourceIndices.set(sourceMessages[i], i);
     }
     baseline = retainedMessages.map((message, index) => {
-      const rawTokens = count(message);
       const sourceIndex = sourceIndices.get(message);
       const indexedTokens =
         sourceIndex != null ? indexTokenCountMap[sourceIndex] : undefined;
-      const accountingWeight =
+      const hasIndexedTokens =
         indexedTokens != null &&
         Number.isFinite(indexedTokens) &&
-        indexedTokens >= 0
-          ? indexedTokens
-          : rawTokens;
+        indexedTokens >= 0;
+      const accountingWeight = hasIndexedTokens
+        ? indexedTokens
+        : count(message);
       if (!origins.has(message)) {
         origins.set(message, index);
       }
-      return { rawTokens, accountingWeight };
+      return {
+        message,
+        /** Exact count is only needed as the subtrahend when a projection changed this message. */
+        get rawTokens(): number {
+          return count(message);
+        },
+        accountingWeight,
+      };
     });
     baselineWeights = {};
     for (let i = 0; i < baseline.length; i++) {
@@ -382,9 +391,7 @@ export function createContextPressureMeter({
     ) {
       let attribution = baselineAttributions.get(availableMessageTokens);
       if (attribution == null) {
-        const replyPrimerTokens = Math.round(
-          REPLY_PRIMER_TOKENS * usageRatio
-        );
+        const replyPrimerTokens = Math.round(REPLY_PRIMER_TOKENS * usageRatio);
         const attributableTokens =
           totalBaselineWeight > 0
             ? Math.min(
@@ -415,17 +422,20 @@ export function createContextPressureMeter({
       let newRawTokens = 0;
       const usedOrigins = new Set<number>();
       for (const message of messages) {
-        const rawTokens = count(message);
         const origin = origins.get(message);
         if (origin == null || usedOrigins.has(origin)) {
-          newRawTokens += rawTokens;
+          newRawTokens += count(message);
           continue;
         }
         usedOrigins.add(origin);
+        const projectionDelta =
+          message === baseline[origin].message
+            ? 0
+            : count(message) - baseline[origin].rawTokens;
         projectedMessageTokens += Math.max(
           0,
           attribution.attributedByOrigin[origin] +
-            Math.round((rawTokens - baseline[origin].rawTokens) * usageRatio)
+            Math.round(projectionDelta * usageRatio)
         );
       }
       projectedMessageTokens += Math.round(newRawTokens * usageRatio);

package/src/llm/init.ts

@@ -6,29 +6,46 @@ import { getChatModelClass } from '@/llm/providers';
 import { isOpenAILike } from '@/utils';
 import { Providers } from '@/common';
 
+type InitializeModelParams<P extends t.ProviderName> = {
+  provider: P;
+  tools?: t.GraphTools;
+} & (
+  | {
+      override: t.ChatModelInstance;
+      clientOptions?: t.ProviderOptionsFor<P>;
+    }
+  | ([P] extends [keyof t.ProviderOptionsMap]
+      ? {
+          override?: t.ChatModelInstance;
+          clientOptions?: t.ProviderOptionsFor<P>;
+        }
+      : object extends t.ProviderOptionsFor<P>
+        ? {
+            override?: t.ChatModelInstance;
+            clientOptions?: t.ProviderOptionsFor<P>;
+          }
+        : {
+            override?: undefined;
+            clientOptions: t.ProviderOptionsFor<P>;
+          })
+);
+
 /**
- * Creates a chat model instance for a given provider, applies provider-specific
- * field assignments, and optionally binds tools.
- *
- * This is the single entry point for model creation across the codebase — used
- * by both the agent graph (main LLM) and the summarization node (compaction LLM).
- * An optional `override` model can be passed to skip construction entirely
- * (useful for cached/reused model instances or test fakes).
+ * Creates a chat model instance for a given built-in or host-registered
+ * provider, applies provider-specific field assignments, and optionally binds
+ * tools.
  */
-export function initializeModel({
+export function initializeModel<P extends t.ProviderName>({
   provider,
   clientOptions,
   tools,
   override,
-}: {
-  provider: Providers;
-  clientOptions?: t.ClientOptions;
-  tools?: t.GraphTools;
-  override?: t.ChatModelInstance;
-}): Runnable {
+}: InitializeModelParams<P>): Runnable {
   const model =
     override ??
-    new (getChatModelClass(provider))(clientOptions ?? ({} as never));
+    new (getChatModelClass(provider))(
+      (clientOptions ?? {}) as t.ProviderOptionsFor<P>
+    );
 
   if (
     isOpenAILike(provider) &&
@@ -56,8 +73,14 @@ export function initializeModel({
   }
 
   if (!tools || tools.length === 0) {
-    return model as unknown as Runnable;
+    return model;
+  }
+
+  if (!('bindTools' in model) || typeof model.bindTools !== 'function') {
+    throw new TypeError(
+      `LLM provider does not support tool binding: ${provider}`
+    );
   }
 
-  return (model as t.ModelWithTools).bindTools(tools);
+  return model.bindTools(tools);
 }