@librechat/agents 3.4.7 → 3.5.0

package/src/llm/google/streamSmoothing.test.ts

@@ -1,121 +0,0 @@
-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 { CustomChatGoogleGenerativeAI } from './index';
-
-describe('Google stream smoothing', () => {
-  function textResponse(text: string): Record<string, unknown> {
-    return {
-      candidates: [
-        {
-          content: { role: 'model', parts: [{ text }] },
-          index: 0,
-        },
-      ],
-    };
-  }
-
-  async function runStream(
-    responses: Record<string, unknown>[],
-    modelFields: Record<string, unknown> = {}
-  ): Promise<{
-    yielded: ChatGenerationChunk[];
-    dispatchedTokens: string[];
-  }> {
-    const model = new CustomChatGoogleGenerativeAI({
-      model: 'gemini-2.5-flash',
-      apiKey: 'test-key',
-      ...modelFields,
-    });
-
-    (
-      model as unknown as {
-        client: { generateContentStream: unknown };
-      }
-    ).client.generateContentStream = jest.fn(async () => ({
-      stream: (async function* () {
-        yield* responses;
-      })(),
-    }));
-
-    const dispatchedTokens: string[] = [];
-    const runManager = {
-      handleLLMNewToken: jest.fn(async (token: string) => {
-        dispatchedTokens.push(token);
-      }),
-    } as unknown as CallbackManagerForLLMRun;
-
-    const yielded: ChatGenerationChunk[] = [];
-    for await (const chunk of model._streamResponseChunks(
-      [new HumanMessage('hi')],
-      {} as Parameters<
-        CustomChatGoogleGenerativeAI['_streamResponseChunks']
-      >[1],
-      runManager
-    )) {
-      yielded.push(chunk);
-    }
-    return { yielded, dispatchedTokens };
-  }
-
-  test('splits large text responses at stream boundaries with pacing', async () => {
-    const { yielded, dispatchedTokens } = await runStream(
-      [textResponse('alpha beta gamma')],
-      { _lc_stream_delay: 1 }
-    );
-
-    const texts = yielded.map((chunk) => chunk.text).filter(Boolean);
-    expect(texts).toEqual(['alpha ', 'beta ', 'gamma']);
-    expect(dispatchedTokens.filter(Boolean)).toEqual([
-      'alpha ',
-      'beta ',
-      'gamma',
-    ]);
-  });
-
-  test('passes chunks through unsplit when smoothing is disabled', async () => {
-    const { yielded } = await runStream([textResponse('alpha beta gamma')], {
-      _lc_stream_delay: 0,
-    });
-
-    expect(yielded.map((chunk) => chunk.text).filter(Boolean)).toEqual([
-      'alpha beta gamma',
-    ]);
-  });
-
-  test('emits the final usage chunk without pacing delay', async () => {
-    const start = Date.now();
-    const { yielded } = await runStream(
-      [
-        {
-          ...textResponse('short text here'),
-          usageMetadata: {
-            promptTokenCount: 3,
-            candidatesTokenCount: 4,
-            totalTokenCount: 7,
-          },
-        },
-      ],
-      { _lc_stream_delay: 30 }
-    );
-    const elapsed = Date.now() - start;
-
-    const usageChunk = yielded.find(
-      (chunk) =>
-        chunk.text === '' &&
-        (chunk.message as AIMessageChunk).usage_metadata != null
-    );
-    expect(usageChunk).toBeDefined();
-    expect(elapsed).toBeLessThan(1000);
-  });
-
-  test('defaults to 25ms adaptive smoothing with 0 disabling', () => {
-    const base = { model: 'gemini-2.5-flash', apiKey: 'test-key' };
-    expect(new CustomChatGoogleGenerativeAI(base)._lc_stream_delay).toBe(25);
-    expect(
-      new CustomChatGoogleGenerativeAI({ ...base, _lc_stream_delay: 0 })
-        ._lc_stream_delay
-    ).toBe(0);
-  });
-});

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

