@librechat/agents 3.3.10 → 3.3.12

package/src/summarization/__tests__/node.test.ts

@@ -7,6 +7,7 @@ import {
   DEFAULT_SUMMARIZATION_PROMPT,
   DEFAULT_UPDATE_SUMMARIZATION_PROMPT,
 } from '@/summarization/node';
+import { StreamLimitExceededError } from '@/llm/streamLimits';
 import { convertInjectedMessages } from '@/messages/injected';
 import { Constants, GraphEvents, Providers } from '@/common';
 import { AgentContext } from '@/agents/AgentContext';
@@ -1707,3 +1708,271 @@ describe('createSummarizeNode — overflow recovery', () => {
     expect(agentContext.hasSummary()).toBe(true);
   });
 });
+
+describe('summarize node breaker capture', () => {
+  it('stamps the entry-captured breaker epoch into summary attempt metadata', async () => {
+    captureEvents();
+    const capturedConfigs: Array<{ metadata?: Record<string, unknown> }> = [];
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return {
+            invoke: jest
+              .fn()
+              .mockImplementation(
+                async (_messages: unknown, config?: unknown) => {
+                  capturedConfigs.push(
+                    config as { metadata?: Record<string, unknown> }
+                  );
+                  return { content: 'Summary text' };
+                }
+              ),
+          };
+        }
+      } as never
+    );
+
+    const agentContext = createAgentContext();
+    const graph = {
+      ...mockGraph(),
+      getBreakerEpoch: (): number => 7,
+    };
+    const node = createSummarizeNode({
+      agentContext,
+      graph,
+      generateStepId,
+    });
+
+    await node(
+      {
+        messages: [new HumanMessage('Hello'), new HumanMessage('World')],
+        summarizationRequest: {
+          remainingContextTokens: 1000,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    expect(capturedConfigs.length).toBeGreaterThan(0);
+    for (const config of capturedConfigs) {
+      expect(config.metadata?.lc_stream_limit_epoch).toBe(7);
+    }
+  });
+
+  it('rejects before the model call when the breaker trips during pre-call awaits', async () => {
+    const trip = new StreamLimitExceededError({
+      kind: 'tool_call_args',
+      limit: 10,
+      observed: 11,
+      toolName: 'db_query',
+    });
+    const entryBreaker = new AbortController();
+    /** The trip lands while ON_SUMMARIZE_START is awaited — after the
+     * entry check already passed. */
+    jest.spyOn(eventUtils, 'safeDispatchCustomEvent').mockImplementation((async (
+      ...args: unknown[]
+    ) => {
+      if (args[0] === GraphEvents.ON_SUMMARIZE_START) {
+        entryBreaker.abort(trip);
+      }
+    }) as never);
+    const modelClassSpy = jest
+      .spyOn(providers, 'getChatModelClass')
+      .mockReturnValue(
+        class {
+          constructor() {
+            return mockInvokeModel('should never run');
+          }
+        } as never
+      );
+
+    const agentContext = createAgentContext();
+    const graph = {
+      ...mockGraph(),
+      getBreakerSignal: (): AbortSignal => entryBreaker.signal,
+    };
+    const node = createSummarizeNode({
+      agentContext,
+      graph,
+      generateStepId,
+    });
+
+    await expect(
+      node(
+        {
+          messages: [new HumanMessage('Hello'), new HumanMessage('World')],
+          summarizationRequest: {
+            remainingContextTokens: 1000,
+            agentId: 'agent_0',
+          },
+        },
+        {} as RunnableConfig
+      )
+    ).rejects.toBe(trip);
+    expect(modelClassSpy).not.toHaveBeenCalled();
+  });
+
+  it('rethrows a parent trip on the config signal instead of degrading to the stub', async () => {
+    const trip = new StreamLimitExceededError({
+      kind: 'tool_call_args',
+      limit: 10,
+      observed: 11,
+      toolName: 'db_query',
+    });
+    /** Child graph's own breaker stays live: in a subagent, a ROOT
+     * sibling's trip arrives only through the composed invocation signal. */
+    const childBreaker = new AbortController();
+    const configAbort = new AbortController();
+    captureEvents();
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return {
+            invoke: jest.fn().mockImplementation(async () => {
+              configAbort.abort(trip);
+              throw new Error('The operation was aborted');
+            }),
+          };
+        }
+      } as never
+    );
+
+    const agentContext = createAgentContext();
+    const graph = {
+      ...mockGraph(),
+      getBreakerSignal: (): AbortSignal => childBreaker.signal,
+    };
+    const node = createSummarizeNode({
+      agentContext,
+      graph,
+      generateStepId,
+    });
+
+    await expect(
+      node(
+        {
+          messages: [new HumanMessage('Hello'), new HumanMessage('World')],
+          summarizationRequest: {
+            remainingContextTokens: 1000,
+            agentId: 'agent_0',
+          },
+        },
+        { signal: configAbort.signal } as RunnableConfig
+      )
+    ).rejects.toBe(trip);
+  });
+
+  it('rejects at entry when the breaker has already tripped', async () => {
+    const trip = new StreamLimitExceededError({
+      kind: 'tool_call_args',
+      limit: 10,
+      observed: 11,
+      toolName: 'db_query',
+    });
+    const entryBreaker = new AbortController();
+    entryBreaker.abort(trip);
+
+    const modelClassSpy = jest
+      .spyOn(providers, 'getChatModelClass')
+      .mockReturnValue(
+        class {
+          constructor() {
+            return mockInvokeModel('should never run');
+          }
+        } as never
+      );
+
+    const agentContext = createAgentContext();
+    const graph = {
+      ...mockGraph(),
+      getBreakerSignal: (): AbortSignal => entryBreaker.signal,
+    };
+    const node = createSummarizeNode({
+      agentContext,
+      graph,
+      generateStepId,
+    });
+
+    await expect(
+      node(
+        {
+          messages: [new HumanMessage('Hello'), new HumanMessage('World')],
+          summarizationRequest: {
+            remainingContextTokens: 1000,
+            agentId: 'agent_0',
+          },
+        },
+        {} as RunnableConfig
+      )
+    ).rejects.toBe(trip);
+
+    expect(graph.contentData).toHaveLength(0);
+    expect(modelClassSpy).not.toHaveBeenCalled();
+  });
+
+  it('binds the model call to the breaker signal read at node entry', async () => {
+    const entryBreaker = new AbortController();
+    const lateBreaker = new AbortController();
+    let started = false;
+    jest.spyOn(eventUtils, 'safeDispatchCustomEvent').mockImplementation((async (
+      ...args: unknown[]
+    ) => {
+      if (args[0] === GraphEvents.ON_SUMMARIZE_START) {
+        started = true;
+      }
+    }) as never);
+
+    const capturedSignals: Array<AbortSignal | undefined> = [];
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return {
+            invoke: jest
+              .fn()
+              .mockImplementation(
+                async (_messages: unknown, config?: unknown) => {
+                  capturedSignals.push(
+                    (config as RunnableConfig | undefined)?.signal
+                  );
+                  return { content: 'Summary text' };
+                }
+              ),
+          };
+        }
+      } as never
+    );
+
+    const agentContext = createAgentContext();
+    /** Simulates a graph reset between node entry and the model call: once
+     * ON_SUMMARIZE_START has been awaited, the live accessor hands out a
+     * fresh controller's signal. The model call must still see the signal
+     * captured at entry. */
+    const graph = {
+      ...mockGraph(),
+      getBreakerSignal: (): AbortSignal =>
+        started ? lateBreaker.signal : entryBreaker.signal,
+    };
+    const node = createSummarizeNode({
+      agentContext,
+      graph,
+      generateStepId,
+    });
+
+    await node(
+      {
+        messages: [new HumanMessage('Hello'), new HumanMessage('World')],
+        summarizationRequest: {
+          remainingContextTokens: 1000,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    expect(capturedSignals.length).toBeGreaterThan(0);
+    for (const signal of capturedSignals) {
+      expect(signal).toBe(entryBreaker.signal);
+    }
+  });
+});

