@librechat/agents 3.8.4 → 3.8.6

package/src/tools/local/LocalProgrammaticToolCalling.ts

@@ -214,6 +214,7 @@ export async function applyPreToolUseHooksForBridge(
       runId: hookContext.runId,
       threadId: hookContext.threadId,
       agentId: hookContext.agentId,
+      executionContext: hookContext.executionContext,
       executingAgentId: hookContext.executingAgentId,
       toolName,
       toolInput,

package/src/tools/subagent/SubagentExecutionRegistry.ts

@@ -783,7 +783,6 @@ export class SubagentExecutionRecord<
     this.transitionTo('completed', ['active']);
     this.completedValue = true;
     this.completedResultValue = result;
-    this.resolvedConfigValue = undefined;
   }
 
   releaseActiveRun(): TActiveRun | undefined {

package/src/tools/subagent/SubagentExecutor.ts

@@ -52,6 +52,10 @@ import type {
   ResolvedSubagentConfig,
   ResolvedSubagentConfigEntry,
   SubagentExecutionContext,
+  SubagentContextAdapter,
+  SubagentContextInput,
+  SubagentContextResult,
+  PreparedSubagentContext,
   SubagentTaskConfig,
   SubagentTaskRuntime,
   SubagentResolveConfigurable,
@@ -88,11 +92,6 @@ import type {
   ToolApprovalReplaySnapshot,
 } from '@/hooks';
 import type { GraphFactory } from '@/graphs/graphFactory';
-import {
-  rebindToolBatchReplayScope,
-  rebindToolBatchReplayPayload,
-  restoreToolReplayConfig,
-} from '@/tools/toolBatchReplay';
 import type { StandardGraph } from '@/graphs/Graph';
 import {
   getSubagentApprovalExecutionScope,
@@ -108,6 +107,11 @@ import {
   SUBAGENT_RESUME_ATTEMPT_CONFIG_KEY,
   SUBAGENT_RESUME_MANIFEST_CONFIG_KEY,
 } from './SubagentReplay';
+import {
+  rebindToolBatchReplayScope,
+  rebindToolBatchReplayPayload,
+  restoreToolReplayConfig,
+} from '@/tools/toolBatchReplay';
 import {
   executeHooks,
   HookRegistry,
@@ -138,6 +142,7 @@ import { stableStringify } from '@/tools/eagerEventExecution';
 import { convertInjectedMessages } from '@/messages/injected';
 import { resolveClientOptionsModel } from '@/llm/request';
 import { composeAbortSignals } from '@/utils/misc';
+import { sleep } from '@/utils/run';
 import { HandlerRegistry } from '@/events';
 
 export {
@@ -168,6 +173,31 @@ function seedChildGraphSessions(
   seedAgentInitialSessions(childGraph.sessions, agents);
 }
 
+async function awaitWithAbort<T>(
+  promise: Promise<T>,
+  signal: AbortSignal
+): Promise<T> {
+  signal.throwIfAborted();
+  let onAbort: (() => void) | undefined;
+  const aborted = new Promise<never>((_resolve, reject) => {
+    onAbort = (): void => {
+      reject(
+        signal.reason instanceof Error
+          ? signal.reason
+          : new Error('Detached subagent task cancelled.')
+      );
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([promise, aborted]);
+  } finally {
+    if (onAbort != null) {
+      signal.removeEventListener('abort', onAbort);
+    }
+  }
+}
+
 async function dispatchObservationalSubagentUpdate(
   handler: EventHandler,
   event: SubagentUpdateEvent
@@ -831,11 +861,11 @@ export type SubagentExecuteParams = {
   initialMessages?: BaseMessage[];
 };
 
-export type SubagentExecuteResult = {
-  content: string;
-  messages: BaseMessage[];
+export type SubagentExecuteResult = SubagentContextResult & {
   /** Tagged internal failure; foreground callers retain the legacy content. */
   error?: string;
+  /** Completed child work whose host projection must be retried without re-execution. */
+  retryableDelivery?: true;
 };
 
 function createSubagentFailure(
@@ -931,6 +961,7 @@ export type SubagentExecutorOptions = {
   usageSink?: SubagentUsageSink;
   /** Host-owned process-local task namespace for detached execution. */
   taskConfig?: SubagentTaskConfig;
+  subagentContext?: SubagentContextAdapter;
 };
 
 type DurableExecutionRecord = SubagentExecutionRecord<
@@ -968,6 +999,7 @@ export class SubagentExecutor {
   ) => GraphFactory;
   private readonly usageSink?: SubagentUsageSink;
   private readonly taskConfig?: SubagentTaskConfig;
+  private readonly subagentContext?: SubagentContextAdapter;
   private readonly executions: SubagentExecutionRegistry<
     SubagentExecuteResult,
     ResolvedSubagentConfig,
@@ -1012,6 +1044,7 @@ export class SubagentExecutor {
       options.createDetachedChildGraphFactory;
     this.usageSink = options.usageSink;
     this.taskConfig = options.taskConfig;
+    this.subagentContext = options.subagentContext;
     const rawRegistry = options.parentHandlerRegistry;
     if (typeof rawRegistry === 'function') {
       this.resolveParentHandlerRegistry = rawRegistry;
@@ -1257,6 +1290,7 @@ export class SubagentExecutor {
       langfuse: this.langfuse,
       tokenCounter: this.tokenCounter,
       usageSink: this.usageSink,
+      subagentContext: this.subagentContext,
       streamLimits: this.streamLimits,
       maxDepth: this.maxDepth,
       createChildGraph:
@@ -1268,21 +1302,38 @@ export class SubagentExecutor {
         detachedGraphFactory ?? this.createChildGraphByKind,
     });
     try {
-      const result = await detached.execute({
-        ...params,
-        signal: undefined,
-        breaker: undefined,
-        hookSessionId: taskHookSessionId,
-        taskRuntime: runtime,
-        parentConfigurable: {
-          ...params.parentConfigurable,
-          run_id: taskHookSessionId,
-        },
-      });
-      if (runtime.signal.aborted) {
-        throw runtime.signal.reason instanceof Error
-          ? runtime.signal.reason
-          : new Error('Detached subagent task cancelled.');
+      const executeAttempt = async (): Promise<SubagentExecuteResult> => {
+        const result = await detached.execute({
+          ...params,
+          signal: undefined,
+          breaker: undefined,
+          hookSessionId: taskHookSessionId,
+          taskRuntime: runtime,
+          parentConfigurable: {
+            ...params.parentConfigurable,
+            run_id: taskHookSessionId,
+          },
+        });
+        if (runtime.signal.aborted) {
+          throw runtime.signal.reason instanceof Error
+            ? runtime.signal.reason
+            : new Error('Detached subagent task cancelled.');
+        }
+        return result;
+      };
+      let deliveryAttempts = 1;
+      let result = await executeAttempt();
+      while (
+        result.retryableDelivery === true &&
+        deliveryAttempts < 3
+      ) {
+        if (deliveryAttempts > 1) {
+          await sleep(
+            Math.min(100 * 2 ** Math.min(deliveryAttempts - 2, 6), 5_000)
+          );
+        }
+        deliveryAttempts += 1;
+        result = await executeAttempt();
       }
       if (result.error != null) {
         throw new Error(result.error);
@@ -1454,7 +1505,10 @@ export class SubagentExecutor {
         resumeExecution.checkpoints,
         branchChildThreadId,
         lease,
-        { source: resumeExecution.approvalExecutionScope, target: approvalExecutionScope }
+        {
+          source: resumeExecution.approvalExecutionScope,
+          target: approvalExecutionScope,
+        }
       );
       let previousApprovals: ToolApprovalReplaySnapshot[] = [];
       let approvalsMutated = false;
@@ -1765,11 +1819,20 @@ export class SubagentExecutor {
           }
           /** Repeated unconsumed forks must persist their current owner. */
           const reboundValue =
-            channel === INTERRUPT && approvalScope != null &&
-            value != null && typeof value === 'object' && 'value' in value
-              ? { ...value, value: rebindToolBatchReplayPayload(
-                value.value, approvalScope.source, approvalScope.target
-              ) }
+            channel === INTERRUPT &&
+            approvalScope != null &&
+            value != null &&
+            typeof value === 'object' &&
+            'value' in value
+              ? {
+                ...value,
+                value: rebindToolBatchReplayPayload(
+                  value.value,
+                  approvalScope.source,
+                  approvalScope.target,
+                  targetThreadId
+                ),
+              }
               : value;
           writes.push([channel, reboundValue]);
         }
@@ -2114,6 +2177,9 @@ export class SubagentExecutor {
     ) {
       return;
     }
+    if (settled.output.status === 'error' && config.signal?.aborted === true) {
+      return;
+    }
     const parentConfigurable = config.configurable as
       | Record<string, unknown>
       | undefined;
@@ -2123,6 +2189,9 @@ export class SubagentExecutor {
       parentToolCallId,
       parentConfigurable,
     });
+    if (execution.completedResult != null && settled.output.status === 'error') {
+      return;
+    }
     const { resumeExecution } = execution;
     const resolvedSubagentType = getSubagentTypeFromArgs(settled.resolvedArgs);
     const resolvedDescription = getSubagentDescriptionFromArgs(
@@ -2383,11 +2452,6 @@ export class SubagentExecutor {
     if (!bound) {
       return createSubagentFailure(SUBAGENT_CONFIG_CHANGED_MESSAGE);
     }
-    const completedChildResult = execution.completedResult;
-    if (completedChildResult != null) {
-      return completedChildResult;
-    }
-
     let config: ResolvedSubagentConfigEntry;
     try {
       config = await this.resolveExecutionConfig(executableConfig, execution, {
@@ -2447,6 +2511,63 @@ export class SubagentExecutor {
         },
       ],
     };
+    const hostContextInput: SubagentContextInput = {
+      executionContext: childExecutionContext,
+      parentThreadId: threadId,
+      memberAgentIds: childPlan.agents.map((agent) => agent.agentId),
+      signal: childSignal,
+      resumed: execution.started || resumeExecution != null,
+    };
+    let preparedContext: PreparedSubagentContext | undefined;
+    try {
+      preparedContext =
+        this.subagentContext?.prepare == null
+          ? undefined
+          : await awaitWithAbort(
+            Promise.resolve(this.subagentContext.prepare(hostContextInput)),
+            childSignal
+          );
+      execution.assertUsable(childSignal);
+      for (const [agentId, sessions] of Object.entries(
+        preparedContext?.agentSessions ?? {}
+      )) {
+        const member = childPlan.memberInputs.get(agentId);
+        if (member == null) throw new Error('Unknown subagent context member.');
+        const activeMember =
+          execution.activeRun?.graph.agentContexts.get(agentId);
+        if (
+          activeMember != null &&
+          activeMember.codeSessionKey !== sessions.codeSessionKey
+        ) {
+          throw new Error(
+            'Subagent session partition changed during execution.'
+          );
+        }
+        member.codeSessionKey = sessions.codeSessionKey;
+        member.initialSessions = sessions.initialSessions;
+      }
+    } catch (error) {
+      if (childSignal.aborted) {
+        throw childSignal.reason instanceof Error
+          ? childSignal.reason
+          : error;
+      }
+      if (execution.completedResult != null) {
+        return {
+          ...createSubagentFailure(
+            'Subagent context is unavailable or access was denied.'
+          ),
+          retryableDelivery: true,
+        };
+      }
+      return createSubagentFailure(
+        'Subagent context is unavailable or access was denied.'
+      );
+    }
+    const completedChildResult = execution.completedResult;
+    if (completedChildResult != null) {
+      return this.completeHostContext(hostContextInput, completedChildResult);
+    }
     const maxTurns = config.maxTurns ?? DEFAULT_SUBAGENT_MAX_TURNS;
     const memberRecursionLimit = maxTurns * SUBAGENT_RECURSION_MULTIPLIER;
     const recursionLimit =
@@ -2473,6 +2594,7 @@ export class SubagentExecutor {
       streamLimits: this.streamLimits,
       subagentScope: true,
       subagentExecutionContext: childExecutionContext,
+      subagentContext: this.subagentContext,
       ...(resumeExecution?.graphState.fadingTier == null
         ? {}
         : { fadingTier: resumeExecution.graphState.fadingTier }),
@@ -2519,9 +2641,7 @@ export class SubagentExecutor {
     if (params.taskRuntime != null) {
       childGraph.hookRegistry = this.hookRegistry;
     }
-    if (cachedChildRun == null) {
-      seedChildGraphSessions(childGraph, childPlan.agents);
-    }
+    seedChildGraphSessions(childGraph, childPlan.agents);
     let forwarding: ForwarderCallback | undefined;
     if (forwardingEnabled) {
       forwarding = this.createForwarderCallback({
@@ -2623,6 +2743,8 @@ export class SubagentExecutor {
       }
       const childConfigurable: Record<string, unknown> = {
         ...inheritedConfigurable,
+        ...sanitizePreparedConfigurable(preparedContext?.configurable),
+        executionContext: childExecutionContext,
       };
       if (this.humanInTheLoop?.enabled === true) {
         childConfigurable[TOOL_APPROVAL_EXECUTION_SCOPE_CONFIG_KEY] =
@@ -2663,11 +2785,18 @@ export class SubagentExecutor {
         }
         const persistedInterrupts = getPersistedInterrupts(persistedState);
         if (persistedInterrupts.length > 0) {
-          activeChildRun.pendingInterrupts = resumeExecution == null ? persistedInterrupts :
-            persistedInterrupts.map((pending) => ({
-              ...pending,
-              value: rebindToolBatchReplayPayload(pending.value, resumeExecution.approvalExecutionScope, approvalExecutionScope),
-            }));
+          activeChildRun.pendingInterrupts =
+            resumeExecution == null
+              ? persistedInterrupts
+              : persistedInterrupts.map((pending) => ({
+                ...pending,
+                value: rebindToolBatchReplayPayload(
+                  pending.value,
+                  resumeExecution.approvalExecutionScope,
+                  approvalExecutionScope,
+                  childThreadId
+                ),
+              }));
           execution.markStarted();
           childAlreadyStarted = true;
         } else if (persistedState.next.length > 0) {
@@ -2702,14 +2831,18 @@ export class SubagentExecutor {
         }
         let childInput: BaseGraphState | Command | null;
         if (childResumeMap != null) {
-          const pending = activeChildRun.pendingInterrupts.find((entry) =>
-            entry.id != null && Object.prototype.hasOwnProperty.call(childResumeMap, entry.id)
-          ) ?? activeChildRun.pendingInterrupts[0];
+          const pending =
+            activeChildRun.pendingInterrupts.find(
+              (entry) =>
+                entry.id != null &&
+                Object.prototype.hasOwnProperty.call(childResumeMap, entry.id)
+            ) ?? activeChildRun.pendingInterrupts[0];
           restoreToolReplayConfig(childConfigurable, pending.id, pending.value);
           rebindToolBatchReplayScope(
             childConfigurable,
             resumeExecution?.approvalExecutionScope ?? approvalExecutionScope,
-            approvalExecutionScope
+            approvalExecutionScope,
+            childThreadId
           );
           childInput = new Command({ resume: childResumeMap });
         } else if (recoveredInProgress) {
@@ -2725,6 +2858,7 @@ export class SubagentExecutor {
                   [SUBAGENT_RUN_ID_KEY]: childRunId,
                 },
               }),
+              ...(preparedContext?.messages ?? []),
             ],
           };
         }
@@ -2740,6 +2874,7 @@ export class SubagentExecutor {
             registry: this.hookRegistry,
             input: {
               hook_event_name: 'SubagentStart',
+              executionContext: childExecutionContext,
               runId: currentHookSessionId,
               threadId,
               parentAgentId: this.parentAgentId,
@@ -2946,6 +3081,7 @@ export class SubagentExecutor {
         registry: this.hookRegistry,
         input: {
           hook_event_name: 'SubagentStop',
+          executionContext: childExecutionContext,
           runId: currentHookSessionId,
           threadId,
           agentId: childAgentId,
@@ -2988,12 +3124,33 @@ export class SubagentExecutor {
 
     this.clearChildGraph(childGraph);
 
-    const completedResult = {
+    const completedResult: SubagentExecuteResult = {
       content: filteredContent,
       messages: result.messages,
     };
     execution.markCompleted(completedResult);
-    return completedResult;
+    return this.completeHostContext(hostContextInput, completedResult);
+  }
+
+  private async completeHostContext(
+    input: SubagentContextInput,
+    result: SubagentExecuteResult
+  ): Promise<SubagentExecuteResult> {
+    if (this.subagentContext?.complete == null) return result;
+    try {
+      input.signal.throwIfAborted();
+      const completed = await awaitWithAbort(
+        this.subagentContext.complete(input, result),
+        input.signal
+      );
+      input.signal.throwIfAborted();
+      return { ...result, content: completed.content };
+    } catch {
+      return {
+        ...createSubagentFailure('Subagent result delivery failed.'),
+        retryableDelivery: true,
+      };
+    }
   }
 
   /**
@@ -3526,6 +3683,17 @@ function sanitizeChildConfigurable(
   );
 }
 
+function sanitizePreparedConfigurable(
+  configurable: RunnableConfig['configurable']
+): Record<string, unknown> {
+  const prepared = sanitizeChildConfigurable(configurable);
+  delete prepared.run_id;
+  delete prepared.parent_run_id;
+  delete prepared.thread_id;
+  delete prepared.executionContext;
+  return prepared;
+}
+
 function isLangGraphRuntimeConfigKey(key: string): boolean {
   return (
     key.startsWith(LANGGRAPH_RUNTIME_CONFIG_PREFIX) ||

package/src/tools/toolBatchReplay.ts

@@ -46,6 +46,8 @@ export interface ToolBatchReplayRecord {
   referenceState?: ToolOutputReferenceState;
 }
 
+export type ToolReplayResumeStatus = 'active' | 'stale' | 'unverifiable';
+
 interface ToolBatchReplayState {
   version: 1;
   approvalOwner?: string;
@@ -62,6 +64,44 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return value != null && typeof value === 'object' && !Array.isArray(value);
 }
 
+function bindLegacyReplayOwner(
+  owner: string,
+  configurable: Record<string, unknown>
+): string {
+  let identity: unknown;
+  try {
+    identity = JSON.parse(owner);
+  } catch {
+    return owner;
+  }
+  if (!Array.isArray(identity) || identity.length !== 3) {
+    return owner;
+  }
+  return JSON.stringify([
+    ...identity,
+    typeof configurable.user_id === 'string' ? configurable.user_id : '',
+    typeof configurable.thread_id === 'string' ? configurable.thread_id : '',
+  ]);
+}
+
+function bindLegacyReplayState(
+  state: ToolBatchReplayState | undefined,
+  configurable: Record<string, unknown>
+): ToolBatchReplayState | undefined {
+  if (state == null) return undefined;
+  return {
+    ...state,
+    approvalOwner:
+      state.approvalOwner == null
+        ? undefined
+        : bindLegacyReplayOwner(state.approvalOwner, configurable),
+    records: state.records.map((record) => ({
+      ...record,
+      owner: bindLegacyReplayOwner(record.owner, configurable),
+    })),
+  };
+}
+
 /** The only host-to-runtime entry point for checkpoint-owned tool replay state. */
 export function restoreToolReplayConfig(
   configurable: Record<string, unknown>,
@@ -70,7 +110,10 @@ export function restoreToolReplayConfig(
 ): void {
   delete configurable[TOOL_BATCH_REPLAY_KEY];
   delete configurable[TOOL_APPROVAL_REVIEW_CONFIG_KEY];
-  const state = getToolBatchReplayState(payload);
+  const state = bindLegacyReplayState(
+    getToolBatchReplayState(payload),
+    configurable
+  );
   const publicPayload = getPublicToolInterruptPayload(payload);
   const review = createToolApprovalReviewEvidence(
     interruptId,
@@ -95,25 +138,40 @@ export function restoreToolReplayConfig(
  * steps, so the presence of replay evidence alone does not imply a resume.
  * A parent replaying a checkpointed child has no local resume value.
  */
-export function isToolReplayResume(
+export function getToolReplayResumeStatus(
   config: RunnableConfig,
   interruptId: string | undefined,
   isChildReplay: boolean
-): boolean {
-  const resumeMap: object | undefined = config.configurable?.__pregel_resume_map;
-  if (interruptId != null &&
-    resumeMap != null &&
-    !Object.prototype.hasOwnProperty.call(resumeMap, interruptId)) {
-    return false;
+): ToolReplayResumeStatus {
+  const resumeMap: unknown = config.configurable?.__pregel_resume_map;
+  const scratchpad: unknown = config.configurable?.__pregel_scratchpad;
+  if (!isRecord(scratchpad) || !Array.isArray(scratchpad.resume)) {
+    return 'unverifiable';
   }
-  if (isChildReplay && resumeMap != null) {
-    return true;
+  /**
+   * LangGraph supports both an interrupt-id resume map and a task-local
+   * `nullResume` value. The latter is already scoped to the checkpoint task,
+   * so it remains a supported, verifiable resume without a map entry.
+   */
+  if (scratchpad.nullResume !== undefined) {
+    return 'active';
   }
-  const scratchpad: { resume?: { length: number }; nullResume?: unknown } | undefined =
-    config.configurable?.__pregel_scratchpad;
-  return scratchpad == null ||
-    (scratchpad.resume?.length ?? 0) > 0 ||
-    scratchpad.nullResume !== undefined;
+  const hasResume = scratchpad.resume.length > 0;
+  if (!isRecord(resumeMap)) {
+    return hasResume ? 'unverifiable' : 'stale';
+  }
+  if (interruptId == null) {
+    /** Legacy direct graph callers do not restore the ID into replay state. */
+    if (!hasResume) return 'stale';
+    return Object.keys(resumeMap).length === 1 ? 'active' : 'unverifiable';
+  }
+  if (!Object.prototype.hasOwnProperty.call(resumeMap, interruptId)) {
+    return hasResume ? 'unverifiable' : 'stale';
+  }
+  if (isChildReplay) {
+    return 'active';
+  }
+  return hasResume ? 'active' : 'stale';
 }
 
 export function getToolBatchReplayOwner(
@@ -126,9 +184,39 @@ export function getToolBatchReplayOwner(
       ? (config.configurable?.checkpoint_ns ?? '')
       : '',
     agentId,
+    typeof config.configurable?.user_id === 'string'
+      ? config.configurable.user_id
+      : '',
+    typeof config.configurable?.thread_id === 'string'
+      ? config.configurable.thread_id
+      : '',
   ]);
 }
 
+/** Remove stale authorization while retaining only settled results for this batch. */
+export function clearStaleToolApprovalConfig(
+  configurable: Record<string, unknown>,
+  owner: string,
+  batch: string | undefined
+): void {
+  delete configurable[TOOL_APPROVAL_REVIEW_CONFIG_KEY];
+  const state = getToolBatchReplayState(configurable);
+  const records = batch == null
+    ? []
+    : (state?.records.filter(
+      (record) => record.owner === owner && record.batch === batch
+    ) ?? []);
+  if (state == null || records.length === 0) {
+    delete configurable[TOOL_BATCH_REPLAY_KEY];
+    return;
+  }
+  configurable[TOOL_BATCH_REPLAY_KEY] = {
+    version: 1,
+    records,
+    wrappedPayload: state.wrappedPayload,
+  } satisfies ToolBatchReplayState;
+}
+
 export function getToolBatchReplayScope(
   config: RunnableConfig
 ): string | undefined {
@@ -147,7 +235,9 @@ export function isChildToolReplayOwner(
   const manifest = requireValidSubagentResumeManifest(config.configurable);
   if (manifest == null || trustedParentCallIds.size === 0) return false;
   const identity: unknown = JSON.parse(owner);
-  if (!Array.isArray(identity) || identity.length !== 3 || identity[1] !== '') return false;
+  if (!Array.isArray(identity) ||
+    (identity.length !== 3 && identity.length !== 5) ||
+    identity[1] !== '') return false;
   const pending = manifest.executions.filter((execution) => trustedParentCallIds.has(execution.parentToolCallId));
   while (pending.length > 0) {
     const execution = pending.pop()!;
@@ -161,14 +251,19 @@ export function isChildToolReplayOwner(
 export function rebindToolBatchReplayScope(
   configurable: Record<string, unknown>,
   sourceScope: string,
-  destinationScope: string
+  destinationScope: string,
+  destinationThreadId?: string
 ): void {
   const rebind = (key: string): string => {
     const parts: unknown = JSON.parse(key);
     if (!Array.isArray(parts) || parts[0] !== sourceScope) {
       return key;
     }
-    return JSON.stringify([destinationScope, ...parts.slice(1)]);
+    const rebound = [destinationScope, ...parts.slice(1)];
+    if (rebound.length === 5 && destinationThreadId != null) {
+      rebound[4] = destinationThreadId;
+    }
+    return JSON.stringify(rebound);
   };
   const config = { configurable };
   const review = getToolApprovalReviewEvidence(config);
@@ -197,7 +292,8 @@ export function rebindToolBatchReplayScope(
 export function rebindToolBatchReplayPayload(
   payload: unknown,
   sourceScope: string,
-  destinationScope: string
+  destinationScope: string,
+  destinationThreadId?: string
 ): unknown {
   const state = getToolBatchReplayState(payload);
   const value = stripRunStepResumeState(payload);
@@ -205,7 +301,12 @@ export function rebindToolBatchReplayPayload(
     return payload;
   }
   const configurable = { [TOOL_BATCH_REPLAY_KEY]: state };
-  rebindToolBatchReplayScope(configurable, sourceScope, destinationScope);
+  rebindToolBatchReplayScope(
+    configurable,
+    sourceScope,
+    destinationScope,
+    destinationThreadId
+  );
   const rebound = {
     ...value,
     [TOOL_BATCH_REPLAY_KEY]: configurable[TOOL_BATCH_REPLAY_KEY],