@librechat/agents 3.3.10 → 3.3.12

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

@@ -0,0 +1,142 @@
+/**
+ * `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);
+  });
+});

package/src/llm/invoke.test.ts

@@ -18,6 +18,8 @@ import type * as t from '@/types';
 import { _convertMessagesToAnthropicPayload } from '@/llm/anthropic/utils/message_inputs';
 import { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import { convertMessageContentToParts } from '@/llm/google/utils/common';
+import { _convertMessagesToOpenAIParams } from '@/llm/openai/utils';
+import { StreamLimitExceededError } from '@/llm/streamLimits';
 import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
 import { toLangChainContent } from '@/messages/langchain';
 import { Constants, Providers } from '@/common';
@@ -555,7 +557,7 @@ describe('attemptInvoke applies lazy ref annotation', () => {
     responses.model.defaultOptions = { tools: [] };
     responses.model._useResponsesApi = (options) =>
       Array.isArray((options as { tools?: unknown[] } | undefined)?.tools) &&
-      ((options as { tools: unknown[] }).tools.length ?? 0) > 0;
+      (options as { tools: unknown[] }).tools.length > 0;
 
     await attemptInvoke(
       {
@@ -827,6 +829,190 @@ describe('tryFallbackProviders applies the same lazy annotation transform', () =
     jest.dontMock('@/llm/init');
     jest.resetModules();
   });
+
+  it('stops draining a cancellation-ignoring stream once the breaker trips', async () => {
+    const abort = new AbortController();
+    /** Statically imported class: neighboring tests reset the module
+     * registry, and a dynamically imported instance would fail the
+     * statically-linked drain loop's instanceof check. */
+    const trip = new StreamLimitExceededError({
+      kind: 'tool_call_args',
+      limit: 10,
+      observed: 11,
+      toolName: 'db_query',
+    });
+    let yields = 0;
+    const model: StubModel = {
+      stream: jest.fn(async function* (): AsyncGenerator<AIMessageChunk> {
+        for (let i = 0; i < 5; i++) {
+          yields += 1;
+          yield new AIMessageChunk({ content: `c${i}` });
+        }
+      }),
+    };
+
+    /** The stub ignores the abort signal entirely; only the per-chunk
+     * breaker check in the drain loop can stop it. */
+    await expect(
+      attemptInvoke(
+        {
+          model: model as t.ChatModel,
+          messages: [new HumanMessage('hi')],
+          provider: Providers.ANTHROPIC,
+          onChunk: () => {
+            abort.abort(trip);
+          },
+        },
+        { signal: abort.signal }
+      )
+    ).rejects.toBe(trip);
+    expect(yields).toBeLessThanOrEqual(2);
+  });
+
+  it('rejects before invoking a fallback when the breaker tripped during preparation', async () => {
+    const abort = new AbortController();
+    const { invokeMessages, model } = buildCapturingModel();
+    await jest.isolateModulesAsync(async () => {
+      jest.doMock('@/llm/init', () => ({
+        initializeModel: (): unknown => model,
+      }));
+      const { tryFallbackProviders: freshTry } = (await import(
+        '@/llm/invoke'
+      )) as { tryFallbackProviders: typeof tryFallbackProviders };
+      const { StreamLimitExceededError: FreshStreamLimitError } = (await import(
+        '@/llm/streamLimits'
+      )) as typeof import('@/llm/streamLimits');
+      const trip = new FreshStreamLimitError({
+        kind: 'tool_call_args',
+        limit: 10,
+        observed: 11,
+        toolName: 'db_query',
+      });
+
+      /** The sibling's trip lands while fallback preparation is awaited; the
+       * fallback must not be invoked at all — a provider that ignores the
+       * aborted signal and SUCCEEDS would resolve a run that must reject. */
+      await expect(
+        freshTry({
+          fallbacks: [{ provider: Providers.ANTHROPIC }],
+          messages: [
+            new ToolMessage({
+              name: 'echo',
+              tool_call_id: 'tc1',
+              status: 'success',
+              content: 'output',
+            }),
+          ],
+          primaryError: new Error('primary failed'),
+          config: { signal: abort.signal },
+          prepareProviderMessages: async ({ messages: preparedMessages }) => {
+            abort.abort(trip);
+            return preparedMessages;
+          },
+        })
+      ).rejects.toBe(trip);
+    });
+    expect(invokeMessages).toHaveLength(0);
+
+    jest.dontMock('@/llm/init');
+  });
+
+  it('neutralizes preempted Responses history before an OpenAI Chat fallback', async () => {
+    const reasoning = {
+      id: 'rs_fallback',
+      type: 'reasoning',
+      status: 'completed',
+      summary: [],
+      encrypted_content: 'opaque-fallback-reasoning',
+    };
+    const toolOutput = {
+      id: 'ci_fallback',
+      type: 'code_interpreter_call',
+      status: 'completed',
+      code: 'print("fallback result")',
+      outputs: [{ type: 'logs', logs: 'fallback result' }],
+    };
+    const translatedMessage = new AIMessage({
+      content: [{ type: 'text', text: 'Partial answer.' }],
+      additional_kwargs: {
+        reasoning,
+        tool_outputs: [toolOutput],
+      },
+      response_metadata: { model_provider: 'openai' },
+    });
+    const message = new AIMessage({
+      contentBlocks: [
+        ...translatedMessage.contentBlocks,
+        {
+          type: 'non_standard',
+          value: {
+            id: 'rs_bare_fallback',
+            type: 'reasoning',
+            summary: [],
+          },
+        },
+        {
+          type: 'image',
+          mimeType: 'image/png',
+          data: 'AA==',
+          id: 'ig_fallback',
+          metadata: { status: 'completed' },
+        },
+      ],
+      additional_kwargs: {
+        reasoning,
+        tool_outputs: [toolOutput],
+      },
+      response_metadata: {
+        model_provider: 'openai',
+        output_version: 'v1',
+        preempted: true,
+      },
+    });
+    const { invokeMessages, model } = buildCapturingModel();
+    model._useResponsesApi = () => false;
+    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.OPENAI,
+          clientOptions: { model: 'gpt-5.6' },
+        },
+      ],
+      messages: [message],
+      primaryError: new Error('primary failed'),
+    });
+
+    const sent = invokeMessages[invokeMessages.length - 1][0] as AIMessage;
+    expect(sent).not.toBe(message);
+    expect(sent.content).toEqual([
+      { type: 'text', text: 'Partial answer.' },
+      { type: 'text', text: expect.stringContaining('fallback result') },
+    ]);
+    expect(sent.additional_kwargs).toEqual({});
+    expect(JSON.stringify(sent.toJSON())).not.toMatch(/rs_|ci_|ig_/);
+    const chatPayload = _convertMessagesToOpenAIParams([sent], 'gpt-5.6');
+    expect(chatPayload).toEqual([
+      {
+        role: 'assistant',
+        content: sent.content,
+      },
+    ]);
+    expect(JSON.stringify(chatPayload)).not.toMatch(/rs_|ci_|ig_/);
+    expect(JSON.stringify(message.toJSON())).toContain('rs_fallback');
+    expect(JSON.stringify(message.toJSON())).toContain('ci_fallback');
+    expect(JSON.stringify(message.toJSON())).toContain('ig_fallback');
+
+    jest.dontMock('@/llm/init');
+    jest.resetModules();
+  });
 });
 
 describe('invocation attribution metadata', () => {