TypeScript
fix(server): release the previous session when sending to another instance (#23198)
Julius Marmingec0ec87a55bbf
diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.tsindex 035bd9c73db..3dc0a65ae03 100644--- a/apps/server/src/orchestration-v2/Orchestrator.ts+++ b/apps/server/src/orchestration-v2/Orchestrator.ts@@ -6241,24 +6241,69 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functioactiveProviderThread.providerInstanceId !== modelSelection.instanceId;// Account overlays share native history. Selection commands may already// have updated the app thread, so classify against the native thread's owner.+ const providerSwitchPlan = isProviderSwitch+ ? yield* providerSwitchService+ .plan({+ projection: {+ ...projection,+ thread: {+ ...projection.thread,+ modelSelection: {+ ...projection.thread.modelSelection,+ instanceId: activeProviderThread.providerInstanceId,+ },+ },+ },+ targetModelSelection: modelSelection,+ })+ .pipe(mapDispatchError(command))+ : null;const canResumeAcrossInstances =isProviderSwitch &&activeProviderThread.nativeThreadRef !== null &&- (yield* providerSwitchService- .plan({- projection: {- ...projection,- thread: {- ...projection.thread,- modelSelection: {- ...projection.thread.modelSelection,- instanceId: activeProviderThread.providerInstanceId,- },- },- },- targetModelSelection: modelSelection,- })- .pipe(mapDispatchError(command))).transition.type === "restart_and_resume";+ providerSwitchPlan?.transition.type === "restart_and_resume";+ const sessionsToDetach = projection.providerSessions.filter(+ (session) =>+ providerSwitchPlan?.releaseProviderSessionIds.includes(session.id) &&+ session.status !== "stopped" &&+ session.status !== "error",+ );+ // Detaching kills background work running inside the provider process.+ // Probe even with an empty roster: Claude's native subagents never reach+ // pendingBackgroundTasks. Sessions shared across threads probe per thread.+ for (const detaching of sessionsToDetach) {+ const session = yield* providerSessions+ .get(detaching.id)+ .pipe(Effect.orElseSucceed(() => Option.none()));+ if (Option.isNone(session)) {+ continue;+ }+ const runtime = session.value;+ const probes =+ !detaching.capabilities.sessions.supportsMultipleProviderThreadsPerSession &&+ runtime.hasPendingBackgroundWork !== undefined+ ? [runtime.hasPendingBackgroundWork]+ : projection.providerThreads.flatMap((providerThread) =>+ providerThread.providerSessionId === detaching.id &&+ runtime.hasPendingBackgroundWorkForThread !== undefined+ ? [runtime.hasPendingBackgroundWorkForThread(providerThread)]+ : [],+ );+ for (const probe of probes) {+ const stillRunning = yield* probe.pipe(+ // A failed probe cannot confirm that the work ended.+ Effect.catchCause(() => Effect.succeed(true)),+ );+ if (stillRunning) {+ return yield* new OrchestratorDispatchError({+ commandId: command.commandId,+ commandType: command.type,+ cause:+ "The previous provider is still running background agents or commands, and switching would end them. Wait for them to finish, or press Stop, then send the message again.",+ });+ }+ }+ }if (pendingForkTransfer === undefined &&@@ -7565,30 +7610,32 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio});}- if (canResumeAcrossInstances && activeProviderThread.providerSessionId !== null) {- const previousProviderSessionId = activeProviderThread.providerSessionId;+ const detachDetail = canResumeAcrossInstances+ ? "Provider account changed; continuing the native thread."+ : "Provider or model selection changed.";+ for (const session of sessionsToDetach) {yield* emitEvent({type: "provider-session.detached",threadId: command.threadId,- driver: activeProviderThread.driver,- providerInstanceId: activeProviderThread.providerInstanceId,+ driver: session.driver,+ providerInstanceId: session.providerInstanceId,occurredAt: now,payload: {- providerSessionId: previousProviderSessionId,+ providerSessionId: session.id,detachedAt: now,- reason: "Provider account changed; continuing the native thread.",+ reason: detachDetail,},});yield* Ref.update(effects, (existing) => [...existing,{- id: `effect:${command.commandId}:provider-session.detach:${previousProviderSessionId}`,+ id: `effect:${command.commandId}:provider-session.detach:${session.id}`,commandId: command.commandId,threadId: command.threadId,request: {type: "provider-session.detach",- providerSessionId: previousProviderSessionId,- detail: "Provider account changed; continuing the native thread.",+ providerSessionId: session.id,+ detail: detachDetail,},} satisfies PendingOrchestrationEffectV2,]);diff --git a/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts b/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.tsindex bb21d8ca992..f36e463079f 100644--- a/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts+++ b/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts@@ -119,6 +119,8 @@ function makeTestAdapter(input: {readonly subagentOnlyBackgroundWork?: boolean;readonly holdFirstTurn?: Deferred.Deferred<void>;readonly releaseFirstTurn?: Deferred.Deferred<void>;+ readonly backgroundWork?: Ref.Ref<boolean>;+ readonly closedSessions?: Ref.Ref<ReadonlyArray<string>>;}): ProviderAdapter.ProviderAdapterV2["Service"] {return {instanceId: input.instanceId,@@ -128,6 +130,12 @@ function makeTestAdapter(input: {openSession: (sessionInput) =>Effect.gen(function* () {const events = yield* PubSub.unbounded<ProviderAdapter.ProviderAdapterV2Event>();+ if (input.closedSessions !== undefined) {+ const closedSessions = input.closedSessions;+ yield* Effect.addFinalizer(() =>+ Ref.update(closedSessions, (ids) => [...ids, sessionInput.providerSessionId]),+ );+ }const now = yield* DateTime.now;const providerSession: OrchestrationV2ProviderSession = {id: sessionInput.providerSessionId,@@ -162,6 +170,14 @@ function makeTestAdapter(input: {...(input.canReuseContextUsage === undefined? {}: { canReuseContextUsage: input.canReuseContextUsage }),+ ...(input.backgroundWork === undefined+ ? {}+ : {+ // Like Claude: native subagents are visible only to the session-wide+ // probe, never to the per-thread roster probe.+ hasPendingBackgroundWork: Ref.get(input.backgroundWork),+ hasPendingBackgroundWorkForThread: () => Effect.succeed(false),+ }),ensureThread: (threadInput) =>Effect.gen(function* () {const createdAt = yield* DateTime.now;@@ -748,16 +764,7 @@ describe("orchestration v2 provider switching", () => {yield* wait(3);}if (replaceNative) {- const target = (yield* orchestrator.getThreadProjection(threadId)).providerThreads.find(- (thread) => thread.providerInstanceId === CLAUDE_MODEL_SELECTION.instanceId,- )!;- yield* orchestrator.dispatch({- type: "provider-session.detach",- commandId: CommandId.make("detach-for-native-replacement"),- threadId,- providerSessionId: target.providerSessionId!,- });- yield* worker.drain();+ // Switching back to Codex already released Claude's session.yield* Ref.set(failResumeOnce, true);}if (scenario.includes("retry")) yield* Ref.set(failStartOnce, true);@@ -2520,6 +2527,141 @@ describe("orchestration v2 provider switching", () => {),);+ // regression: #20343 sending to an instance with separate history must release the old session+ it.live.each([+ ["detaches the previous instance's session when a send hands off to another instance", false],+ ["refuses the hand-off while the previous instance still runs background work", true],+ ] as const)("%s", ([, backgroundRunning]) =>+ Effect.scoped(+ Effect.gen(function* () {+ const cwd = yield* checkpointWorkspace("handoff-releases-session");+ const capturedTurns = yield* Ref.make<ReadonlyArray<CapturedTurn>>([]);+ const backgroundWork = yield* Ref.make(backgroundRunning);+ const closedSessions = yield* Ref.make<ReadonlyArray<string>>([]);+ const secondSelection: ModelSelection = {+ ...CLAUDE_MODEL_SELECTION,+ instanceId: ProviderInstanceId.make("claude-second-account"),+ };+ // No shared continuation key: each Claude instance owns its own native history.+ const layerRegistry = ProviderAdapterRegistry.layerFromAdapters([+ makeTestAdapter({+ instanceId: CLAUDE_MODEL_SELECTION.instanceId,+ driver: CLAUDE_DRIVER,+ capabilities: ClaudeProviderCapabilitiesV2,+ modelSelection: CLAUDE_MODEL_SELECTION,+ responseByRunOrdinal: { 1: "First account complete" },+ capturedTurns,+ backgroundWork,+ closedSessions,+ }),+ makeTestAdapter({+ instanceId: secondSelection.instanceId,+ driver: CLAUDE_DRIVER,+ capabilities: ClaudeProviderCapabilitiesV2,+ modelSelection: secondSelection,+ responseByRunOrdinal: { 2: "Second account complete" },+ capturedTurns,+ }),+ ]);+ const handoffThreadId = ThreadId.make("thread:handoff-releases-session");+ yield* Effect.gen(function* () {+ const orchestrator = yield* Orchestrator.OrchestratorV2;+ const worker = yield* EffectWorker.OrchestrationEffectWorkerV2;+ const send = (ordinal: number, modelSelection: ModelSelection, attempt = "") =>+ orchestrator.dispatch({+ type: "message.dispatch",+ createdBy: "user",+ creationSource: "web",+ commandId: CommandId.make(`command:handoff-releases-session:${ordinal}${attempt}`),+ threadId: handoffThreadId,+ messageId: MessageId.make(`message:handoff-releases-session:${ordinal}${attempt}`),+ text: `Prompt ${ordinal}`,+ attachments: [],+ modelSelection,+ dispatchMode: { type: "start_immediately" },+ });+ yield* orchestrator.dispatch({+ type: "thread.create",+ createdBy: "user",+ creationSource: "web",+ commandId: CommandId.make("command:handoff-releases-session:create"),+ threadId: handoffThreadId,+ projectId: ProjectId.make("project:handoff-releases-session"),+ title: "Handoff releases session",+ modelSelection: CLAUDE_MODEL_SELECTION,+ runtimeMode: "full-access",+ interactionMode: "default",+ branch: null,+ worktreePath: cwd,+ });+ yield* send(1, CLAUDE_MODEL_SELECTION);+ yield* worker.drain();+ const afterFirst = yield* waitForIdle(handoffThreadId);+ const firstSession = afterFirst.providerSessions.find(+ (session) => session.providerInstanceId === CLAUDE_MODEL_SELECTION.instanceId,+ );+ assert.equal(firstSession?.status, "ready");++ if (backgroundRunning) {+ // Native subagents live only in the adapter's roster, so the projection's+ // pendingBackgroundTasks stays empty while the probe still reports work.+ assert.deepEqual(afterFirst.providerThreads[0]?.pendingBackgroundTasks ?? [], []);+ const refused = yield* send(2, secondSelection, ":refused").pipe(Effect.flip);+ assert.include(String(refused.cause), "still running background agents or commands");+ const unchanged = yield* orchestrator.getThreadProjection(handoffThreadId);+ assert.lengthOf(unchanged.runs, 1);+ assert.deepEqual(yield* Ref.get(closedSessions), []);+ assert.equal(unchanged.thread.providerInstanceId, CLAUDE_MODEL_SELECTION.instanceId);+ assert.deepEqual(+ unchanged.providerSessions.map((session) => [session.id, session.status]),+ [[firstSession!.id, "ready"]],+ );+ yield* Ref.set(backgroundWork, false);+ }++ yield* send(2, secondSelection);+ yield* worker.drain();+ const afterSecond = yield* waitForIdle(handoffThreadId);+ yield* worker.drain();+ const projection = yield* orchestrator.getThreadProjection(handoffThreadId);++ assert.deepEqual(+ projection.runs.map((run) => [run.providerInstanceId, run.status]),+ [+ [CLAUDE_MODEL_SELECTION.instanceId, "completed"],+ [secondSelection.instanceId, "completed"],+ ],+ );+ assert.lengthOf(afterSecond.contextHandoffs, 1);+ assert.deepEqual(+ projection.providerSessions.map((session) => session.providerInstanceId),+ [secondSelection.instanceId],+ );+ // The detached event alone hides the session; the runtime must also close.+ assert.deepEqual(yield* Ref.get(closedSessions), [firstSession!.id]);+ }).pipe(+ Effect.provide(+ ProviderReplayHarness.layerWithRegistry(+ {+ name: "handoff-releases-session",+ runtimePolicyOverride: {+ cwd,+ approvalPolicy: "never",+ sandboxPolicy: {+ type: "readOnly",+ access: { type: "fullAccess" },+ networkAccess: false,+ },+ },+ },+ layerRegistry,+ ),+ ),+ );+ }),+ ),+ );+// regression: #21314 a queued PR update must follow the provider that took over the threadit.live.each([["automatic", "Claude"],