package/src/summarization/chunkHandler.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Summarization streams replace `ChatModelStreamHandler` with an `onChunk`
+ * callback, so the stream circuit breakers are enforced inside
+ * `createSummarizationChunkHandler`: the per-generation event cap, and the
+ * argument byte cap for tool calls a tool-bound summarization model may
+ * emit. Keys derive from the attempt metadata `attemptInvoke` hands each
+ * chunk, so a fallback summary attempt never inherits the failed primary's
+ * counts.
+ */
+import { AIMessageChunk } from '@langchain/core/messages';
+import { describe, it, expect } from '@jest/globals';
+import type { StreamLimitState } from '@/llm/streamLimits';
+import {
+  STREAM_LIMIT_ATTEMPT_KEY,
+  StreamLimitExceededError,
+  enforceStreamLimitsForWireChunk,
+  resolveStreamLimits,
+} from '@/llm/streamLimits';
+import { createSummarizationChunkHandler } from '@/summarization/node';
+import { Providers } from '@/common';
+
+const makeHandler = (graph: StreamLimitState) =>
+  createSummarizationChunkHandler({
+    stepId: 'step_1',
+    config: { metadata: { langgraph_node: 'summarize', langgraph_step: 4 } },
+    provider: Providers.OPENAI,
+    reasoningKey: 'reasoning_content',
+    graph,
+  });
+
+const textChunk = (): AIMessageChunk => new AIMessageChunk({ content: 'part' });
+
+describe('createSummarizationChunkHandler stream limits', () => {
+  it('enforces the event cap on summary streams', async () => {
+    const graph: StreamLimitState = {
+      streamLimits: resolveStreamLimits({ maxDeltaEventsPerTurn: 2 }),
+    };
+    const onChunk = makeHandler(graph);
+    expect(onChunk).toBeDefined();
+    await onChunk!(textChunk());
+    await onChunk!(textChunk());
+    await expect(async () => onChunk!(textChunk())).rejects.toThrow(
+      StreamLimitExceededError
+    );
+  });
+
+  it('keys each summary attempt by the metadata attemptInvoke hands the chunk', async () => {
+    const graph: StreamLimitState = {
+      streamLimits: resolveStreamLimits({ maxDeltaEventsPerTurn: 2 }),
+    };
+    const onChunk = makeHandler(graph);
+    const primary = {
+      langgraph_node: 'summarize',
+      langgraph_step: 4,
+      [STREAM_LIMIT_ATTEMPT_KEY]: 1,
+    };
+    const fallback = { ...primary, [STREAM_LIMIT_ATTEMPT_KEY]: 2 };
+    await onChunk!(textChunk(), primary);
+    await onChunk!(textChunk(), primary);
+    await onChunk!(textChunk(), fallback);
+    await onChunk!(textChunk(), fallback);
+    await expect(async () => onChunk!(textChunk(), fallback)).rejects.toThrow(
+      StreamLimitExceededError
+    );
+  });
+
+  it('enforces the argument byte cap on tool calls from tool-bound summary models', async () => {
+    const graph: StreamLimitState = {
+      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 50 }),
+    };
+    const onChunk = makeHandler(graph);
+    const toolChunk = (args: string): AIMessageChunk =>
+      new AIMessageChunk({
+        content: '',
+        tool_call_chunks: [
+          { type: 'tool_call_chunk', name: 'db_query', args, index: 0 },
+        ],
+      });
+    await onChunk!(toolChunk('x'.repeat(40)));
+    await expect(async () => onChunk!(toolChunk('x'.repeat(20)))).rejects.toThrow(
+      '(tool call: db_query)'
+    );
+  });
+
+  it('trips the run breaker when its own enforcement breaches', async () => {
+    const breaker = new AbortController();
+    const graph: StreamLimitState & {
+      getBreakerController?: () => AbortController;
+    } = {
+      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 50 }),
+      getBreakerController: () => breaker,
+    };
+    const onChunk = createSummarizationChunkHandler({
+      stepId: 'step_1',
+      config: { metadata: { langgraph_node: 'summarize', langgraph_step: 4 } },
+      provider: Providers.OPENAI,
+      reasoningKey: 'reasoning_content',
+      graph,
+    });
+    const toolChunk = (args: string): AIMessageChunk =>
+      new AIMessageChunk({
+        content: '',
+        tool_call_chunks: [
+          { type: 'tool_call_chunk', name: 'db_query', args, index: 0 },
+        ],
+      });
+
+    /** This producer claim wins the race, so the wire consumer's
+     * breaker-aborting catch never fires for the same chunk — the trip has
+     * to happen here or sibling branches keep consuming quota. */
+    await expect(async () => onChunk!(toolChunk('x'.repeat(60)))).rejects.toThrow(
+      StreamLimitExceededError
+    );
+    expect(breaker.signal.aborted).toBe(true);
+    expect(breaker.signal.reason).toMatchObject({ kind: 'tool_call_args' });
+  });
+
+  it('charges a chunk once when the run wire consumer also claims it', async () => {
+    const graph: StreamLimitState = {
+      streamLimits: resolveStreamLimits({ maxToolCallArgBytes: 100 }),
+    };
+    const onChunk = makeHandler(graph);
+    const metadata = { langgraph_node: 'summarize', langgraph_step: 4 };
+    const toolChunk = (args: string): AIMessageChunk =>
+      new AIMessageChunk({
+        content: '',
+        tool_call_chunks: [
+          { type: 'tool_call_chunk', name: 'db_query', args, index: 0 },
+        ],
+      });
+
+    /** Inside a live run the provider callbacks route the same chunk object
+     * through the graph's registered stream consumer as well. Wire consumer
+     * first, then the summarization handler: 60 bytes must be tallied once
+     * (a second same-side claim would put the tally at 120 and trip). */
+    const first = toolChunk('x'.repeat(60));
+    enforceStreamLimitsForWireChunk({
+      graph,
+      metadata,
+      chunk: first,
+      side: 'consumer',
+    });
+    await onChunk!(first, metadata);
+
+    /** Opposite order for the next chunk: handler (producer) before wire
+     * consumer. 60 + 39 = 99 stays under the cap only when each chunk was
+     * charged exactly once. */
+    const second = toolChunk('x'.repeat(39));
+    await onChunk!(second, metadata);
+    enforceStreamLimitsForWireChunk({
+      graph,
+      metadata,
+      chunk: second,
+      side: 'consumer',
+    });
+
+    /** Enforcement stays armed: two more bytes cross the 100-byte cap. */
+    await expect(async () => onChunk!(toolChunk('xx'), metadata)).rejects.toThrow(
+      StreamLimitExceededError
+    );
+  });
+
+  it('counts dual-consumed events once against the event cap', async () => {
+    const graph: StreamLimitState = {
+      streamLimits: resolveStreamLimits({ maxDeltaEventsPerTurn: 2 }),
+    };
+    const onChunk = makeHandler(graph);
+    const metadata = { langgraph_node: 'summarize', langgraph_step: 4 };
+    const passBoth = async (chunk: AIMessageChunk): Promise<void> => {
+      enforceStreamLimitsForWireChunk({
+        graph,
+        metadata,
+        chunk,
+        side: 'consumer',
+      });
+      await onChunk!(chunk, metadata);
+    };
+
+    await passBoth(textChunk());
+    await passBoth(textChunk());
+    await expect(async () => passBoth(textChunk())).rejects.toThrow(
+      StreamLimitExceededError
+    );
+  });
+
+  it('stays inert without graph state', async () => {
+    const onChunk = createSummarizationChunkHandler({
+      stepId: 'step_1',
+      config: { metadata: {} },
+      provider: Providers.OPENAI,
+    });
+    for (let i = 0; i < 10; i++) {
+      await onChunk!(textChunk());
+    }
+  });
+});