Skip to content
TypeScript

test(server): retain delegated child events when detaching a parent (#29622)

benjamin-dia624256ff398
diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
index b1e05577bfb..d5556128ce7 100644
--- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
@@ -3507,6 +3507,153 @@ it.effect(
}),
);
+it.effect(
+ "ProviderSessionManagerV2 detaching a parent keeps an attached delegated child's thread loaded",
+ () =>
+ Effect.gen(function* () {
+ const state = yield* Ref.make(emptyState);
+ const effect = Effect.gen(function* () {
+ const eventSink = yield* EventSink.EventSinkV2;
+ const idAllocator = yield* IdAllocator.IdAllocatorV2;
+ const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
+ const now = yield* DateTime.now;
+ const projectId = yield* idAllocator.allocate.project({
+ fixtureName: "provider-session-manager-delegated-child",
+ });
+ const parentThreadId = yield* idAllocator.allocate.thread({
+ fixtureName: "provider-session-manager-delegated-child-parent",
+ projectId,
+ });
+ const childThreadId = yield* idAllocator.allocate.thread({
+ fixtureName: "provider-session-manager-delegated-child-child",
+ projectId,
+ });
+ const providerSessionId = idAllocator.derive.providerSession({
+ providerInstanceId: modelSelection.instanceId,
+ });
+ const parentProviderThread = makeProviderThread({
+ idAllocator,
+ threadId: parentThreadId,
+ providerSessionId,
+ now,
+ nativeThreadId: "native-parent",
+ });
+ const childProviderThread = makeProviderThread({
+ idAllocator,
+ threadId: childThreadId,
+ providerSessionId,
+ now,
+ nativeThreadId: "native-child",
+ });
+ const childRunId = idAllocator.derive.run({ threadId: childThreadId, ordinal: 2 });
+ const parentRunId = idAllocator.derive.run({ threadId: parentThreadId, ordinal: 1 });
+ const subagentId = idAllocator.derive.rootNode({ runId: childRunId });
+
+ yield* eventSink.write({
+ events: [
+ yield* makeThreadCreatedEvent({ idAllocator, threadId: parentThreadId, now }),
+ yield* makeThreadCreatedEvent({ idAllocator, threadId: childThreadId, now }),
+ {
+ id: yield* idAllocator.allocate.event({ threadId: parentThreadId }),
+ type: "provider-thread.updated",
+ threadId: parentThreadId,
+ driver: CODEX_DRIVER,
+ occurredAt: now,
+ payload: parentProviderThread,
+ },
+ {
+ id: yield* idAllocator.allocate.event({ threadId: childThreadId }),
+ type: "provider-thread.updated",
+ threadId: childThreadId,
+ driver: CODEX_DRIVER,
+ occurredAt: now,
+ payload: childProviderThread,
+ },
+ // The delegated task record already finished; the child was then sent a
+ // follow-up and is running a later turn of its own.
+ {
+ id: yield* idAllocator.allocate.event({ threadId: parentThreadId }),
+ type: "subagent.updated",
+ threadId: parentThreadId,
+ nodeId: subagentId,
+ providerInstanceId: modelSelection.instanceId,
+ occurredAt: now,
+ payload: {
+ id: subagentId,
+ threadId: parentThreadId,
+ runId: null,
+ parentNodeId: idAllocator.derive.rootNode({ runId: parentRunId }),
+ origin: "app_owned",
+ createdBy: "agent",
+ driver: CODEX_DRIVER,
+ providerInstanceId: modelSelection.instanceId,
+ providerThreadId: childProviderThread.id,
+ childThreadId,
+ nativeTaskRef: null,
+ prompt: "Delegated work",
+ title: "Delegated child",
+ model: modelSelection.model,
+ status: "completed",
+ result: "first result",
+ startedAt: now,
+ completedAt: now,
+ updatedAt: now,
+ },
+ },
+ {
+ id: yield* idAllocator.allocate.event({ threadId: childThreadId }),
+ type: "provider-turn.updated",
+ threadId: childThreadId,
+ runId: childRunId,
+ driver: CODEX_DRIVER,
+ occurredAt: now,
+ payload: {
+ id: idAllocator.derive.providerTurn({
+ driver: CODEX_DRIVER,
+ nativeTurnId: "native-child-turn",
+ }),
+ providerThreadId: childProviderThread.id,
+ nodeId: idAllocator.derive.rootNode({ runId: childRunId }),
+ runAttemptId: null,
+ nativeTurnRef: null,
+ ordinal: 2,
+ status: "running",
+ startedAt: now,
+ completedAt: null,
+ },
+ },
+ ],
+ });
+ yield* manager.open({
+ threadId: parentThreadId,
+ providerSessionId,
+ modelSelection,
+ runtimePolicy,
+ });
+ yield* manager.open({
+ threadId: childThreadId,
+ providerSessionId,
+ modelSelection,
+ runtimePolicy,
+ });
+
+ yield* manager.detach({ providerSessionId, threadId: parentThreadId });
+
+ const afterParentDetach = yield* Ref.get(state);
+ assert.equal(afterParentDetach.interruptCount, 0);
+ assert.deepEqual(afterParentDetach.unloadedNativeThreadIds, ["native-parent"]);
+
+ yield* manager.detach({ providerSessionId, threadId: childThreadId });
+ assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, [
+ "native-parent",
+ "native-child",
+ ]);
+ });
+
+ yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
+ }),
+);
+
it.effect(
"ProviderSessionManagerV2 invalidates only errored threads and keeps reusable session errors cached",
() =>