Skip to content

Commit 5e79b4b

Browse files
committed
fix(server): release a finished delegated child's provider session at once
A delegate_task child usually runs once and is never settled, yet its provider session (one claude process plus its MCP servers) stays up for the 30 minute idle timeout. When a delegated child's run completes and its result is recorded, queue an effect that releases the child's one-process-per-thread session if nothing can resume it: no run or queued follow-up, no subagent or background task, no pending wake message. A later message to the child opens a new session as usual. The idle timeout for other threads is unchanged.
1 parent 8b44f42 commit 5e79b4b

9 files changed

Lines changed: 322 additions & 2 deletions

‎apps/server/src/orchestration-v2/DelegatedCompletionDelivery.test.ts‎

Lines changed: 55 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@ import * as Effect from "effect/Effect";
2525
import * as Deferred from "effect/Deferred";
2626
import * as Fiber from "effect/Fiber";
2727
import * as Layer from "effect/Layer";
28+
import * as SqlClient from "effect/sql/SqlClient";
2829
import * as Stream from "effect/Stream";
2930
import * as Tracer from "effect/Tracer";
3031

@@ -144,7 +145,7 @@ const layerTest = Layer.mergeAll(
144145
),
145146
Layer.provide(McpSessionRegistryTestkit.layer),
146147
Layer.provide(McpProviderSessions.layer),
147-
Layer.provide(SqlitePersistence.layerMemory),
148+
Layer.provideMerge(SqlitePersistence.layerMemory),
148149
Layer.provide(layerCheckpointStoreTest),
149150
Layer.provide(layerServerConfig),
150151
Layer.provide(ServerSettings.layerTest()),
@@ -2403,6 +2404,59 @@ it.layer(layerTest)("delegated tasks across a server restart", (it) => {
24032404
}),
24042405
);
24052406

2407+
it.effect(
2408+
"queues the release of a completed child's provider session, not a cancelled one's",
2409+
() =>
2410+
Effect.gen(function* () {
2411+
const orchestrator = yield* Orchestrator.OrchestratorV2;
2412+
const sql = yield* SqlClient.SqlClient;
2413+
const now = yield* DateTime.now;
2414+
const threadId = ThreadId.make("thread:release-delegate-parent");
2415+
const projectId = ProjectId.make("project:release-delegate");
2416+
const runId = RunId.make("run:release-delegate-parent");
2417+
const rootNodeId = NodeId.make("node:release-delegate-parent");
2418+
yield* seedParentWithTerminalTask({
2419+
threadId,
2420+
projectId,
2421+
runId,
2422+
rootNodeId,
2423+
taskId: NodeId.make("node:release-delegate-seed"),
2424+
deliveryState: "acknowledged",
2425+
now,
2426+
});
2427+
const child = (name: string, runStatus: "cancelled" | "completed") =>
2428+
seedRestartCancelledChild({
2429+
parentThreadId: threadId,
2430+
projectId,
2431+
parentRunId: runId,
2432+
rootNodeId,
2433+
name,
2434+
completionWake: "always",
2435+
continuationPending: false,
2436+
runStatus,
2437+
now,
2438+
});
2439+
const completed = yield* child("release-delegate-completed", "completed");
2440+
const cancelled = yield* child("release-delegate-cancelled", "cancelled");
2441+
2442+
yield* orchestrator.recoverDelegatedTasks;
2443+
2444+
const queued = yield* sql<{ readonly thread_id: string }>`
2445+
SELECT thread_id FROM orchestration_v2_effect_outbox
2446+
WHERE effect_type = 'provider-session.release-finished-delegate'
2447+
AND thread_id LIKE 'thread:release-delegate-%'
2448+
`;
2449+
assert.deepEqual(
2450+
queued.map((row) => row.thread_id),
2451+
[completed.childThreadId],
2452+
);
2453+
assert.notInclude(
2454+
queued.map((row) => row.thread_id),
2455+
cancelled.childThreadId,
2456+
);
2457+
}),
2458+
);
2459+
24062460
it.effect("holds a restart-cancelled child for its continuation's result", () =>
24072461
Effect.gen(function* () {
24082462
const orchestrator = yield* Orchestrator.OrchestratorV2;

‎apps/server/src/orchestration-v2/EffectOutbox.ts‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,9 @@ export const OrchestrationEffectRequestV2 = Schema.Union([
4040
detail: Schema.optional(Schema.String),
4141
revokeMcpCredential: Schema.optional(Schema.Boolean),
4242
}),
43+
Schema.Struct({
44+
type: Schema.Literal("provider-session.release-finished-delegate"),
45+
}),
4346
Schema.Struct({
4447
type: Schema.Literal("provider-turn.start"),
4548
runId: RunId,
@@ -136,6 +139,7 @@ export const REPLAY_SAFE_EFFECT_TYPES_AFTER_PROCESS_LOSS = [
136139
] as const satisfies ReadonlyArray<OrchestrationEffectRequestV2["type"]>;
137140

138141
export const PROCESS_BOUND_EFFECT_TYPES = [
142+
"provider-session.release-finished-delegate",
139143
"provider-turn.start",
140144
"provider-turn.interrupt",
141145
"provider-turn.steer",

‎apps/server/src/orchestration-v2/EffectWorker.test.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -111,6 +111,7 @@ function layerExecutorFor(input: {
111111
closeInstance: () => Effect.void,
112112
release: () => record("release"),
113113
detach: () => record("detach"),
114+
releaseFinishedDelegate: () => Effect.void,
114115
otherWorkingThreads: () => Effect.succeed([]),
115116
releaseUnlessBusy: () => Effect.succeed(true),
116117
}),

‎apps/server/src/orchestration-v2/EffectWorker.ts‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -138,6 +138,17 @@ export const layerExecutor: Layer.Layer<
138138
}),
139139
),
140140
);
141+
case "provider-session.release-finished-delegate":
142+
return providerSessions.releaseFinishedDelegate({ threadId: effect.threadId }).pipe(
143+
Effect.mapError(
144+
(cause) =>
145+
new OrchestrationEffectExecutionError({
146+
effectId: effect.id,
147+
effectType: effect.request.type,
148+
cause,
149+
}),
150+
),
151+
);
141152
case "provider-turn.start":
142153
return providerTurnStart
143154
.start({ threadId: effect.threadId, runId: effect.request.runId, willRetry })

‎apps/server/src/orchestration-v2/Orchestrator.ts‎

Lines changed: 19 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12722,7 +12722,25 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
1272212722
payload: resultTransfer,
1272312723
},
1272412724
];
12725-
yield* writeSystemEvents(completionEvents, [], { updateDelegatedCompletionOnly: true });
12725+
// A finished delegate is rarely resumed, so its provider process need not idle for the full
12726+
// timeout. The session manager releases it only if nothing can resume it by then.
12727+
const releaseCommandId = CommandId.make(
12728+
`command:system:release-finished-delegate:${childRun.id}`,
12729+
);
12730+
yield* writeSystemEvents(
12731+
completionEvents,
12732+
terminalStatus === "completed"
12733+
? [
12734+
{
12735+
id: `effect:${releaseCommandId}:provider-session.release-finished-delegate`,
12736+
commandId: releaseCommandId,
12737+
threadId: childThreadId,
12738+
request: { type: "provider-session.release-finished-delegate" },
12739+
} satisfies PendingOrchestrationEffectV2,
12740+
]
12741+
: [],
12742+
{ updateDelegatedCompletionOnly: true },
12743+
);
1272612744

