@librechat/agents 3.3.11 → 3.3.13

package/src/run.ts

@@ -148,6 +148,7 @@ export class Run<_T extends t.BaseGraphState> {
   private toolExecution?: t.ToolExecutionConfig;
   private subagentUsageSink?: t.SubagentUsageSink;
   private preemption?: t.StreamPreemption;
+  private streamLimits?: t.StreamLimits;
   private indexTokenCountMap?: Record<string, number>;
   calibrationRatio: number = 1;
   graphRunnable?: t.CompiledStateWorkflow;
@@ -210,6 +211,7 @@ export class Run<_T extends t.BaseGraphState> {
     this.toolExecution = config.toolExecution;
     this.subagentUsageSink = config.subagentUsageSink;
     this.preemption = config.preemption;
+    this.streamLimits = config.streamLimits;
 
     if (!config.graphConfig) {
       throw new Error('Graph config not provided');
@@ -285,6 +287,7 @@ export class Run<_T extends t.BaseGraphState> {
       calibrationRatio: this.calibrationRatio,
       subagentUsageSink: this.subagentUsageSink,
       preemption: this.preemption,
+      streamLimits: this.streamLimits,
     });
     /** Propagate compile options from graph config */
     standardGraph.compileOptions = this.applyHITLCheckpointerFallback(
@@ -317,6 +320,7 @@ export class Run<_T extends t.BaseGraphState> {
       calibrationRatio: this.calibrationRatio,
       subagentUsageSink: this.subagentUsageSink,
       preemption: this.preemption,
+      streamLimits: this.streamLimits,
     });
 
     multiAgentGraph.compileOptions =

package/src/session/AgentSession.ts

@@ -25,6 +25,7 @@ import type { HookRegistry } from '@/hooks';
 import type * as t from '@/types';
 import { deserializeMessage } from './messageSerialization';
 import { createSummarizeNode } from '@/summarization/node';
+import { resolveStreamLimits } from '@/llm/streamLimits';
 import { JsonlSessionStore } from './JsonlSessionStore';
 import { AgentContext } from '@/agents/AgentContext';
 import { ContentTypes, GraphEvents } from '@/common';
@@ -610,6 +611,8 @@ function createManualCompactGraph(params: {
   runId: string;
   customHandlers?: Record<string, t.EventHandler>;
   hooks?: HookRegistry;
+  /** Session run-level stream limits, so manual compaction honors them. */
+  streamLimits?: t.StreamLimits;
 }): {
   graph: Parameters<typeof createSummarizeNode>[0]['graph'];
   completedSummary?: t.SummaryContentBlock;
@@ -626,6 +629,7 @@ function createManualCompactGraph(params: {
       runId: params.runId,
       isMultiAgent: false,
       hookRegistry: params.hooks,
+      streamLimits: resolveStreamLimits(params.streamLimits),
       dispatchRunStep: async (runStep): Promise<void> => {
         contentData.push(runStep);
         contentIndexMap.set(runStep.id, runStep.index);
@@ -1251,6 +1255,7 @@ export class AgentSession {
       runId: compactRunId,
       customHandlers: this.runConfig.customHandlers,
       hooks: this.runConfig.hooks,
+      streamLimits: this.runConfig.streamLimits,
     });
     const summarizeNode = createSummarizeNode({
       agentContext,

package/src/specs/langfuse-instrumentation.test.ts

@@ -320,6 +320,32 @@ describe('Langfuse instrumentation', () => {
     });
   });
 
+  it('does not reuse processors across different media upload policies', async () => {
+    const { initializeLangfuseTracing } = await import('@/instrumentation');
+    initializeLangfuseTracing({
+      publicKey: 'pk-media',
+      secretKey: 'sk-media',
+      baseUrl: 'https://langfuse.media',
+      mediaUploadEnabled: false,
+    });
+    initializeLangfuseTracing({
+      publicKey: 'pk-media',
+      secretKey: 'sk-media',
+      baseUrl: 'https://langfuse.media',
+      mediaUploadEnabled: true,
+    });
+
+    expect(mockLangfuseSpanProcessor).toHaveBeenCalledTimes(2);
+    expect(mockLangfuseSpanProcessor).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ mediaUploadEnabled: false })
+    );
+    expect(mockLangfuseSpanProcessor).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ mediaUploadEnabled: true })
+    );
+  });
+
   it('reuses the isolated provider after initialization', async () => {
     process.env.LANGFUSE_SECRET_KEY = 'sk-test';
     process.env.LANGFUSE_PUBLIC_KEY = 'pk-test';

package/src/specs/langfuse-span-registry.test.ts

@@ -1,6 +1,7 @@
 import type { Span } from '@opentelemetry/api';
 import type * as t from '@/types';
 import {
+  getLangfuseSpanProcessorParams,
   getLangfuseManagedSpanDestination,
   registerLangfuseManagedSpan,
   resolveLangfuseDestinationKey,
@@ -41,7 +42,23 @@ describe('Langfuse span registry', () => {
     const redacting = resolveLangfuseDestinationKey(
       tenantConfig({ toolOutputTracing: { enabled: false } })
     );
+    const mediaDisabled = resolveLangfuseDestinationKey(
+      tenantConfig({ mediaUploadEnabled: false })
+    );
     expect(redacting).toBe(base);
+    expect(mediaDisabled).toBe(base);
+  });
+
+  it('passes media upload policy to the Langfuse span processor params', () => {
+    expect(
+      getLangfuseSpanProcessorParams(
+        tenantConfig({ mediaUploadEnabled: false })
+      )
+    ).toEqual(
+      expect.objectContaining({
+        mediaUploadEnabled: false,
+      })
+    );
   });
 
   it('separates destinations by credentials, endpoint, and environment', () => {

package/src/specs/summarization.test.ts

@@ -1162,7 +1162,7 @@ const hasBedrock = hasEveryEnv(requiredBedrockEnv);
 
 const hasOpenAI = hasEnv('OPENAI_API_KEY');
 (hasOpenAI ? describe : describe.skip)('OpenAI Summarization E2E', () => {
-  jest.setTimeout(120_000);
+  jest.setTimeout(240_000);
 
   const agentProvider = Providers.OPENAI;
   const streamConfig = {
@@ -1190,6 +1190,9 @@ const hasOpenAI = hasEnv('OPENAI_API_KEY');
         agentProvider,
         summarizationProvider: Providers.OPENAI,
         summarizationModel: 'gpt-4.1-mini',
+        llmConfigOverride: {
+          model: 'gpt-4.1-mini',
+        },
         maxContextTokens: maxTokens,
         instructions:
           'You are a helpful math tutor. Use the calculator tool for ALL computations. Keep responses concise.',
@@ -1320,7 +1323,7 @@ const hasOpenAI = hasEnv('OPENAI_API_KEY');
       `  OpenAI summary: "${getSummaryText(completePayload.summary).substring(0, 200)}…"`
     );
     console.log(`  Final messages: ${conversationHistory.length}`);
-  }, 120_000);
+  }, 240_000);
 });
 
 // ---------------------------------------------------------------------------

package/src/stream.ts

@@ -39,9 +39,21 @@ import {
   calculateMaxToolResultChars,
   truncateToolResultContent,
 } from '@/utils/truncation';
+import type { RunBreakerScope } from '@/llm/streamLimits';
+import {
+  claimStreamLimitCharge,
+  combineCompleteToolCalls,
+  enforceCompleteToolCallArgLimit,
+  enforceStreamedToolCallArgLimit,
+  enforceStreamDeltaEventLimit,
+  requiresStreamLimitAccounting,
+  StreamLimitExceededError,
+  STREAM_LIMIT_EPOCH_KEY,
+} from '@/llm/streamLimits';
 import { resolveToolOutcome, outcomeFieldsFromResult } from '@/tools/intentArg';
 import { TOOL_OUTPUT_REF_PATTERN } from '@/tools/toolOutputReferences';
 import { safeDispatchCustomEvent } from '@/utils/events';
+import { composeAbortSignals } from '@/utils/misc';
 import { isGoogleLike } from '@/utils/llm';
 import { getMessageId } from '@/messages';
 
@@ -166,7 +178,10 @@ function isEagerExecutionExcludedTool(
   // the final request ("changed after eager execution started"), stop
   // prestarting it so the model's retry executes normally instead of
   // re-diverging in a loop (LibreChat#14371).
-  if (graph.eagerEventToolSuppressions?.has(name) === true) {
+  if (
+    (graph.eagerEventToolSuppressions as Set<string> | undefined)?.has(name) ===
+    true
+  ) {
     return true;
   }
   // A code-session participant writes to the shared sandbox, so it is
@@ -778,6 +793,10 @@ function startEagerToolExecutions(args: {
         | Record<string, unknown>
         | undefined,
       metadata,
+      signal: composeAbortSignals(
+        graph.config?.signal,
+        graph.breakerAbort.signal
+      ),
       resolve: (results): void => {
         resultSettled = true;
         settledResults = results;
@@ -1069,9 +1088,8 @@ function recordEagerToolCallChunks(args: {
     const sealCoversChunk =
       seal != null &&
       (seal.kind === 'all' ||
-        (seal.kind === 'single' &&
-          ((seal.id != null && seal.id === id) ||
-            (seal.index != null && seal.index === index))));
+        (seal.id != null && seal.id === id) ||
+        (seal.index != null && seal.index === index));
     const next = {
       id,
       name,
@@ -1512,10 +1530,119 @@ export class ChatModelStreamHandler implements t.EventHandler {
       return;
     }
 
-    const agentContext = graph.getAgentContext(metadata);
-
     const chunk = data.chunk as Partial<AIMessageChunk>;
 
+    /** Attempts stamp their breaker epoch into event metadata; a mismatch
+     * marks a straggling chunk from a failed run that outlived
+     * `resetValues()`. Dropped OUTRIGHT: content handling and the eager
+     * paths below compose the LIVE controller, so acting on a dead run's
+     * chunk could dispatch host tools into the run now using it. Events
+     * without a stamp (direct handler callers, partial stubs) keep the
+     * live-controller behavior. */
+    const eventEpoch = metadata?.[STREAM_LIMIT_EPOCH_KEY];
+    /** Runtime-honest widening: partial handler stubs carry neither an
+     * epoch nor a run scope despite the field types. */
+    const liveEpoch = graph.breakerEpoch as number | undefined;
+    if (eventEpoch != null && liveEpoch != null && eventEpoch !== liveEpoch) {
+      return;
+    }
+    const eventBreaker =
+      graph.breakerAbort instanceof AbortController
+        ? graph.breakerAbort
+        : undefined;
+    /** Immutable scope captured at handler entry. A reset while this
+     * handler is suspended in an await replaces the object, so ONE
+     * reference comparison proves the event still belongs to the live run
+     * before anything composes `graph.breakerAbort` or `graph.config`. */
+    const entryRunScope = graph.runScope as RunBreakerScope | undefined;
+    const runScopeInvalidated = (): boolean =>
+      entryRunScope != null && graph.runScope !== entryRunScope;
+    const throwIfRunBreakerTripped = (): void => {
+      if (
+        eventBreaker != null &&
+        eventBreaker.signal.aborted &&
+        eventBreaker.signal.reason instanceof StreamLimitExceededError
+      ) {
+        throw eventBreaker.signal.reason;
+      }
+    };
+
+    /**
+     * Enforced before every content-specific early return below
+     * (server-tool results, deferred mixed reasoning, late OpenRouter
+     * reasoning): a looping provider can flood through any of those paths,
+     * a coalesced event can carry client `tool_call_chunks` alongside a
+     * server-tool result, and the complete-call dispatch branch further
+     * down can prestart a side-effecting tool from an arrival-sealed
+     * oversized call. Charging is claim-based: the producer loop and this
+     * decoupled echo can observe the same chunk object in either order, and
+     * only the first claimer charges it. The argument guard is
+     * deliberately NOT gated on numeric chunk indices, so id-only or
+     * index-less runaway streams stay bounded, and complete parsed
+     * `tool_calls` without a raw chunk representation are judged standalone.
+     */
+    if (
+      requiresStreamLimitAccounting(graph, chunk) &&
+      claimStreamLimitCharge(graph, data.chunk, 'consumer', metadata)
+    ) {
+      try {
+        enforceStreamDeltaEventLimit({ graph, metadata });
+        /** Combined first so raw-chunk name correlation sees invalid calls
+         * too; an unnamed raw chunk twinned with a named invalid call must
+         * select that tool's override, not the global cap. */
+        const completeCalls = combineCompleteToolCalls(chunk);
+        if (chunk.tool_call_chunks && chunk.tool_call_chunks.length > 0) {
+          enforceStreamedToolCallArgLimit({
+            graph,
+            metadata,
+            toolCallChunks: chunk.tool_call_chunks,
+            responseMetadata: chunk.response_metadata as
+              | Record<string, unknown>
+              | undefined,
+            parsedToolCalls: completeCalls,
+          });
+        }
+        /** Judged whenever parsed calls are present, not only when raw
+         * chunks are absent — an adapter can pair an empty or partial raw
+         * chunk with a complete parsed call; the standalone check is
+         * stateless, so the common both-present case is not double-tallied.
+         * Invalid calls are included because ToolNode processes and
+         * promotes them. */
+        if (completeCalls != null) {
+          enforceCompleteToolCallArgLimit({
+            graph,
+            metadata,
+            toolCalls: completeCalls,
+          });
+        }
+      } catch (error) {
+        /** A breach detected on this consumer path must still stop parallel
+         * fan-out work: the producer skips its own enforcement once this
+         * side has claimed the emission, so createCallModel's breaker-abort
+         * never fires for it. Trip the EVENT's run-bound breaker before the
+         * throw rejects the run — never the live controller of a newer run. */
+        if (error instanceof StreamLimitExceededError && eventBreaker != null) {
+          eventBreaker.abort(error);
+        }
+        throw error;
+      }
+    }
+
+    /** A parallel producer can trip the shared breaker while this event was
+     * already queued in `streamEvents`. Stop before content handling or the
+     * eager-tool paths below — those can dispatch a side-effecting host
+     * tool with an already-aborted signal the handler never inspects.
+     * Rechecked again immediately before each eager dispatch: the awaits in
+     * between (server-tool results, tool-call handling, content dispatch)
+     * are windows for a sibling's trip — or for a full reset, after which
+     * this event belongs to a dead run and is dropped. */
+    if (runScopeInvalidated()) {
+      return;
+    }
+    throwIfRunBreakerTripped();
+
+    const agentContext = graph.getAgentContext(metadata);
+
     const content = getChunkContent({
       chunk,
       reasoningKey: agentContext.reasoningKey,
@@ -1576,6 +1703,10 @@ export class ChatModelStreamHandler implements t.EventHandler {
     ) {
       hasToolCalls = true;
       await handleToolCalls(chunk.tool_calls, metadata, graph);
+      if (runScopeInvalidated()) {
+        return;
+      }
+      throwIfRunBreakerTripped();
       if (hasFinalToolCallSignal(chunk)) {
         startEagerToolExecutions({
           graph,
@@ -1655,6 +1786,10 @@ export class ChatModelStreamHandler implements t.EventHandler {
         metadata,
       });
       if (canStreamEager) {
+        if (runScopeInvalidated()) {
+          return;
+        }
+        throwIfRunBreakerTripped();
         startReadyStreamedEagerToolExecutions({
           graph,
           metadata,

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);
+    }
+  });
+});