@librechat/agents 3.6.1 → 3.6.3

package/src/graphs/Graph.ts

@@ -161,6 +161,7 @@ import { createCloudflareCodingToolBundle } from '@/tools/cloudflare';
 import { buildSubagentToolParams } from '@/tools/SubagentTool';
 import { initializeLangfuseTracing } from '@/instrumentation';
 import { shouldTriggerSummarization } from '@/summarization';
+import { isRunStepResumeState } from '@/tools/runStepResume';
 import { resolveLocalToolsForBinding } from '@/tools/local';
 import { createSummarizeNode } from '@/summarization/node';
 import { messagesStateReducer } from '@/messages/reducer';
@@ -168,7 +169,6 @@ import { createSchemaOnlyTools } from '@/tools/schema';
 import { AgentContext } from '@/agents/AgentContext';
 import { createFakeStreamingLLM } from '@/llm/fake';
 import { handleToolCalls } from '@/tools/handlers';
-import { isRunStepResumeState } from '@/tools/runStepResume';
 import { isThinkingEnabled } from '@/llm/request';
 import { resolveMaxSeals } from '@/llm/preempt';
 import { initializeModel } from '@/llm/init';
@@ -1800,9 +1800,10 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       version: 1,
       revision: this.runStepStateRevision,
       nextIndex: this.nextContentIndex,
-      toolCallSteps: [...this.toolCallStepIds].map(
-        ([toolCallId, stepId]) => ({ toolCallId, stepId })
-      ),
+      toolCallSteps: [...this.toolCallStepIds].map(([toolCallId, stepId]) => ({
+        toolCallId,
+        stepId,
+      })),
       steps,
     };
   }
