@librechat/agents 3.2.33 → 3.2.35

package/src/llm/bedrock/streamSealDispatch.test.ts

@@ -0,0 +1,158 @@
+import { expect, test, describe, jest } from '@jest/globals';
+import { HumanMessage, AIMessageChunk } from '@langchain/core/messages';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { CustomChatBedrockConverse } from './index';
+
+/**
+ * Registered stream handlers consume chunks through `handleLLMNewToken`
+ * callback events, not the yielded generator (`attemptInvoke` skips manual
+ * dispatch when a handler is registered). These tests drive the Converse
+ * stream loop with a stubbed client and assert that toolUse start and stop
+ * seal chunks reach BOTH paths.
+ */
+describe('Converse stream seal dispatch', () => {
+  async function runStream(
+    events: Array<Record<string, unknown>>,
+    modelFields: Record<string, unknown> = {}
+  ): Promise<{
+    yielded: AIMessageChunk[];
+    dispatched: AIMessageChunk[];
+  }> {
+    const model = new CustomChatBedrockConverse({
+      model: 'anthropic.claude-3-5-sonnet-20240620-v1:0',
+      region: 'us-east-1',
+      credentials: { accessKeyId: 'test', secretAccessKey: 'test' },
+      ...modelFields,
+    });
+
+    (model as unknown as { client: { send: unknown } }).client.send = jest.fn(
+      async () => ({
+        stream: (async function* () {
+          yield* events;
+        })(),
+      })
+    );
+
+    const dispatched: AIMessageChunk[] = [];
+    const runManager = {
+      handleLLMNewToken: jest.fn(
+        async (
+          _token: string,
+          _idx?: unknown,
+          _runId?: unknown,
+          _parentRunId?: unknown,
+          _tags?: unknown,
+          fields?: { chunk?: ChatGenerationChunk }
+        ) => {
+          const message = fields?.chunk?.message;
+          if (message instanceof AIMessageChunk) {
+            dispatched.push(message);
+          }
+        }
+      ),
+    } as unknown as CallbackManagerForLLMRun;
+
+    const yielded: AIMessageChunk[] = [];
+    for await (const chunk of model._streamResponseChunks(
+      [new HumanMessage('hi')],
+      {} as Parameters<CustomChatBedrockConverse['_streamResponseChunks']>[1],
+      runManager
+    )) {
+      if (chunk.message instanceof AIMessageChunk) {
+        yielded.push(chunk.message);
+      }
+    }
+    return { yielded, dispatched };
+  }
+
+  const toolUseEvents = [
+    {
+      contentBlockStart: {
+        contentBlockIndex: 1,
+        start: { toolUse: { toolUseId: 'call_1', name: 'weather' } },
+      },
+    },
+    {
+      contentBlockDelta: {
+        contentBlockIndex: 1,
+        delta: { toolUse: { input: '{"city":"NYC"}' } },
+      },
+    },
+    { contentBlockStop: { contentBlockIndex: 1 } },
+  ];
+
+  test('dispatches toolUse start and stop seal chunks to callbacks', async () => {
+    const { yielded, dispatched } = await runStream(toolUseEvents);
+
+    const sealOf = (m: AIMessageChunk): unknown =>
+      (m.response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
+      ];
+
+    expect(yielded.some((m) => sealOf(m) != null)).toBe(true);
+
+    expect(dispatched).toHaveLength(3);
+    expect(dispatched[0].tool_call_chunks).toMatchObject([
+      { id: 'call_1', name: 'weather', index: 1 },
+    ]);
+    expect(dispatched[1].tool_call_chunks).toMatchObject([
+      { args: '{"city":"NYC"}', index: 1 },
+    ]);
+    expect(sealOf(dispatched[2])).toEqual({ kind: 'single', index: 1 });
+    expect(
+      (dispatched[2].response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY
+      ]
+    ).toBe(BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER);
+  });
+
+  test('does not emit seal chunks when guardrails are configured', async () => {
+    const { yielded, dispatched } = await runStream(toolUseEvents, {
+      guardrailConfig: {
+        guardrailIdentifier: 'guardrail_1',
+        guardrailVersion: '1',
+      },
+    });
+
+    const hasSeal = (m: AIMessageChunk): boolean =>
+      (m.response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
+      ] != null;
+
+    // Guardrails can reject the turn at messageStop after contentBlockStop,
+    // so no eager seal may be emitted — but tool chunks still stream.
+    expect(yielded.some(hasSeal)).toBe(false);
+    expect(dispatched.some(hasSeal)).toBe(false);
+    expect(dispatched).toHaveLength(2);
+    expect(dispatched[0].tool_call_chunks).toMatchObject([
+      { id: 'call_1', name: 'weather', index: 1 },
+    ]);
+  });
+
+  test('does not emit seal chunks for non-toolUse block stops', async () => {
+    const { yielded, dispatched } = await runStream([
+      {
+        contentBlockDelta: {
+          contentBlockIndex: 0,
+          delta: { text: 'hello' },
+        },
+      },
+      { contentBlockStop: { contentBlockIndex: 0 } },
+    ]);
+
+    const hasSeal = (m: AIMessageChunk): boolean =>
+      (m.response_metadata as Record<string, unknown>)[
+        STREAMED_TOOL_CALL_SEAL_METADATA_KEY
+      ] != null;
+
+    expect(yielded.some(hasSeal)).toBe(false);
+    expect(dispatched.some(hasSeal)).toBe(false);
+    expect(dispatched).toHaveLength(1);
+  });
+});

