@librechat/agents 3.8.4 → 3.8.6

package/src/graphs/Graph.ts

@@ -133,10 +133,18 @@ import {
   annotateMessagesForLLM,
   ToolOutputReferenceRegistry,
 } from '@/tools/toolOutputReferences';
+import {
+  prepareProviderRequest,
+  usesNativeOpenAIResponses,
+} from '@/llm/prepareProviderRequest';
 import {
   resolveLangfuseRuntimeScope,
   withLangfuseRuntimeScope,
 } from '@/langfuseRuntimeScope';
+import {
+  ManualSummarizationSkippedError,
+  shouldTriggerSummarization,
+} from '@/summarization';
 import {
   getToolContentCharLength,
   serializeToolContentBounded,
@@ -150,6 +158,11 @@ import {
   PreparedSubagents,
   PreparedSubagentError,
 } from '@/tools/preparedSubagents';
+import {
+  createRemoveAllMessage,
+  messagesStateReducer,
+} from '@/messages/reducer';
+import { createToolHistoryPreparation } from '@/messages/toolHistoryProjection';
 import { ToolNode as CustomToolNode, toolsCondition } from '@/tools/ToolNode';
 import { shouldTraceToolNodeForLangfuse } from '@/langfuseToolOutputTracing';
 import { createLocalCodingToolBundle } from '@/tools/local/LocalCodingTools';
@@ -157,29 +170,16 @@ import { SUBAGENT_REPLAY_CONTROLLER } from '@/tools/subagent/SubagentReplay';
 import { applyGraphRuntimeConfig } from '@/graphs/applyGraphRuntimeConfig';
 import { isFadingTier, isInformativeFadingTier } from '@/messages/fading';
 import { createContextPressureMeter } from '@/llm/contextPressureMeter';
-import { createToolHistoryPreparation } from '@/messages/toolHistoryProjection';
 import { safeDispatchCustomEvent, emitAgentLog } from '@/utils/events';
-import {
-  prepareProviderRequest,
-  usesNativeOpenAIResponses,
-} from '@/llm/prepareProviderRequest';
 import { createCloudflareCodingToolBundle } from '@/tools/cloudflare';
 import { calculateMaxToolCallInputChars } from '@/utils/truncation';
 import { prepareToolsForPromptCache } from '@/llm/promptCacheTools';
 import { providerRequiresStrictAlternation } from '@/llm/providers';
 import { buildSubagentToolParams } from '@/tools/SubagentTool';
 import { initializeLangfuseTracing } from '@/instrumentation';
-import {
-  ManualSummarizationSkippedError,
-  shouldTriggerSummarization,
-} from '@/summarization';
 import { isRunStepResumeState } from '@/tools/runStepResume';
 import { resolveLocalToolsForBinding } from '@/tools/local';
 import { createSummarizeNode } from '@/summarization/node';
-import {
-  createRemoveAllMessage,
-  messagesStateReducer,
-} from '@/messages/reducer';
 import { getTruncationStopReason } from '@/llm/truncation';
 import { createSchemaOnlyTools } from '@/tools/schema';
 import { AgentContext } from '@/agents/AgentContext';
@@ -1356,7 +1356,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   /** See {@link t.StandardGraphInput.subagentTasks}. */
   subagentTasks: t.SubagentTaskConfig | undefined;
   /** See {@link t.StandardGraphInput.subagentExecutionContext}. */
-  private readonly subagentExecutionContext?: t.SubagentExecutionContext;
+  readonly subagentExecutionContext?: t.SubagentExecutionContext;
+  private readonly subagentContext?: t.SubagentContextAdapter;
   /** See {@link t.StandardGraphInput.preemption}. */
   preemption?: t.StreamPreemption;
   /**
@@ -1534,6 +1535,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       subagentTasks,
       subagentScope,
       subagentExecutionContext,
+      subagentContext,
       preemption,
       streamLimits,
       toolExecution,
@@ -1560,6 +1562,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     this.subagentTasks = subagentTasks;
     this.subagentScope = subagentScope === true;
     this.subagentExecutionContext = subagentExecutionContext;
+    this.subagentContext = subagentContext;
     this.preemption = preemption;
     this.streamLimits = resolveStreamLimits(streamLimits);
     this.toolExecution = toolExecution;
@@ -2881,6 +2884,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         // run_id); `executingAgentId` always identifies the owning agent.
         agentId: this.subagentScope ? agentContext?.agentId : undefined,
         executingAgentId: agentContext?.agentId,
+        executionContext: this.subagentExecutionContext,
         executingAgentName: agentContext?.name,
         rootAgentId: this.defaultAgentId,
         rootAgentName: this.agentContexts.get(this.defaultAgentId)?.name,
@@ -2965,6 +2969,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       // hooks can attribute the batch even at the top level.
       agentId: this.subagentScope ? agentContext?.agentId : undefined,
       executingAgentId: agentContext?.agentId,
+      executionContext: this.subagentExecutionContext,
       executingAgentName: agentContext?.name,
       rootAgentId: this.defaultAgentId,
       rootAgentName: this.agentContexts.get(this.defaultAgentId)?.name,
@@ -4627,7 +4632,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
                       fallbackProvider,
                       fallbackClientOptions
                     );
-                    let projection: ReturnType<typeof measureProviderPayload> | undefined;
+                    let projection:
+                      | ReturnType<typeof measureProviderPayload>
+                      | undefined;
                     const request = prepareProviderRequest({
                       model: fallbackModel,
                       messages: cached,
@@ -4644,7 +4651,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
                       },
                     });
                     if (projection == null) {
-                      throw new Error('Fallback preparation did not measure its payload');
+                      throw new Error(
+                        'Fallback preparation did not measure its payload'
+                      );
                     }
                     return { request, projection };
                   };
@@ -4664,8 +4673,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
                   if (!projection.fits) {
                     const compacted = compactSyntheticProviderContext(
                       servingFallbackMessages,
-                      (candidate) =>
-                        prepareFallback(candidate).projection
+                      (candidate) => prepareFallback(candidate).projection
                     );
                     if (compacted !== servingFallbackMessages) {
                       preparedFallbackRequest = prepareFallback(compacted);
@@ -5025,6 +5033,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         runId,
         threadId: configurable?.thread_id as string | undefined,
         agentId: this.subagentScope ? agentId : undefined,
+        executionContext: this.subagentExecutionContext,
         executingAgentId: agentId,
         sealCount: this.preemptSealCount,
       },
@@ -5247,6 +5256,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
           tokenCounter: agentContext.tokenCounter,
           usageSink: this.subagentUsageSink,
           taskConfig: this.subagentTasks,
+          subagentContext: this.subagentContext,
           streamLimits: this.streamLimits,
           humanInTheLoop: this.humanInTheLoop,
           checkpointer: this.compileOptions?.checkpointer,
@@ -5343,6 +5353,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
               });
             }
             const result = await executor.execute(executeParams);
+            if (result.retryableDelivery === true) {
+              throw new Error(result.content);
+            }
             return result.content;
           },
           buildSubagentToolParams(executableConfigs, {
@@ -5527,6 +5540,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
             },
             runId: this.runId,
             isMultiAgent: this.isMultiAgentGraph(),
+            getSubagentExecutionContext: () => this.subagentExecutionContext,
             hookRegistry: this.hookRegistry,
             getToolsForBinding: (
               provider: t.ProviderName,

package/src/hooks/types.ts

@@ -1,5 +1,6 @@
 // src/hooks/types.ts
 import type { BaseMessage } from '@langchain/core/messages';
+import type { SubagentExecutionContext } from '@/types/graph';
 import type { InjectedMessage } from '@/types/tools';
 
 /**
@@ -57,6 +58,8 @@ export type StopDecision = 'continue' | 'block';
  *   hook to a specific agent regardless of subagent scope.
  */
 export interface BaseHookInput {
+  /** SDK-owned child lineage, including distinct identities for concurrent self-spawns. */
+  executionContext?: SubagentExecutionContext;
   runId: string;
   threadId?: string;
   agentId?: string;

package/src/run.ts

@@ -37,11 +37,6 @@ import {
   DEFAULT_MAX_STOP_CONTINUATIONS,
   DEFAULT_RECURSION_LIMIT,
 } from '@/common';
-import {
-  requireValidSubagentResumeManifest,
-  SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY,
-  SUBAGENT_RESUME_MANIFEST_CONFIG_KEY,
-} from '@/tools/subagent/SubagentReplay';
 import {
   ACTIVITY_PHASE_LABEL_PROMPT,
   ACTIVITY_LABEL_PROMPT,
@@ -57,12 +52,23 @@ import {
   isLangfuseCallbackHandler,
   withLangfuseAttributes,
 } from '@/langfuse';
+import {
+  requireValidSubagentResumeManifest,
+  SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY,
+  SUBAGENT_RESUME_MANIFEST_CONFIG_KEY,
+} from '@/tools/subagent/SubagentReplay';
 import {
   REASONING_LABEL_PROMPT,
   buildReasoningLabelTraceSeed,
   buildReasoningLabelPrompt,
   normalizeReasoningLabel,
 } from '@/prompts/reasoningLabel';
+import {
+  TOOL_BATCH_REPLAY_KEY,
+  restoreToolReplayConfig,
+  stripToolBatchReplayState,
+  getPublicToolInterruptPayload,
+} from '@/tools/toolBatchReplay';
 import {
   hasToolOutputTracingConfig,
   resolveLangfuseConfig,
@@ -72,12 +78,6 @@ import {
   cloneToolApprovalInterruptPayload,
   TOOL_APPROVAL_REVIEW_CONFIG_KEY,
 } from '@/hitl/approvalReview';
-import {
-  TOOL_BATCH_REPLAY_KEY,
-  restoreToolReplayConfig,
-  stripToolBatchReplayState,
-  getPublicToolInterruptPayload,
-} from '@/tools/toolBatchReplay';
 import {
   resolveLangfuseDestinationKey,
   resolveLangfuseTraceAnchorParent,
@@ -474,6 +474,7 @@ export class Run<_T extends t.BaseGraphState> {
   private maxStopContinuations: number;
   private streamLimits?: t.StreamLimits;
   private subagentTasks?: t.SubagentTaskConfig;
+  private subagentContext?: t.SubagentContextAdapter;
   private indexTokenCountMap?: Record<string, number>;
   calibrationRatio: number = 1;
   fadingTier?: t.FadingTier;
@@ -556,6 +557,7 @@ export class Run<_T extends t.BaseGraphState> {
     this.toolExecution = config.toolExecution;
     this.subagentUsageSink = config.subagentUsageSink;
     this.subagentTasks = config.subagentTasks;
+    this.subagentContext = config.subagentContext;
     this.preemption = config.preemption;
     this.maxStopContinuations = resolveMaxStopContinuations(
       config.maxStopContinuations
@@ -654,6 +656,7 @@ export class Run<_T extends t.BaseGraphState> {
         fadingTiers: this.fadingTiers,
         subagentUsageSink: this.subagentUsageSink,
         subagentTasks: this.subagentTasks,
+        subagentContext: this.subagentContext,
         preemption: this.preemption,
         streamLimits: this.streamLimits,
         toolExecution: this.toolExecution,
@@ -696,6 +699,7 @@ export class Run<_T extends t.BaseGraphState> {
         fadingTiers: this.fadingTiers,
         subagentUsageSink: this.subagentUsageSink,
         subagentTasks: this.subagentTasks,
+        subagentContext: this.subagentContext,
         preemption: this.preemption,
         streamLimits: this.streamLimits,
         toolExecution: this.toolExecution,
@@ -1283,7 +1287,11 @@ export class Run<_T extends t.BaseGraphState> {
       );
       const publicPayload = stripRunStepResumeState(this._interrupt?.payload);
       if (config.configurable != null) {
-        restoreToolReplayConfig(config.configurable, this._interrupt?.interruptId, publicPayload);
+        restoreToolReplayConfig(
+          config.configurable,
+          this._interrupt?.interruptId,
+          publicPayload
+        );
       }
       if (graph.getStopContinuationExecutionId() === '') {
         graph.startStopContinuationExecution(nanoid());
@@ -2015,8 +2023,11 @@ export class Run<_T extends t.BaseGraphState> {
     await this.restoreInterruptFromCheckpoint(callerConfig, resumeUpdate);
     const interrupt = this._interrupt;
     const replayPayload = stripRunStepResumeState(interrupt?.payload);
-    const resumeManifest = requireValidSubagentResumeManifest(replayPayload) ??
-      requireValidSubagentResumeManifest(stripToolBatchReplayState(replayPayload));
+    const resumeManifest =
+      requireValidSubagentResumeManifest(replayPayload) ??
+      requireValidSubagentResumeManifest(
+        stripToolBatchReplayState(replayPayload)
+      );
     const resumeConfigurable = { ...callerConfig.configurable };
     delete resumeConfigurable[TOOL_APPROVAL_REVIEW_CONFIG_KEY];
     delete resumeConfigurable[TOOL_BATCH_REPLAY_KEY];
@@ -2027,7 +2038,11 @@ export class Run<_T extends t.BaseGraphState> {
       resumeConfigurable[SUBAGENT_RESUME_MANIFEST_CONFIG_KEY] = resumeManifest;
     }
     const publicPayload = stripRunStepResumeState(interrupt?.payload);
-    restoreToolReplayConfig(resumeConfigurable, interrupt?.interruptId, publicPayload);
+    restoreToolReplayConfig(
+      resumeConfigurable,
+      interrupt?.interruptId,
+      publicPayload
+    );
     const manifestConfig = {
       ...callerConfig,
       configurable: resumeConfigurable,

package/src/stream.ts

@@ -805,6 +805,21 @@ function startEagerToolExecutions(args: {
     return;
   }
 
+  const codeSessionBaselineById = new Map(
+    entries.map((entry) => [
+      entry.id,
+      new Map(
+        (entry.request.codeSessionContext?.files ?? []).map((file) => [
+          file.name,
+          `${file.storage_session_id}\0${file.id}`,
+        ])
+      ),
+    ])
+  );
+  for (const entry of entries) {
+    entry.request.codeSessionBaselineId =
+      entry.request.codeSessionContext?.session_id;
+  }
   const records: t.EagerEventToolExecution[] = [];
   const promise: Promise<t.EagerEventToolExecutionOutcome> = new Promise<
     t.ToolExecuteResult[]
@@ -818,6 +833,7 @@ function startEagerToolExecutions(args: {
       }
     };
     const batchRequest: t.ToolExecuteBatchRequest = {
+      executionContext: graph.subagentExecutionContext,
       toolCalls: entries.map((entry) => entry.request),
       userId: graph.config?.configurable?.user_id as string | undefined,
       agentId: agentContext?.agentId,
@@ -826,10 +842,14 @@ function startEagerToolExecutions(args: {
           | Partial<Pick<AgentContext, 'getCallerCapabilityProjectionSnapshot'>>
           | undefined
       )?.getCallerCapabilityProjectionSnapshot?.(),
-      configurable: graph.config?.configurable as
-        | Record<string, unknown>
-        | undefined,
-      metadata,
+      configurable: {
+        ...graph.config?.configurable,
+        executionContext: graph.subagentExecutionContext,
+      },
+      metadata: {
+        ...metadata,
+        executionContext: graph.subagentExecutionContext,
+      },
       signal: composeAbortSignals(
         graph.config?.signal,
         graph.breakerAbort.signal
@@ -873,6 +893,7 @@ function startEagerToolExecutions(args: {
       toolName: entry.toolName,
       args: entry.coercedArgs,
       request: entry.request,
+      codeSessionBaselineByName: codeSessionBaselineById.get(entry.id),
       promise,
     };
     records.push(record);
@@ -1653,7 +1674,8 @@ export class ChatModelStreamHandler implements t.EventHandler {
       if (
         eventBreaker != null &&
         eventBreaker.signal.aborted &&
-        (eventBreaker.signal.reason instanceof StreamLimitExceededError || eventBreaker.signal.reason instanceof PreparedSubagentError)
+        (eventBreaker.signal.reason instanceof StreamLimitExceededError ||
+          eventBreaker.signal.reason instanceof PreparedSubagentError)
       ) {
         throw eventBreaker.signal.reason;
       }

package/src/summarization/node.ts

@@ -924,6 +924,7 @@ async function dispatchCompletionEvents(params: {
         runId: sessionId,
         threadId,
         agentId,
+        executionContext: graph.getSubagentExecutionContext?.(),
         summary: summaryText,
         messagesAfterCount,
       },
@@ -948,6 +949,7 @@ interface CreateSummarizeNodeParams {
     config?: RunnableConfig;
     runId?: string;
     isMultiAgent: boolean;
+    getSubagentExecutionContext?: () => t.SubagentExecutionContext | undefined;
     hookRegistry?: HookRegistry;
     getToolsForBinding?: (
       provider: t.ProviderName,
@@ -1331,6 +1333,7 @@ export function createSummarizeNode({
           runId: sessionId,
           threadId,
           agentId: request.agentId,
+          executionContext: graph.getSubagentExecutionContext?.(),
           messagesBeforeCount: messagesToRefine.length,
           trigger:
             request.reason === 'manual'