@librechat/agents 3.3.10 → 3.3.12

package/src/specs/preemptSeal.test.ts

@@ -6,14 +6,21 @@
  * the dispatch-synchronous loop in `attemptInvoke` (no registered
  * CHAT_MODEL_STREAM handler), which is the only loop allowed to seal.
  */
-import { HumanMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
 import { RunnableBinding } from '@langchain/core/runnables';
+import { AIMessageChunk, HumanMessage } from '@langchain/core/messages';
+import {
+  type OpenAIClient,
+  convertMessagesToResponsesInput,
+  convertResponsesDeltaToChatGenerationChunk,
+} from '@langchain/openai';
+import type { ChatGeneration, LLMResult } from '@langchain/core/outputs';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { HookCallback } from '@/hooks/types';
 import type * as t from '@/types';
-import { Providers } from '@/common';
 import { HookRegistry } from '@/hooks/HookRegistry';
-import type { HookCallback } from '@/hooks/types';
 import { FakeChatModel } from '@/llm/fake';
+import { ChatOpenAI } from '@/llm/openai';
+import { Providers } from '@/common';
 import { Run } from '@/run';
 
 const FULL_RESPONSE = 'Alpha beta gamma delta epsilon zeta';
@@ -89,6 +96,133 @@ class CountingChatModel extends FakeChatModel {
   }
 }
 
+class ResponsesReasoningChatModel extends FakeChatModel {
+  invocations: BaseMessage[][] = [];
+  includeServerToolResult = false;
+
+  _useResponsesApi(): boolean {
+    return true;
+  }
+
+  override async *_streamResponseChunks(
+    ...args: Parameters<FakeChatModel['_streamResponseChunks']>
+  ): ReturnType<FakeChatModel['_streamResponseChunks']> {
+    const [messages] = args;
+    this.invocations.push(messages);
+    if (this.invocations.length !== 1) {
+      yield* super._streamResponseChunks(...args);
+      return;
+    }
+
+    const outputOffset = this.includeServerToolResult ? 1 : 0;
+    const events: Parameters<
+      typeof convertResponsesDeltaToChatGenerationChunk
+    >[0][] = [
+      {
+        type: 'response.created',
+        sequence_number: 0,
+        response: {
+          id: 'resp_interrupted',
+          created_at: 0,
+          output_text: '',
+          error: null,
+          incomplete_details: null,
+          instructions: null,
+          metadata: null,
+          model: 'gpt-5.6',
+          object: 'response',
+          output: [],
+          parallel_tool_calls: true,
+          temperature: null,
+          tool_choice: 'auto',
+          tools: [],
+          top_p: null,
+          status: 'in_progress',
+        },
+      },
+      ...(this.includeServerToolResult
+        ? [
+          {
+            type: 'response.output_item.done' as const,
+            sequence_number: 1,
+            output_index: 0,
+            item: {
+              id: 'ci_interrupted',
+              type: 'code_interpreter_call' as const,
+              status: 'completed' as const,
+              code: 'print("server result")',
+              container_id: 'container_interrupted',
+              outputs: [
+                { type: 'logs' as const, logs: 'server result' },
+                {
+                  type: 'image' as const,
+                  url: 'https://example.com/ephemeral-chart.png',
+                },
+              ],
+            },
+          },
+        ]
+        : []),
+      {
+        type: 'response.output_item.added',
+        sequence_number: 1 + outputOffset,
+        output_index: outputOffset,
+        item: {
+          id: 'rs_interrupted',
+          type: 'reasoning',
+          status: 'in_progress',
+          summary: [],
+        },
+      },
+      {
+        type: 'response.output_item.done',
+        sequence_number: 2 + outputOffset,
+        output_index: outputOffset,
+        item: {
+          id: 'rs_interrupted',
+          type: 'reasoning',
+          status: 'completed',
+          summary: [],
+          encrypted_content: 'encrypted-reasoning',
+        },
+      },
+      {
+        type: 'response.output_item.added',
+        sequence_number: 3 + outputOffset,
+        output_index: 1 + outputOffset,
+        item: {
+          id: 'msg_interrupted',
+          type: 'message',
+          role: 'assistant',
+          status: 'in_progress',
+          content: [],
+        },
+      },
+      {
+        type: 'response.output_text.delta',
+        sequence_number: 4 + outputOffset,
+        output_index: 1 + outputOffset,
+        content_index: 0,
+        item_id: 'msg_interrupted',
+        delta: 'Partial answer.',
+        logprobs: [],
+      },
+    ];
+    for (const event of events) {
+      const chunk = convertResponsesDeltaToChatGenerationChunk(event);
+      if (chunk != null) {
+        yield chunk;
+      }
+    }
+  }
+}
+
+type StreamingResponsesDelegate = {
+  completionWithRetry: (
+    request: OpenAIClient.Responses.ResponseCreateParamsStreaming
+  ) => Promise<AsyncIterable<OpenAIClient.Responses.ResponseStreamEvent>>;
+};
+
 const aiContents = (messages: BaseMessage[]): string[] =>
   messages
     .filter((message) => message.getType() === 'ai')