package/src/llm/bedrock/utils/index.ts

@@ -10,6 +10,7 @@ export {
 
 export {
   convertConverseMessageToLangChainMessage,
+  createConverseToolUseStopChunk,
   handleConverseStreamContentBlockStart,
   handleConverseStreamContentBlockDelta,
   handleConverseStreamMetadata,

package/src/llm/bedrock/utils/message_outputs.test.ts

@@ -0,0 +1,85 @@
+import { expect, test, describe } from '@jest/globals';
+import { AIMessageChunk } from '@langchain/core/messages';
+import type { ContentBlockDeltaEvent, ContentBlockStartEvent } from '../types';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import {
+  createConverseToolUseStopChunk,
+  handleConverseStreamContentBlockStart,
+  handleConverseStreamContentBlockDelta,
+} from './message_outputs';
+
+function asAIMessageChunk(message: unknown): AIMessageChunk {
+  expect(message).toBeInstanceOf(AIMessageChunk);
+  return message as AIMessageChunk;
+}
+
+describe('Converse streamed tool-call seal metadata', () => {
+  test('stamps the adapter on toolUse content block starts', () => {
+    const chunk = handleConverseStreamContentBlockStart({
+      contentBlockIndex: 1,
+      start: {
+        toolUse: { toolUseId: 'call_1', name: 'weather' },
+      },
+    } as ContentBlockStartEvent);
+
+    const message = asAIMessageChunk(chunk?.message);
+    expect(message.response_metadata).toMatchObject({
+      contentBlockIndex: 1,
+      [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+        BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+    });
+    expect(message.tool_call_chunks).toEqual([
+      {
+        id: 'call_1',
+        name: 'weather',
+        index: 1,
+        type: 'tool_call_chunk',
+      },
+    ]);
+  });
+
+  test('stamps the adapter on toolUse deltas but not text deltas', () => {
+    const toolChunk = handleConverseStreamContentBlockDelta({
+      contentBlockIndex: 1,
+      delta: { toolUse: { input: '{"city":' } },
+    } as ContentBlockDeltaEvent);
+    const toolMetadata = asAIMessageChunk(toolChunk.message)
+      .response_metadata as Record<string, unknown>;
+    expect(toolMetadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]).toBe(
+      BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER
+    );
+
+    const textChunk = handleConverseStreamContentBlockDelta({
+      contentBlockIndex: 0,
+      delta: { text: 'hello' },
+    } as ContentBlockDeltaEvent);
+    const textMetadata = asAIMessageChunk(textChunk.message)
+      .response_metadata as Record<string, unknown>;
+    expect(
+      textMetadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]
+    ).toBeUndefined();
+  });
+
+  test('builds an explicit single seal chunk for a stopped toolUse block', () => {
+    const chunk = createConverseToolUseStopChunk(2);
+
+    const message = asAIMessageChunk(chunk.message);
+    expect(message.response_metadata).toEqual({
+      [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+        BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+      [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'single', index: 2 },
+    });
+    expect(message.tool_call_chunks).toEqual([
+      {
+        args: '',
+        index: 2,
+        type: 'tool_call_chunk',
+      },
+    ]);
+    expect(message.content).toBe('');
+  });
+});

package/src/llm/bedrock/utils/message_outputs.ts

@@ -17,6 +17,11 @@ import type {
   MessageContentReasoningBlockReasoningTextPartial,
   MessageContentReasoningBlockRedacted,
 } from '../types';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
 import { toLangChainContent } from '@/messages/langchain';
 
 /**
@@ -235,6 +240,8 @@ export function handleConverseStreamContentBlockDelta(
         ],
         response_metadata: {
           contentBlockIndex: contentBlockDelta.contentBlockIndex,
+          [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+            BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
         },
       }),
     });
@@ -292,6 +299,8 @@ export function handleConverseStreamContentBlockStart(
         ],
         response_metadata: {
           contentBlockIndex: index,
+          [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+            BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
         },
       }),
     });
@@ -301,6 +310,40 @@ export function handleConverseStreamContentBlockStart(
   return null;
 }
 
+/**
+ * Build the chunk emitted when a Converse `contentBlockStop` event closes a
+ * toolUse block. The Converse protocol guarantees a block's input is complete
+ * at `contentBlockStop`, so this chunk carries an explicit streamed tool-call
+ * seal for that block index. The empty `args` delta merges as a no-op into the
+ * accumulated tool call; id/name are omitted so the chunk matches the existing
+ * entry purely by index.
+ */
+export function createConverseToolUseStopChunk(
+  contentBlockIndex: number
+): ChatGenerationChunk {
+  return new ChatGenerationChunk({
+    text: '',
+    message: new AIMessageChunk({
+      content: '',
+      tool_call_chunks: [
+        {
+          args: '',
+          index: contentBlockIndex,
+          type: 'tool_call_chunk',
+        },
+      ],
+      response_metadata: {
+        [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+          BEDROCK_CONVERSE_STREAMED_TOOL_CALL_ADAPTER,
+        [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: {
+          kind: 'single',
+          index: contentBlockIndex,
+        },
+      },
+    }),
+  });
+}
+
 /**
  * Handle a metadata event from Bedrock Converse stream.
  */

package/src/llm/google/utils/common.test.ts

@@ -0,0 +1,64 @@
+import { expect, test, describe } from '@jest/globals';
+import { AIMessageChunk } from '@langchain/core/messages';
+import type { EnhancedGenerateContentResponse } from '@google/generative-ai';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
+import { convertResponseContentToChatGenerationChunk } from './common';
+
+function buildResponse(
+  parts: Array<Record<string, unknown>>
+): EnhancedGenerateContentResponse {
+  return {
+    candidates: [
+      {
+        content: { role: 'model', parts },
+        index: 0,
+      },
+    ],
+  } as unknown as EnhancedGenerateContentResponse;
+}
+
+function asAIMessageChunk(message: unknown): AIMessageChunk {
+  expect(message).toBeInstanceOf(AIMessageChunk);
+  return message as AIMessageChunk;
+}
+
+describe('convertResponseContentToChatGenerationChunk seal metadata', () => {
+  test('stamps an on-arrival seal on function call chunks', () => {
+    const chunk = convertResponseContentToChatGenerationChunk(
+      buildResponse([
+        {
+          functionCall: { name: 'weather', args: { city: 'NYC' } },
+        },
+      ]),
+      { usageMetadata: undefined, index: 0 }
+    );
+
+    const message = asAIMessageChunk(chunk?.message);
+    expect(message.response_metadata).toMatchObject({
+      [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+        GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+      [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' },
+    });
+    expect(message.tool_call_chunks).toHaveLength(1);
+    expect(message.tool_calls?.[0]).toMatchObject({
+      name: 'weather',
+      args: { city: 'NYC' },
+    });
+  });
+
+  test('does not stamp seal metadata on text-only chunks', () => {
+    const chunk = convertResponseContentToChatGenerationChunk(
+      buildResponse([{ text: 'hello' }]),
+      { usageMetadata: undefined, index: 0 }
+    );
+
+    const metadata = asAIMessageChunk(chunk?.message)
+      .response_metadata as Record<string, unknown>;
+    expect(metadata[STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]).toBeUndefined();
+    expect(metadata[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]).toBeUndefined();
+  });
+});

package/src/llm/google/utils/common.ts

@@ -35,6 +35,11 @@ import {
   type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool,
 } from '@google/generative-ai';
 import type { ChatGeneration, ChatResult } from '@langchain/core/outputs';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
 import {
   jsonSchemaToGeminiParameters,
   schemaToGenerativeAIParameters,
@@ -770,6 +775,18 @@ export function convertResponseContentToChatGenerationChunk(
     response.candidates[0]?.finishReason === 'MAX_TOKENS' ||
     response.candidates[0]?.finishReason === 'SAFETY';
 
+  // The GenAI API delivers function calls as complete objects (never partial
+  // arg deltas), so every call on this chunk is sealed on arrival for eager
+  // tool execution.
+  const response_metadata: Record<string, unknown> | undefined =
+    toolCallChunks.length > 0
+      ? {
+        [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
+            GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
+        [STREAMED_TOOL_CALL_SEAL_METADATA_KEY]: { kind: 'all' },
+      }
+      : undefined;
+
   return new ChatGenerationChunk({
     text,
     message: new AIMessageChunk({
@@ -779,6 +796,7 @@ export function convertResponseContentToChatGenerationChunk(
       // Each chunk can have unique "generationInfo", and merging strategy is unclear,
       // so leave blank for now.
       additional_kwargs,
+      response_metadata,
       usage_metadata: isFinalChunk ? extra.usageMetadata : undefined,
     }),
     generationInfo,

package/src/llm/invoke.test.ts

@@ -12,8 +12,8 @@ import type { BaseMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
 import { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
+import { Constants, Providers } from '@/common';
 import { ToolNode } from '@/tools/ToolNode';
-import { Providers } from '@/common';
 
 /**
  * Minimal stub model shape `attemptInvoke` reads. Either `invoke` or
@@ -341,6 +341,84 @@ describe('tryFallbackProviders applies the same lazy annotation transform', () =
   });
 });
 
+describe('invocation attribution metadata', () => {
+  it('stamps INVOKED_PROVIDER on the config passed to the model', async () => {
+    const capturedConfigs: unknown[] = [];
+    const model: StubModel = {
+      invoke: jest.fn(
+        async (_m: BaseMessage[], config?: unknown): Promise<AIMessage> => {
+          capturedConfigs.push(config);
+          return new AIMessage({ content: 'ok' });
+        }
+      ),
+    };
+
+    await attemptInvoke(
+      {
+        model: model as t.ChatModel,
+        messages: [new HumanMessage('hi')],
+        /** A ChatOpenAI-derived provider — `ls_provider` would lie here. */
+        provider: Providers.DEEPSEEK,
+      },
+      { configurable: { run_id: 'run-attr' }, metadata: { existing: true } }
+    );
+
+    const config = capturedConfigs[0] as {
+      metadata?: Record<string, unknown>;
+    };
+    expect(config.metadata?.[Constants.INVOKED_PROVIDER]).toBe(
+      Providers.DEEPSEEK
+    );
+    /** Pre-existing metadata is preserved, not replaced. */
+    expect(config.metadata?.existing).toBe(true);
+  });
+
+  it('stamps INVOKED_MODEL from the fallback clientOptions in tryFallbackProviders', async () => {
+    const capturedConfigs: unknown[] = [];
+    const model: StubModel = {
+      invoke: jest.fn(
+        async (_m: BaseMessage[], config?: unknown): Promise<AIMessage> => {
+          capturedConfigs.push(config);
+          return new AIMessage({ content: 'ok' });
+        }
+      ),
+    };
+
+    jest.doMock('@/llm/init', () => ({
+      initializeModel: (): unknown => model,
+    }));
+    jest.resetModules();
+    const { tryFallbackProviders: freshTry } = (await import(
+      '@/llm/invoke'
+    )) as { tryFallbackProviders: typeof tryFallbackProviders };
+
+    await freshTry({
+      fallbacks: [
+        {
+          provider: Providers.ANTHROPIC,
+          clientOptions: { model: 'claude-fallback-1' },
+        },
+      ],
+      messages: [new HumanMessage('hi')],
+      primaryError: new Error('primary failed'),
+      config: { configurable: { run_id: 'run-attr-fb' } },
+    });
+
+    const config = capturedConfigs[0] as {
+      metadata?: Record<string, unknown>;
+    };
+    expect(config.metadata?.[Constants.INVOKED_MODEL]).toBe(
+      'claude-fallback-1'
+    );
+    expect(config.metadata?.[Constants.INVOKED_PROVIDER]).toBe(
+      Providers.ANTHROPIC
+    );
+
+    jest.dontMock('@/llm/init');
+    jest.resetModules();
+  });
+});
+
 describe('cross-run hydration through ToolNode + attemptInvoke', () => {
   it('annotates run 2 refs but leaves hydrated run 1 ToolMessages untouched', async () => {
     /**

package/src/llm/invoke.ts

@@ -6,10 +6,10 @@ import type { BaseMessage } from '@langchain/core/messages';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
 import { annotateMessagesForLLM } from '@/tools/toolOutputReferences';
+import { Constants, GraphEvents, Providers } from '@/common';
 import { manualToolStreamProviders } from '@/llm/providers';
 import { modifyDeltaProperties } from '@/messages';
 import { ChatModelStreamHandler } from '@/stream';
-import { GraphEvents, Providers } from '@/common';
 import { initializeModel } from '@/llm/init';
 
 /**
@@ -208,6 +208,23 @@ export async function attemptInvoke(
   const runId = config?.configurable?.run_id as string | undefined;
   const messagesForProvider = annotateMessagesForLLM(messages, registry, runId);
 
+  /**
+   * Stamp the provider that is ACTUALLY serving this invocation onto the
+   * callback metadata. `attemptInvoke` is the single funnel for primary,
+   * fallback, and summarization model calls, so consumers that need
+   * provider attribution per call (the subagent usage-capture handler)
+   * read this key instead of trusting static agent config — which is
+   * wrong for fallback-served calls — or `ls_provider` — which derived
+   * providers inherit from their base class.
+   */
+  config = {
+    ...config,
+    metadata: {
+      ...(config?.metadata ?? {}),
+      [Constants.INVOKED_PROVIDER]: provider,
+    },
+  };
+
   if (model.stream) {
     const stream = await model.stream(messagesForProvider, config);
     let finalChunk: AIMessageChunk | undefined;
@@ -224,7 +241,7 @@ export async function attemptInvoke(
         });
       }
     } else if (registeredStreamHandler == null) {
-      const metadata = config?.metadata as Record<string, unknown> | undefined;
+      const metadata = config.metadata as Record<string, unknown> | undefined;
       const streamHandler = new ChatModelStreamHandler();
       for await (const chunk of stream) {
         const handlingChunk = getStreamHandlingChunk({
@@ -247,7 +264,7 @@ export async function attemptInvoke(
         });
       }
     } else {
-      const metadata = config?.metadata as Record<string, unknown> | undefined;
+      const metadata = config.metadata as Record<string, unknown> | undefined;
       for await (const chunk of stream) {
         const handlingChunk = getStreamHandlingChunk({
           current: finalChunk,
@@ -292,6 +309,25 @@ export async function attemptInvoke(
   return { messages: [finalMessage] };
 }
 
+/**
+ * Best-effort read of the configured model name from client options.
+ * Providers disagree on the key (`model` vs `modelName`).
+ */
+function extractClientOptionsModel(
+  clientOptions: t.ClientOptions | undefined
+): string | undefined {
+  const options = clientOptions as
+    | { model?: unknown; modelName?: unknown }
+    | undefined;
+  if (typeof options?.model === 'string' && options.model !== '') {
+    return options.model;
+  }
+  if (typeof options?.modelName === 'string' && options.modelName !== '') {
+    return options.modelName;
+  }
+  return undefined;
+}
+
 /**
  * Attempts each fallback provider in order until one succeeds.
  * Throws the last error if all fallbacks fail.
@@ -321,6 +357,24 @@ export async function tryFallbackProviders({
         clientOptions: fb.clientOptions,
         tools,
       });
+      /**
+       * Stamp the fallback's configured model onto callback metadata so
+       * per-call attribution (subagent usage capture) doesn't fall back to
+       * the PRIMARY config's model when the provider reports no
+       * `ls_model_name`. The serving provider is stamped uniformly by
+       * `attemptInvoke` (`INVOKED_PROVIDER`).
+       */
+      const fbModelName = extractClientOptionsModel(fb.clientOptions);
+      const fbConfig: RunnableConfig | undefined =
+        fbModelName == null
+          ? config
+          : {
+            ...config,
+            metadata: {
+              ...(config?.metadata ?? {}),
+              [Constants.INVOKED_MODEL]: fbModelName,
+            },
+          };
       const result = await attemptInvoke(
         {
           model: fbModel as t.ChatModel,
@@ -329,7 +383,7 @@ export async function tryFallbackProviders({
           context,
           onChunk,
         },
-        config
+        fbConfig
       );
       return result;
     } catch (e) {