@@ -1,196 +0,0 @@
-import { expect, test, describe } from '@jest/globals';
-import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
-import type {
-  Content,
-  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,
-  convertMessageContentToParts,
-  dropUnsupportedModelTurnPrefill,
-  rejectsModelTurnPrefill,
-} from './common';
-import { toLangChainContent } from '@/messages/langchain';
-
-describe('convertMessageContentToParts cross-provider tool calls', () => {
-  test('deduplicates Anthropic tool_use content mirrored in parsed tool_calls', () => {
-    const message = new AIMessage({
-      content: toLangChainContent([
-        { type: 'text', text: 'Checking.' },
-        {
-          type: 'tool_use',
-          id: 'call_weather',
-          name: 'weather',
-          input: '',
-        },
-        { type: 'text', index: 0, input: '{"city":"NYC"}' },
-      ]),
-      tool_calls: [
-        {
-          id: 'call_weather',
-          name: 'weather',
-          args: { city: 'NYC' },
-        },
-      ],
-    });
-
-    const parts = convertMessageContentToParts(
-      message,
-      false,
-      [],
-      'gemini-3.5-flash'
-    );
-    const functionCalls = parts.filter((part) => 'functionCall' in part);
-
-    expect(functionCalls).toHaveLength(1);
-    expect(parts).not.toContainEqual({});
-    expect(functionCalls[0]).toMatchObject({
-      functionCall: {
-        id: 'call_weather',
-        name: 'weather',
-        args: { city: 'NYC' },
-      },
-    });
-  });
-});
-
-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();
-  });
-});
-
-describe('rejectsModelTurnPrefill', () => {
-  test('is true for models that reject a trailing model turn', () => {
-    expect(rejectsModelTurnPrefill('gemini-3.7-flash')).toBe(true);
-    expect(rejectsModelTurnPrefill('gemini-3.6-flash')).toBe(true);
-    expect(rejectsModelTurnPrefill('gemini-3.5-flash-lite')).toBe(true);
-    expect(rejectsModelTurnPrefill('models/gemini-3.6-flash')).toBe(true);
-    expect(rejectsModelTurnPrefill('models/gemini-3.7-flash-latest')).toBe(true);
-    expect(rejectsModelTurnPrefill('google/gemini-3.5-flash-lite-latest')).toBe(
-      true
-    );
-  });
-
-  test('is false for models that still accept prefill and for empty input', () => {
-    expect(rejectsModelTurnPrefill('gemini-3.5-flash')).toBe(false);
-    expect(rejectsModelTurnPrefill('gemini-2.5-flash')).toBe(false);
-    expect(rejectsModelTurnPrefill('gemini-3-pro-preview')).toBe(false);
-    expect(rejectsModelTurnPrefill(undefined)).toBe(false);
-    expect(rejectsModelTurnPrefill('')).toBe(false);
-  });
-});
-
-describe('dropUnsupportedModelTurnPrefill', () => {
-  const userTurn: Content = { role: 'user', parts: [{ text: 'Hi' }] };
-  const modelTurn: Content = {
-    role: 'model',
-    parts: [{ text: 'Hello, I am' }],
-  };
-
-  test('drops a trailing model turn for no-prefill models', () => {
-    const contents: Content[] = [userTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(
-      contents,
-      'gemini-3.6-flash'
-    );
-    expect(result).toEqual([userTurn]);
-  });
-
-  test('drops a trailing model turn for Gemini 3.7 Flash', () => {
-    const contents: Content[] = [userTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(
-      contents,
-      'gemini-3.7-flash'
-    );
-    expect(result).toEqual([userTurn]);
-  });
-
-  test('drops multiple consecutive trailing model turns but keeps one turn', () => {
-    const contents: Content[] = [userTurn, modelTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(
-      contents,
-      'gemini-3.5-flash-lite'
-    );
-    expect(result).toEqual([userTurn]);
-  });
-
-  test('leaves a trailing model turn for models that accept prefill', () => {
-    const contents: Content[] = [userTurn, modelTurn];
-    const result = dropUnsupportedModelTurnPrefill(
-      contents,
-      'gemini-3.5-flash'
-    );
-    expect(result).toBe(contents);
-  });
-
-  test('is a no-op when the request already ends with a user turn', () => {
-    const contents: Content[] = [modelTurn, userTurn];
-    const result = dropUnsupportedModelTurnPrefill(
-      contents,
-      'gemini-3.6-flash'
-    );
-    expect(result).toBe(contents);
-  });
-
-  test('is a no-op for empty or undefined contents', () => {
-    expect(dropUnsupportedModelTurnPrefill([], 'gemini-3.6-flash')).toEqual([]);
-    expect(
-      dropUnsupportedModelTurnPrefill(undefined, 'gemini-3.6-flash')
-    ).toBeUndefined();
-  });
-});

package/src/llm/invoke.alternation.test.ts

@@ -1,87 +0,0 @@
-// src/llm/invoke.alternation.test.ts
-/**
- * `attemptInvoke` is the single funnel for primary, fallback and
- * summarization model calls, and it keys the alternation pass on the provider
- * ACTUALLY serving the call. This is the seam that protects a fallback: an
- * OpenAI primary that failed after a boundary injected two human turns hands
- * the same array to a Bedrock fallback, which rejects consecutive user turns.
- */
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import type { ChatGenerationChunk } from '@langchain/core/outputs';
-import { Providers } from '@/common';
-import { FakeChatModel } from '@/llm/fake';
-import { attemptInvoke } from './invoke';
-import type * as t from '@/types';
-
-class CapturingChatModel extends FakeChatModel {
-  readonly invocations: BaseMessage[][] = [];
-
-  constructor() {
-    super({ responses: ['ok'] });
-  }
-
-  override async *_streamResponseChunks(
-    messages: BaseMessage[],
-    options: this['ParsedCallOptions'],
-    runManager?: CallbackManagerForLLMRun
-  ): AsyncGenerator<ChatGenerationChunk> {
-    this.invocations.push(messages);
-    yield* super._streamResponseChunks(messages, options, runManager);
-  }
-}
-
-const adjacentUserPayload = (): BaseMessage[] => [
-  new HumanMessage({ content: 'question' }),
-  new AIMessage({ content: 'partial answer' }),
-  new HumanMessage({ content: 'hook context' }),
-  new HumanMessage({ content: 'steer' }),
-];
-
-async function invokeAs(provider: Providers): Promise<BaseMessage[]> {
-  const model = new CapturingChatModel();
-  await attemptInvoke({
-    model: model as unknown as t.ChatModel,
-    messages: adjacentUserPayload(),
-    provider,
-    onChunk: async () => undefined,
-  });
-  expect(model.invocations).toHaveLength(1);
-  return model.invocations[0];
-}
-
-describe('attemptInvoke alternation funnel', () => {
-  it('coalesces adjacent user turns when the serving provider is strict', async () => {
-    const sent = await invokeAs(Providers.BEDROCK);
-    expect(sent.map((m) => m.getType())).toEqual(['human', 'ai', 'human']);
-    expect(sent[2].content).toBe('hook context\n\nsteer');
-  });
-
-  it('leaves the payload alone for a tolerant provider', async () => {
-    const sent = await invokeAs(Providers.OPENAI);
-    expect(sent.map((m) => m.getType())).toEqual([
-      'human',
-      'ai',
-      'human',
-      'human',
-    ]);
-  });
-
-  it('is idempotent when the graph already coalesced for the primary', async () => {
-    const model = new CapturingChatModel();
-    const once = await invokeAs(Providers.BEDROCK);
-    await attemptInvoke({
-      model: model as unknown as t.ChatModel,
-      messages: once,
-      provider: Providers.BEDROCK,
-      onChunk: async () => undefined,
-    });
-    expect(model.invocations[0].map((m) => m.getType())).toEqual([
-      'human',
-      'ai',
-      'human',
-    ]);
-    expect(model.invocations[0][2].content).toBe('hook context\n\nsteer');
-  });
-});

package/src/llm/invoke.handoffCue.test.ts

@@ -1,112 +0,0 @@
-// src/llm/invoke.handoffCue.test.ts
-/**
- * The handoff cue is re-keyed on the provider ACTUALLY serving the call at
- * the `attemptInvoke` funnel — the seam every fallback send passes through.
- * A tolerant primary falling back to a Claude surface must gain the cue; an
- * Anthropic primary falling back to a tolerant provider must have the baked
- * cue stripped; and the serving model id must be read through the wrapper
- * stack, or a wrapped Bedrock-Nova model would default to Claude.
- */
-import { AIMessage, HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import type { ChatGenerationChunk } from '@langchain/core/outputs';
-import { RunnableBinding } from '@langchain/core/runnables';
-import { Providers } from '@/common';
-import { PREDECESSOR_HANDOFF_CUE } from '@/messages/handoffCue';
-import { FakeChatModel } from '@/llm/fake';
-import { attemptInvoke, type InvokeContext } from './invoke';
-
-class CapturingChatModel extends FakeChatModel {
-  readonly invocations: BaseMessage[][] = [];
-  /** Serving model id, as a real provider client would expose it. */
-  model?: string;
-
-  constructor(modelId?: string) {
-    super({ responses: ['ok'] });
-    this.model = modelId;
-  }
-
-  override async *_streamResponseChunks(
-    messages: BaseMessage[],
-    options: this['ParsedCallOptions'],
-    runManager?: CallbackManagerForLLMRun
-  ): AsyncGenerator<ChatGenerationChunk> {
-    this.invocations.push(messages);
-    yield* super._streamResponseChunks(messages, options, runManager);
-  }
-}
-
-const runTail = new AIMessage({ content: 'predecessor output', id: 'run-1' });
-const context = {
-  isRunProducedMessage: (message: BaseMessage): boolean =>
-    message.id === 'run-1',
-  getOrCreateToolOutputRegistry: (): undefined => undefined,
-} as unknown as InvokeContext;
-
-const bakedCue = (): HumanMessage =>
-  new HumanMessage({
-    content: PREDECESSOR_HANDOFF_CUE,
-    additional_kwargs: { role: 'user', isMeta: true, source: 'handoff' },
-  });
-
-async function sentBy(
-  provider: Providers,
-  options?: { modelId?: string; wrap?: boolean; messages?: BaseMessage[] }
-): Promise<BaseMessage[]> {
-  const model = new CapturingChatModel(options?.modelId);
-  const served =
-    options?.wrap === true
-      ? new RunnableBinding({ bound: model, kwargs: {}, config: {} })
-      : model;
-  await attemptInvoke({
-    model: served as never,
-    messages: options?.messages ?? [new HumanMessage('go'), runTail],
-    provider,
-    context,
-    onChunk: async () => undefined,
-  });
-  return model.invocations[0];
-}
-
-describe('attemptInvoke handoff-cue funnel', () => {
-  it('applies the cue when the serving provider is Anthropic', async () => {
-    const sent = await sentBy(Providers.ANTHROPIC);
-    expect(sent.at(-1)?.content).toBe(PREDECESSOR_HANDOFF_CUE);
-  });
-
-  it('applies the cue for Bedrock serving a WRAPPED Claude model', async () => {
-    const sent = await sentBy(Providers.BEDROCK, {
-      modelId: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
-      wrap: true,
-    });
-    expect(sent.at(-1)?.content).toBe(PREDECESSOR_HANDOFF_CUE);
-  });
-
-  it('does not apply the cue for Bedrock serving a WRAPPED Nova model', async () => {
-    const sent = await sentBy(Providers.BEDROCK, {
-      modelId: 'us.amazon.nova-pro-v1:0',
-      wrap: true,
-    });
-    expect(sent.at(-1)?.getType()).toBe('ai');
-  });
-
-  it('strips a baked cue for a tolerant serving provider', async () => {
-    const sent = await sentBy(Providers.OPENAI, {
-      messages: [new HumanMessage('go'), runTail, bakedCue()],
-    });
-    expect(sent.at(-1)?.getType()).toBe('ai');
-    expect(sent.some((m) => m.content === PREDECESSOR_HANDOFF_CUE)).toBe(
-      false
-    );
-  });
-
-  it('is idempotent when the primary already baked the cue', async () => {
-    const sent = await sentBy(Providers.ANTHROPIC, {
-      messages: [new HumanMessage('go'), runTail, bakedCue()],
-    });
-    expect(
-      sent.filter((m) => m.content === PREDECESSOR_HANDOFF_CUE)
-    ).toHaveLength(1);
-  });
-});

package/src/llm/invoke.streamLimits.test.ts

@@ -1,142 +0,0 @@
-/**
- * `attemptInvoke`'s local stream branch (no registered SDK dispatcher) must
- * charge the event budget even for chunks that produce no handling chunk:
- * a pure OpenRouter reasoning-replay chunk is skipped for content handling,
- * and in this branch no `streamEvents` consumer counts the wire event
- * either, so a looping replay stream would otherwise bypass an enabled
- * `maxDeltaEventsPerTurn` indefinitely.
- */
-import { AIMessageChunk, HumanMessage } from '@langchain/core/messages';
-import { describe, it, expect, jest } from '@jest/globals';
-import type { AgentContext } from '@/agents/AgentContext';
-import type { StandardGraph } from '@/graphs';
-import type * as t from '@/types';
-import {
-  StreamLimitExceededError,
-  resolveStreamLimits,
-} from '@/llm/streamLimits';
-import { attemptInvoke } from '@/llm/invoke';
-import { ContentTypes, Providers } from '@/common';
-
-function createContext(
-  overrides: Partial<StandardGraph> = {}
-): StandardGraph {
-  const runSteps = new Map<string, t.RunStep>();
-  const stepIdsByKey = new Map<string, string>();
-  let stepCounter = 0;
-
-  const graph = {
-    config: { configurable: { user_id: 'user_1' }, metadata: { run_id: 'r1' } },
-    eagerEventToolExecution: undefined,
-    eagerEventToolExecutions: new Map(),
-    eagerEventToolCallChunks: new Map(),
-    eagerEventToolSuppressions: new Set<string>(),
-    handlerRegistry: undefined,
-    hookRegistry: undefined,
-    humanInTheLoop: undefined,
-    toolOutputReferences: undefined,
-    sessions: new Map(),
-    toolCallStepIds: new Map(),
-    messageIdsByStepKey: new Map(),
-    messageStepHasToolCalls: new Map(),
-    prelimMessageIdsByStepKey: new Map([['step-key', 'msg_1']]),
-    getAgentContext: jest.fn(
-      (): Partial<AgentContext> => ({
-        provider: Providers.OPENAI,
-        reasoningKey: 'reasoning_content',
-        currentTokenType: ContentTypes.TEXT,
-        toolDefinitions: [],
-        graphTools: [],
-        agentId: 'agent_1',
-      })
-    ),
-    getOrCreateToolOutputRegistry: jest.fn(() => undefined),
-    shouldPreemptStream: jest.fn(() => false),
-    claimPreemptSeal: jest.fn(() => false),
-    getStepKey: jest.fn(() => 'step-key'),
-    getStepIdByKey: jest.fn((stepKey: string) => {
-      const stepId = stepIdsByKey.get(stepKey);
-      if (stepId == null) {
-        throw new Error('no current step');
-      }
-      return stepId;
-    }),
-    getRunStep: jest.fn((stepId: string) => runSteps.get(stepId)),
-    dispatchRunStep: jest.fn(async (stepKey: string, details: unknown) => {
-      const id = `step_${++stepCounter}`;
-      stepIdsByKey.set(stepKey, id);
-      runSteps.set(id, {
-        id,
-        type: (details as { type: t.RunStep['type'] }).type,
-        stepDetails: details as t.RunStep['stepDetails'],
-      } as t.RunStep);
-      return id;
-    }),
-    dispatchRunStepDelta: jest.fn(async () => undefined),
-    dispatchMessageDelta: jest.fn(async () => undefined),
-    dispatchReasoningDelta: jest.fn(async () => undefined),
-    ...overrides,
-  };
-  return graph as unknown as StandardGraph;
-}
-
-const replayChunk = (): AIMessageChunk =>
-  new AIMessageChunk({
-    content: 'abc',
-    additional_kwargs: { reasoning_details: [{ type: 'reasoning.text' }] },
-  });
-
-function createReplayModel(replays: number): t.ChatModel {
-  return {
-    stream: async function* stream(): AsyncGenerator<AIMessageChunk> {
-      yield new AIMessageChunk({ content: 'abc' });
-      for (let i = 0; i < replays; i++) {
-        yield replayChunk();
-      }
-    },
-  } as unknown as t.ChatModel;
-}
-
-describe('attemptInvoke local branch stream limits', () => {
-  it('charges skipped OpenRouter replay chunks against the event budget', async () => {
-    const context = createContext({
-      streamLimits: resolveStreamLimits({ maxDeltaEventsPerTurn: 3 }),
-    });
-
-    let caught: unknown;
-    try {
-      await attemptInvoke(
-        {
-          model: createReplayModel(10),
-          messages: [new HumanMessage('hi')],
-          provider: Providers.OPENROUTER,
-          context: context as unknown as Parameters<
-            typeof attemptInvoke
-          >[0]['context'],
-        },
-        { metadata: { langgraph_node: 'agent', langgraph_step: 1 } }
-      );
-    } catch (error) {
-      caught = error;
-    }
-    expect(caught).toBeInstanceOf(StreamLimitExceededError);
-    expect((caught as StreamLimitExceededError).kind).toBe('delta_events');
-  });
-
-  it('leaves replay streams unbounded when the cap is disabled', async () => {
-    const context = createContext({ streamLimits: resolveStreamLimits() });
-
-    const result = await attemptInvoke(
-      {
-        model: createReplayModel(10),
-        messages: [new HumanMessage('hi')],
-        provider: Providers.OPENROUTER,
-        context: context as unknown as Parameters<
-          typeof attemptInvoke
-        >[0]['context'],
-      },
-      { metadata: { langgraph_node: 'agent', langgraph_step: 1 } }
-    );
-    expect(result.messages).toHaveLength(1);
-  });
-});