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.tsindex 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",() =>