@@ -1836,10 +1837,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         this.pendingToolCallsByStep.set(runStep.id, pending);
       }
       if (entry.latestCompletionAt != null) {
-        this.latestCompletionByStep.set(
-          runStep.id,
-          entry.latestCompletionAt
-        );
+        this.latestCompletionByStep.set(runStep.id, entry.latestCompletionAt);
       }
       if (entry.openMessageStep) {
         this.openMessageStepByAgent.set(runStep.agentId ?? '', runStep.id);
@@ -1964,10 +1962,11 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   /**
    * Closes a run step: stamps its terminal status + timestamp on the stored
    * `RunStep` and emits `ON_RUN_STEP_CLOSED`. First close wins — later calls
-   * are no-ops — except a `restamp` close, which lets a `completed`
-   * TOOL_CALLS step refresh `completed_at` when a late-registered parallel
-   * tool call finishes after the step already closed (the eager-execution
-   * race). `cancelled`/`failed` are immutable once stamped.
+   * are no-ops with no exceptions; every terminal status is immutable once
+   * stamped. (A `restamp` option once let a completed TOOL_CALLS step
+   * refresh `completed_at` for the eager-execution race, but that race is
+   * unreachable — each step registers its calls before any completion can
+   * reference it — and the mechanism was removed.)
    */
   async closeRunStep(
     stepId: string,
@@ -2025,12 +2024,36 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       GraphEvents.ON_RUN_STEP_CLOSED
     );
     if (handler) {
-      await handler.handle(
-        GraphEvents.ON_RUN_STEP_CLOSED,
-        closedEvent,
-        options?.metadata,
-        this
-      );
+      /**
+       * Isolated, unlike the other dual-dispatch sites, because this one
+       * reports state that is already committed: the step was stamped
+       * terminal and untracked above, and nothing a failed delivery can do
+       * will undo that. Propagating instead costs two things.
+       *
+       * First, it fails an entire run over an observational event —
+       * `closeOpenMessageStep` awaits this inside the stream loop on every
+       * CHAT_MODEL_END, where a rejection sets `streamThrew` and fires the
+       * StopFailure hooks for a response that was fully delivered.
+       *
+       * Second, and worse, it skips the secondary custom-event dispatch
+       * below. That channel exists precisely as the fallback for when the
+       * primary path does not deliver, so letting the primary's failure
+       * suppress it removes the redundancy exactly when it is needed.
+       *
+       * `closeUnfinishedRunSteps` and `dispatchRunStep` already wrap their
+       * own calls for the same reason; this closes the gap inside, which
+       * those wrappers cannot reach.
+       */
+      try {
+        await handler.handle(
+          GraphEvents.ON_RUN_STEP_CLOSED,
+          closedEvent,
+          options?.metadata,
+          this
+        );
+      } catch (_e) {
+        /** Host delivery failure must not fail the run or block the echo */
+      }
       this.handlerDispatchedStepIds.add(stepId);
     }
     const unmarkHandlerDispatchedEvent = handler
@@ -4990,10 +5013,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       .addNode(agentNode, (state, config) =>
         invokeWithRunStepState(state, config, () => callModel(state, config))
       )
-      .addNode(
-        toolNode,
-        callTools
-      )
+      .addNode(toolNode, callTools)
       .addNode(
         summarizeNode,
         createSummarizeNode({

package/src/llm/openai/index.ts

@@ -43,6 +43,7 @@ import type { SeenScalarMetadata } from './streamMetadata';
 import type { HeaderValue, HeadersLike } from './types';
 import type { PromptCacheTtl } from '@/messages/cache';
 import {
+  OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY,
   OPENAI_RESPONSES_REPLAY_POSITIONS_KEY,
   projectOpenAIResponsesToolMessageContent,
   projectToolStreamContentForProvider,
@@ -606,6 +607,85 @@ function isResponsesReplayOutputItem(item: unknown): boolean {
   );
 }
 
+type ResponsesReasoningSlot = {
+  encrypted_content?: string;
+  id?: string;
+  status?: string;
+};
+
+function getResponsesReasoningSlot(
+  reasoning: unknown
+): ResponsesReasoningSlot | undefined {
+  return typeof reasoning === 'object' && reasoning != null
+    ? (reasoning as ResponsesReasoningSlot)
+    : undefined;
+}
+
+function isSealedReasoningSlot(
+  slot: ResponsesReasoningSlot | undefined
+): slot is ResponsesReasoningSlot & { encrypted_content: string } {
+  return (
+    typeof slot?.encrypted_content === 'string' &&
+    slot.encrypted_content.length > 0
+  );
+}
+
+function resolveActiveReasoningItemId(
+  incoming: ResponsesReasoningSlot | undefined,
+  carried: unknown
+): string | undefined {
+  if (typeof incoming?.id === 'string' && incoming.id.length > 0) {
+    return incoming.id;
+  }
+  return typeof carried === 'string' ? carried : undefined;
+}
+
+/**
+ * A single `additional_kwargs.reasoning` slot has to stand in for a turn that
+ * can emit many reasoning items, and the chunk merge folds it field by field:
+ * `encrypted_content` and `status` are strings, so they concatenate, while
+ * `id` takes whichever item arrived last. An interrupted turn replays from
+ * that slot, handing the provider one item id welded to every item's
+ * ciphertext — rejected as "Encrypted content could not be decrypted or
+ * parsed". Keep the slot describing whichever item most recently sealed, so
+ * the id, its ciphertext, and its status always come from the same item.
+ *
+ * `activeItemId` tracks the item currently streaming, which is the one a
+ * terminal `encrypted_content` belongs to: the slot's own id has already been
+ * pinned back to the last sealed item by an earlier merge.
+ */
+function resealReasoningItemBoundary(
+  combined: AIMessageChunk,
+  accumulated: ResponsesReasoningSlot | undefined,
+  incoming: ResponsesReasoningSlot | undefined,
+  activeItemId: string | undefined
+): void {
+  const merged = getResponsesReasoningSlot(
+    combined.additional_kwargs.reasoning
+  );
+  if (merged == null || incoming == null) {
+    return;
+  }
+  if (isSealedReasoningSlot(incoming)) {
+    combined.additional_kwargs.reasoning = {
+      ...merged,
+      id: activeItemId ?? merged.id,
+      encrypted_content: incoming.encrypted_content,
+      status: incoming.status,
+    };
+    return;
+  }
+  if (!isSealedReasoningSlot(accumulated)) {
+    return;
+  }
+  combined.additional_kwargs.reasoning = {
+    ...merged,
+    id: accumulated.id,
+    encrypted_content: accumulated.encrypted_content,
+    status: accumulated.status,
+  };
+}
+
 /**
  * LangChain's Responses converter places the authoritative terminal output in
  * response_metadata.output. Its chunk merge has no way to delete provisional
@@ -619,10 +699,26 @@ class ResponsesReplayAIMessageChunk extends AIMessageChunk {
   }
 
   override concat(chunk: AIMessageChunk): this {
+    const accumulated = getResponsesReasoningSlot(
+      this.additional_kwargs.reasoning
+    );
+    const incoming = getResponsesReasoningSlot(
+      chunk.additional_kwargs.reasoning
+    );
+    const activeItemId = resolveActiveReasoningItemId(
+      incoming,
+      this.additional_kwargs[OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY]
+    );
     const combined = super.concat(chunk);
+    resealReasoningItemBoundary(combined, accumulated, incoming, activeItemId);
+    if (activeItemId != null) {
+      combined.additional_kwargs[OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY] =
+        activeItemId;
+    }
     if (!Array.isArray(chunk.response_metadata.output)) {
       return combined;
     }
+    delete combined.additional_kwargs[OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY];
     delete combined.additional_kwargs[OPENAI_RESPONSES_REPLAY_POSITIONS_KEY];
     const toolOutputs = combined.additional_kwargs.tool_outputs;
     if (!Array.isArray(toolOutputs)) {

package/src/messages/core.ts

@@ -671,6 +671,10 @@ type ResponsesReplayProjection = 'fallback' | 'native';
 export const OPENAI_RESPONSES_REPLAY_POSITIONS_KEY =
   '__openai_responses_replay_positions__';
 
+/** Reasoning item currently streaming, so a terminal ciphertext seals against its own id. */
+export const OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY =
+  '__openai_responses_active_reasoning_id__';
+
 export type ResponsesReplayPosition = {
   contentIndex?: number;
   itemId: string;
@@ -1813,6 +1817,7 @@ function projectPreemptedOpenAIResponsesMessage(
   }
   delete additionalKwargs.tool_outputs;
   delete additionalKwargs[OPENAI_RESPONSES_REPLAY_POSITIONS_KEY];
+  delete additionalKwargs[OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY];
   delete additionalKwargs.__openai_function_call_ids__;
   delete additionalKwargs.__openai_custom_tool_call_ids__;
 

package/src/run.ts

@@ -826,12 +826,23 @@ export class Run<_T extends t.BaseGraphState> {
              * The producer stamped `completed_at` before dispatch. Carrying it
              * through keeps the recorded duration the tool's, not the host
              * handler's — this runs after an arbitrarily slow handler resolves.
+             *
+             * Isolated because this is a `finally`: a throw here would
+             * REPLACE an in-flight error from the handler above, so the
+             * host's original failure would be reported as whatever went
+             * wrong during closure instead. Closing is best-effort at this
+             * point either way — the end-of-run sweep still stamps any step
+             * this misses.
              */
-            await this.Graph.recordStepCompletion(completion.stepId, {
-              toolCallId: completion.toolCallId,
-              metadata,
-              at: completion.completedAt,
-            });
+            try {
+              await this.Graph.recordStepCompletion(completion.stepId, {
+                toolCallId: completion.toolCallId,
+                metadata,
+                at: completion.completedAt,
+              });
+            } catch (_e) {
+              /** Never mask the handler's error with a closure failure */
+            }
           }
         }
       }

package/src/tools/subagent/SubagentExecutor.ts

@@ -87,7 +87,6 @@ import type {
 import type { GraphFactory } from '@/graphs/graphFactory';
 import type { StandardGraph } from '@/graphs/Graph';
 import type { HandlerRegistry } from '@/events';
-import { stripRunStepResumeState } from '@/tools/runStepResume';
 import {
   getSubagentApprovalExecutionScope,
   SubagentDefinitionBindingError,
@@ -125,6 +124,7 @@ import {
   createChildGraphPlan,
   isGraphSubagentConfig,
 } from './childGraphConfig';
+import { stripRunStepResumeState } from '@/tools/runStepResume';
 import { seedAgentInitialSessions } from '@/utils/toolSessions';
 import { stableStringify } from '@/tools/eagerEventExecution';
 import { composeAbortSignals } from '@/utils/misc';
@@ -2450,6 +2450,18 @@ export class SubagentExecutor {
     } catch (error) {
       /** Stamped at failure, not after the error-envelope work below. */
       const childTerminalAt = Date.now();
+      /**
+       * Captured at catch entry, BEFORE the self-abort below flips it. The
+       * closure sweep distinguishes "stopped on purpose" from "died of this
+       * error" by whether the child was already aborted when the error
+       * arrived — reading the signal after `childBreaker.abort(error)` would
+       * relabel the child's own stream-limit failure as an intentional stop
+       * (`cancelled`), while the parent stamps `failed` for the same
+       * incident. A trip that arrived from a parallel sibling has already
+       * aborted the composed signal by this point, so it still reads as
+       * `cancelled` here.
+       */
+      const abortedBeforeError = childSignal.aborted;
       if (isGraphInterrupt(error)) {
         const activeChildRun = execution.activeRun;
         if (activeChildRun != null) {
@@ -2488,11 +2500,13 @@ export class SubagentExecutor {
       /**
        * `cancelled` vs `failed` mirrors `Run.resolveSweepStatus`: an aborted
        * child was stopped on purpose (caller abort, or a breaker trip from a
-       * parallel sibling), anything else died of an unexpected error.
+       * parallel sibling), anything else died of an unexpected error. Uses
+       * the pre-error snapshot, not the live signal — the self-abort above
+       * has already tripped it for the child's own limit error.
        */
       await this.closeChildRunSteps(
         childGraph,
-        childSignal.aborted ? 'cancelled' : 'failed',
+        abortedBeforeError ? 'cancelled' : 'failed',
         childTerminalAt
       );
       if (forwarding) {