@@ -204,6 +338,43 @@ describe('cooperative seal (end-to-end via Run)', () => {
     expect(ends).toBe(2);
   });
 
+  it('preserves the preempted marker through constructor-kwargs rehydration', async () => {
+    let sealedChunk: AIMessageChunk | undefined;
+    const run = await createSealRun({
+      runId: 'seal-serialized-preempted-marker',
+      hook: async () => ({ preventContinuation: true }),
+      responses: [FULL_RESPONSE],
+      modelCallbacks: [
+        {
+          handleLLMEnd(output: LLMResult): void {
+            const generation = output.generations[0]?.[0] as
+              | ChatGeneration
+              | undefined;
+            const message = generation?.message;
+            if (
+              AIMessageChunk.isInstance(message) &&
+              message.response_metadata.preempted === true
+            ) {
+              sealedChunk = message;
+            }
+          },
+        },
+      ],
+    });
+
+    await run.processStream(
+      { messages: [new HumanMessage('hello there')] },
+      streamConfig
+    );
+
+    expect(sealedChunk).toBeDefined();
+    const serializedFields = JSON.parse(
+      JSON.stringify(sealedChunk!.lc_kwargs)
+    ) as ConstructorParameters<typeof AIMessageChunk>[0];
+    const rehydrated = new AIMessageChunk(serializedFields);
+    expect(rehydrated.response_metadata.preempted).toBe(true);
+  });
+
   it('a halting boundary stops multi-agent successors, not just the sealed subgraph', async () => {
     const registry = new HookRegistry();
     registry.register('PreemptBoundary', {
@@ -272,7 +443,11 @@ describe('cooperative seal (end-to-end via Run)', () => {
       runId: 'seal-inject-resume',
       hook: async () => ({
         injectedMessages: [
-          { role: 'user' as const, content: 'Make it shorter.', source: 'steer' },
+          {
+            role: 'user' as const,
+            content: 'Make it shorter.',
+            source: 'steer',
+          },
         ],
       }),
       responses: [FULL_RESPONSE, RESUMED_RESPONSE],
@@ -306,4 +481,198 @@ describe('cooperative seal (end-to-end via Run)', () => {
     expect(contents[0].length).toBeLessThan(FULL_RESPONSE.length);
     expect(contents[1]).toBe(RESUMED_RESPONSE);
   });
+
+  it.each(['v0', 'v1'] as const)(
+    'does not replay interrupted OpenAI Responses item ids on %s resume',
+    async (outputVersion) => {
+      const run = await createSealRun({
+        runId: `seal-openai-responses-reasoning-${outputVersion}`,
+        hook: async () => ({
+          injectedMessages: [
+            { role: 'user' as const, content: 'Go on.', source: 'steer' },
+          ],
+        }),
+        responses: [],
+      });
+      const model = new ResponsesReasoningChatModel({
+        responses: [RESUMED_RESPONSE],
+      });
+      model.outputVersion = outputVersion;
+      run.Graph!.overrideModel = model;
+
+      await run.processStream(
+        { messages: [new HumanMessage('hello there')] },
+        streamConfig
+      );
+
+      expect(model.invocations).toHaveLength(2);
+      const sealedMessage = model.invocations[1].find(
+        (message) => message.getType() === 'ai'
+      );
+      expect(sealedMessage).toBeDefined();
+      expect(sealedMessage?.text).toBe('Partial answer.');
+      expect(sealedMessage?.response_metadata).not.toHaveProperty('id');
+      const actualOutputVersion = (
+        sealedMessage?.response_metadata as { output_version?: unknown }
+      ).output_version;
+      expect(actualOutputVersion).toBe(
+        outputVersion === 'v1' ? 'v1' : undefined
+      );
+
+      const providerInput = convertMessagesToResponsesInput({
+        messages: model.invocations[1],
+        model: 'gpt-5.6',
+        zdrEnabled: false,
+      });
+      const unsafeReasoning = providerInput.find(
+        (item) =>
+          item.type === 'reasoning' &&
+          item.id === 'rs_interrupted' &&
+          (typeof item.encrypted_content !== 'string' ||
+            item.encrypted_content.length === 0)
+      );
+      expect(unsafeReasoning).toBeUndefined();
+      expect(JSON.stringify(providerInput)).toContain('Partial answer.');
+    }
+  );
+
+  it.each(['v0', 'v1'] as const)(
+    'preserves completed Responses server results on %s resume without ids',
+    async (outputVersion) => {
+      const run = await createSealRun({
+        runId: `seal-openai-responses-server-result-${outputVersion}`,
+        hook: async () => ({
+          injectedMessages: [
+            { role: 'user' as const, content: 'Go on.', source: 'steer' },
+          ],
+        }),
+        responses: [],
+      });
+      const model = new ResponsesReasoningChatModel({
+        responses: [RESUMED_RESPONSE],
+      });
+      model.outputVersion = outputVersion;
+      model.includeServerToolResult = true;
+      run.Graph!.overrideModel = model;
+
+      await run.processStream(
+        { messages: [new HumanMessage('hello there')] },
+        streamConfig
+      );
+
+      expect(model.invocations).toHaveLength(2);
+      const sealedMessage = model.invocations[1].find(
+        (message) => message.getType() === 'ai'
+      );
+      expect(sealedMessage).toBeDefined();
+      expect(sealedMessage?.text).toContain('Partial answer.');
+      expect(sealedMessage?.text).toContain('server result');
+      expect(sealedMessage?.text).toContain('ephemeral-chart.png');
+      expect(
+        (sealedMessage?.response_metadata as { output_version?: unknown })
+          .output_version
+      ).toBe('v1');
+
+      const providerInput = convertMessagesToResponsesInput({
+        messages: model.invocations[1],
+        model: 'gpt-5.6',
+        zdrEnabled: false,
+      });
+      const serializedProviderInput = JSON.stringify(providerInput);
+      expect(serializedProviderInput).toContain('server result');
+      expect(serializedProviderInput).toContain('ephemeral-chart.png');
+      expect(serializedProviderInput).not.toContain('ci_interrupted');
+      expect(serializedProviderInput).not.toContain('code_interpreter_call');
+      expect(serializedProviderInput).not.toContain('function_call_output');
+    }
+  );
+
+  it('preserves dropped raw Responses results through a real model resume', async () => {
+    const run = await createSealRun({
+      runId: 'seal-openai-responses-raw-result',
+      hook: async () => ({
+        injectedMessages: [
+          { role: 'user' as const, content: 'Go on.', source: 'steer' },
+        ],
+      }),
+      responses: [],
+    });
+    const model = new ChatOpenAI({
+      model: 'gpt-5.6',
+      apiKey: 'test-key',
+      useResponsesApi: true,
+    });
+    const responses = (
+      model as unknown as { responses: StreamingResponsesDelegate }
+    ).responses;
+    const requests: OpenAIClient.Responses.ResponseCreateParamsStreaming[] = [];
+    responses.completionWithRetry = async (request) => {
+      requests.push(request);
+      const invocation = requests.length;
+      return (async function* () {
+        if (invocation === 1) {
+          yield {
+            type: 'response.output_item.done',
+            sequence_number: 0,
+            output_index: 0,
+            item: {
+              id: 'local_output_item',
+              type: 'local_shell_call_output',
+              status: 'completed',
+              output: 'local shell result',
+            },
+          } as OpenAIClient.Responses.ResponseStreamEvent;
+          yield {
+            type: 'response.output_item.added',
+            sequence_number: 1,
+            output_index: 1,
+            item: {
+              id: 'rs_interrupted',
+              type: 'reasoning',
+              status: 'in_progress',
+              summary: [],
+            },
+          } as OpenAIClient.Responses.ResponseStreamEvent;
+          yield {
+            type: 'response.output_text.delta',
+            sequence_number: 2,
+            output_index: 2,
+            content_index: 0,
+            item_id: 'msg_interrupted',
+            delta: 'Partial answer.',
+            logprobs: [],
+          } as OpenAIClient.Responses.ResponseStreamEvent;
+          return;
+        }
+        yield {
+          type: 'response.output_text.delta',
+          sequence_number: 0,
+          output_index: 0,
+          content_index: 0,
+          item_id: 'msg_resumed',
+          delta: RESUMED_RESPONSE,
+          logprobs: [],
+        } as OpenAIClient.Responses.ResponseStreamEvent;
+      })();
+    };
+    run.Graph!.overrideModel = model;
+
+    await run.processStream(
+      { messages: [new HumanMessage('hello there')] },
+      streamConfig
+    );
+
+    expect(requests).toHaveLength(2);
+    const resumedInput = JSON.stringify(requests[1].input);
+    expect(resumedInput).toContain('Partial answer.');
+    expect(resumedInput).toContain('local shell result');
+    expect(resumedInput).toContain('serverToolResult');
+    expect(resumedInput.indexOf('local shell result')).toBeLessThan(
+      resumedInput.indexOf('Partial answer.')
+    );
+    expect(resumedInput).not.toContain('local_output_item');
+    expect(resumedInput).not.toContain('local_shell_call_output');
+    expect(resumedInput).not.toContain('rs_interrupted');
+    expect(run.getHaltReason()).toBeUndefined();
+  });
 });

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,