⏯️ feat: Enable Graph Subagent Approval and Resume

src/common/constants.ts

@@ -1,6 +1,9 @@
 /** Host context preparation and trusted subagent execution identity are supported. */
 export const SUBAGENT_CONTEXT_VERSION = 1;
 
+/** Foreground graph-subagent approval and durable resume support. */
+export const GRAPH_SUBAGENT_HITL_VERSION = 1;
+
 /**
  * Anthropic direct API tool schema overhead multiplier.
  * Empirically calibrated against real MCP tool sets (29 tools).

src/graphs/__tests__/Graph.subagentResumeState.test.ts

@@ -1,19 +1,20 @@
 import { describe, it, expect } from '@jest/globals';
 import type { SubagentToolNodeResumeState } from '@/tools/subagent/SubagentReplay';
 import { StandardGraph } from '../Graph';
-import { Providers } from '@/common';
+import { Constants, Providers } from '@/common';
 
 type ResumeToolNode = {
   createSubagentResumeState(): SubagentToolNodeResumeState;
   restoreSubagentResumeState(state: SubagentToolNodeResumeState): void;
 };
 
-const makeGraph = (runId: string): StandardGraph =>
+const makeGraph = (runId: string, codeSessionKey?: string): StandardGraph =>
   new StandardGraph({
     runId,
     agents: [
       {
         agentId: 'child-agent',
+        codeSessionKey,
         provider: Providers.OPENAI,
         instructions: 'Test child state restoration.',
       },
@@ -77,4 +78,59 @@ describe('subagent graph resume state', () => {
       new Set(['unstable_search'])
     );
   });
+
+  it('keeps the legacy default partition identity', () => {
+    const implicit = initializeToolNode(makeGraph('implicit'));
+    const explicit = initializeToolNode(
+      makeGraph('explicit', Constants.EXECUTE_CODE)
+    );
+    expect(explicit.createSubagentResumeState().stateKey).toBe(
+      implicit.createSubagentResumeState().stateKey
+    );
+  });
+
+  it.each([undefined, 'partition-B'])(
+    'rejects partition-A restoration into %s before replacing state',
+    (codeSessionKey) => {
+      const source = makeGraph('source', 'partition-A');
+      initializeToolNode(source);
+      source.sessions.set('partition-A', {
+        session_id: 'session-A',
+        lastUpdated: 1,
+      });
+      const target = makeGraph('target', codeSessionKey);
+      initializeToolNode(target);
+      target.sessions.set('sentinel', {
+        session_id: 'unchanged',
+        lastUpdated: 2,
+      });
+      target.toolCallStepIds.set('existing', 'unchanged-step');
+      const before = target.createSubagentResumeState('target-scope');
+      expect(() =>
+        target.restoreSubagentResumeState(
+          source.createSubagentResumeState('source-scope'),
+          'target-scope'
+        )
+      ).toThrow('Cannot restore subagent tool state');
+      expect(target.createSubagentResumeState('target-scope')).toEqual(before);
+    }
+  );
+
+  it('restores an unchanged custom partition', () => {
+    const source = makeGraph('source', 'partition-A');
+    initializeToolNode(source);
+    source.sessions.set('partition-A', {
+      session_id: 'session-A',
+      lastUpdated: 1,
+    });
+    const target = makeGraph('target', 'partition-A');
+    initializeToolNode(target);
+    target.restoreSubagentResumeState(
+      source.createSubagentResumeState('source-scope'),
+      'target-scope'
+    );
+    expect(target.sessions.get('partition-A')).toEqual(
+      source.sessions.get('partition-A')
+    );
+  });
 });

src/hitl/approvalReview.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from '@jest/globals';
-import { createToolApprovalReviewEvidence } from './approvalReview';
+import { createToolApprovalReviewEvidence, cloneToolApprovalInterruptPayload } from './approvalReview';
 
 describe('approval review evidence', () => {
   const request = {
@@ -102,4 +102,29 @@ describe('approval review evidence', () => {
       ).toBeUndefined();
     }
   );
+
+  it.each([
+    { resolve: () => 'resolved' },
+    { resolution: Symbol('resolved') },
+    new Date(0),
+  ])('detaches approval fields without cloning opaque checkpoint siblings: %p', (opaque) => {
+    const manifest = { pendingInterrupts: [{ interruptId: 'sibling', payload: opaque }] };
+    const payload = {
+      type: 'tool_approval' as const,
+      action_requests: [{ ...request, arguments: { command: 'reviewed', options: { cwd: '/safe' } } }],
+      review_configs: [{ ...reviewConfig, allowed_decisions: ['approve', 'reject'] }],
+      subagent: { run_id: 'child', agent_id: 'member', subagent_type: 'team' },
+      __librechat_subagent_resume_manifest: manifest,
+    };
+    const cloned = cloneToolApprovalInterruptPayload(payload);
+    expect(cloned.__librechat_subagent_resume_manifest).toBe(manifest);
+    expect(cloned.__librechat_subagent_resume_manifest.pendingInterrupts[0].payload).toBe(opaque);
+    cloned.action_requests[0].arguments.options.cwd = '/unsafe';
+    cloned.review_configs[0].allowed_decisions.length = 0;
+    cloned.subagent.agent_id = 'foreign';
+    expect(payload.action_requests[0].arguments.options.cwd).toBe('/safe');
+    expect(payload.review_configs[0].allowed_decisions).toEqual(['approve', 'reject']);
+    expect(payload.subagent.agent_id).toBe('member');
+  });
+
 });

src/hitl/approvalReview.ts

@@ -27,9 +27,17 @@ export interface ReviewedToolApproval {
 
 const APPROVAL_DECISIONS = new Set(['approve', 'reject', 'edit', 'respond']);
 
-/** Detach approval payloads from host- or transport-owned object graphs. */
+/** Detach approval fields without deep-cloning checkpoint-owned metadata. */
 export function cloneToolApprovalInterruptPayload<T>(payload: T): T {
-  return isToolApprovalInterrupt(payload) ? structuredClone(payload) : payload;
+  if (!isToolApprovalInterrupt(payload)) return payload;
+  return {
+    ...payload,
+    ...structuredClone({
+      action_requests: payload.action_requests,
+      review_configs: payload.review_configs,
+      ...(payload.subagent == null ? {} : { subagent: payload.subagent }),
+    }),
+  };
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {