@librechat/agents 3.2.2 → 3.2.31

package/dist/types/types/tools.d.ts

@@ -1,11 +1,11 @@
 import type { StructuredToolInterface } from '@langchain/core/tools';
 import type { RunnableToolLike } from '@langchain/core/runnables';
 import type { ToolCall } from '@langchain/core/messages/tool';
-import type { HookRegistry } from '@/hooks';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type { MessageContentComplex, ToolErrorData } from './stream';
 import type { HumanInTheLoopConfig } from './hitl';
 import type { LangfuseConfig } from './graph';
+import type { HookRegistry } from '@/hooks';
 /** Replacement type for `import type { ToolCall } from '@langchain/core/messages/tool'` in order to have stringified args typed */
 export type CustomToolCall = {
     name: string;
@@ -83,6 +83,9 @@ export type ToolNodeOptions = {
     toolDefinitions?: Map<string, LCTool>;
     /** Agent ID for event-driven mode (used to identify which agent's context to use) */
     agentId?: string;
+    /** ID of the agent that owns this tool node, surfaced to hooks as `executingAgentId`
+     * so a batch can be attributed to a specific agent even where `agentId` is undefined. */
+    executingAgentId?: string;
     /** Tool names that must be executed directly (via runTool) even in event-driven mode (e.g., graph-managed handoff tools) */
     directToolNames?: Set<string>;
     /** Opt-in eager execution for event-driven tool calls. */
@@ -892,6 +895,7 @@ export type ProgrammaticHookContext = {
     runId: string;
     threadId?: string;
     agentId?: string;
+    executingAgentId?: string;
 };
 /** Search mode: code_interpreter uses external sandbox, local uses safe substring matching */
 export type ToolSearchMode = 'code_interpreter' | 'local';

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

@@ -14,9 +14,9 @@
  * });
  * ```
  */
-import { GraphEvents } from '@/common';
-import { createContentAggregator } from '@/stream';
 import type * as t from '@/types';
+import { createContentAggregator } from '@/stream';
+import { GraphEvents } from '@/common';
 interface HandlerCallbacks {
     onRunStep?: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData) => void;
     onRunStepCompleted?: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData) => void;

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

@@ -1,5 +1,5 @@
 import { CallbackManagerForChainRun } from '@langchain/core/callbacks/manager';
-import { Runnable, RunnableConfig } from '@langchain/core/runnables';
+import { RunnableConfig, Runnable } from '@langchain/core/runnables';
 /**
  * Delays the execution for a specified number of milliseconds.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.2.02",
+  "version": "3.2.31",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -103,7 +103,7 @@
   ],
   "packageManager": "npm@10.5.2",
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.0.0"
   },
   "files": [
     "dist",
@@ -116,6 +116,8 @@
     "prepublishOnly": "npm run build",
     "build": "NODE_ENV=production rollup -c && tsc -p tsconfig.build.json",
     "build:dev": "rollup -c",
+    "sort-imports": "node scripts/sort-imports.ts",
+    "sort-imports:check": "node scripts/sort-imports.ts --check",
     "start": "node dist/esm/main.js",
     "clean": "node ./config/clean.js",
     "script": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli.ts",
@@ -269,7 +271,7 @@
     "@rollup/plugin-typescript": "^12.1.2",
     "@swc/core": "^1.6.13",
     "@types/jest": "^30.0.0",
-    "@types/node": "^20.14.11",
+    "@types/node": "^24.13.1",
     "@types/node-fetch": "^2.6.13",
     "@types/yargs-parser": "^21.0.3",
     "@typescript-eslint/eslint-plugin": "^8.24.0",
@@ -294,6 +296,7 @@
   },
   "lint-staged": {
     "*.{js,ts}": [
+      "node scripts/sort-imports.ts",
       "prettier --write",
       "eslint --fix"
     ],

package/src/__tests__/stream.eagerEventExecution.test.ts

@@ -2,21 +2,22 @@ import { describe, it, expect, jest, afterEach } from '@jest/globals';
 import type { AgentContext } from '@/agents/AgentContext';
 import type { StandardGraph } from '@/graphs';
 import type * as t from '@/types';
+import {
+  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
+  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
+  OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
+} from '@/tools/streamedToolCallSeals';
 import {
   Constants,
   ContentTypes,
   GraphEvents,
   Providers,
   StepTypes,
+  ToolCallTypes,
 } from '@/common';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
 import { HandlerRegistry } from '@/events';
 import * as events from '@/utils/events';
-import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
-import {
-  STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
-  STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
-  OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
-} from '@/tools/streamedToolCallSeals';
 
 function createGraph(overrides: Partial<StandardGraph> = {}): StandardGraph {
   const runSteps = new Map<string, t.RunStep>();
@@ -97,6 +98,42 @@ function chunkStateKey(stepKey: string, chunkKey: string | number): string {
   return `${stepKey}\u0000${String(chunkKey)}`;
 }
 
+function attachContentAggregator(graph: StandardGraph): {
+  contentParts: Array<t.MessageContentComplex | undefined>;
+} {
+  const { contentParts, aggregateContent } = createContentAggregator();
+  const dispatchRunStep = graph.dispatchRunStep.bind(graph);
+  const stepIndices = new Map<string, number>();
+  graph.dispatchRunStep = jest.fn<StandardGraph['dispatchRunStep']>(
+    async (stepKey, stepDetails, metadata) => {
+      const stepId = await dispatchRunStep(stepKey, stepDetails, metadata);
+      const runStep = graph.getRunStep(stepId);
+      if (runStep != null) {
+        if (!stepIndices.has(stepId)) {
+          stepIndices.set(stepId, stepIndices.size);
+        }
+        aggregateContent({
+          event: GraphEvents.ON_RUN_STEP,
+          data: {
+            ...runStep,
+            index: stepIndices.get(stepId) ?? 0,
+          },
+        });
+      }
+      return stepId;
+    }
+  );
+  graph.dispatchMessageDelta = jest.fn<StandardGraph['dispatchMessageDelta']>(
+    async (id, delta) => {
+      aggregateContent({
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: { id, delta } as t.MessageDeltaEvent,
+      });
+    }
+  );
+  return { contentParts };
+}
+
 const finalToolCallResponseMetadata = { finish_reason: 'tool_calls' };
 const openAIResponsesToolCallMetadata = {
   [STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY]:
@@ -1611,6 +1648,506 @@ describe('ChatModelStreamHandler eager event tool execution', () => {
     );
   });
 
+  it('defers disableStreaming mixed hidden reasoning and visible text chunks', async () => {
+    const dispatchMessageDelta = jest.fn<StandardGraph['dispatchMessageDelta']>(
+      async () => undefined
+    );
+    const dispatchReasoningDelta = jest.fn<
+      StandardGraph['dispatchReasoningDelta']
+    >(async () => undefined);
+    const agentContext: Partial<AgentContext> = {
+      provider: Providers.OPENAI,
+      reasoningKey: 'reasoning_content',
+      clientOptions: { disableStreaming: true } as t.OpenAIClientOptions,
+      currentTokenType: ContentTypes.TEXT,
+      toolDefinitions: [],
+      graphTools: [],
+      agentId: 'agent_1',
+    };
+    const graph = createGraph({
+      dispatchMessageDelta,
+      dispatchReasoningDelta,
+      getAgentContext: jest.fn(
+        () => agentContext
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+
+    const mixedChunk = {
+      content: 'final answer',
+      additional_kwargs: {
+        reasoning_content: 'hidden reasoning',
+      },
+    } as unknown as t.StreamChunk;
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      { chunk: mixedChunk },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      { chunk: mixedChunk },
+      metadata,
+      graph
+    );
+
+    expect(dispatchReasoningDelta).not.toHaveBeenCalled();
+    expect(dispatchMessageDelta).not.toHaveBeenCalled();
+    expect(graph.dispatchRunStep).not.toHaveBeenCalled();
+  });
+
+  it('leaves mixed hidden reasoning and visible text chunks on the streaming path', async () => {
+    const dispatchMessageDelta = jest.fn<StandardGraph['dispatchMessageDelta']>(
+      async () => undefined
+    );
+    const dispatchReasoningDelta = jest.fn<
+      StandardGraph['dispatchReasoningDelta']
+    >(async () => undefined);
+    const graph = createGraph({
+      dispatchMessageDelta,
+      dispatchReasoningDelta,
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.OPENAI,
+          reasoningKey: 'reasoning_content',
+          currentTokenType: ContentTypes.TEXT,
+          toolDefinitions: [],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const metadata = { langgraph_node: 'agent' };
+
+    await new ChatModelStreamHandler().handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: 'streamed answer',
+          additional_kwargs: {
+            reasoning_content: 'hidden reasoning',
+          },
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(dispatchReasoningDelta).not.toHaveBeenCalled();
+    expect(dispatchMessageDelta).toHaveBeenCalledTimes(1);
+    expect(dispatchMessageDelta).toHaveBeenCalledWith(
+      expect.stringMatching(/^step_/),
+      {
+        content: [{ type: ContentTypes.TEXT, text: 'streamed answer' }],
+      },
+      metadata
+    );
+  });
+
+  it('dispatches Gemini server-side tool context blocks from mixed stream content', async () => {
+    const dispatchMessageDelta = jest.fn<StandardGraph['dispatchMessageDelta']>(
+      async () => undefined
+    );
+    const graph = createGraph({
+      dispatchMessageDelta,
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.GOOGLE,
+          reasoningKey: 'reasoning',
+          currentTokenType: ContentTypes.TEXT,
+          toolDefinitions: [],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+    const toolCallPart: t.MessageContentComplex = {
+      type: 'toolCall',
+      toolCall: {
+        id: 'server-search-1',
+        name: 'google_search',
+        args: {},
+      },
+    };
+    const textPart: t.MessageContentComplex = {
+      type: ContentTypes.TEXT,
+      text: 'Search complete.',
+    };
+    const toolResponsePart: t.MessageContentComplex = {
+      type: 'toolResponse',
+      toolResponse: {
+        id: 'server-search-1',
+        name: 'google_search',
+        response: { results: [] },
+      },
+    };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: [toolCallPart, textPart, toolResponsePart],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(dispatchMessageDelta).toHaveBeenCalledTimes(3);
+    expect(dispatchMessageDelta).toHaveBeenNthCalledWith(
+      1,
+      expect.stringMatching(/^step_/),
+      { content: [toolCallPart] },
+      metadata
+    );
+    expect(dispatchMessageDelta).toHaveBeenNthCalledWith(
+      2,
+      expect.stringMatching(/^step_/),
+      { content: [textPart] },
+      metadata
+    );
+    expect(dispatchMessageDelta).toHaveBeenNthCalledWith(
+      3,
+      expect.stringMatching(/^step_/),
+      { content: [toolResponsePart] },
+      metadata
+    );
+  });
+
+  it('dispatches Gemini server-side tool context onto message steps after tool chunks', async () => {
+    const messageDeltas: Array<{
+      id: string;
+      delta: t.MessageDelta;
+    }> = [];
+    const dispatchMessageDelta = jest.fn<StandardGraph['dispatchMessageDelta']>(
+      async (id, delta) => {
+        messageDeltas.push({
+          id,
+          delta,
+        });
+      }
+    );
+    const graph = createGraph({
+      dispatchMessageDelta,
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.GOOGLE,
+          reasoningKey: 'reasoning',
+          currentTokenType: ContentTypes.TEXT,
+          toolDefinitions: [{ name: 'weather' }],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+    const toolCallPart: t.MessageContentComplex = {
+      type: 'toolCall',
+      toolCall: {
+        id: 'server-search-1',
+        name: 'google_search',
+        args: {},
+      },
+    };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: [toolCallPart],
+          tool_call_chunks: [
+            {
+              id: 'call_weather',
+              name: 'weather',
+              args: '{"city":"NYC"}',
+              index: 0,
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(dispatchMessageDelta).toHaveBeenCalledTimes(1);
+    expect(graph.getRunStep(messageDeltas[0]?.id ?? '')?.type).toBe(
+      StepTypes.MESSAGE_CREATION
+    );
+    expect(messageDeltas[0]?.delta).toEqual({ content: [toolCallPart] });
+  });
+
+  it('dispatches Gemini server-side tool context when reasoning is present', async () => {
+    const dispatchMessageDelta = jest.fn<StandardGraph['dispatchMessageDelta']>(
+      async () => undefined
+    );
+    const dispatchReasoningDelta = jest.fn<
+      StandardGraph['dispatchReasoningDelta']
+    >(async () => undefined);
+    const graph = createGraph({
+      dispatchMessageDelta,
+      dispatchReasoningDelta,
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.GOOGLE,
+          reasoningKey: 'reasoning',
+          currentTokenType: ContentTypes.TEXT,
+          toolDefinitions: [],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+    const toolCallPart: t.MessageContentComplex = {
+      type: 'toolCall',
+      toolCall: {
+        id: 'server-search-1',
+        name: 'google_search',
+        args: {},
+      },
+    };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: [toolCallPart],
+          additional_kwargs: {
+            reasoning: 'Need to search before answering.',
+          },
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(dispatchMessageDelta).toHaveBeenCalledTimes(1);
+    expect(dispatchMessageDelta).toHaveBeenCalledWith(
+      expect.stringMatching(/^step_/),
+      { content: [toolCallPart] },
+      metadata
+    );
+    expect(dispatchReasoningDelta).toHaveBeenCalledWith(
+      expect.stringMatching(/^step_/),
+      {
+        content: [
+          {
+            type: ContentTypes.THINK,
+            think: 'Need to search before answering.',
+          },
+        ],
+      },
+      metadata
+    );
+  });
+
+  it('dispatches Gemini server-side tool context before client tool calls in mixed chunks', async () => {
+    const dispatchOrder: string[] = [];
+    const dispatchMessageDelta = jest.fn<StandardGraph['dispatchMessageDelta']>(
+      async (_id, delta) => {
+        if (
+          delta.content?.some(
+            (contentPart) => contentPart.type === 'toolCall'
+          ) === true
+        ) {
+          dispatchOrder.push('server-context');
+        }
+      }
+    );
+    const graph = createGraph({
+      dispatchMessageDelta,
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.GOOGLE,
+          reasoningKey: 'reasoning',
+          currentTokenType: ContentTypes.TEXT,
+          toolDefinitions: [{ name: 'weather' }],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const dispatchRunStep = graph.dispatchRunStep.bind(graph);
+    graph.dispatchRunStep = jest.fn<StandardGraph['dispatchRunStep']>(
+      async (stepKey, stepDetails, metadata) => {
+        const stepId = await dispatchRunStep(stepKey, stepDetails, metadata);
+        if ((stepDetails as t.StepDetails).type === StepTypes.TOOL_CALLS) {
+          dispatchOrder.push('client-tool-calls');
+        }
+        return stepId;
+      }
+    );
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+    const toolCallPart: t.MessageContentComplex = {
+      type: 'toolCall',
+      toolCall: {
+        id: 'server-search-1',
+        name: 'google_search',
+        args: {},
+      },
+    };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: [toolCallPart],
+          tool_calls: [
+            {
+              type: ToolCallTypes.TOOL_CALL,
+              id: 'call_weather',
+              name: 'weather',
+              args: { city: 'NYC' },
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(dispatchOrder).toEqual(['server-context', 'client-tool-calls']);
+  });
+
+  it('does not dispatch Gemini server-side tool context blocks for non-Google providers', async () => {
+    const dispatchMessageDelta = jest.fn<StandardGraph['dispatchMessageDelta']>(
+      async () => undefined
+    );
+    const graph = createGraph({
+      dispatchMessageDelta,
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.OPENAI,
+          reasoningKey: 'reasoning_content',
+          currentTokenType: ContentTypes.TEXT,
+          toolDefinitions: [],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+    const toolCallPart: t.MessageContentComplex = {
+      type: 'toolCall',
+      toolCall: {
+        id: 'server-search-1',
+        name: 'google_search',
+        args: {},
+      },
+    };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: [toolCallPart],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(dispatchMessageDelta).not.toHaveBeenCalled();
+  });
+
+  it('keeps separately streamed Gemini server-side tool context blocks on separate message steps', async () => {
+    const graph = createGraph({
+      getAgentContext: jest.fn(
+        (): Partial<AgentContext> => ({
+          provider: Providers.GOOGLE,
+          reasoningKey: 'reasoning',
+          currentTokenType: ContentTypes.TEXT,
+          toolDefinitions: [],
+          graphTools: [],
+          agentId: 'agent_1',
+        })
+      ) as unknown as StandardGraph['getAgentContext'],
+    });
+    const { contentParts } = attachContentAggregator(graph);
+    const handler = new ChatModelStreamHandler();
+    const metadata = { langgraph_node: 'agent' };
+    const toolCallPart: t.MessageContentComplex = {
+      type: 'toolCall',
+      toolCall: {
+        id: 'server-search-1',
+        name: 'google_search',
+        args: {},
+      },
+    };
+    const toolResponsePart: t.MessageContentComplex = {
+      type: 'toolResponse',
+      toolResponse: {
+        id: 'server-search-1',
+        name: 'google_search',
+        response: { results: [] },
+      },
+    };
+
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: [toolCallPart],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: [toolResponsePart],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: [
+            {
+              type: ContentTypes.TEXT,
+              text: 'Done',
+            },
+          ],
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+    await handler.handle(
+      GraphEvents.CHAT_MODEL_STREAM,
+      {
+        chunk: {
+          content: ' again.',
+        } as unknown as t.StreamChunk,
+      },
+      metadata,
+      graph
+    );
+
+    expect(contentParts).toEqual([
+      toolCallPart,
+      toolResponsePart,
+      {
+        type: ContentTypes.TEXT,
+        text: 'Done again.',
+      },
+    ]);
+  });
+
   it('processes a reused chunk object when its streamed payload changes', async () => {
     const graph = createGraph();
     const handler = new ChatModelStreamHandler();

package/src/agents/AgentContext.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
-import { HumanMessage, SystemMessage } from '@langchain/core/messages';
 import { RunnableLambda } from '@langchain/core/runnables';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
 import type {
   UsageMetadata,
   BaseMessage,
@@ -16,11 +16,11 @@ import {
   Constants,
   Providers,
 } from '@/common';
-import { createSchemaOnlyTools } from '@/tools/schema';
 import {
   addCacheControl,
   addCacheControlToStablePrefixMessages,
 } from '@/messages/cache';
+import { createSchemaOnlyTools } from '@/tools/schema';
 import { DEFAULT_RESERVE_RATIO } from '@/messages';
 import { toJsonSchema } from '@/utils/schema';
 

package/src/agents/__tests__/AgentContext.test.ts

@@ -1,9 +1,9 @@
 // src/agents/__tests__/AgentContext.test.ts
 import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
-import { AgentContext } from '../AgentContext';
-import { Constants, Providers } from '@/common';
-import { addBedrockCacheControl } from '@/messages/cache';
 import type * as t from '@/types';
+import { addBedrockCacheControl } from '@/messages/cache';
+import { Constants, Providers } from '@/common';
+import { AgentContext } from '../AgentContext';
 
 describe('AgentContext', () => {
   type TestSystemContentBlock =