@devries-cameron20 / t3code Mirror · read-only / commits / 693e8c7db4
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

fix(server): released provider sessions no longer stay on the heap (#39049)

Julius Marminge committed Nov 19, 2026 at 02:21 UTC 693e8c7db41e1090ada14f1cb16a91ce9886909b
2 files changed +58 -5
apps/server/src/orchestration-v2/ProviderSessionManager.test.ts
+50 -3
@@ -157,6 +157,31 @@ const layerPausingAttachEventSink = (pause: {
157 }),
158 ).pipe(Layer.provide(layerTestEventSink));
159
160 +const layerReleaseRecordedEventSink = (recorded: Deferred.Deferred<void>) =>
161 + Layer.effect(
162 + EventSink.EventSinkV2,
163 + Effect.gen(function* () {
164 + const delegate = yield* EventSink.EventSinkV2;
165 + return EventSink.EventSinkV2.of({
166 + ...delegate,
167 + write: (input) =>
168 + delegate
169 + .write(input)
170 + .pipe(
171 + Effect.tap(() =>
172 + input.events.some(
173 + (event) =>
174 + event.type === "provider-session.updated" &&
175 + (event.payload.status === "stopped" || event.payload.status === "error"),
176 + )
177 + ? Deferred.succeed(recorded, undefined)
178 + : Effect.void,
179 + ),
180 + ),
181 + });
182 + }),
183 + ).pipe(Layer.provide(layerTestEventSink));
184 +
185 const layerBeforeUnchangedWriteEventSink = (
186 before: Ref.Ref<Effect.Effect<void>>,
187 // One effect runs before each turn-item write, in order.
@@ -466,6 +491,7 @@ const makeProviderAdapter = Effect.fnUntraced(function* (
491 readonly archive?: Effect.Effect<void, ProviderAdapter.ProviderAdapterProtocolError>;
492 readonly spawnBeforeOpen?: boolean;
493 readonly scopeCloseReached?: Deferred.Deferred<void>;
494 + readonly eventStreamsEnded?: Queue.Queue<ProviderSessionId>;
495 } = {},
496 ) {
497 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
@@ -558,6 +584,11 @@ const makeProviderAdapter = Effect.fnUntraced(function* (
584 if (event.type === "provider_session.updated") session = event.providerSession;
585 }),
586 ),
587 + Stream.ensuring(
588 + options.eventStreamsEnded === undefined
589 + ? Effect.void
590 + : Queue.offer(options.eventStreamsEnded, input.providerSessionId),
591 + ),
592 ),
593 ...(options.backgroundTasksEndWithProcess === false
594 ? {}
@@ -648,6 +679,8 @@ function layerTest(input: {
679 readonly archive?: Effect.Effect<void, ProviderAdapter.ProviderAdapterProtocolError>;
680 readonly spawnBeforeOpen?: boolean;
681 readonly scopeCloseReached?: Deferred.Deferred<void>;
682 + readonly eventStreamsEnded?: Queue.Queue<ProviderSessionId>;
683 + readonly releaseRecorded?: Deferred.Deferred<void>;
684 readonly serverSettingsLayer?: ReturnType<typeof ServerSettings.layerTest>;
685 readonly projectServiceLayer?: Layer.Layer<ProjectService.ProjectService>;
686 readonly installationGateLayer?: Layer.Layer<ProviderInstallationGate.ProviderInstallationGate>;
@@ -664,7 +697,9 @@ function layerTest(input: {
697 )
698 : input.failReleaseEventWrites
699 ? layerFailingReleaseEventSink
667 - : layerTestEventSink;
700 + : input.releaseRecorded !== undefined
701 + ? layerReleaseRecordedEventSink(input.releaseRecorded)
702 + : layerTestEventSink;
703 const layerRegistry = Layer.unwrap(
704 makeProviderAdapter(input.state, {
705 failEventStream: input.failEventStream ?? false,
@@ -698,6 +733,9 @@ function layerTest(input: {
733 ...(input.scopeCloseReached === undefined
734 ? {}
735 : { scopeCloseReached: input.scopeCloseReached }),
736 + ...(input.eventStreamsEnded === undefined
737 + ? {}
738 + : { eventStreamsEnded: input.eventStreamsEnded }),
739 }).pipe(Effect.map(ProviderAdapterRegistry.layerSingle)),
740 );
741 const layerConfiguredMcpRegistry =
@@ -1099,6 +1137,7 @@ it.effect("ProviderSessionManagerV2 opens independent sessions concurrently", ()
1137 it.effect("ProviderSessionManagerV2 closes every live session for a provider instance", () =>
1138 Effect.gen(function* () {
1139 const state = yield* Ref.make(emptyState);
1140 + const eventStreamsEnded = yield* Queue.unbounded<ProviderSessionId>();
1141 const effect = Effect.gen(function* () {
1142 const eventSink = yield* EventSink.EventSinkV2;
1143 const idAllocator = yield* IdAllocator.IdAllocatorV2;
@@ -1139,6 +1178,9 @@ it.effect("ProviderSessionManagerV2 closes every live session for a provider ins
1178 assert.isTrue(Option.isNone(yield* manager.get(firstProviderSessionId)));
1179 assert.isTrue(Option.isNone(yield* manager.get(secondProviderSessionId)));
1180 assert.equal((yield* Ref.get(state)).closeCount, 2);
1181 + // Like Codex and Claude, the fake adapter never ends its event queue; release must still stop the pump.
1182 + const ended = [yield* Queue.take(eventStreamsEnded), yield* Queue.take(eventStreamsEnded)];
1183 + assert.sameMembers(ended, [firstProviderSessionId, secondProviderSessionId]);
1184 });
1185
1186 yield* effect.pipe(
@@ -1146,6 +1188,7 @@ it.effect("ProviderSessionManagerV2 closes every live session for a provider ins
1188 layerTest({
1189 state,
1190 idleTimeoutMs: 60_000,
1191 + eventStreamsEnded,
1192 }),
1193 ),
1194 );
@@ -2216,6 +2259,7 @@ it.effect("ProviderSessionManagerV2 interrupts event subscriptions on server shu
2259 it.effect("ProviderSessionManagerV2 drains subscribers when the provider stops", () =>
2260 Effect.gen(function* () {
2261 const state = yield* Ref.make(emptyState);
2262 + const unloads = yield* Queue.unbounded<string>();
2263 const effect = Effect.gen(function* () {
2264 const eventSink = yield* EventSink.EventSinkV2;
2265 const idAllocator = yield* IdAllocator.IdAllocatorV2;
@@ -2273,11 +2317,12 @@ it.effect("ProviderSessionManagerV2 drains subscribers when the provider stops",
2317 events.map((event) => event.type),
2318 ["turn.terminal", "provider_session.updated"],
2319 );
2320 + assert.equal(yield* Queue.take(unloads), "close");
2321 assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
2322 assert.equal((yield* Ref.get(state)).closeCount, 1);
2323 });
2324
2280 - yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60_000 })));
2325 + yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, unloads })));
2326 }),
2327 );
2328
@@ -3847,6 +3892,7 @@ it.effect(
3892 it.effect("ProviderSessionManagerV2 releases sessions when provider event streams fail", () =>
3893 Effect.gen(function* () {
3894 const state = yield* Ref.make(emptyState);
3895 + const releaseRecorded = yield* Deferred.make<void>();
3896 const effect = Effect.gen(function* () {
3897 const eventSink = yield* EventSink.EventSinkV2;
3898 const idAllocator = yield* IdAllocator.IdAllocatorV2;
@@ -3875,7 +3921,7 @@ it.effect("ProviderSessionManagerV2 releases sessions when provider event stream
3921 runtimePolicy,
3922 });
3923 yield* runtime.events.pipe(Stream.runDrain, Effect.ignore, Effect.forkScoped);
3878 - yield* Effect.yieldNow;
3924 + yield* Deferred.await(releaseRecorded);
3925
3926 const liveSession = yield* manager.get(providerSessionId);
3927 const runtimeState = yield* Ref.get(state);
@@ -3896,6 +3942,7 @@ it.effect("ProviderSessionManagerV2 releases sessions when provider event stream
3942 state,
3943 idleTimeoutMs: 1000,
3944 failEventStream: true,
3945 + releaseRecorded,
3946 }),
3947 ),
3948 );
apps/server/src/orchestration-v2/ProviderSessionManager.ts
+8 -2
@@ -23,6 +23,7 @@ import * as Cause from "effect/Cause";
23 import * as Clock from "effect/Clock";
24 import * as Context from "effect/Context";
25 import * as DateTime from "effect/DateTime";
26 +import * as Deferred from "effect/Deferred";
27 import * as Duration from "effect/Duration";
28 import * as Effect from "effect/Effect";
29 import * as Exit from "effect/Exit";
@@ -2774,11 +2775,13 @@ export const layerWithOptions = (
2775 };
2776 };
2777
2777 - const startEventPump = (entry: LiveSessionEntry) => {
2778 + const startEventPump = (entry: LiveSessionEntry, sessionClosed: Deferred.Deferred<void>) => {
2779 let stoppedByProvider = false;
2780 let lastSessionStatus = entry.runtime.providerSession.status;
2781 const retryStalls = makeRetryStallWatch(entry);
2782 return entry.runtime.events.pipe(
2783 + // Several adapters never end their event stream, and a parked pump retains the whole session.
2784 + Stream.interruptWhen(Deferred.await(sessionClosed)),
2785 Stream.runForEach((nativeEvent) => {
2786 if (shutdownSignal.received) return Effect.void;
2787 // Live output bypasses persistence and subscribers so floods cannot delay domain events.
@@ -3043,6 +3046,9 @@ export const layerWithOptions = (
3046 }
3047 });
3048 const sessionScope = yield* Scope.fork(sessionScopes);
3049 + // Added before the adapter's finalizers so it runs after them: the pump drains shutdown events first.
3050 + const sessionClosed = yield* Deferred.make<void>();
3051 + yield* Scope.addFinalizer(sessionScope, Deferred.done(sessionClosed, Exit.void));
3052 yield* agentScope.clear(input.threadId);
3053 const runtime = yield* installationGate
3054 .execute(
@@ -3157,7 +3163,7 @@ export const layerWithOptions = (
3163 ).pipe(logReleaseFailure(input.providerSessionId)),
3164 ),
3165 );
3160 - yield* startEventPump(entry);
3166 + yield* startEventPump(entry, sessionClosed);
3167 yield* scheduleIdleRelease(input.providerSessionId);
3168 return exposedRuntime;
3169 }),