Skip to content

Commit 3bd6fb4

Browse files
committed
test(server): retain delegated child events when detaching a parent
1 parent a21d788 commit 3bd6fb4

1 file changed

Lines changed: 147 additions & 0 deletions

File tree

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

Lines changed: 147 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3507,6 +3507,153 @@ it.effect(
35073507
}),
35083508
);
35093509

3510+
it.effect(
3511+
"ProviderSessionManagerV2 detaching a parent keeps an attached delegated child's thread loaded",
3512+
() =>
3513+
Effect.gen(function* () {
3514+
const state = yield* Ref.make(emptyState);
3515+
const effect = Effect.gen(function* () {
3516+
const eventSink = yield* EventSink.EventSinkV2;
3517+
const idAllocator = yield* IdAllocator.IdAllocatorV2;
3518+
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3519+
const now = yield* DateTime.now;
3520+
const projectId = yield* idAllocator.allocate.project({
3521+
fixtureName: "provider-session-manager-delegated-child",
3522+
});
3523+
const parentThreadId = yield* idAllocator.allocate.thread({
3524+
fixtureName: "provider-session-manager-delegated-child-parent",
3525+
projectId,
3526+
});
3527+
const childThreadId = yield* idAllocator.allocate.thread({
3528+
fixtureName: "provider-session-manager-delegated-child-child",
3529+
projectId,
3530+
});
3531+
const providerSessionId = idAllocator.derive.providerSession({
3532+
providerInstanceId: modelSelection.instanceId,
3533+
});
3534+
const parentProviderThread = makeProviderThread({
3535+
idAllocator,
3536+
threadId: parentThreadId,
3537+
providerSessionId,
3538+
now,
3539+
nativeThreadId: "native-parent",
3540+
});
3541+
const childProviderThread = makeProviderThread({
3542+
idAllocator,
3543+
threadId: childThreadId,
3544+
providerSessionId,
3545+
now,
3546+
nativeThreadId: "native-child",
3547+
});
3548+
const childRunId = idAllocator.derive.run({ threadId: childThreadId, ordinal: 2 });
3549+
const parentRunId = idAllocator.derive.run({ threadId: parentThreadId, ordinal: 1 });
3550+
const subagentId = idAllocator.derive.rootNode({ runId: childRunId });
3551+
3552+
yield* eventSink.write({
3553+
events: [
3554+
yield* makeThreadCreatedEvent({ idAllocator, threadId: parentThreadId, now }),
3555+
yield* makeThreadCreatedEvent({ idAllocator, threadId: childThreadId, now }),
3556+
{
3557+
id: yield* idAllocator.allocate.event({ threadId: parentThreadId }),
3558+
type: "provider-thread.updated",
3559+
threadId: parentThreadId,
3560+
driver: CODEX_DRIVER,
3561+
occurredAt: now,
3562+
payload: parentProviderThread,
3563+
},
3564+
{
3565+
id: yield* idAllocator.allocate.event({ threadId: childThreadId }),
3566+
type: "provider-thread.updated",
3567+
threadId: childThreadId,
3568+
driver: CODEX_DRIVER,
3569+
occurredAt: now,
3570+
payload: childProviderThread,
3571+
},
3572+
// The delegated task record already finished; the child was then sent a
3573+
// follow-up and is running a later turn of its own.
3574+
{
3575+
id: yield* idAllocator.allocate.event({ threadId: parentThreadId }),
3576+
type: "subagent.updated",
3577+
threadId: parentThreadId,
3578+
nodeId: subagentId,
3579+
providerInstanceId: modelSelection.instanceId,
3580+
occurredAt: now,
3581+
payload: {
3582+
id: subagentId,
3583+
threadId: parentThreadId,
3584+
runId: null,
3585+
parentNodeId: idAllocator.derive.rootNode({ runId: parentRunId }),
3586+
origin: "app_owned",
3587+
createdBy: "agent",
3588+
driver: CODEX_DRIVER,
3589+
providerInstanceId: modelSelection.instanceId,
3590+
providerThreadId: childProviderThread.id,
3591+
childThreadId,
3592+
nativeTaskRef: null,
3593+
prompt: "Delegated work",
3594+
title: "Delegated child",
3595+
model: modelSelection.model,
3596+
status: "completed",
3597+
result: "first result",
3598+
startedAt: now,
3599+
completedAt: now,
3600+
updatedAt: now,
3601+
},
3602+
},
3603+
{
3604+
id: yield* idAllocator.allocate.event({ threadId: childThreadId }),
3605+
type: "provider-turn.updated",
3606+
threadId: childThreadId,
3607+
runId: childRunId,
3608+
driver: CODEX_DRIVER,
3609+
occurredAt: now,
3610+
payload: {
3611+
id: idAllocator.derive.providerTurn({
3612+
driver: CODEX_DRIVER,
3613+
nativeTurnId: "native-child-turn",
3614+
}),
3615+
providerThreadId: childProviderThread.id,
3616+
nodeId: idAllocator.derive.rootNode({ runId: childRunId }),
3617+
runAttemptId: null,
3618+
nativeTurnRef: null,
3619+
ordinal: 2,
3620+
status: "running",
3621+
startedAt: now,
3622+
completedAt: null,
3623+
},
3624+
},
3625+
],
3626+
});
3627+
yield* manager.open({
3628+
threadId: parentThreadId,
3629+
providerSessionId,
3630+
modelSelection,
3631+
runtimePolicy,
3632+
});
3633+
yield* manager.open({
3634+
threadId: childThreadId,
3635+
providerSessionId,
3636+
modelSelection,
3637+
runtimePolicy,
3638+
});
3639+
3640+
yield* manager.detach({ providerSessionId, threadId: parentThreadId });
3641+
3642+
const afterParentDetach = yield* Ref.get(state);
3643+
assert.equal(afterParentDetach.interruptCount, 0);
3644+
assert.deepEqual(afterParentDetach.unloadedNativeThreadIds, ["native-parent"]);
3645+
3646+
yield* manager.detach({ providerSessionId, threadId: childThreadId });
3647+
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, [
3648+
"native-parent",
3649+
"native-child",
3650+
]);
3651+
});
3652+
3653+
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
3654+
}),
3655+
);
3656+
35103657
it.effect(
35113658
"ProviderSessionManagerV2 invalidates only errored threads and keeps reusable session errors cached",
35123659
() =>

0 commit comments

Comments
 (0)