1272712745
if (completionPlan.offer && completionPlan.parentRun !== undefined) {
1272812746
yield* offerDelegatedCompletionDelivery(parentThreadId, completionPlan.parentRun.id);

‎apps/server/src/orchestration-v2/ProviderSessionManager.test.ts‎

Lines changed: 174 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3950,3 +3950,177 @@ it.effect("ProviderSessionManagerV2 gives a delegated child its project's device
39503950
assert.isTrue(child?.capabilities?.has("device"));
39513951
}),
39523952
);
3953+
3954+
const finishedDelegateRunEvent = (input: {
3955+
readonly idAllocator: IdAllocator.IdAllocatorV2["Service"];
3956+
readonly threadId: ThreadId;
3957+
readonly ordinal: number;
3958+
readonly status: "completed" | "queued" | "running";
3959+
readonly now: DateTime.Utc;
3960+
}) =>
3961+
Effect.gen(function* () {
3962+
const runId = input.idAllocator.derive.run({
3963+
threadId: input.threadId,
3964+
ordinal: input.ordinal,
3965+
});
3966+
return {
3967+
id: yield* input.idAllocator.allocate.event({ threadId: input.threadId }),
3968+
type: "run.updated" as const,
3969+
threadId: input.threadId,
3970+
runId,
3971+
occurredAt: input.now,
3972+
payload: {
3973+
id: runId,
3974+
threadId: input.threadId,
3975+
ordinal: input.ordinal,
3976+
providerInstanceId: modelSelection.instanceId,
3977+
modelSelection,
3978+
providerThreadId: null,
3979+
userMessageId: yield* input.idAllocator.allocate.message({
3980+
threadId: input.threadId,
3981+
ordinal: input.ordinal,
3982+
}),
3983+
rootNodeId: null,
3984+
activeAttemptId: null,
3985+
status: input.status,
3986+
requestedAt: input.now,
3987+
startedAt: input.status === "queued" ? null : input.now,
3988+
completedAt: input.status === "completed" ? input.now : null,
3989+
checkpointId: null,
3990+
contextHandoffId: null,
3991+
},
3992+
};
3993+
});
3994+
3995+
// Opens a one-process-per-thread session on a thread with the given runs, then asks to release
3996+
// it as a finished delegate with no clock advance, far inside the idle timeout.
3997+
const runFinishedDelegateScenario = (input: {
3998+
readonly delegated: boolean;
3999+
readonly runs: ReadonlyArray<"completed" | "queued" | "running">;
4000+
readonly hasPendingBackgroundWork?: boolean;
4001+
}) =>
4002+
Effect.gen(function* () {
4003+
const state = yield* Ref.make(emptyState);
4004+
const effect = Effect.gen(function* () {
4005+
const eventSink = yield* EventSink.EventSinkV2;
4006+
const idAllocator = yield* IdAllocator.IdAllocatorV2;
4007+
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4008+
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4009+
const now = yield* DateTime.now;
4010+
const projectId = yield* idAllocator.allocate.project({
4011+
fixtureName: "provider-session-manager-finished-delegate",
4012+
});
4013+
const threadId = yield* idAllocator.allocate.thread({
4014+
fixtureName: "provider-session-manager-finished-delegate",
4015+
projectId,
4016+
});
4017+
const providerSessionId = yield* idAllocator.allocate.providerSession({
4018+
providerInstanceId: modelSelection.instanceId,
4019+
threadId,
4020+
});
4021+
yield* eventSink.write({
4022+
events: [
4023+
yield* makeThreadCreatedEvent({
4024+
idAllocator,
4025+
threadId,
4026+
now,
4027+
projectId,
4028+
...(input.delegated
4029+
? { delegatedBy: ThreadId.make("thread-provider-session-manager-parent") }
4030+
: {}),
4031+
}),
4032+
...(yield* Effect.forEach(input.runs, (status, index) =>
4033+
finishedDelegateRunEvent({
4034+
idAllocator,
4035+
threadId,
4036+
ordinal: index + 1,
4037+
status,
4038+
now,
4039+
}),
4040+
)),
4041+
],
4042+
});
4043+
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
4044+
4045+
yield* manager.releaseFinishedDelegate({ threadId });
4046+
4047+
const released = (yield* Ref.get(state)).closeCount === 1;
4048+
const live = yield* manager.isLive(providerSessionId);
4049+
const sessionStatus = (yield* projectionStore.getThreadProjection(threadId))
4050+
.providerSessions[0]?.status;
4051+
// A message to the child after the release opens a new session as usual.
4052+
const reopened = yield* manager.open({
4053+
threadId,
4054+
providerSessionId,
4055+
modelSelection,
4056+
runtimePolicy,
4057+
});
4058+
return {
4059+
released,
4060+
live,
4061+
sessionStatus,
4062+
openCount: (yield* Ref.get(state)).openCount,
4063+
reopenedLive: yield* manager.isLive(providerSessionId),
4064+
reopened,
4065+
};
4066+
});
4067+
return yield* effect.pipe(
4068+
Effect.provide(
4069+
layerTest({
4070+
state,
4071+
idleTimeoutMs: 60 * 60_000,
4072+
capabilities: ExclusiveCapabilities,
4073+
...(input.hasPendingBackgroundWork === undefined
4074+
? {}
4075+
: { hasPendingBackgroundWork: Effect.succeed(input.hasPendingBackgroundWork) }),
4076+
}),
4077+
),
4078+
);
4079+
});
4080+
4081+
it.effect(
4082+
"ProviderSessionManagerV2 releases a finished delegated child's session at once and reopens it for a follow-up",
4083+
() =>
4084+
Effect.gen(function* () {
4085+
const result = yield* runFinishedDelegateScenario({ delegated: true, runs: ["completed"] });
4086+
assert.isTrue(result.released);
4087+
assert.isFalse(result.live);
4088+
assert.equal(result.sessionStatus, "stopped");
4089+
assert.equal(result.openCount, 2);
4090+
assert.isTrue(result.reopenedLive);
4091+
}),
4092+
);
4093+
4094+
it.effect.each<{
4095+
readonly name: string;
4096+
readonly delegated: boolean;
4097+
readonly runs: ReadonlyArray<"completed" | "queued" | "running">;
4098+
readonly hasPendingBackgroundWork?: boolean;
4099+
}>([
4100+
{ name: "an ordinary thread", delegated: false, runs: ["completed"] },
4101+
{ name: "a delegated child whose run is still running", delegated: true, runs: ["running"] },
4102+
{
4103+
name: "a delegated child with a queued follow-up",
4104+
delegated: true,
4105+
runs: ["completed", "queued"],
4106+
},
4107+
{
4108+
name: "a delegated child with pending background work",
4109+
delegated: true,
4110+
runs: ["completed"],
4111+
hasPendingBackgroundWork: true,
4112+
},
4113+
])("ProviderSessionManagerV2 keeps the session of $name", (scenario) =>
4114+
Effect.gen(function* () {
4115+
const result = yield* runFinishedDelegateScenario({
4116+
delegated: scenario.delegated,
4117+
runs: scenario.runs,
4118+
...(scenario.hasPendingBackgroundWork === undefined
4119+
? {}
4120+
: { hasPendingBackgroundWork: scenario.hasPendingBackgroundWork }),
4121+
});
4122+
assert.isFalse(result.released);
4123+
assert.isTrue(result.live);
4124+
assert.equal(result.openCount, 1);
4125+
}),
4126+
);

0 commit comments

Comments
 (0)