@devries-cameron20 / t3code Mirror · read-only
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, 03:37 UTC

main
ts 5,819 lines 219 KB
Raw
1 import * as NetAddress from "effect/net/NetAddress";
2 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
3 import * as NodeServices from "@effect/platform-node/NodeServices";
4 import { assert, it } from "@effect/vitest";
5 import { AgentScope } from "@t3tools/shared/AgentScope";
6 import {
7 EnvironmentId,
8 type ModelSelection,
9 type OrchestrationV2AppThread,
10 type OrchestrationV2DomainEvent,
11 type OrchestrationV2PromptSuggestion,
12 type OrchestrationV2ProviderCapabilities,
13 type OrchestrationV2ProviderSession,
14 type OrchestrationV2ProviderThread,
15 type OrchestrationV2TurnItem,
16 type Project,
17 ProjectId,
18 ProviderDriverKind,
19 ProviderInstanceId,
20 type ProviderSessionId,
21 RunId,
22 ThreadId,
23 TurnItemId,
24 } from "@t3tools/contracts";
25 import * as Cause from "effect/Cause";
26 import * as DateTime from "effect/DateTime";
27 import * as Deferred from "effect/Deferred";
28 import * as Effect from "effect/Effect";
29 import * as Exit from "effect/Exit";
30 import * as Fiber from "effect/Fiber";
31 import * as FileSystem from "effect/FileSystem";
32 import * as Layer from "effect/Layer";
33 import * as Option from "effect/Option";
34 import * as Queue from "effect/Queue";
35 import * as Ref from "effect/Ref";
36 import * as Stream from "effect/Stream";
37 import { TestClock } from "effect/testing";
38 import { HttpServer } from "effect/http";
39
40 import { ProviderWorkspaceMissingError } from "../provider/Errors.ts";
41 import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
42 import * as ProjectService from "../project/ProjectService.ts";
43 import * as McpProviderSession from "@t3tools/provider-core/server/mcpSession";
44 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
45 import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts";
46 import * as SqlitePersistence from "../persistence/Sqlite.ts";
47 import * as ServerSettings from "../serverSettings.ts";
48 import {
49 CodexProviderCapabilitiesV2,
50 normalizeCodexThreadLoadModelSelection,
51 } from "./Adapters/CodexAdapterV2.ts";
52 import * as EventSink from "./EventSink.ts";
53 import * as EventStore from "./EventStore.ts";
54 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
55 import * as ProjectionStore from "./ProjectionStore.ts";
56 import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts";
57 import * as ProviderEventIngestor from "./ProviderEventIngestor.ts";
58 import * as ProviderInstallationGate from "../provider/ProviderInstallationGate.ts";
59 import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
60 import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
61 import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts";
62 import * as ProviderSessionManager from "./ProviderSessionManager.ts";
63 import * as CommandOutputHub from "./CommandOutputHub.ts";
64 import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
65 import {
66 makeProviderFailure,
67 makeProviderRetryTurnItem,
68 } from "@t3tools/provider-core/server/failure";
69
70 const layerTestDatabase = SqlitePersistence.layerMemory;
71 const layerTestStores = Layer.merge(EventStore.layer, ProjectionStore.layer).pipe(
72 Layer.provide(layerTestDatabase),
73 );
74 const layerTestEventSink = EventSink.layer.pipe(
75 Layer.provide(Layer.mergeAll(layerTestStores, layerTestDatabase)),
76 );
77 const layerFailingReleaseEventSink = Layer.effect(
78 EventSink.EventSinkV2,
79 Effect.gen(function* () {
80 const delegate = yield* EventSink.EventSinkV2;
81 return EventSink.EventSinkV2.of({
82 ...delegate,
83 write: (input) =>
84 input.events.some(
85 (event) =>
86 event.type === "provider-session.updated" &&
87 (event.payload.status === "stopped" || event.payload.status === "error"),
88 )
89 ? Effect.fail(new EventSink.EventSinkWriteError({ eventCount: input.events.length }))
90 : delegate.write(input),
91 });
92 }),
93 ).pipe(Layer.provide(layerTestEventSink));
94
95 interface FlakyReleaseWrites {
96 readonly failing: Ref.Ref<"none" | "session" | "session-and-requests">;
97 readonly failures: Queue.Queue<void>;
98 readonly pauseRequestWrites?: {
99 readonly paused: Deferred.Deferred<void>;
100 readonly resume: Deferred.Deferred<void>;
101 };
102 }
103
104 const layerFlakyReleaseEventSink = (flaky: FlakyReleaseWrites) =>
105 Layer.effect(
106 EventSink.EventSinkV2,
107 Effect.gen(function* () {
108 const delegate = yield* EventSink.EventSinkV2;
109 return EventSink.EventSinkV2.of({
110 ...delegate,
111 write: (input) =>
112 Effect.gen(function* () {
113 const failing = yield* Ref.get(flaky.failing);
114 const fails = input.events.some(
115 (event) =>
116 (failing !== "none" &&
117 event.type === "provider-session.updated" &&
118 (event.payload.status === "stopped" || event.payload.status === "error")) ||
119 (failing === "session-and-requests" && event.type === "runtime-request.updated"),
120 );
121 const pause = flaky.pauseRequestWrites;
122 if (
123 pause !== undefined &&
124 input.events.some((event) => event.type === "runtime-request.updated")
125 ) {
126 yield* Deferred.succeed(pause.paused, undefined);
127 yield* Deferred.await(pause.resume);
128 }
129 if (!fails) return yield* delegate.write(input);
130 yield* Queue.offer(flaky.failures, undefined);
131 return yield* Effect.die(new Error("simulated commit failure"));
132 }),
133 });
134 }),
135 ).pipe(Layer.provide(layerTestEventSink));
136
137 const layerPausingAttachEventSink = (pause: {
138 readonly armed: Ref.Ref<boolean>;
139 readonly paused: Deferred.Deferred<void>;
140 }) =>
141 Layer.effect(
142 EventSink.EventSinkV2,
143 Effect.gen(function* () {
144 const delegate = yield* EventSink.EventSinkV2;
145 return EventSink.EventSinkV2.of({
146 ...delegate,
147 write: (input) =>
148 Effect.gen(function* () {
149 const attach = input.events.some((event) => event.type === "provider-session.attached");
150 if (attach && (yield* Ref.getAndSet(pause.armed, false))) {
151 yield* Deferred.succeed(pause.paused, undefined);
152 return yield* Effect.never;
153 }
154 return yield* delegate.write(input);
155 }),
156 });
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.
188 beforeTurnItems: Ref.Ref<ReadonlyArray<Effect.Effect<void>>> | undefined,
189 ) =>
190 Layer.effect(
191 EventSink.EventSinkV2,
192 Effect.gen(function* () {
193 const delegate = yield* EventSink.EventSinkV2;
194 return EventSink.EventSinkV2.of({
195 ...delegate,
196 writeIfProviderThreadUnchanged: (input) =>
197 Ref.getAndSet(before, Effect.void).pipe(
198 Effect.flatten,
199 Effect.andThen(delegate.writeIfProviderThreadUnchanged(input)),
200 ),
201 writeIfTurnItemUnchanged: (input) =>
202 (beforeTurnItems === undefined
203 ? Effect.void
204 : Ref.modify(beforeTurnItems, ([next, ...rest]) => [next ?? Effect.void, rest]).pipe(
205 Effect.flatten,
206 )
207 ).pipe(Effect.andThen(delegate.writeIfTurnItemUnchanged(input))),
208 });
209 }),
210 ).pipe(Layer.provide(layerTestEventSink));
211
212 const CodexCapabilities: OrchestrationV2ProviderCapabilities = CodexProviderCapabilitiesV2;
213 const ExclusiveCapabilities: OrchestrationV2ProviderCapabilities = {
214 ...CodexCapabilities,
215 sessions: {
216 ...CodexCapabilities.sessions,
217 supportsMultipleProviderThreadsPerSession: false,
218 },
219 };
220
221 interface TestProviderRuntimeState {
222 readonly openCount: number;
223 readonly closeCount: number;
224 readonly interruptCount: number;
225 readonly resumeCount: number;
226 readonly unloadedNativeThreadIds: ReadonlyArray<string>;
227 readonly eventQueues: ReadonlyMap<
228 string,
229 Queue.Queue<ProviderAdapter.ProviderAdapterV2Event, Cause.Done>
230 >;
231 }
232
233 const emptyState: TestProviderRuntimeState = {
234 openCount: 0,
235 closeCount: 0,
236 interruptCount: 0,
237 resumeCount: 0,
238 unloadedNativeThreadIds: [],
239 eventQueues: new Map(),
240 };
241
242 const modelSelection = {
243 instanceId: ProviderInstanceId.make("codex"),
244 model: "gpt-5.4",
245 } satisfies ModelSelection;
246 const CODEX_DRIVER = ProviderDriverKind.make("codex");
247
248 const runtimePolicy = {
249 runtimeMode: "full-access",
250 interactionMode: "default",
251 cwd: process.cwd(),
252 } satisfies ProviderAdapter.ProviderAdapterV2RuntimePolicy;
253
254 function makeProviderSession(input: {
255 readonly providerSessionId: ProviderSessionId;
256 readonly now: DateTime.Utc;
257 readonly capabilities?: OrchestrationV2ProviderCapabilities;
258 }): OrchestrationV2ProviderSession {
259 return {
260 id: input.providerSessionId,
261 driver: CODEX_DRIVER,
262 providerInstanceId: modelSelection.instanceId,
263 status: "ready",
264 cwd: process.cwd(),
265 model: "gpt-5.4",
266 capabilities: input.capabilities ?? CodexCapabilities,
267 createdAt: input.now,
268 updatedAt: input.now,
269 lastError: null,
270 };
271 }
272
273 function makeThreadCreatedEvent(input: {
274 readonly idAllocator: IdAllocator.IdAllocatorV2["Service"];
275 readonly threadId: ThreadId;
276 readonly now: DateTime.Utc;
277 readonly projectId?: ProjectId;
278 readonly delegatedBy?: ThreadId;
279 }) {
280 return Effect.gen(function* () {
281 const projectId =
282 input.projectId ??
283 (yield* input.idAllocator.allocate.project({
284 fixtureName: "provider-session-manager",
285 }));
286 const providerThreadId = input.idAllocator.derive.providerThread({
287 driver: CODEX_DRIVER,
288 nativeThreadId: "native-thread",
289 });
290 const thread: OrchestrationV2AppThread = {
291 createdBy: "user",
292 creationSource: "web",
293 id: input.threadId,
294 projectId,
295 title: "Provider session manager",
296 providerInstanceId: modelSelection.instanceId,
297 modelSelection,
298 runtimeMode: "full-access",
299 interactionMode: "default",
300 branch: null,
301 worktreePath: null,
302 activeProviderThreadId: providerThreadId,
303 lineage:
304 input.delegatedBy === undefined
305 ? { parentThreadId: null, relationshipToParent: null, rootThreadId: input.threadId }
306 : {
307 parentThreadId: input.delegatedBy,
308 relationshipToParent: "subagent",
309 rootThreadId: input.delegatedBy,
310 },
311 forkedFrom: null,
312 createdAt: input.now,
313 updatedAt: input.now,
314 archivedAt: null,
315 settledOverride: null,
316 settledAt: null,
317 lastVisitedAt: null,
318 deletedAt: null,
319 };
320 return {
321 id: yield* input.idAllocator.allocate.event({ threadId: input.threadId }),
322 type: "thread.created" as const,
323 threadId: input.threadId,
324 occurredAt: input.now,
325 payload: thread,
326 };
327 });
328 }
329
330 function makeProviderThread(input: {
331 readonly idAllocator: IdAllocator.IdAllocatorV2["Service"];
332 readonly threadId: ThreadId;
333 readonly providerSessionId: ProviderSessionId;
334 readonly now: DateTime.Utc;
335 readonly nativeThreadId?: string;
336 }): OrchestrationV2ProviderThread {
337 const nativeThreadId = input.nativeThreadId ?? "native-thread";
338 return {
339 id: input.idAllocator.derive.providerThread({
340 driver: CODEX_DRIVER,
341 nativeThreadId,
342 }),
343 driver: CODEX_DRIVER,
344 providerInstanceId: modelSelection.instanceId,
345 providerSessionId: input.providerSessionId,
346 appThreadId: input.threadId,
347 ownerNodeId: null,
348 nativeThreadRef: {
349 driver: CODEX_DRIVER,
350 nativeId: nativeThreadId,
351 strength: "strong",
352 },
353 nativeConversationHeadRef: null,
354 status: "idle",
355 firstRunOrdinal: null,
356 lastRunOrdinal: null,
357 handoffIds: [],
358 forkedFrom: null,
359 createdAt: input.now,
360 updatedAt: input.now,
361 };
362 }
363
364 // A Codex native subagent's provider thread is owned by its child app thread
365 // but reachable from the parent's projection through the subagent record.
366 const makeNativeChildFixture = Effect.fnUntraced(function* () {
367 const idAllocator = yield* IdAllocator.IdAllocatorV2;
368 const eventSink = yield* EventSink.EventSinkV2;
369 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
370 const now = yield* DateTime.now;
371 const parentThreadId = ThreadId.make("native-parent");
372 const childThreadId = ThreadId.make("native-child");
373 const providerSessionId = idAllocator.derive.providerSession({
374 providerInstanceId: modelSelection.instanceId,
375 });
376 const childThreadEvent = yield* makeThreadCreatedEvent({
377 idAllocator,
378 threadId: childThreadId,
379 now,
380 });
381 const childProviderThread = makeProviderThread({
382 idAllocator,
383 threadId: childThreadId,
384 providerSessionId,
385 nativeThreadId: "native-child-thread",
386 now,
387 });
388 const parentRunId = idAllocator.derive.run({ threadId: parentThreadId, ordinal: 1 });
389 yield* eventSink.write({
390 events: [
391 yield* makeThreadCreatedEvent({ idAllocator, threadId: parentThreadId, now }),
392 {
393 ...childThreadEvent,
394 payload: {
395 ...childThreadEvent.payload,
396 createdBy: "agent",
397 creationSource: "provider",
398 activeProviderThreadId: null,
399 lineage: {
400 parentThreadId,
401 relationshipToParent: "subagent",
402 rootThreadId: parentThreadId,
403 },
404 },
405 },
406 {
407 id: yield* idAllocator.allocate.event({ threadId: childThreadId }),
408 type: "provider-thread.updated",
409 threadId: childThreadId,
410 occurredAt: now,
411 payload: childProviderThread,
412 },
413 {
414 id: yield* idAllocator.allocate.event({ threadId: parentThreadId }),
415 type: "subagent.updated",
416 threadId: parentThreadId,
417 occurredAt: now,
418 payload: {
419 id: idAllocator.derive.nodeFromProviderItem({
420 driver: CODEX_DRIVER,
421 nativeItemId: "native-child-task",
422 }),
423 threadId: parentThreadId,
424 runId: parentRunId,
425 parentNodeId: idAllocator.derive.rootNode({ runId: parentRunId }),
426 origin: "provider_native",
427 createdBy: "agent",
428 driver: CODEX_DRIVER,
429 providerInstanceId: modelSelection.instanceId,
430 providerThreadId: childProviderThread.id,
431 childThreadId,
432 nativeTaskRef: {
433 driver: CODEX_DRIVER,
434 nativeId: "native-child-task",
435 strength: "strong",
436 },
437 prompt: "Reply READY",
438 title: "Native child",
439 model: null,
440 status: "completed",
441 result: "READY",
442 startedAt: now,
443 completedAt: now,
444 updatedAt: now,
445 },
446 },
447 ],
448 });
449 const parent = { threadId: parentThreadId, providerSessionId };
450 const runtime = yield* manager.open({ ...parent, modelSelection, runtimePolicy });
451 const resumeChild = runtime.resumeThread({
452 providerThread: childProviderThread,
453 threadId: childThreadId,
454 modelSelection,
455 runtimePolicy,
456 });
457 return { manager, parent, resumeChild };
458 });
459
460 function unimplemented(detail: string) {
461 return Effect.fail(
462 new ProviderAdapter.ProviderAdapterProtocolError({
463 driver: CODEX_DRIVER,
464 detail,
465 }),
466 );
467 }
468
469 const makeProviderAdapter = Effect.fnUntraced(function* (
470 state: Ref.Ref<TestProviderRuntimeState>,
471 options: {
472 readonly failEventStream?: boolean;
473 readonly normalizeThreadLoadModelSelection?: (selection: ModelSelection) => ModelSelection;
474 readonly capabilities?: OrchestrationV2ProviderCapabilities;
475 readonly extensionStatuses?: OrchestrationV2ProviderSession["extensionStatuses"];
476 readonly mcpConfigs?: Ref.Ref<
477 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
478 >;
479 readonly beforeOpen?: (input: {
480 readonly providerSessionId: ProviderSessionId;
481 readonly initialProviderItemIdentityVersion?: 2;
482 }) => Effect.Effect<void>;
483 readonly hasPendingBackgroundWork?: Effect.Effect<boolean>;
484 readonly hasPendingBackgroundWorkForThread?: Effect.Effect<boolean>;
485 readonly backgroundTasksEndWithProcess?: boolean;
486 readonly hangSessionScopeClose?: boolean;
487 readonly startTurn?: Effect.Effect<void, ProviderAdapter.ProviderAdapterProtocolError>;
488 readonly interruptTurn?: Effect.Effect<void>;
489 readonly beforeUnload?: Effect.Effect<void>;
490 readonly unloads?: Queue.Queue<string>;
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;
498 const countClose = Effect.addFinalizer(() =>
499 Ref.update(state, (current) => ({
500 ...current,
501 closeCount: current.closeCount + 1,
502 })).pipe(
503 Effect.andThen(
504 options.unloads === undefined ? Effect.void : Queue.offer(options.unloads, "close"),
505 ),
506 ),
507 );
508 // Register after countClose to wedge teardown before its finalizer, matching a provider stream that never yields.
509 const hangClose = Effect.addFinalizer(() =>
510 (options.scopeCloseReached === undefined
511 ? Effect.void
512 : Deferred.succeed(options.scopeCloseReached, undefined)
513 ).pipe(Effect.andThen(Effect.never)),
514 );
515 return ProviderAdapter.ProviderAdapterV2.of({
516 instanceId: ProviderInstanceId.make("codex"),
517 driver: CODEX_DRIVER,
518 getCapabilities: () => Effect.succeed(options.capabilities ?? CodexCapabilities),
519 planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" }),
520 openSession: (input) =>
521 Effect.gen(function* () {
522 if (options.spawnBeforeOpen === true) {
523 yield* countClose;
524 if (options.hangSessionScopeClose === true) yield* hangClose;
525 }
526 if (options.mcpConfigs !== undefined && options.spawnBeforeOpen === true) {
527 const mcpConfig = yield* mcpSessions.read(input.threadId);
528 yield* Ref.update(options.mcpConfigs, (configs) => [...configs, mcpConfig]);
529 }
530 if (options.beforeOpen !== undefined) {
531 yield* options.beforeOpen(input);
532 }
533 if (options.mcpConfigs !== undefined && options.spawnBeforeOpen !== true) {
534 const mcpConfig = yield* mcpSessions.read(input.threadId);
535 yield* Ref.update(options.mcpConfigs, (configs) => [...configs, mcpConfig]);
536 }
537 const now = yield* DateTime.now;
538 const events = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event, Cause.Done>();
539 let session: OrchestrationV2ProviderSession = {
540 ...makeProviderSession({
541 providerSessionId: input.providerSessionId,
542 now,
543 ...(options.capabilities === undefined ? {} : { capabilities: options.capabilities }),
544 }),
545 ...(options.extensionStatuses === undefined
546 ? {}
547 : { extensionStatuses: options.extensionStatuses }),
548 };
549 yield* Ref.update(state, (current) => {
550 const eventQueues = new Map(current.eventQueues);
551 eventQueues.set(String(input.providerSessionId), events);
552 return {
553 ...current,
554 openCount: current.openCount + 1,
555 eventQueues,
556 };
557 });
558 if (options.spawnBeforeOpen !== true) {
559 yield* countClose;
560 if (options.hangSessionScopeClose === true) yield* hangClose;
561 }
562
563 return {
564 instanceId: ProviderInstanceId.make("codex"),
565 driver: CODEX_DRIVER,
566 providerSessionId: input.providerSessionId,
567 ...(options.normalizeThreadLoadModelSelection === undefined
568 ? {}
569 : { normalizeThreadLoadModelSelection: options.normalizeThreadLoadModelSelection }),
570 get providerSession() {
571 return session;
572 },
573 events: options.failEventStream
574 ? Stream.fail(
575 new ProviderAdapter.ProviderAdapterEventStreamError({
576 driver: CODEX_DRIVER,
577 providerSessionId: input.providerSessionId,
578 cause: "process exited",
579 }),
580 )
581 : Stream.fromQueue(events).pipe(
582 Stream.tap((event) =>
583 Effect.sync(() => {
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 ? {}
595 : { backgroundTasksEndWithProcess: true as const }),
596 ...(options.hasPendingBackgroundWork === undefined
597 ? {}
598 : { hasPendingBackgroundWork: options.hasPendingBackgroundWork }),
599 ...(options.hasPendingBackgroundWorkForThread === undefined
600 ? {}
601 : {
602 hasPendingBackgroundWorkForThread: () => options.hasPendingBackgroundWorkForThread!,
603 }),
604 ensureThread: () => unimplemented("ensureThread unused in test"),
605 resumeThread: (threadInput) =>
606 Ref.update(state, (current) => ({
607 ...current,
608 resumeCount: current.resumeCount + 1,
609 })).pipe(Effect.as(threadInput.providerThread)),
610 startTurn: () => options.startTurn ?? Effect.void,
611 steerTurn: () => Effect.void,
612 interruptTurn: () =>
613 Ref.update(state, (current) => ({
614 ...current,
615 interruptCount: current.interruptCount + 1,
616 })).pipe(Effect.andThen(options.interruptTurn ?? Effect.void)),
617 unloadThread: ({ providerThread, archive }) =>
618 (options.beforeUnload ?? Effect.void).pipe(
619 Effect.andThen(
620 Ref.update(state, (current) => ({
621 ...current,
622 unloadedNativeThreadIds: [
623 ...current.unloadedNativeThreadIds,
624 providerThread.nativeThreadRef?.nativeId ?? "",
625 ],
626 })),
627 ),
628 Effect.andThen(
629 options.unloads === undefined
630 ? Effect.void
631 : Queue.offer(
632 options.unloads,
633 `${archive === true ? "archive" : "unload"}:${providerThread.nativeThreadRef?.nativeId}`,
634 ),
635 ),
636 Effect.andThen(archive === true ? (options.archive ?? Effect.void) : Effect.void),
637 ),
638 respondToRuntimeRequest: () => Effect.void,
639 readThreadSnapshot: () => unimplemented("readThreadSnapshot unused in test"),
640 rollbackThread: () => unimplemented("rollbackThread unused in test"),
641 forkThread: () => unimplemented("forkThread unused in test"),
642 } satisfies ProviderAdapter.ProviderAdapterV2SessionRuntime;
643 }),
644 });
645 });
646
647 function layerTest(input: {
648 readonly state: Ref.Ref<TestProviderRuntimeState>;
649 readonly idleTimeoutMs: number;
650 readonly maxIdlePinMs?: number;
651 readonly failEventStream?: boolean;
652 readonly normalizeThreadLoadModelSelection?: (selection: ModelSelection) => ModelSelection;
653 readonly capabilities?: OrchestrationV2ProviderCapabilities;
654 readonly extensionStatuses?: OrchestrationV2ProviderSession["extensionStatuses"];
655 readonly mcpConfigs?: Ref.Ref<
656 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
657 >;
658 readonly beforeOpen?: (input: {
659 readonly providerSessionId: ProviderSessionId;
660 readonly initialProviderItemIdentityVersion?: 2;
661 }) => Effect.Effect<void>;
662 readonly failReleaseEventWrites?: boolean;
663 readonly flakyReleaseWrites?: FlakyReleaseWrites;
664 readonly pauseAttachWrite?: Parameters<typeof layerPausingAttachEventSink>[0];
665 readonly beforeUnchangedWrite?: Ref.Ref<Effect.Effect<void>>;
666 readonly beforeTurnItemsWrite?: Ref.Ref<ReadonlyArray<Effect.Effect<void>>>;
667 readonly pauseResolve?: {
668 readonly armed: Ref.Ref<boolean>;
669 readonly paused: Deferred.Deferred<void>;
670 };
671 readonly hasPendingBackgroundWork?: Effect.Effect<boolean>;
672 readonly hasPendingBackgroundWorkForThread?: Effect.Effect<boolean>;
673 readonly backgroundTasksEndWithProcess?: boolean;
674 readonly hangSessionScopeClose?: boolean;
675 readonly startTurn?: Effect.Effect<void, ProviderAdapter.ProviderAdapterProtocolError>;
676 readonly interruptTurn?: Effect.Effect<void>;
677 readonly beforeUnload?: Effect.Effect<void>;
678 readonly unloads?: Queue.Queue<string>;
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>;
687 }) {
688 const layerConfiguredEventSink =
689 input.flakyReleaseWrites !== undefined
690 ? layerFlakyReleaseEventSink(input.flakyReleaseWrites)
691 : input.pauseAttachWrite !== undefined
692 ? layerPausingAttachEventSink(input.pauseAttachWrite)
693 : input.beforeUnchangedWrite !== undefined
694 ? layerBeforeUnchangedWriteEventSink(
695 input.beforeUnchangedWrite,
696 input.beforeTurnItemsWrite,
697 )
698 : input.failReleaseEventWrites
699 ? layerFailingReleaseEventSink
700 : input.releaseRecorded !== undefined
701 ? layerReleaseRecordedEventSink(input.releaseRecorded)
702 : layerTestEventSink;
703 const layerRegistry = Layer.unwrap(
704 makeProviderAdapter(input.state, {
705 failEventStream: input.failEventStream ?? false,
706 ...(input.normalizeThreadLoadModelSelection === undefined
707 ? {}
708 : { normalizeThreadLoadModelSelection: input.normalizeThreadLoadModelSelection }),
709 ...(input.capabilities === undefined ? {} : { capabilities: input.capabilities }),
710 ...(input.extensionStatuses === undefined
711 ? {}
712 : { extensionStatuses: input.extensionStatuses }),
713 ...(input.mcpConfigs === undefined ? {} : { mcpConfigs: input.mcpConfigs }),
714 ...(input.beforeOpen === undefined ? {} : { beforeOpen: input.beforeOpen }),
715 ...(input.hasPendingBackgroundWork === undefined
716 ? {}
717 : { hasPendingBackgroundWork: input.hasPendingBackgroundWork }),
718 ...(input.hasPendingBackgroundWorkForThread === undefined
719 ? {}
720 : { hasPendingBackgroundWorkForThread: input.hasPendingBackgroundWorkForThread }),
721 ...(input.backgroundTasksEndWithProcess === undefined
722 ? {}
723 : { backgroundTasksEndWithProcess: input.backgroundTasksEndWithProcess }),
724 ...(input.hangSessionScopeClose === undefined
725 ? {}
726 : { hangSessionScopeClose: input.hangSessionScopeClose }),
727 ...(input.startTurn === undefined ? {} : { startTurn: input.startTurn }),
728 ...(input.interruptTurn === undefined ? {} : { interruptTurn: input.interruptTurn }),
729 ...(input.beforeUnload === undefined ? {} : { beforeUnload: input.beforeUnload }),
730 ...(input.unloads === undefined ? {} : { unloads: input.unloads }),
731 ...(input.archive === undefined ? {} : { archive: input.archive }),
732 ...(input.spawnBeforeOpen === undefined ? {} : { spawnBeforeOpen: input.spawnBeforeOpen }),
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 =
742 input.pauseResolve === undefined
743 ? layerTestMcpRegistry
744 : layerPausingMcpRegistry(input.pauseResolve);
745 const layerProviderEventIngestorTest = ProviderEventIngestor.layer.pipe(
746 Layer.provide(
747 Layer.mergeAll(
748 Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
749 getInstance: () => Effect.undefined,
750 }),
751 layerConfiguredEventSink,
752 IdAllocator.layer,
753 layerTestStores,
754 ThreadCommandExecutor.layer,
755 Layer.mock(GitVcsDriver.GitVcsDriver)({
756 resolveBranchName: () => Effect.succeed(null),
757 }),
758 ),
759 ),
760 );
761 return Layer.mergeAll(
762 layerTestStores,
763 layerConfiguredEventSink,
764 IdAllocator.layer,
765 layerConfiguredMcpRegistry,
766 McpProviderSessions.layer,
767 ProviderSessionManager.layerWithOptions({
768 idleTimeoutMs: input.idleTimeoutMs,
769 ...(input.maxIdlePinMs === undefined ? {} : { maxIdlePinMs: input.maxIdlePinMs }),
770 }).pipe(
771 Layer.provide(
772 Layer.mergeAll(
773 layerRegistry.pipe(Layer.provideMerge(McpProviderSessions.layer)),
774 CommandOutputHub.layer.pipe(
775 Layer.provide(Layer.merge(layerConfiguredEventSink, layerTestStores)),
776 ),
777 layerConfiguredEventSink,
778 IdAllocator.layer,
779 layerProviderEventIngestorTest,
780 layerConfiguredMcpRegistry,
781 layerTestStores,
782 input.installationGateLayer ?? ProviderInstallationGate.layer,
783 ...(input.serverSettingsLayer === undefined ? [] : [input.serverSettingsLayer]),
784 ...(input.projectServiceLayer === undefined ? [] : [input.projectServiceLayer]),
785 ),
786 ),
787 ),
788 ).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
789 }
790
791 const fakeHttpServer = HttpServer.HttpServer.of({
792 address: NetAddress.inetAddressFromIpStringUnsafe("127.0.0.1", 43123),
793 serve: (() => Effect.void) as HttpServer.HttpServer["Service"]["serve"],
794 });
795
796 const fakeEnvironment = ServerEnvironment.ServerEnvironment.of({
797 getEnvironmentId: Effect.succeed(EnvironmentId.make("environment-provider-session-manager")),
798 getDescriptor: Effect.die("unused"),
799 });
800
801 const layerTestMcpRegistry = Layer.effect(
802 McpSessionRegistry.McpSessionRegistry,
803 McpSessionRegistry.__testing.make(),
804 ).pipe(
805 Layer.provide(Layer.succeed(HttpServer.HttpServer, fakeHttpServer)),
806 Layer.provide(Layer.succeed(ServerEnvironment.ServerEnvironment, fakeEnvironment)),
807 Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
808 );
809
810 const layerPausingMcpRegistry = (pause: {
811 readonly armed: Ref.Ref<boolean>;
812 readonly paused: Deferred.Deferred<void>;
813 }) =>
814 Layer.effect(
815 McpSessionRegistry.McpSessionRegistry,
816 Effect.gen(function* () {
817 const delegate = yield* McpSessionRegistry.McpSessionRegistry;
818 return McpSessionRegistry.McpSessionRegistry.of({
819 ...delegate,
820 resolve: (rawToken) =>
821 Ref.getAndSet(pause.armed, false).pipe(
822 Effect.flatMap((armed) =>
823 armed
824 ? Deferred.succeed(pause.paused, undefined).pipe(Effect.andThen(Effect.never))
825 : delegate.resolve(rawToken),
826 ),
827 ),
828 });
829 }),
830 ).pipe(Layer.provide(layerTestMcpRegistry));
831
832 function makeBrowserAccessProject(projectId: ProjectId): Project {
833 return {
834 id: projectId,
835 title: "Browser access project",
836 workspaceRoot: process.cwd(),
837 repositoryIdentity: null,
838 faviconPath: null,
839 projectIcon: null,
840 defaultModelSelection: null,
841 defaultThreadEnvMode: null,
842 autoPull: false,
843 scripts: [],
844 createdAt: "2026-01-01T00:00:00.000Z",
845 updatedAt: "2026-01-01T00:00:00.000Z",
846 deletedAt: null,
847 };
848 }
849
850 function runBrowserAccessScenario(input: {
851 readonly enableAgentBrowserAccess: boolean;
852 readonly projectOverride: boolean;
853 readonly deviceOverride?: boolean;
854 readonly enableAgentDeviceAccess?: boolean;
855 readonly enableDeviceSupport?: boolean;
856 readonly createThread?: boolean;
857 readonly projectExists?: boolean;
858 readonly delegatedBy?: ThreadId;
859 }) {
860 return Effect.gen(function* () {
861 const state = yield* Ref.make(emptyState);
862 const mcpConfigs = yield* Ref.make<
863 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
864 >([]);
865 const projectId = ProjectId.make("project-provider-session-manager-browser-access");
866 const threadId = ThreadId.make("thread-provider-session-manager-browser-access");
867 const layerProjectService = Layer.mock(ProjectService.ProjectService)({
868 getById: (requestedProjectId) =>
869 Effect.succeed(
870 input.projectExists === false
871 ? Option.none()
872 : Option.some(makeBrowserAccessProject(requestedProjectId)),
873 ),
874 });
875
876 yield* Effect.gen(function* () {
877 const eventSink = yield* EventSink.EventSinkV2;
878 const idAllocator = yield* IdAllocator.IdAllocatorV2;
879 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
880 const now = yield* DateTime.now;
881 const providerSessionId = yield* idAllocator.allocate.providerSession({
882 providerInstanceId: modelSelection.instanceId,
883 threadId,
884 });
885 if (input.createThread !== false) {
886 yield* eventSink.write({
887 events: [
888 yield* makeThreadCreatedEvent({
889 idAllocator,
890 threadId,
891 now,
892 projectId,
893 ...(input.delegatedBy === undefined ? {} : { delegatedBy: input.delegatedBy }),
894 }),
895 ],
896 });
897 }
898 yield* manager
899 .open({ threadId, providerSessionId, modelSelection, runtimePolicy })
900 .pipe(Effect.ignore);
901 }).pipe(
902 Effect.provide(
903 layerTest({
904 state,
905 idleTimeoutMs: 1_000,
906 mcpConfigs,
907 projectServiceLayer: layerProjectService,
908 serverSettingsLayer: ServerSettings.layerTest({
909 enableAgentBrowserAccess: input.enableAgentBrowserAccess,
910 ...(input.enableAgentDeviceAccess === undefined
911 ? {}
912 : { enableAgentDeviceAccess: input.enableAgentDeviceAccess }),
913 ...(input.enableDeviceSupport === undefined
914 ? {}
915 : { enableDeviceSupport: input.enableDeviceSupport }),
916 projectSettingsOverrides: {
917 [projectId]: {
918 enableAgentBrowserAccess: input.projectOverride,
919 ...(input.deviceOverride === undefined
920 ? {}
921 : { enableAgentDeviceAccess: input.deviceOverride }),
922 },
923 },
924 }),
925 }),
926 ),
927 );
928
929 return (yield* Ref.get(mcpConfigs))[0];
930 });
931 }
932
933 function makePendingRuntimeRequestEvents(input: {
934 readonly idAllocator: IdAllocator.IdAllocatorV2["Service"];
935 readonly threadId: ThreadId;
936 readonly providerSessionId: ProviderSessionId;
937 readonly providerThread: OrchestrationV2ProviderThread;
938 readonly now: DateTime.Utc;
939 }) {
940 return Effect.gen(function* () {
941 const requestId = yield* input.idAllocator.allocate.runtimeRequest({
942 driver: CODEX_DRIVER,
943 nativeRequestId: "pending-approval",
944 });
945 const nodeId = input.idAllocator.derive.approvalNode({ requestId });
946 const node = {
947 id: nodeId,
948 threadId: input.threadId,
949 runId: null,
950 parentNodeId: null,
951 rootNodeId: nodeId,
952 kind: "approval_request" as const,
953 status: "waiting" as const,
954 countsForRun: false,
955 providerThreadId: input.providerThread.id,
956 providerTurnId: null,
957 nativeItemRef: null,
958 runtimeRequestId: requestId,
959 checkpointScopeId: null,
960 startedAt: input.now,
961 completedAt: null,
962 };
963 const request = {
964 id: requestId,
965 nodeId,
966 providerTurnId: null,
967 nativeRequestRef: {
968 driver: CODEX_DRIVER,
969 nativeId: "pending-approval",
970 strength: "strong" as const,
971 },
972 kind: "command" as const,
973 status: "pending" as const,
974 responseCapability: {
975 type: "live" as const,
976 providerSessionId: input.providerSessionId,
977 },
978 createdAt: input.now,
979 resolvedAt: null,
980 };
981 const turnItem = {
982 id: input.idAllocator.derive.approvalTurnItem({ requestId }),
983 threadId: input.threadId,
984 runId: null,
985 nodeId,
986 providerThreadId: input.providerThread.id,
987 providerTurnId: null,
988 nativeItemRef: null,
989 parentItemId: null,
990 ordinal: 1,
991 status: "waiting" as const,
992 title: null,
993 startedAt: input.now,
994 completedAt: null,
995 updatedAt: input.now,
996 type: "approval_request" as const,
997 requestId,
998 requestKind: "command" as const,
999 };
1000 const events = [
1001 {
1002 id: yield* input.idAllocator.allocate.event({
1003 threadId: input.threadId,
1004 providerSessionId: input.providerSessionId,
1005 }),
1006 type: "node.updated" as const,
1007 threadId: input.threadId,
1008 nodeId,
1009 driver: CODEX_DRIVER,
1010 occurredAt: input.now,
1011 payload: node,
1012 },
1013 {
1014 id: yield* input.idAllocator.allocate.event({
1015 threadId: input.threadId,
1016 providerSessionId: input.providerSessionId,
1017 }),
1018 type: "runtime-request.updated" as const,
1019 threadId: input.threadId,
1020 nodeId,
1021 driver: CODEX_DRIVER,
1022 occurredAt: input.now,
1023 payload: request,
1024 },
1025 {
1026 id: yield* input.idAllocator.allocate.event({
1027 threadId: input.threadId,
1028 providerSessionId: input.providerSessionId,
1029 }),
1030 type: "turn-item.updated" as const,
1031 threadId: input.threadId,
1032 nodeId,
1033 driver: CODEX_DRIVER,
1034 occurredAt: input.now,
1035 payload: turnItem,
1036 },
1037 ] satisfies ReadonlyArray<OrchestrationV2DomainEvent>;
1038 const providerEvents = [
1039 {
1040 type: "runtime_request.updated" as const,
1041 driver: CODEX_DRIVER,
1042 threadId: input.threadId,
1043 runtimeRequest: request,
1044 },
1045 {
1046 type: "node.updated" as const,
1047 driver: CODEX_DRIVER,
1048 node,
1049 },
1050 {
1051 type: "turn_item.updated" as const,
1052 driver: CODEX_DRIVER,
1053 turnItem,
1054 },
1055 ] satisfies ReadonlyArray<ProviderAdapter.ProviderAdapterV2Event>;
1056 return { events, providerEvents, requestId, nodeId };
1057 });
1058 }
1059
1060 it.effect("ProviderSessionManagerV2 opens independent sessions concurrently", () =>
1061 Effect.gen(function* () {
1062 const state = yield* Ref.make(emptyState);
1063 const openStartedCount = yield* Ref.make(0);
1064 const firstOpenStarted = yield* Deferred.make<void>();
1065 const secondOpenStarted = yield* Deferred.make<void>();
1066 const releaseOpens = yield* Deferred.make<void>();
1067 const beforeOpen = () =>
1068 Effect.gen(function* () {
1069 const openNumber = yield* Ref.modify(openStartedCount, (count) => [count + 1, count + 1]);
1070 yield* Deferred.succeed(openNumber === 1 ? firstOpenStarted : secondOpenStarted, undefined);
1071 yield* Deferred.await(releaseOpens);
1072 });
1073
1074 const effect = Effect.gen(function* () {
1075 const eventSink = yield* EventSink.EventSinkV2;
1076 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1077 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1078 const now = yield* DateTime.now;
1079 const firstThreadId = ThreadId.make("thread-provider-session-manager-concurrent-a");
1080 const secondThreadId = ThreadId.make("thread-provider-session-manager-concurrent-b");
1081 const firstProviderSessionId = yield* idAllocator.allocate.providerSession({
1082 providerInstanceId: modelSelection.instanceId,
1083 threadId: firstThreadId,
1084 });
1085 const secondProviderSessionId = yield* idAllocator.allocate.providerSession({
1086 providerInstanceId: modelSelection.instanceId,
1087 threadId: secondThreadId,
1088 });
1089
1090 yield* eventSink.write({
1091 events: [
1092 yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
1093 yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
1094 ],
1095 });
1096 const firstFiber = yield* manager
1097 .open({
1098 threadId: firstThreadId,
1099 providerSessionId: firstProviderSessionId,
1100 modelSelection,
1101 runtimePolicy,
1102 })
1103 .pipe(Effect.forkScoped);
1104 yield* Deferred.await(firstOpenStarted);
1105 const secondFiber = yield* manager
1106 .open({
1107 threadId: secondThreadId,
1108 providerSessionId: secondProviderSessionId,
1109 modelSelection,
1110 runtimePolicy,
1111 })
1112 .pipe(Effect.forkScoped);
1113
1114 yield* Deferred.await(secondOpenStarted);
1115 assert.equal(yield* Ref.get(openStartedCount), 2);
1116 yield* Deferred.succeed(releaseOpens, undefined);
1117 const [firstRuntime, secondRuntime] = yield* Effect.all([
1118 Fiber.join(firstFiber),
1119 Fiber.join(secondFiber),
1120 ]);
1121 assert.notStrictEqual(firstRuntime, secondRuntime);
1122 assert.equal((yield* Ref.get(state)).openCount, 2);
1123 });
1124
1125 yield* effect.pipe(
1126 Effect.provide(
1127 layerTest({
1128 state,
1129 idleTimeoutMs: 60_000,
1130 beforeOpen,
1131 }),
1132 ),
1133 );
1134 }),
1135 );
1136
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;
1144 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1145 const now = yield* DateTime.now;
1146 const firstThreadId = ThreadId.make("thread-provider-session-manager-logout-a");
1147 const secondThreadId = ThreadId.make("thread-provider-session-manager-logout-b");
1148 const firstProviderSessionId = yield* idAllocator.allocate.providerSession({
1149 providerInstanceId: modelSelection.instanceId,
1150 threadId: firstThreadId,
1151 });
1152 const secondProviderSessionId = yield* idAllocator.allocate.providerSession({
1153 providerInstanceId: modelSelection.instanceId,
1154 threadId: secondThreadId,
1155 });
1156
1157 yield* eventSink.write({
1158 events: [
1159 yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
1160 yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
1161 ],
1162 });
1163 yield* manager.open({
1164 threadId: firstThreadId,
1165 providerSessionId: firstProviderSessionId,
1166 modelSelection,
1167 runtimePolicy,
1168 });
1169 yield* manager.open({
1170 threadId: secondThreadId,
1171 providerSessionId: secondProviderSessionId,
1172 modelSelection,
1173 runtimePolicy,
1174 });
1175
1176 yield* manager.closeInstance(modelSelection.instanceId);
1177
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(
1187 Effect.provide(
1188 layerTest({
1189 state,
1190 idleTimeoutMs: 60_000,
1191 eventStreamsEnded,
1192 }),
1193 ),
1194 );
1195 }),
1196 );
1197
1198 it.effect("ProviderSessionManagerV2 opens provider sessions inside the installation gate", () =>
1199 Effect.gen(function* () {
1200 const state = yield* Ref.make(emptyState);
1201 const log: Array<string> = [];
1202 const effect = Effect.gen(function* () {
1203 const eventSink = yield* EventSink.EventSinkV2;
1204 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1205 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1206 const threadId = ThreadId.make("thread-provider-session-manager-installation-gate");
1207 const providerSessionId = yield* idAllocator.allocate.providerSession({
1208 providerInstanceId: modelSelection.instanceId,
1209 threadId,
1210 });
1211 yield* eventSink.write({
1212 events: [
1213 yield* makeThreadCreatedEvent({ idAllocator, threadId, now: yield* DateTime.now }),
1214 ],
1215 });
1216
1217 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
1218
1219 assert.deepStrictEqual(log, [`enter ${modelSelection.instanceId}`, "openSession", "exit"]);
1220 });
1221
1222 yield* effect.pipe(
1223 Effect.provide(
1224 layerTest({
1225 state,
1226 idleTimeoutMs: 60_000,
1227 beforeOpen: () => Effect.sync(() => log.push("openSession")),
1228 installationGateLayer: Layer.succeed(
1229 ProviderInstallationGate.ProviderInstallationGate,
1230 ProviderInstallationGate.ProviderInstallationGate.of({
1231 execute: (instanceId, gated) =>
1232 Effect.sync(() => log.push(`enter ${instanceId}`)).pipe(
1233 Effect.andThen(gated),
1234 Effect.ensuring(Effect.sync(() => log.push("exit"))),
1235 ),
1236 update: () => Effect.die("unused"),
1237 }),
1238 ),
1239 }),
1240 ),
1241 );
1242 }),
1243 );
1244
1245 it.effect("ProviderSessionManagerV2 opens a duplicate session only once", () =>
1246 Effect.gen(function* () {
1247 const state = yield* Ref.make(emptyState);
1248 const openStartedCount = yield* Ref.make(0);
1249 const firstOpenStarted = yield* Deferred.make<void>();
1250 const releaseOpen = yield* Deferred.make<void>();
1251 const beforeOpen = () =>
1252 Ref.updateAndGet(openStartedCount, (count) => count + 1).pipe(
1253 Effect.tap(() => Deferred.succeed(firstOpenStarted, undefined)),
1254 Effect.andThen(Deferred.await(releaseOpen)),
1255 );
1256
1257 const effect = Effect.gen(function* () {
1258 const eventSink = yield* EventSink.EventSinkV2;
1259 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1260 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1261 const now = yield* DateTime.now;
1262 const threadId = ThreadId.make("thread-provider-session-manager-single-flight");
1263 const providerSessionId = yield* idAllocator.allocate.providerSession({
1264 providerInstanceId: modelSelection.instanceId,
1265 threadId,
1266 });
1267 const open = manager.open({
1268 threadId,
1269 providerSessionId,
1270 modelSelection,
1271 runtimePolicy,
1272 });
1273
1274 yield* eventSink.write({
1275 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
1276 });
1277 const firstFiber = yield* open.pipe(Effect.forkScoped);
1278 yield* Deferred.await(firstOpenStarted);
1279 const secondFiber = yield* open.pipe(Effect.forkScoped);
1280 yield* Effect.yieldNow;
1281 yield* Effect.yieldNow;
1282 assert.equal(yield* Ref.get(openStartedCount), 1);
1283
1284 yield* Deferred.succeed(releaseOpen, undefined);
1285 const [firstRuntime, secondRuntime] = yield* Effect.all([
1286 Fiber.join(firstFiber),
1287 Fiber.join(secondFiber),
1288 ]);
1289 assert.strictEqual(firstRuntime, secondRuntime);
1290 assert.equal((yield* Ref.get(state)).openCount, 1);
1291 });
1292
1293 yield* effect.pipe(
1294 Effect.provide(
1295 layerTest({
1296 state,
1297 idleTimeoutMs: 60_000,
1298 beforeOpen,
1299 }),
1300 ),
1301 );
1302 }),
1303 );
1304
1305 it.effect(
1306 "ProviderSessionManagerV2 starts a thread's session without its last agent's OOM kill",
1307 () =>
1308 Effect.gen(function* () {
1309 const state = yield* Ref.make(emptyState);
1310 const owner = ThreadId.make("thread-provider-session-manager-oom-owner");
1311 const joiner = ThreadId.make("thread-provider-session-manager-oom-joiner");
1312 const oomKilledThreads = new Set<string>([owner, joiner]);
1313 const agentScope = {
1314 ...AgentScope.defaultValue(),
1315 oomKilled: (id: string) => Effect.sync(() => oomKilledThreads.has(id)),
1316 clear: (id: string) => Effect.sync(() => void oomKilledThreads.delete(id)),
1317 };
1318
1319 const effect = Effect.gen(function* () {
1320 const eventSink = yield* EventSink.EventSinkV2;
1321 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1322 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1323 const now = yield* DateTime.now;
1324 const providerSessionId = yield* idAllocator.allocate.providerSession({
1325 providerInstanceId: modelSelection.instanceId,
1326 threadId: owner,
1327 });
1328 yield* eventSink.write({
1329 events: [
1330 yield* makeThreadCreatedEvent({ idAllocator, threadId: owner, now }),
1331 yield* makeThreadCreatedEvent({ idAllocator, threadId: joiner, now }),
1332 ],
1333 });
1334 yield* manager.open({ threadId: owner, providerSessionId, modelSelection, runtimePolicy });
1335 assert.isFalse(yield* agentScope.oomKilled(owner));
1336
1337 yield* manager.open({ threadId: joiner, providerSessionId, modelSelection, runtimePolicy });
1338 assert.isFalse(yield* agentScope.oomKilled(joiner));
1339
1340 oomKilledThreads.add(owner);
1341 yield* manager.open({ threadId: owner, providerSessionId, modelSelection, runtimePolicy });
1342 assert.isTrue(yield* agentScope.oomKilled(owner));
1343 assert.equal((yield* Ref.get(state)).openCount, 1);
1344 });
1345
1346 yield* effect.pipe(
1347 Effect.provide(layerTest({ state, idleTimeoutMs: 60_000 })),
1348 Effect.provideService(AgentScope, agentScope),
1349 );
1350 }),
1351 );
1352
1353 it.effect("ProviderSessionManagerV2 cleans up an open interrupted mid-handshake", () =>
1354 Effect.gen(function* () {
1355 const state = yield* Ref.make(emptyState);
1356 const mcpConfigs = yield* Ref.make<
1357 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
1358 >([]);
1359 const handshakeStarted = yield* Deferred.make<void>();
1360 const holdHandshake = yield* Ref.make(true);
1361 const effect = Effect.gen(function* () {
1362 const eventSink = yield* EventSink.EventSinkV2;
1363 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1364 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1365 const registry = yield* McpSessionRegistry.McpSessionRegistry;
1366 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
1367 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
1368 const now = yield* DateTime.now;
1369 const threadId = ThreadId.make("thread-provider-session-manager-interrupted-open");
1370 const providerSessionId = yield* idAllocator.allocate.providerSession({
1371 providerInstanceId: modelSelection.instanceId,
1372 threadId,
1373 });
1374 yield* eventSink.write({
1375 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
1376 });
1377
1378 const opening = yield* manager
1379 .open({ threadId, providerSessionId, modelSelection, runtimePolicy })
1380 .pipe(Effect.forkScoped);
1381 yield* Deferred.await(handshakeStarted);
1382 const issued = (yield* Ref.get(mcpConfigs)).at(-1);
1383 const token = issued?.authorizationHeader.replace(/^Bearer\s+/, "");
1384 assert.isDefined(token);
1385 assert.isDefined(yield* registry.resolve(token!));
1386
1387 yield* Fiber.interrupt(opening);
1388
1389 assert.equal((yield* Ref.get(state)).closeCount, 1);
1390 assert.isUndefined(yield* registry.resolve(token!));
1391 assert.isUndefined(yield* mcpSessions.read(threadId));
1392 assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
1393
1394 yield* Ref.set(holdHandshake, false);
1395 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
1396 const replacement = (yield* Ref.get(mcpConfigs)).at(-1);
1397 const replacementToken = replacement?.authorizationHeader.replace(/^Bearer\s+/, "");
1398 assert.isDefined(replacementToken);
1399 assert.notEqual(replacementToken, token);
1400 const projection = yield* projectionStore.getThreadProjection(threadId);
1401 assert.equal(projection.providerSessions.at(-1)?.status, "ready");
1402
1403 yield* manager.close(providerSessionId);
1404 assert.isUndefined(yield* registry.resolve(replacementToken!));
1405 });
1406
1407 yield* effect.pipe(
1408 Effect.provide(
1409 layerTest({
1410 state,
1411 idleTimeoutMs: 60_000,
1412 mcpConfigs,
1413 beforeOpen: () =>
1414 Ref.get(holdHandshake).pipe(
1415 Effect.flatMap((hold) =>
1416 hold
1417 ? Deferred.succeed(handshakeStarted, undefined).pipe(Effect.andThen(Effect.never))
1418 : Effect.void,
1419 ),
1420 ),
1421 spawnBeforeOpen: true,
1422 }),
1423 ),
1424 );
1425 }),
1426 );
1427
1428 it.effect(
1429 "ProviderSessionManagerV2 keeps a shared session busy when another thread's start is stopped early",
1430 () =>
1431 Effect.gen(function* () {
1432 const state = yield* Ref.make(emptyState);
1433 const projectId = ProjectId.make("project-provider-session-manager-shared-stopped-start");
1434 const holdProjectRead = yield* Ref.make(false);
1435 const projectReadHeld = yield* Deferred.make<void>();
1436 const projectServiceLayer = Layer.mock(ProjectService.ProjectService)({
1437 getById: (requestedProjectId) =>
1438 Ref.get(holdProjectRead).pipe(
1439 Effect.flatMap((hold) =>
1440 hold
1441 ? Deferred.succeed(projectReadHeld, undefined).pipe(Effect.andThen(Effect.never))
1442 : Effect.succeedSome(makeBrowserAccessProject(requestedProjectId)),
1443 ),
1444 ),
1445 });
1446 yield* Effect.gen(function* () {
1447 const eventSink = yield* EventSink.EventSinkV2;
1448 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1449 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1450 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
1451 const now = yield* DateTime.now;
1452 const threadA = ThreadId.make("thread-provider-session-manager-shared-stopped-a");
1453 const threadB = ThreadId.make("thread-provider-session-manager-shared-stopped-b");
1454 const providerSessionId = idAllocator.derive.providerSession({
1455 providerInstanceId: modelSelection.instanceId,
1456 });
1457 yield* eventSink.write({
1458 events: [
1459 yield* makeThreadCreatedEvent({ idAllocator, threadId: threadA, now, projectId }),
1460 yield* makeThreadCreatedEvent({ idAllocator, threadId: threadB, now, projectId }),
1461 ],
1462 });
1463 const runtime = yield* manager.open({
1464 threadId: threadA,
1465 providerSessionId,
1466 modelSelection,
1467 runtimePolicy,
1468 });
1469 yield* manager.open({
1470 threadId: threadB,
1471 providerSessionId,
1472 modelSelection,
1473 runtimePolicy,
1474 });
1475 const startTurn = (threadId: ThreadId) =>
1476 Effect.gen(function* () {
1477 const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
1478 return yield* runtime.startTurn({
1479 appThread: (yield* projectionStore.getThreadProjection(threadId)).thread,
1480 threadId,
1481 runId,
1482 runOrdinal: 1,
1483 providerTurnOrdinal: 1,
1484 attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
1485 rootNodeId: idAllocator.derive.rootNode({ runId }),
1486 providerThread: makeProviderThread({ idAllocator, threadId, providerSessionId, now }),
1487 message: {
1488 createdBy: "user",
1489 creationSource: "web",
1490 messageId: yield* idAllocator.allocate.message({ threadId, ordinal: 1 }),
1491 text: "turn",
1492 attachments: [],
1493 },
1494 modelSelection,
1495 runtimePolicy,
1496 });
1497 });
1498
1499 yield* startTurn(threadB);
1500
1501 yield* manager.detach({ providerSessionId, threadId: threadA });
1502 yield* Ref.set(holdProjectRead, true);
1503 const startingA = yield* startTurn(threadA).pipe(Effect.forkChild);
1504 yield* Deferred.await(projectReadHeld);
1505 yield* Fiber.interrupt(startingA);
1506
1507 yield* TestClock.adjust("2 seconds");
1508 yield* Effect.yieldNow;
1509 assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
1510 assert.equal((yield* Ref.get(state)).closeCount, 0);
1511 }).pipe(
1512 Effect.provide(
1513 layerTest({
1514 state,
1515 idleTimeoutMs: 1000,
1516 projectServiceLayer,
1517 serverSettingsLayer: ServerSettings.layerTest({
1518 projectSettingsOverrides: { [projectId]: { enableAgentBrowserAccess: true } },
1519 }),
1520 }),
1521 ),
1522 );
1523 }),
1524 );
1525
1526 // regression: #15571 an interrupted session start did not clean up
1527 it.effect(
1528 "ProviderSessionManagerV2 keeps a shared session busy when a stopped start still ends its turn",
1529 () =>
1530 Effect.gen(function* () {
1531 const state = yield* Ref.make(emptyState);
1532 // Like OpenCode2, a stopped start can still emit turn.terminal later.
1533 const holdStart = yield* Ref.make(false);
1534 const startHeld = yield* Deferred.make<void>();
1535 yield* Effect.gen(function* () {
1536 const eventSink = yield* EventSink.EventSinkV2;
1537 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1538 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1539 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
1540 const now = yield* DateTime.now;
1541 const threadA = ThreadId.make("thread-provider-session-manager-stopped-ended-a");
1542 const threadB = ThreadId.make("thread-provider-session-manager-stopped-ended-b");
1543 const providerSessionId = idAllocator.derive.providerSession({
1544 providerInstanceId: modelSelection.instanceId,
1545 });
1546 yield* eventSink.write({
1547 events: [
1548 yield* makeThreadCreatedEvent({ idAllocator, threadId: threadA, now }),
1549 yield* makeThreadCreatedEvent({ idAllocator, threadId: threadB, now }),
1550 ],
1551 });
1552 const runtime = yield* manager.open({
1553 threadId: threadA,
1554 providerSessionId,
1555 modelSelection,
1556 runtimePolicy,
1557 });
1558 yield* manager.open({
1559 threadId: threadB,
1560 providerSessionId,
1561 modelSelection,
1562 runtimePolicy,
1563 });
1564 const providerThreadOf = (threadId: ThreadId) =>
1565 makeProviderThread({
1566 idAllocator,
1567 threadId,
1568 providerSessionId,
1569 now,
1570 nativeThreadId: `native-${threadId}`,
1571 });
1572 const startTurn = (threadId: ThreadId) =>
1573 Effect.gen(function* () {
1574 const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
1575 return yield* runtime.startTurn({
1576 appThread: (yield* projectionStore.getThreadProjection(threadId)).thread,
1577 threadId,
1578 runId,
1579 runOrdinal: 1,
1580 providerTurnOrdinal: 1,
1581 attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
1582 rootNodeId: idAllocator.derive.rootNode({ runId }),
1583 providerThread: providerThreadOf(threadId),
1584 message: {
1585 createdBy: "user",
1586 creationSource: "web",
1587 messageId: yield* idAllocator.allocate.message({ threadId, ordinal: 1 }),
1588 text: "turn",
1589 attachments: [],
1590 },
1591 modelSelection,
1592 runtimePolicy,
1593 });
1594 });
1595
1596 yield* startTurn(threadB);
1597
1598 yield* Ref.set(holdStart, true);
1599 const startingA = yield* startTurn(threadA).pipe(Effect.forkChild);
1600 yield* Deferred.await(startHeld);
1601 yield* Fiber.interrupt(startingA);
1602
1603 const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
1604 assert.isDefined(queue);
1605 yield* Queue.offer(queue!, {
1606 type: "turn.terminal",
1607 driver: CODEX_DRIVER,
1608 providerThreadId: providerThreadOf(threadA).id,
1609 providerTurnId: idAllocator.derive.providerTurn({
1610 driver: CODEX_DRIVER,
1611 nativeTurnId: "native-turn-stopped-a",
1612 }),
1613 runOrdinal: 1,
1614 status: "completed",
1615 failure: null,
1616 threadDisposition: "reusable",
1617 });
1618
1619 yield* TestClock.adjust("2 seconds");
1620 yield* Effect.yieldNow;
1621 assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
1622 assert.equal((yield* Ref.get(state)).closeCount, 0);
1623 }).pipe(
1624 Effect.provide(
1625 layerTest({
1626 state,
1627 idleTimeoutMs: 1000,
1628 startTurn: Ref.get(holdStart).pipe(
1629 Effect.flatMap((hold) =>
1630 hold
1631 ? Deferred.succeed(startHeld, undefined).pipe(Effect.andThen(Effect.never))
1632 : Effect.void,
1633 ),
1634 ),
1635 }),
1636 ),
1637 );
1638 }),
1639 );
1640
1641 it.effect("ProviderSessionManagerV2 gives up on a provider that never confirms a Stop", () =>
1642 Effect.gen(function* () {
1643 const state = yield* Ref.make(emptyState);
1644 yield* Effect.gen(function* () {
1645 const eventSink = yield* EventSink.EventSinkV2;
1646 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1647 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1648 const now = yield* DateTime.now;
1649 const threadId = ThreadId.make("thread-provider-session-manager-unresponsive-stop");
1650 const providerSessionId = yield* idAllocator.allocate.providerSession({
1651 providerInstanceId: modelSelection.instanceId,
1652 threadId,
1653 });
1654 yield* eventSink.write({
1655 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
1656 });
1657 const runtime = yield* manager.open({
1658 threadId,
1659 providerSessionId,
1660 modelSelection,
1661 runtimePolicy,
1662 });
1663 const stopping = yield* runtime
1664 .interruptTurn({
1665 providerThread: makeProviderThread({ idAllocator, threadId, providerSessionId, now }),
1666 providerTurnId: idAllocator.derive.providerTurn({
1667 driver: CODEX_DRIVER,
1668 nativeTurnId: "native-turn-unresponsive",
1669 }),
1670 })
1671 .pipe(Effect.flip, Effect.forkChild);
1672 yield* TestClock.adjust(ProviderSessionManager.PROVIDER_INTERRUPT_TIMEOUT_MS);
1673 assert.equal((yield* Fiber.join(stopping))._tag, "ProviderAdapterInterruptTimeoutError");
1674 }).pipe(
1675 Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, interruptTurn: Effect.never })),
1676 );
1677 }),
1678 );
1679
1680 // A failed start can leave its native thread gone, as when Claude rejects a resume.
1681 it.effect("ProviderSessionManagerV2 resumes a thread natively again after its start failed", () =>
1682 Effect.gen(function* () {
1683 const state = yield* Ref.make(emptyState);
1684 yield* Effect.gen(function* () {
1685 const eventSink = yield* EventSink.EventSinkV2;
1686 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1687 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1688 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
1689 const now = yield* DateTime.now;
1690 const threadId = ThreadId.make("thread-provider-session-manager-failed-start-resume");
1691 const providerSessionId = idAllocator.derive.providerSession({
1692 providerInstanceId: modelSelection.instanceId,
1693 });
1694 yield* eventSink.write({
1695 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
1696 });
1697 const runtime = yield* manager.open({
1698 threadId,
1699 providerSessionId,
1700 modelSelection,
1701 runtimePolicy,
1702 });
1703 const providerThread = makeProviderThread({
1704 idAllocator,
1705 threadId,
1706 providerSessionId,
1707 now,
1708 nativeThreadId: `native-${threadId}`,
1709 });
1710 const resume = runtime.resumeThread({
1711 providerThread,
1712 threadId,
1713 modelSelection,
1714 runtimePolicy,
1715 });
1716 yield* resume;
1717 yield* resume;
1718 assert.equal((yield* Ref.get(state)).resumeCount, 1);
1719 const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
1720 yield* runtime
1721 .startTurn({
1722 appThread: (yield* projectionStore.getThreadProjection(threadId)).thread,
1723 threadId,
1724 runId,
1725 runOrdinal: 1,
1726 providerTurnOrdinal: 1,
1727 attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
1728 rootNodeId: idAllocator.derive.rootNode({ runId }),
1729 providerThread,
1730 message: {
1731 createdBy: "user",
1732 creationSource: "web",
1733 messageId: yield* idAllocator.allocate.message({ threadId, ordinal: 1 }),
1734 text: "turn",
1735 attachments: [],
1736 },
1737 modelSelection,
1738 runtimePolicy,
1739 })
1740 .pipe(Effect.flip);
1741 yield* resume;
1742 assert.equal((yield* Ref.get(state)).resumeCount, 2);
1743 }).pipe(
1744 Effect.provide(
1745 layerTest({
1746 state,
1747 idleTimeoutMs: 60_000,
1748 startTurn: Effect.fail(
1749 new ProviderAdapter.ProviderAdapterProtocolError({
1750 driver: CODEX_DRIVER,
1751 detail: "query ended before the turn could start",
1752 }),
1753 ),
1754 }),
1755 ),
1756 );
1757 }),
1758 );
1759
1760 it.effect("ProviderSessionManagerV2 still idles out a session releaseUnlessBusy kept", () =>
1761 Effect.gen(function* () {
1762 const state = yield* Ref.make(emptyState);
1763 yield* Effect.gen(function* () {
1764 const eventSink = yield* EventSink.EventSinkV2;
1765 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1766 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1767 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
1768 const now = yield* DateTime.now;
1769 const threadId = ThreadId.make("thread-provider-session-manager-kept-idles");
1770 const providerSessionId = idAllocator.derive.providerSession({
1771 providerInstanceId: modelSelection.instanceId,
1772 });
1773 yield* eventSink.write({
1774 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
1775 });
1776 const runtime = yield* manager.open({
1777 threadId,
1778 providerSessionId,
1779 modelSelection,
1780 runtimePolicy,
1781 });
1782 const providerThread = makeProviderThread({
1783 idAllocator,
1784 threadId,
1785 providerSessionId,
1786 now,
1787 nativeThreadId: `native-${threadId}`,
1788 });
1789 const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
1790 yield* runtime.startTurn({
1791 appThread: (yield* projectionStore.getThreadProjection(threadId)).thread,
1792 threadId,
1793 runId,
1794 runOrdinal: 1,
1795 providerTurnOrdinal: 1,
1796 attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
1797 rootNodeId: idAllocator.derive.rootNode({ runId }),
1798 providerThread,
1799 message: {
1800 createdBy: "user",
1801 creationSource: "web",
1802 messageId: yield* idAllocator.allocate.message({ threadId, ordinal: 1 }),
1803 text: "turn",
1804 attachments: [],
1805 },
1806 modelSelection,
1807 runtimePolicy,
1808 });
1809
1810 assert.isFalse(
1811 yield* manager.releaseUnlessBusy({
1812 providerSessionId,
1813 ownProviderThreadIds: [providerThread.id],
1814 throughRunOrdinal: 1,
1815 keepIf: Effect.succeed(true),
1816 reason: "manual_shutdown",
1817 }),
1818 );
1819 assert.isTrue(yield* manager.isLive(providerSessionId));
1820 // The stopped run 1 never reports its end.
1821 yield* TestClock.adjust("2 seconds");
1822 assert.isFalse(yield* manager.isLive(providerSessionId));
1823 }).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1_000 })));
1824 }),
1825 );
1826
1827 it.effect(
1828 "ProviderSessionManagerV2 keeps a shared session a sibling is busy on when releasing",
1829 () =>
1830 Effect.gen(function* () {
1831 const state = yield* Ref.make(emptyState);
1832 yield* Effect.gen(function* () {
1833 const eventSink = yield* EventSink.EventSinkV2;
1834 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1835 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1836 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
1837 const now = yield* DateTime.now;
1838 const stopping = ThreadId.make("thread-provider-session-manager-release-stopping");
1839 const sibling = ThreadId.make("thread-provider-session-manager-release-sibling");
1840 const providerSessionId = idAllocator.derive.providerSession({
1841 providerInstanceId: modelSelection.instanceId,
1842 });
1843 yield* eventSink.write({
1844 events: [
1845 yield* makeThreadCreatedEvent({ idAllocator, threadId: stopping, now }),
1846 yield* makeThreadCreatedEvent({ idAllocator, threadId: sibling, now }),
1847 ],
1848 });
1849 const runtime = yield* manager.open({
1850 threadId: stopping,
1851 providerSessionId,
1852 modelSelection,
1853 runtimePolicy,
1854 });
1855 yield* manager.open({
1856 threadId: sibling,
1857 providerSessionId,
1858 modelSelection,
1859 runtimePolicy,
1860 });
1861 const providerThreadOf = (threadId: ThreadId) =>
1862 makeProviderThread({
1863 idAllocator,
1864 threadId,
1865 providerSessionId,
1866 now,
1867 nativeThreadId: `native-${threadId}`,
1868 });
1869 const runId = idAllocator.derive.run({ threadId: sibling, ordinal: 1 });
1870 yield* runtime.startTurn({
1871 appThread: (yield* projectionStore.getThreadProjection(sibling)).thread,
1872 threadId: sibling,
1873 runId,
1874 runOrdinal: 1,
1875 providerTurnOrdinal: 1,
1876 attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
1877 rootNodeId: idAllocator.derive.rootNode({ runId }),
1878 providerThread: providerThreadOf(sibling),
1879 message: {
1880 createdBy: "user",
1881 creationSource: "web",
1882 messageId: yield* idAllocator.allocate.message({ threadId: sibling, ordinal: 1 }),
1883 text: "turn",
1884 attachments: [],
1885 },
1886 modelSelection,
1887 runtimePolicy,
1888 });
1889 const release = (own: ThreadId) =>
1890 manager.releaseUnlessBusy({
1891 providerSessionId,
1892 ownProviderThreadIds: [providerThreadOf(own).id],
1893 throughRunOrdinal: 1,
1894 reason: "manual_shutdown",
1895 });
1896
1897 assert.isFalse(yield* release(stopping));
1898 assert.isTrue(yield* manager.isLive(providerSessionId));
1899 assert.isTrue(yield* release(sibling));
1900 assert.isFalse(yield* manager.isLive(providerSessionId));
1901
1902 // A turn that starts on a runtime released meanwhile fails instead of running on it.
1903 const startOnReleasedRuntime = Effect.gen(function* () {
1904 const lateRunId = idAllocator.derive.run({ threadId: stopping, ordinal: 1 });
1905 return yield* Effect.flip(
1906 runtime.startTurn({
1907 appThread: (yield* projectionStore.getThreadProjection(stopping)).thread,
1908 threadId: stopping,
1909 runId: lateRunId,
1910 runOrdinal: 1,
1911 providerTurnOrdinal: 1,
1912 attemptId: idAllocator.derive.runAttempt({ runId: lateRunId, attemptOrdinal: 1 }),
1913 rootNodeId: idAllocator.derive.rootNode({ runId: lateRunId }),
1914 providerThread: providerThreadOf(stopping),
1915 message: {
1916 createdBy: "user",
1917 creationSource: "web",
1918 messageId: yield* idAllocator.allocate.message({ threadId: stopping, ordinal: 1 }),
1919 text: "turn",
1920 attachments: [],
1921 },
1922 modelSelection,
1923 runtimePolicy,
1924 }),
1925 );
1926 });
1927 assert.equal((yield* startOnReleasedRuntime)._tag, "ProviderAdapterTurnStartError");
1928
1929 // Nor may it leave its turn busy on a replacement opened under the same id.
1930 yield* manager.open({
1931 threadId: sibling,
1932 providerSessionId,
1933 modelSelection,
1934 runtimePolicy,
1935 });
1936 assert.equal((yield* startOnReleasedRuntime)._tag, "ProviderAdapterTurnStartError");
1937 assert.isTrue(yield* release(sibling));
1938 }).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60 * 60_000 })));
1939 }),
1940 );
1941
1942 it.effect("ProviderSessionManagerV2 stops a session still opening when its layer shuts down", () =>
1943 Effect.gen(function* () {
1944 const state = yield* Ref.make(emptyState);
1945 const handshakeStarted = yield* Deferred.make<void>();
1946 yield* Effect.gen(function* () {
1947 const eventSink = yield* EventSink.EventSinkV2;
1948 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1949 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1950 const now = yield* DateTime.now;
1951 const threadId = ThreadId.make("thread-provider-session-manager-shutdown-during-open");
1952 const providerSessionId = yield* idAllocator.allocate.providerSession({
1953 providerInstanceId: modelSelection.instanceId,
1954 threadId,
1955 });
1956 yield* eventSink.write({
1957 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
1958 });
1959 yield* manager
1960 .open({ threadId, providerSessionId, modelSelection, runtimePolicy })
1961 .pipe(Effect.forkDetach);
1962 yield* Deferred.await(handshakeStarted);
1963 assert.equal((yield* Ref.get(state)).closeCount, 0);
1964 }).pipe(
1965 Effect.provide(
1966 layerTest({
1967 state,
1968 idleTimeoutMs: 60_000,
1969 beforeOpen: () =>
1970 Deferred.succeed(handshakeStarted, undefined).pipe(Effect.andThen(Effect.never)),
1971 spawnBeforeOpen: true,
1972 }),
1973 ),
1974 );
1975
1976 assert.equal((yield* Ref.get(state)).closeCount, 1);
1977 }),
1978 );
1979
1980 it.effect(
1981 "ProviderSessionManagerV2 projects idle extension statuses and rejects a retired runtime's updates",
1982 () =>
1983 Effect.gen(function* () {
1984 const state = yield* Ref.make(emptyState);
1985 yield* Effect.gen(function* () {
1986 const eventSink = yield* EventSink.EventSinkV2;
1987 const idAllocator = yield* IdAllocator.IdAllocatorV2;
1988 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
1989 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
1990 const threadId = ThreadId.make("thread-extension-status");
1991 const providerSessionId = yield* idAllocator.allocate.providerSession({
1992 providerInstanceId: modelSelection.instanceId,
1993 threadId,
1994 });
1995 yield* eventSink.write({
1996 events: [
1997 yield* makeThreadCreatedEvent({ idAllocator, threadId, now: yield* DateTime.now }),
1998 ],
1999 });
2000 const runtime = yield* manager.open({
2001 threadId,
2002 providerSessionId,
2003 modelSelection,
2004 runtimePolicy,
2005 });
2006 const firstClient = yield* runtime.subscribeEvents!;
2007 const secondClient = yield* runtime.subscribeEvents!;
2008 const oldQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
2009 assert.isDefined(oldQueue);
2010 const statuses = [{ key: "watch", text: "Watching 4 files" }];
2011 yield* Queue.offer(oldQueue!, {
2012 type: "provider_session.updated",
2013 driver: CODEX_DRIVER,
2014 providerSession: { ...runtime.providerSession, extensionStatuses: statuses },
2015 });
2016 yield* Effect.all([
2017 firstClient.events.pipe(Stream.runHead),
2018 secondClient.events.pipe(Stream.runHead),
2019 ]);
2020 assert.deepEqual(
2021 (yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
2022 ?.extensionStatuses,
2023 statuses,
2024 );
2025 const reused = yield* manager.open({
2026 threadId,
2027 providerSessionId,
2028 modelSelection,
2029 runtimePolicy,
2030 });
2031 assert.deepEqual(reused.providerSession.extensionStatuses, statuses);
2032 yield* eventSink.write({
2033 events: [
2034 {
2035 id: yield* idAllocator.allocate.event({ threadId, providerSessionId }),
2036 type: "provider-session.updated",
2037 threadId,
2038 driver: CODEX_DRIVER,
2039 providerInstanceId: modelSelection.instanceId,
2040 occurredAt: yield* DateTime.now,
2041 payload: reused.providerSession,
2042 },
2043 ],
2044 });
2045 assert.deepEqual(
2046 (yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
2047 ?.extensionStatuses,
2048 statuses,
2049 );
2050 yield* manager.close(providerSessionId);
2051 assert.deepEqual(
2052 (yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
2053 ?.extensionStatuses,
2054 [],
2055 );
2056 const replacement = yield* manager.open({
2057 threadId,
2058 providerSessionId,
2059 modelSelection,
2060 runtimePolicy,
2061 });
2062 const replacementClient = yield* replacement.subscribeEvents!;
2063 const newQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
2064 assert.isDefined(newQueue);
2065 yield* Queue.offer(oldQueue!, {
2066 type: "provider_session.updated",
2067 driver: CODEX_DRIVER,
2068 providerSession: {
2069 ...runtime.providerSession,
2070 extensionStatuses: [{ key: "stale", text: "Old session" }],
2071 },
2072 });
2073 yield* Queue.offer(newQueue!, {
2074 type: "provider_session.updated",
2075 driver: CODEX_DRIVER,
2076 providerSession: {
2077 ...replacement.providerSession,
2078 extensionStatuses: [{ key: "new", text: "New session" }],
2079 },
2080 });
2081 yield* replacementClient.events.pipe(Stream.runHead);
2082 assert.deepEqual(
2083 (yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
2084 ?.extensionStatuses,
2085 [{ key: "new", text: "New session" }],
2086 );
2087 assert.lengthOf((yield* projectionStore.getThreadProjection(threadId)).messages, 0);
2088 assert.lengthOf((yield* projectionStore.getThreadProjection(threadId)).turnItems, 0);
2089 }).pipe(
2090 Effect.provide(
2091 layerTest({
2092 state,
2093 idleTimeoutMs: 60_000,
2094 extensionStatuses: [{ key: "initial", text: "Watching" }],
2095 }),
2096 ),
2097 );
2098 }),
2099 );
2100
2101 it.effect.each(["session metadata", "session status changes", "provider work"] as const)(
2102 "ProviderSessionManagerV2 expires idle sessions according to %s",
2103 (activity) =>
2104 Effect.gen(function* () {
2105 const state = yield* Ref.make(emptyState);
2106 yield* Effect.gen(function* () {
2107 const eventSink = yield* EventSink.EventSinkV2;
2108 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2109 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2110 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
2111 const threadId = ThreadId.make("thread-session-metadata-idle");
2112 const providerSessionId = yield* idAllocator.allocate.providerSession({
2113 providerInstanceId: modelSelection.instanceId,
2114 threadId,
2115 });
2116 yield* eventSink.write({
2117 events: [
2118 yield* makeThreadCreatedEvent({ idAllocator, threadId, now: yield* DateTime.now }),
2119 ],
2120 });
2121 const runtime = yield* manager.open({
2122 threadId,
2123 providerSessionId,
2124 modelSelection,
2125 runtimePolicy,
2126 });
2127 const subscriber = yield* runtime.subscribeEvents!;
2128 const observed = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
2129 yield* subscriber.events.pipe(
2130 Stream.runForEach((event) => Queue.offer(observed, event)),
2131 Effect.ignore,
2132 Effect.forkScoped,
2133 );
2134 const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
2135 assert.isDefined(queue);
2136 const waitingSession = { ...runtime.providerSession, status: "waiting" as const };
2137 yield* Queue.offer(queue!, {
2138 type: "provider_session.updated",
2139 driver: CODEX_DRIVER,
2140 providerSession: waitingSession,
2141 });
2142 yield* Queue.take(observed);
2143
2144 for (const text of ["Watching 1 file", "Watching 2 files"]) {
2145 yield* TestClock.adjust("300 millis");
2146 yield* Queue.offer(queue!, {
2147 type: "provider_session.updated",
2148 driver: CODEX_DRIVER,
2149 providerSession: {
2150 ...waitingSession,
2151 extensionStatuses: [{ key: "watch", text }],
2152 },
2153 });
2154 yield* Queue.take(observed);
2155 }
2156 yield* TestClock.adjust("300 millis");
2157 const statuses = [{ key: "watch", text: "Watching 3 files" }];
2158 yield* Queue.offer(
2159 queue!,
2160 activity === "provider work"
2161 ? {
2162 type: "provider_thread.updated",
2163 driver: CODEX_DRIVER,
2164 providerThread: makeProviderThread({
2165 idAllocator,
2166 threadId,
2167 providerSessionId,
2168 now: yield* DateTime.now,
2169 }),
2170 }
2171 : {
2172 type: "provider_session.updated",
2173 driver: CODEX_DRIVER,
2174 providerSession: {
2175 ...waitingSession,
2176 status: activity === "session status changes" ? "ready" : "waiting",
2177 extensionStatuses: statuses,
2178 },
2179 },
2180 );
2181 yield* Queue.take(observed);
2182 if (activity !== "provider work") {
2183 assert.deepEqual(
2184 (yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
2185 ?.extensionStatuses,
2186 statuses,
2187 );
2188 }
2189 const afterSequence = yield* eventSink.latestSequence({ threadId });
2190 yield* TestClock.adjust("100 millis");
2191 assert.equal(yield* manager.isLive(providerSessionId), activity !== "session metadata");
2192 if (activity !== "session metadata") {
2193 yield* TestClock.adjust("900 millis");
2194 }
2195 assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
2196 yield* eventSink
2197 .stream({ threadId, afterSequence, eventType: "provider-session.updated" })
2198 .pipe(
2199 Stream.filter(
2200 (stored) =>
2201 stored.event.type === "provider-session.updated" &&
2202 stored.event.payload.status === "stopped",
2203 ),
2204 Stream.runHead,
2205 );
2206 assert.deepEqual(
2207 (yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
2208 ?.extensionStatuses,
2209 [],
2210 );
2211 assert.equal((yield* Ref.get(state)).closeCount, 1);
2212 }).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1_000 })));
2213 }),
2214 );
2215
2216 it.effect("ProviderSessionManagerV2 interrupts event subscriptions on server shutdown", () =>
2217 Effect.gen(function* () {
2218 const state = yield* Ref.make(emptyState);
2219 const effect = Effect.gen(function* () {
2220 const eventSink = yield* EventSink.EventSinkV2;
2221 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2222 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2223 const now = yield* DateTime.now;
2224 const threadId = ThreadId.make("thread-provider-session-manager-shutdown-subscription");
2225 const providerSessionId = yield* idAllocator.allocate.providerSession({
2226 providerInstanceId: modelSelection.instanceId,
2227 threadId,
2228 });
2229 yield* eventSink.write({
2230 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
2231 });
2232 const runtime = yield* manager.open({
2233 threadId,
2234 providerSessionId,
2235 modelSelection,
2236 runtimePolicy,
2237 });
2238 const bufferedSubscription = yield* runtime.subscribeEvents!;
2239 const activeSubscription = yield* runtime.subscribeEvents!;
2240 const adapterQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
2241 assert.isDefined(adapterQueue);
2242 yield* Queue.offer(adapterQueue!, {
2243 type: "provider_session.updated",
2244 driver: CODEX_DRIVER,
2245 providerSession: runtime.providerSession,
2246 });
2247 assert.isTrue(Option.isSome(yield* activeSubscription.events.pipe(Stream.runHead)));
2248
2249 yield* manager.shutdown;
2250
2251 const exit = yield* bufferedSubscription.events.pipe(Stream.runCollect, Effect.exit);
2252 assert.isTrue(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause));
2253 });
2254
2255 yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60_000 })));
2256 }),
2257 );
2258
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;
2266 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2267 const now = yield* DateTime.now;
2268 const threadId = ThreadId.make("thread-provider-session-manager-provider-stop");
2269 const providerSessionId = yield* idAllocator.allocate.providerSession({
2270 providerInstanceId: modelSelection.instanceId,
2271 threadId,
2272 });
2273 yield* eventSink.write({
2274 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
2275 });
2276 const runtime = yield* manager.open({
2277 threadId,
2278 providerSessionId,
2279 modelSelection,
2280 runtimePolicy,
2281 });
2282 const subscription = yield* runtime.subscribeEvents!;
2283 const collected = yield* subscription.events.pipe(Stream.runCollect, Effect.forkScoped);
2284 const adapterQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
2285 assert.isDefined(adapterQueue);
2286 const providerThreadId = idAllocator.derive.providerThread({
2287 driver: CODEX_DRIVER,
2288 nativeThreadId: "provider-stop-thread",
2289 });
2290 const providerTurnId = idAllocator.derive.providerTurn({
2291 driver: CODEX_DRIVER,
2292 nativeTurnId: "provider-stop-turn",
2293 });
2294 yield* Queue.offer(adapterQueue!, {
2295 type: "turn.terminal",
2296 driver: CODEX_DRIVER,
2297 providerThreadId,
2298 providerTurnId,
2299 runOrdinal: 1,
2300 status: "completed",
2301 failure: null,
2302 threadDisposition: "reusable",
2303 });
2304 yield* Queue.offer(adapterQueue!, {
2305 type: "provider_session.updated",
2306 driver: CODEX_DRIVER,
2307 providerSession: {
2308 ...runtime.providerSession,
2309 status: "stopped",
2310 updatedAt: now,
2311 },
2312 });
2313 yield* Queue.end(adapterQueue!);
2314
2315 const events = Array.from(yield* Fiber.join(collected));
2316 assert.deepEqual(
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
2325 yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, unloads })));
2326 }),
2327 );
2328
2329 it.effect("ProviderSessionManagerV2 fails a turn whose provider retry never resumes", () =>
2330 Effect.gen(function* () {
2331 const state = yield* Ref.make(emptyState);
2332 const interrupted = yield* Deferred.make<void>();
2333 const effect = Effect.gen(function* () {
2334 const eventSink = yield* EventSink.EventSinkV2;
2335 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2336 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2337 const now = yield* DateTime.now;
2338 const threadId = ThreadId.make("thread-provider-session-manager-retry-stall");
2339 const providerSessionId = yield* idAllocator.allocate.providerSession({
2340 providerInstanceId: modelSelection.instanceId,
2341 threadId,
2342 });
2343 const providerThread = makeProviderThread({ idAllocator, threadId, providerSessionId, now });
2344 yield* eventSink.write({
2345 events: [
2346 yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
2347 {
2348 id: yield* idAllocator.allocate.event({ threadId }),
2349 type: "provider-thread.updated",
2350 threadId,
2351 occurredAt: now,
2352 payload: providerThread,
2353 },
2354 ],
2355 });
2356 const runtime = yield* manager.open({
2357 threadId,
2358 providerSessionId,
2359 modelSelection,
2360 runtimePolicy,
2361 });
2362 const subscription = yield* runtime.subscribeEvents!;
2363 const published = yield* Queue.unbounded<void>();
2364 // The pump updates the stall watch before it publishes a turn item.
2365 const collected = yield* subscription.events.pipe(
2366 Stream.tap((event) =>
2367 event.type === "turn_item.updated" ? Queue.offer(published, undefined) : Effect.void,
2368 ),
2369 Stream.runCollect,
2370 Effect.forkScoped,
2371 );
2372 const adapterQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
2373 assert.isDefined(adapterQueue);
2374 const providerTurnId = idAllocator.derive.providerTurn({
2375 driver: CODEX_DRIVER,
2376 nativeTurnId: "retry-stall-turn",
2377 });
2378 const failure = makeProviderFailure({
2379 message: "Rate limit exceeded",
2380 code: "rate_limited",
2381 class: "usage_limit",
2382 retryable: true,
2383 });
2384 const retry = { attempt: 2, maxAttempts: 5, retryDelayMs: 60_000 };
2385 const retryItem = (status: "running" | "interrupted") =>
2386 makeProviderRetryTurnItem({
2387 driver: CODEX_DRIVER,
2388 threadId,
2389 runId: null,
2390 nodeId: null,
2391 providerThreadId: providerThread.id,
2392 providerTurnId,
2393 itemOrdinal: 3,
2394 failure,
2395 retry,
2396 status,
2397 startedAt: now,
2398 updatedAt: now,
2399 });
2400 yield* Queue.offer(adapterQueue!, {
2401 type: "turn_item.updated",
2402 driver: CODEX_DRIVER,
2403 turnItem: retryItem("running"),
2404 });
2405 yield* Queue.take(published);
2406 const offerOutput = (outputThreadId: ThreadId) =>
2407 Queue.offer(adapterQueue!, {
2408 type: "turn_item.updated",
2409 driver: CODEX_DRIVER,
2410 turnItem: {
2411 id: idAllocator.derive.turnItemFromProviderItem({
2412 driver: CODEX_DRIVER,
2413 nativeItemId: `retry-stall-output-${outputThreadId}`,
2414 }),
2415 threadId: outputThreadId,
2416 runId: null,
2417 nodeId: null,
2418 providerThreadId: providerThread.id,
2419 providerTurnId,
2420 nativeItemRef: null,
2421 parentItemId: null,
2422 ordinal: 4,
2423 type: "compaction",
2424 driver: CODEX_DRIVER,
2425 status: "running",
2426 title: "Compacting context",
2427 startedAt: now,
2428 completedAt: null,
2429 updatedAt: now,
2430 },
2431 }).pipe(Effect.andThen(Queue.take(published)));
2432 // The stall window is 15 minutes plus the provider's announced retry delay.
2433 yield* TestClock.adjust("15 minutes");
2434 assert.equal((yield* Ref.get(state)).interruptCount, 0);
2435 // Output on the retry's thread proves the provider is alive, so a new window starts.
2436 yield* offerOutput(threadId);
2437 yield* TestClock.adjust("1 minute");
2438 // Another thread's output lets the timer start its next wait and does not count.
2439 yield* offerOutput(ThreadId.make("thread-provider-session-manager-retry-stall-other"));
2440 yield* TestClock.adjust("15 minutes");
2441 assert.equal((yield* Ref.get(state)).interruptCount, 0);
2442 yield* TestClock.adjust("1 minute");
2443 yield* Deferred.await(interrupted);
2444 yield* Queue.offer(adapterQueue!, {
2445 type: "turn_item.updated",
2446 driver: CODEX_DRIVER,
2447 turnItem: retryItem("interrupted"),
2448 });
2449 yield* Queue.offer(adapterQueue!, {
2450 type: "provider_turn.updated",
2451 driver: CODEX_DRIVER,
2452 threadId,
2453 providerTurn: {
2454 id: providerTurnId,
2455 providerThreadId: providerThread.id,
2456 nodeId: idAllocator.derive.rootNode({
2457 runId: idAllocator.derive.run({ threadId, ordinal: 1 }),
2458 }),
2459 runAttemptId: null,
2460 nativeTurnRef: null,
2461 ordinal: 1,
2462 status: "interrupted",
2463 startedAt: now,
2464 completedAt: now,
2465 },
2466 });
2467 yield* Queue.offer(adapterQueue!, {
2468 type: "turn.terminal",
2469 driver: CODEX_DRIVER,
2470 providerThreadId: providerThread.id,
2471 providerTurnId,
2472 runOrdinal: 1,
2473 status: "interrupted",
2474 failure: null,
2475 threadDisposition: "reusable",
2476 });
2477 yield* Queue.offer(adapterQueue!, {
2478 type: "provider_session.updated",
2479 driver: CODEX_DRIVER,
2480 providerSession: { ...runtime.providerSession, status: "stopped", updatedAt: now },
2481 });
2482 yield* Queue.end(adapterQueue!);
2483
2484 const events = Array.from(yield* Fiber.join(collected));
2485 const terminal = events.find((event) => event.type === "turn.terminal");
2486 const providerTurn = events.find((event) => event.type === "provider_turn.updated");
2487 assert.equal(
2488 providerTurn?.type === "provider_turn.updated" ? providerTurn.providerTurn.status : null,
2489 "failed",
2490 );
2491 assert.deepEqual(terminal, {
2492 type: "turn.terminal",
2493 driver: CODEX_DRIVER,
2494 providerThreadId: providerThread.id,
2495 providerTurnId,
2496 runOrdinal: 1,
2497 failureItemOrdinal: 3,
2498 status: "failed",
2499 failure: { ...failure, retryable: false },
2500 retry,
2501 retryStartedAt: now,
2502 threadDisposition: "reusable",
2503 });
2504 });
2505
2506 yield* effect.pipe(
2507 Effect.provide(
2508 layerTest({
2509 state,
2510 idleTimeoutMs: 60 * 60_000,
2511 interruptTurn: Deferred.succeed(interrupted, undefined).pipe(Effect.asVoid),
2512 }),
2513 ),
2514 );
2515 }),
2516 );
2517
2518 it("ProviderSessionManagerV2 counts a delegated task as a wake only while its result can be delivered", () => {
2519 const runId = RunId.make("run-delegating");
2520 const thread = { archivedAt: null, deletedAt: null };
2521 const task = {
2522 origin: "app_owned" as const,
2523 status: "running" as const,
2524 runId,
2525 completionDelivery: undefined,
2526 };
2527 const run = (disposition: "open" | "disposed") => ({
2528 id: runId,
2529 delegatedCompletion: { disposition, nextGeneration: 1, delivery: null },
2530 });
2531 assert.isTrue(
2532 ProviderSessionManager.delegatedTaskWillWake({
2533 thread,
2534 runs: [run("open")],
2535 subagents: [task],
2536 }),
2537 );
2538 // An interrupted completion wake disposes the cohort, so the result never wakes the thread.
2539 assert.isFalse(
2540 ProviderSessionManager.delegatedTaskWillWake({
2541 thread,
2542 runs: [run("disposed")],
2543 subagents: [task],
2544 }),
2545 );
2546 assert.isFalse(
2547 ProviderSessionManager.delegatedTaskWillWake({
2548 thread,
2549 runs: [run("open")],
2550 subagents: [{ ...task, origin: "provider_native" }],
2551 }),
2552 );
2553 });
2554
2555 it.effect(
2556 "ProviderSessionManagerV2 issues MCP credentials before opening and revokes them on close",
2557 () =>
2558 Effect.gen(function* () {
2559 const state = yield* Ref.make(emptyState);
2560 const mcpConfigs = yield* Ref.make<
2561 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
2562 >([]);
2563 const effect = Effect.gen(function* () {
2564 const eventSink = yield* EventSink.EventSinkV2;
2565 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2566 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2567 const registry = yield* McpSessionRegistry.McpSessionRegistry;
2568 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
2569 const now = yield* DateTime.now;
2570 const threadId = ThreadId.make("thread-provider-session-manager-mcp");
2571 const providerSessionId = yield* idAllocator.allocate.providerSession({
2572 providerInstanceId: modelSelection.instanceId,
2573 threadId,
2574 });
2575
2576 yield* eventSink.write({
2577 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
2578 });
2579 yield* manager.open({
2580 threadId,
2581 providerSessionId,
2582 modelSelection,
2583 runtimePolicy,
2584 });
2585
2586 const captured = (yield* Ref.get(mcpConfigs))[0];
2587 assert.isDefined(captured);
2588 assert.equal(captured?.threadId, threadId);
2589 assert.equal(captured?.providerInstanceId, modelSelection.instanceId);
2590 assert.equal(captured?.endpoint, "http://127.0.0.1:43123/mcp");
2591 const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");
2592 assert.isDefined(token);
2593 const resolved = yield* registry.resolve(token!);
2594 assert.equal(resolved?.thread.threadId, threadId);
2595 assert.deepEqual(
2596 resolved?.capabilities,
2597 new Set(["preview", "orchestration", "worktree", "pull-requests", "issues"]),
2598 );
2599
2600 assert.isFalse(yield* captured!.hasPendingWake!);
2601
2602 yield* manager.close(providerSessionId);
2603 assert.isUndefined(yield* mcpSessions.read(threadId));
2604 assert.isUndefined(yield* registry.resolve(token!));
2605 });
2606
2607 yield* effect.pipe(
2608 Effect.provide(
2609 layerTest({
2610 state,
2611 idleTimeoutMs: 1_000,
2612 mcpConfigs,
2613 }),
2614 ),
2615 );
2616 }),
2617 );
2618
2619 it.effect.each([
2620 { relationshipToParent: null, subagent: false },
2621 { relationshipToParent: "subagent", subagent: true },
2622 ] as const)(
2623 "ProviderSessionManagerV2 marks MCP credentials of delegated children ($relationshipToParent)",
2624 ({ relationshipToParent, subagent }) =>
2625 Effect.gen(function* () {
2626 const state = yield* Ref.make(emptyState);
2627 const mcpConfigs = yield* Ref.make<
2628 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
2629 >([]);
2630 const effect = Effect.gen(function* () {
2631 const eventSink = yield* EventSink.EventSinkV2;
2632 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2633 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2634 const registry = yield* McpSessionRegistry.McpSessionRegistry;
2635 const now = yield* DateTime.now;
2636 const threadId = ThreadId.make("thread-provider-session-manager-mcp-lineage");
2637 const providerSessionId = yield* idAllocator.allocate.providerSession({
2638 providerInstanceId: modelSelection.instanceId,
2639 threadId,
2640 });
2641 const created = yield* makeThreadCreatedEvent({ idAllocator, threadId, now });
2642 const parentThreadId = ThreadId.make("thread-provider-session-manager-mcp-parent");
2643 yield* eventSink.write({
2644 events: [
2645 {
2646 ...created,
2647 payload: {
2648 ...created.payload,
2649 lineage:
2650 relationshipToParent === null
2651 ? created.payload.lineage
2652 : { parentThreadId, relationshipToParent, rootThreadId: parentThreadId },
2653 },
2654 },
2655 ],
2656 });
2657 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
2658
2659 const token = (yield* Ref.get(mcpConfigs))[0]?.authorizationHeader.replace(
2660 /^Bearer\s+/,
2661 "",
2662 );
2663 assert.isDefined(token);
2664 assert.equal((yield* registry.resolve(token!))?.thread.subagent, subagent);
2665 yield* manager.close(providerSessionId);
2666 });
2667
2668 yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1_000, mcpConfigs })));
2669 }),
2670 );
2671
2672 it.effect(
2673 "ProviderSessionManagerV2 withholds the preview capability when agent browser access is off",
2674 () =>
2675 Effect.gen(function* () {
2676 const state = yield* Ref.make(emptyState);
2677 const mcpConfigs = yield* Ref.make<
2678 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
2679 >([]);
2680 const effect = Effect.gen(function* () {
2681 const eventSink = yield* EventSink.EventSinkV2;
2682 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2683 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2684 const registry = yield* McpSessionRegistry.McpSessionRegistry;
2685 const now = yield* DateTime.now;
2686 const threadId = ThreadId.make("thread-provider-session-manager-no-browser");
2687 const providerSessionId = yield* idAllocator.allocate.providerSession({
2688 providerInstanceId: modelSelection.instanceId,
2689 threadId,
2690 });
2691
2692 yield* eventSink.write({
2693 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
2694 });
2695 yield* manager.open({
2696 threadId,
2697 providerSessionId,
2698 modelSelection,
2699 runtimePolicy,
2700 });
2701
2702 const captured = (yield* Ref.get(mcpConfigs))[0];
2703 assert.isDefined(captured);
2704 assert.equal(captured?.browserToolsAvailable, false);
2705 const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");
2706 const resolved = yield* registry.resolve(token!);
2707 assert.deepEqual(
2708 resolved?.capabilities,
2709 new Set(["orchestration", "worktree", "pull-requests", "issues"]),
2710 );
2711
2712 yield* manager.close(providerSessionId);
2713 });
2714
2715 yield* effect.pipe(
2716 Effect.provide(
2717 layerTest({
2718 state,
2719 idleTimeoutMs: 1_000,
2720 mcpConfigs,
2721 serverSettingsLayer: ServerSettings.layerTest({
2722 enableAgentBrowserAccess: false,
2723 }).pipe(Layer.orDie),
2724 }),
2725 ),
2726 );
2727 }),
2728 );
2729
2730 it.effect("ProviderSessionManagerV2 honors a project browser-access opt-out", () =>
2731 Effect.gen(function* () {
2732 const captured = yield* runBrowserAccessScenario({
2733 enableAgentBrowserAccess: true,
2734 projectOverride: false,
2735 });
2736 assert.isDefined(captured);
2737 assert.equal(captured?.browserToolsAvailable, false);
2738 }),
2739 );
2740
2741 it.effect("ProviderSessionManagerV2 fails browser access closed for a missing project", () =>
2742 Effect.gen(function* () {
2743 const captured = yield* runBrowserAccessScenario({
2744 enableAgentBrowserAccess: true,
2745 projectOverride: true,
2746 projectExists: false,
2747 });
2748 assert.isDefined(captured);
2749 assert.equal(captured?.browserToolsAvailable, false);
2750 }),
2751 );
2752
2753 it.effect("ProviderSessionManagerV2 revokes MCP credentials when release persistence fails", () =>
2754 Effect.gen(function* () {
2755 const state = yield* Ref.make(emptyState);
2756 const mcpConfigs = yield* Ref.make<
2757 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
2758 >([]);
2759 const effect = Effect.gen(function* () {
2760 const eventSink = yield* EventSink.EventSinkV2;
2761 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2762 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2763 const registry = yield* McpSessionRegistry.McpSessionRegistry;
2764 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
2765 const now = yield* DateTime.now;
2766 const threadId = ThreadId.make("thread-provider-session-manager-mcp-release-failure");
2767 const providerSessionId = yield* idAllocator.allocate.providerSession({
2768 providerInstanceId: modelSelection.instanceId,
2769 threadId,
2770 });
2771
2772 yield* eventSink.write({
2773 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
2774 });
2775 yield* manager.open({
2776 threadId,
2777 providerSessionId,
2778 modelSelection,
2779 runtimePolicy,
2780 });
2781
2782 const captured = (yield* Ref.get(mcpConfigs))[0];
2783 const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");
2784 assert.isDefined(token);
2785 assert.isDefined(yield* registry.resolve(token!));
2786
2787 const closeError = yield* manager.close(providerSessionId).pipe(Effect.flip);
2788 assert.equal(closeError._tag, "ProviderSessionCloseError");
2789 assert.isUndefined(yield* mcpSessions.read(threadId));
2790 assert.isUndefined(yield* registry.resolve(token!));
2791 });
2792
2793 yield* effect.pipe(
2794 Effect.provide(
2795 layerTest({
2796 state,
2797 idleTimeoutMs: 1_000,
2798 mcpConfigs,
2799 failReleaseEventWrites: true,
2800 }),
2801 ),
2802 );
2803 }),
2804 );
2805
2806 it.effect(
2807 "ProviderSessionManagerV2 keeps a thread attached when an earlier attach of it is interrupted",
2808 () =>
2809 Effect.gen(function* () {
2810 const state = yield* Ref.make(emptyState);
2811 const armed = yield* Ref.make(false);
2812 const paused = yield* Deferred.make<void>();
2813 yield* Effect.gen(function* () {
2814 const eventSink = yield* EventSink.EventSinkV2;
2815 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2816 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2817 const registry = yield* McpSessionRegistry.McpSessionRegistry;
2818 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
2819 const now = yield* DateTime.now;
2820 const owner = ThreadId.make("thread-provider-session-manager-attach-race-owner");
2821 const threadId = ThreadId.make("thread-provider-session-manager-attach-race");
2822 const providerSessionId = idAllocator.derive.providerSession({
2823 providerInstanceId: modelSelection.instanceId,
2824 });
2825 yield* eventSink.write({
2826 events: [
2827 yield* makeThreadCreatedEvent({ idAllocator, threadId: owner, now }),
2828 yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
2829 ],
2830 });
2831 const runtime = yield* manager.open({
2832 threadId: owner,
2833 providerSessionId,
2834 modelSelection,
2835 runtimePolicy,
2836 });
2837 const resume = runtime.resumeThread({
2838 threadId,
2839 providerThread: makeProviderThread({
2840 idAllocator,
2841 threadId,
2842 providerSessionId,
2843 now,
2844 nativeThreadId: "native-attach-race",
2845 }),
2846 });
2847
2848 yield* Ref.set(armed, true);
2849 const first = yield* resume.pipe(Effect.forkChild({ startImmediately: true }));
2850 yield* Deferred.await(paused);
2851 const second = yield* resume.pipe(Effect.forkChild({ startImmediately: true }));
2852 yield* Fiber.interrupt(first);
2853 yield* Fiber.join(second);
2854
2855 const config = yield* mcpSessions.read(threadId);
2856 assert.isDefined(config);
2857 const token = config!.authorizationHeader.replace(/^Bearer\s+/, "");
2858 assert.equal((yield* registry.resolve(token))?.thread.threadId, threadId);
2859 }).pipe(
2860 Effect.provide(
2861 layerTest({ state, idleTimeoutMs: 60_000, pauseAttachWrite: { armed, paused } }),
2862 ),
2863 );
2864 }),
2865 );
2866
2867 // regression: #15571 an interrupted session start did not clean up
2868 it.effect(
2869 "ProviderSessionManagerV2 keeps a replacement session's attachment when a stale attach is interrupted",
2870 () =>
2871 Effect.gen(function* () {
2872 const state = yield* Ref.make(emptyState);
2873 const armed = yield* Ref.make(false);
2874 const paused = yield* Deferred.make<void>();
2875 yield* Effect.gen(function* () {
2876 const eventSink = yield* EventSink.EventSinkV2;
2877 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2878 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2879 const registry = yield* McpSessionRegistry.McpSessionRegistry;
2880 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
2881 const eventStore = yield* EventStore.EventStoreV2;
2882 const now = yield* DateTime.now;
2883 const owner = ThreadId.make("thread-provider-session-manager-stale-attach-owner");
2884 const threadId = ThreadId.make("thread-provider-session-manager-stale-attach");
2885 const providerSessionId = idAllocator.derive.providerSession({
2886 providerInstanceId: modelSelection.instanceId,
2887 });
2888 yield* eventSink.write({
2889 events: [
2890 yield* makeThreadCreatedEvent({ idAllocator, threadId: owner, now }),
2891 yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
2892 ],
2893 });
2894 const runtime = yield* manager.open({
2895 threadId: owner,
2896 providerSessionId,
2897 modelSelection,
2898 runtimePolicy,
2899 });
2900
2901 yield* Ref.set(armed, true);
2902 const stale = yield* runtime
2903 .resumeThread({
2904 threadId,
2905 providerThread: makeProviderThread({
2906 idAllocator,
2907 threadId,
2908 providerSessionId,
2909 now,
2910 nativeThreadId: "native-stale-attach",
2911 }),
2912 })
2913 .pipe(Effect.forkChild({ startImmediately: true }));
2914 yield* Deferred.await(paused);
2915
2916 yield* manager.release({ providerSessionId, reason: "runtime_error" });
2917 const replacement = yield* manager.open({
2918 threadId,
2919 providerSessionId,
2920 modelSelection,
2921 runtimePolicy,
2922 });
2923 const config = yield* mcpSessions.read(threadId);
2924 assert.isDefined(config);
2925
2926 yield* Fiber.interrupt(stale);
2927
2928 assert.equal(
2929 (yield* mcpSessions.read(threadId))?.providerSessionId,
2930 config!.providerSessionId,
2931 );
2932 const token = config!.authorizationHeader.replace(/^Bearer\s+/, "");
2933 assert.equal((yield* registry.resolve(token))?.thread.threadId, threadId);
2934 const attachedEvents = eventStore
2935 .read({ threadId, eventType: "provider-session.attached" })
2936 .pipe(
2937 Stream.runCollect,
2938 Effect.map((events) => events.length),
2939 );
2940 const attachedBefore = yield* attachedEvents;
2941 yield* replacement.resumeThread({
2942 threadId,
2943 providerThread: makeProviderThread({
2944 idAllocator,
2945 threadId,
2946 providerSessionId,
2947 now,
2948 nativeThreadId: "native-stale-attach",
2949 }),
2950 });
2951 assert.equal(yield* attachedEvents, attachedBefore);
2952 }).pipe(
2953 Effect.provide(
2954 layerTest({ state, idleTimeoutMs: 60_000, pauseAttachWrite: { armed, paused } }),
2955 ),
2956 );
2957 }),
2958 );
2959
2960 // regression: #15571 an interrupted session start did not clean up
2961 it.effect(
2962 "ProviderSessionManagerV2 revokes a reused credential after a resume stopped while checking it",
2963 () =>
2964 Effect.gen(function* () {
2965 const state = yield* Ref.make(emptyState);
2966 const armed = yield* Ref.make(false);
2967 const paused = yield* Deferred.make<void>();
2968 yield* Effect.gen(function* () {
2969 const eventSink = yield* EventSink.EventSinkV2;
2970 const idAllocator = yield* IdAllocator.IdAllocatorV2;
2971 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
2972 const registry = yield* McpSessionRegistry.McpSessionRegistry;
2973 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
2974 const now = yield* DateTime.now;
2975 const owner = ThreadId.make("thread-provider-session-manager-resolve-stop-owner");
2976 const threadId = ThreadId.make("thread-provider-session-manager-resolve-stop");
2977 const providerSessionId = idAllocator.derive.providerSession({
2978 providerInstanceId: modelSelection.instanceId,
2979 });
2980 yield* eventSink.write({
2981 events: [
2982 yield* makeThreadCreatedEvent({ idAllocator, threadId: owner, now }),
2983 yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
2984 ],
2985 });
2986 const runtime = yield* manager.open({
2987 threadId: owner,
2988 providerSessionId,
2989 modelSelection,
2990 runtimePolicy,
2991 });
2992 const resume = runtime.resumeThread({
2993 threadId,
2994 providerThread: makeProviderThread({
2995 idAllocator,
2996 threadId,
2997 providerSessionId,
2998 now,
2999 nativeThreadId: "native-resolve-stop",
3000 }),
3001 });
3002 yield* resume;
3003 yield* manager.detach({ providerSessionId, threadId });
3004 const config = yield* mcpSessions.read(threadId);
3005 assert.isDefined(config);
3006 const token = config!.authorizationHeader.replace(/^Bearer\s+/, "");
3007
3008 yield* Ref.set(armed, true);
3009 const stopped = yield* resume.pipe(Effect.forkChild({ startImmediately: true }));
3010 yield* Deferred.await(paused);
3011 yield* Fiber.interrupt(stopped);
3012
3013 yield* manager.release({ providerSessionId, reason: "manual_shutdown" });
3014 assert.isUndefined(yield* registry.resolve(token));
3015 }).pipe(
3016 Effect.provide(
3017 layerTest({ state, idleTimeoutMs: 60_000, pauseResolve: { armed, paused } }),
3018 ),
3019 );
3020 }),
3021 );
3022
3023 it.effect("ProviderSessionManagerV2 duplicate detach preserves replacement MCP credentials", () =>
3024 Effect.gen(function* () {
3025 const state = yield* Ref.make(emptyState);
3026 const mcpConfigs = yield* Ref.make<
3027 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
3028 >([]);
3029 const effect = Effect.gen(function* () {
3030 const eventSink = yield* EventSink.EventSinkV2;
3031 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3032 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3033 const registry = yield* McpSessionRegistry.McpSessionRegistry;
3034 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
3035 const now = yield* DateTime.now;
3036 const threadId = ThreadId.make("thread-provider-session-manager-replacement-mcp");
3037 const oldSessionId = yield* idAllocator.allocate.providerSession({
3038 providerInstanceId: modelSelection.instanceId,
3039 threadId,
3040 });
3041 const replacementSessionId = yield* idAllocator.allocate.providerSession({
3042 providerInstanceId: modelSelection.instanceId,
3043 threadId,
3044 });
3045
3046 yield* eventSink.write({
3047 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
3048 });
3049 yield* manager.open({
3050 threadId,
3051 providerSessionId: oldSessionId,
3052 modelSelection,
3053 runtimePolicy,
3054 });
3055 yield* manager.detach({ providerSessionId: oldSessionId, threadId });
3056 yield* manager.open({
3057 threadId,
3058 providerSessionId: replacementSessionId,
3059 modelSelection,
3060 runtimePolicy,
3061 });
3062
3063 const replacement = (yield* Ref.get(mcpConfigs)).at(-1);
3064 assert.isDefined(replacement);
3065 const replacementToken = replacement?.authorizationHeader.replace(/^Bearer\s+/, "");
3066 assert.isDefined(replacementToken);
3067 assert.equal(
3068 (yield* mcpSessions.read(threadId))?.providerSessionId,
3069 replacement?.providerSessionId,
3070 );
3071
3072 yield* manager.detach({ providerSessionId: oldSessionId, threadId });
3073
3074 assert.equal(
3075 (yield* mcpSessions.read(threadId))?.providerSessionId,
3076 replacement?.providerSessionId,
3077 );
3078 assert.equal((yield* registry.resolve(replacementToken!))?.thread.threadId, threadId);
3079 });
3080
3081 yield* effect.pipe(
3082 Effect.provide(
3083 layerTest({
3084 state,
3085 idleTimeoutMs: 1_000,
3086 capabilities: ExclusiveCapabilities,
3087 mcpConfigs,
3088 }),
3089 ),
3090 );
3091 }),
3092 );
3093
3094 it.effect(
3095 "ProviderSessionManagerV2 keeps a thread's MCP credential stable across detach and re-attach on a shared session",
3096 () =>
3097 Effect.gen(function* () {
3098 const state = yield* Ref.make(emptyState);
3099 const mcpConfigs = yield* Ref.make<
3100 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
3101 >([]);
3102 const effect = Effect.gen(function* () {
3103 const eventSink = yield* EventSink.EventSinkV2;
3104 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3105 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3106 const registry = yield* McpSessionRegistry.McpSessionRegistry;
3107 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
3108 const now = yield* DateTime.now;
3109 const threadId = ThreadId.make("thread-provider-session-manager-stable-mcp");
3110 const providerSessionId = yield* idAllocator.allocate.providerSession({
3111 providerInstanceId: modelSelection.instanceId,
3112 threadId,
3113 });
3114
3115 yield* eventSink.write({
3116 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
3117 });
3118 yield* manager.open({
3119 threadId,
3120 providerSessionId,
3121 modelSelection,
3122 runtimePolicy,
3123 });
3124
3125 const original = (yield* Ref.get(mcpConfigs)).at(-1);
3126 assert.isDefined(original);
3127 const originalToken = original?.authorizationHeader.replace(/^Bearer\s+/, "");
3128 assert.isDefined(originalToken);
3129
3130 yield* manager.detach({ providerSessionId, threadId, detail: "Workspace changed." });
3131 assert.equal(
3132 (yield* registry.resolve(originalToken!))?.thread.threadId,
3133 threadId,
3134 "detach must not revoke the credential the live provider process still holds",
3135 );
3136
3137 yield* manager.open({
3138 threadId,
3139 providerSessionId,
3140 modelSelection,
3141 runtimePolicy,
3142 });
3143 assert.equal(
3144 (yield* mcpSessions.read(threadId))?.providerSessionId,
3145 original?.providerSessionId,
3146 "re-attach must reuse the existing credential, not rotate it",
3147 );
3148 assert.equal((yield* registry.resolve(originalToken!))?.thread.threadId, threadId);
3149
3150 yield* manager.close(providerSessionId);
3151 assert.isUndefined(yield* registry.resolve(originalToken!));
3152 });
3153
3154 yield* effect.pipe(
3155 Effect.provide(
3156 layerTest({
3157 state,
3158 idleTimeoutMs: 1_000,
3159 mcpConfigs,
3160 }),
3161 ),
3162 );
3163 }),
3164 );
3165
3166 it.effect(
3167 "ProviderSessionManagerV2 protects a reused credential from a predecessor release during open",
3168 () =>
3169 Effect.gen(function* () {
3170 const state = yield* Ref.make(emptyState);
3171 const mcpConfigs = yield* Ref.make<
3172 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
3173 >([]);
3174 const duringOpen = yield* Ref.make<Effect.Effect<void>>(Effect.void);
3175 const effect = Effect.gen(function* () {
3176 const eventSink = yield* EventSink.EventSinkV2;
3177 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3178 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3179 const registry = yield* McpSessionRegistry.McpSessionRegistry;
3180 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
3181 const now = yield* DateTime.now;
3182 const threadId = ThreadId.make("thread-provider-session-manager-open-race");
3183 const s1 = yield* idAllocator.allocate.providerSession({
3184 providerInstanceId: modelSelection.instanceId,
3185 threadId,
3186 });
3187 const s2 = yield* idAllocator.allocate.providerSession({
3188 providerInstanceId: modelSelection.instanceId,
3189 threadId,
3190 });
3191
3192 yield* eventSink.write({
3193 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
3194 });
3195 yield* manager.open({ threadId, providerSessionId: s1, modelSelection, runtimePolicy });
3196 const original = (yield* Ref.get(mcpConfigs)).at(-1);
3197 const originalToken = original?.authorizationHeader.replace(/^Bearer\s+/, "");
3198 assert.isDefined(originalToken);
3199 yield* manager.detach({ providerSessionId: s1, threadId });
3200
3201 // ACP and OpenCode consume credentials during openSession; predecessor release must not revoke them before entry publication.
3202 yield* Ref.set(duringOpen, manager.close(s1).pipe(Effect.orDie));
3203 yield* manager.open({ threadId, providerSessionId: s2, modelSelection, runtimePolicy });
3204
3205 const slot = yield* mcpSessions.read(threadId);
3206 assert.equal(
3207 slot?.providerSessionId,
3208 original?.providerSessionId,
3209 "the credential the adapter was configured with must remain current",
3210 );
3211 assert.equal(
3212 (yield* registry.resolve(originalToken!))?.thread.threadId,
3213 threadId,
3214 "the predecessor release must not revoke a credential reserved by an in-flight open",
3215 );
3216 yield* manager.close(s2);
3217 });
3218
3219 yield* effect.pipe(
3220 Effect.provide(
3221 layerTest({
3222 state,
3223 idleTimeoutMs: 1_000,
3224 mcpConfigs,
3225 beforeOpen: (input) =>
3226 input.providerSessionId === undefined
3227 ? Effect.void
3228 : Ref.get(duringOpen).pipe(
3229 Effect.flatten,
3230 Effect.tap(() => Ref.set(duringOpen, Effect.void)),
3231 ),
3232 }),
3233 ),
3234 );
3235 }),
3236 );
3237
3238 it.effect("ProviderSessionManagerV2 terminal detach revokes the thread's MCP credential", () =>
3239 Effect.gen(function* () {
3240 const state = yield* Ref.make(emptyState);
3241 const mcpConfigs = yield* Ref.make<
3242 ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
3243 >([]);
3244 const effect = Effect.gen(function* () {
3245 const eventSink = yield* EventSink.EventSinkV2;
3246 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3247 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3248 const registry = yield* McpSessionRegistry.McpSessionRegistry;
3249 const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
3250 const now = yield* DateTime.now;
3251 const threadId = ThreadId.make("thread-provider-session-manager-terminal-detach");
3252 const providerSessionId = yield* idAllocator.allocate.providerSession({
3253 providerInstanceId: modelSelection.instanceId,
3254 threadId,
3255 });
3256
3257 yield* eventSink.write({
3258 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
3259 });
3260 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
3261 const issued = (yield* Ref.get(mcpConfigs)).at(-1);
3262 const token = issued?.authorizationHeader.replace(/^Bearer\s+/, "");
3263 assert.isDefined(yield* registry.resolve(token!));
3264
3265 yield* manager.detach({
3266 providerSessionId,
3267 threadId,
3268 detail: "Thread deleted.",
3269 revokeMcpCredential: true,
3270 });
3271 assert.isUndefined(yield* registry.resolve(token!));
3272 assert.isUndefined(yield* mcpSessions.read(threadId));
3273 });
3274
3275 yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1_000, mcpConfigs })));
3276 }),
3277 );
3278
3279 it.effect(
3280 "ProviderSessionManagerV2 stops serving prompt suggestions once a thread is deleted",
3281 () =>
3282 Effect.gen(function* () {
3283 const state = yield* Ref.make(emptyState);
3284 const effect = Effect.gen(function* () {
3285 const eventSink = yield* EventSink.EventSinkV2;
3286 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3287 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3288 const now = yield* DateTime.now;
3289 const threadId = ThreadId.make("thread-provider-session-manager-suggestion");
3290 const providerSessionId = yield* idAllocator.allocate.providerSession({
3291 providerInstanceId: modelSelection.instanceId,
3292 threadId,
3293 });
3294 const created = yield* makeThreadCreatedEvent({ idAllocator, threadId, now });
3295 yield* eventSink.write({ events: [created] });
3296 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
3297 const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
3298 const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
3299 const suggest = (text: string) =>
3300 Queue.offer(queue!, {
3301 type: "prompt_suggestion.updated",
3302 driver: CODEX_DRIVER,
3303 threadId,
3304 runId,
3305 text,
3306 });
3307 const received = yield* Queue.unbounded<OrchestrationV2PromptSuggestion>();
3308 yield* manager.subscribePromptSuggestion(threadId).pipe(
3309 Stream.runForEach((suggestion) => Queue.offer(received, suggestion)),
3310 Effect.forkScoped,
3311 );
3312 assert.isNull(yield* Queue.take(received));
3313
3314 yield* suggest("add tests");
3315 assert.deepEqual(yield* Queue.take(received), { runId, text: "add tests" });
3316
3317 yield* eventSink.write({
3318 events: [
3319 {
3320 ...created,
3321 id: yield* idAllocator.allocate.event({ threadId }),
3322 type: "thread.deleted",
3323 payload: { ...created.payload, deletedAt: now },
3324 },
3325 ],
3326 });
3327 // A late Codex sample can land after deletion; the open subscription must drop it.
3328 yield* suggest("ship it");
3329 assert.isNull(yield* Queue.take(received));
3330 });
3331
3332 yield* effect.pipe(Effect.scoped, Effect.provide(layerTest({ state, idleTimeoutMs: 1_000 })));
3333 }),
3334 );
3335
3336 const openSessionWithBackgroundCommand = (fixtureName: string) =>
3337 Effect.gen(function* () {
3338 const eventSink = yield* EventSink.EventSinkV2;
3339 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3340 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3341 const now = yield* DateTime.now;
3342 const threadId = yield* idAllocator.allocate.thread({
3343 fixtureName,
3344 projectId: yield* idAllocator.allocate.project({ fixtureName }),
3345 });
3346 const providerSessionId = yield* idAllocator.allocate.providerSession({
3347 providerInstanceId: modelSelection.instanceId,
3348 threadId,
3349 });
3350 const otherProviderSessionId = yield* idAllocator.allocate.providerSession({
3351 providerInstanceId: modelSelection.instanceId,
3352 threadId,
3353 });
3354 const pendingBackgroundTasks = [
3355 { taskId: "dev-server", kind: "command", description: "python3 -m http.server" },
3356 ] as const;
3357 const providerThreads = [
3358 {
3359 ...makeProviderThread({ idAllocator, threadId, providerSessionId, now }),
3360 pendingBackgroundTasks,
3361 },
3362 {
3363 ...makeProviderThread({
3364 idAllocator,
3365 threadId,
3366 providerSessionId: otherProviderSessionId,
3367 now,
3368 nativeThreadId: "native-thread-other-session",
3369 }),
3370 pendingBackgroundTasks,
3371 },
3372 ];
3373 const writeProviderThread = (payload: OrchestrationV2ProviderThread) =>
3374 Effect.gen(function* () {
3375 yield* eventSink.write({
3376 events: [
3377 {
3378 id: yield* idAllocator.allocate.event({ threadId }),
3379 type: "provider-thread.updated",
3380 threadId,
3381 driver: CODEX_DRIVER,
3382 occurredAt: now,
3383 payload,
3384 },
3385 ],
3386 });
3387 });
3388 yield* eventSink.write({
3389 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
3390 });
3391 yield* Effect.forEach(providerThreads, writeProviderThread);
3392 const toolCall = (
3393 nativeItemId: string,
3394 providerThread: OrchestrationV2ProviderThread,
3395 status: "running" | "completed",
3396 startedAt: DateTime.Utc,
3397 ) =>
3398 ({
3399 id: idAllocator.derive.turnItemFromProviderItem({ driver: CODEX_DRIVER, nativeItemId }),
3400 threadId,
3401 runId: null,
3402 nodeId: null,
3403 providerThreadId: providerThread.id,
3404 providerTurnId: null,
3405 nativeItemRef: null,
3406 parentItemId: null,
3407 ordinal: 1,
3408 status,
3409 title: null,
3410 startedAt,
3411 completedAt: status === "completed" ? startedAt : null,
3412 updatedAt: startedAt,
3413 type: "dynamic_tool",
3414 toolName: "mcp__t3-code__t3_worktree_handoff",
3415 input: {},
3416 }) satisfies OrchestrationV2TurnItem;
3417 const cutOffNodeId = idAllocator.derive.nodeFromProviderItem({
3418 driver: CODEX_DRIVER,
3419 nativeItemId: "cut-off",
3420 });
3421 const seededToolCalls = {
3422 cutOff: { ...toolCall("cut-off", providerThreads[0]!, "running", now), nodeId: cutOffNodeId },
3423 finished: toolCall("finished", providerThreads[0]!, "completed", now),
3424 otherSession: toolCall("other-session", providerThreads[1]!, "running", now),
3425 // Started by a replacement session after the release.
3426 replacement: toolCall(
3427 "replacement",
3428 providerThreads[0]!,
3429 "running",
3430 DateTime.add(now, { hours: 1 }),
3431 ),
3432 };
3433 const writeToolCall = (payload: OrchestrationV2TurnItem) =>
3434 Effect.gen(function* () {
3435 yield* eventSink.write({
3436 events: [
3437 {
3438 id: yield* idAllocator.allocate.event({ threadId }),
3439 type: "turn-item.updated",
3440 threadId,
3441 driver: CODEX_DRIVER,
3442 occurredAt: now,
3443 payload,
3444 },
3445 ],
3446 });
3447 });
3448 yield* eventSink.write({
3449 events: [
3450 {
3451 id: yield* idAllocator.allocate.event({ threadId }),
3452 type: "node.updated",
3453 threadId,
3454 nodeId: cutOffNodeId,
3455 driver: CODEX_DRIVER,
3456 occurredAt: now,
3457 payload: {
3458 id: cutOffNodeId,
3459 threadId,
3460 runId: null,
3461 parentNodeId: null,
3462 rootNodeId: cutOffNodeId,
3463 kind: "tool_call",
3464 status: "running",
3465 countsForRun: true,
3466 providerThreadId: providerThreads[0]!.id,
3467 providerTurnId: null,
3468 nativeItemRef: null,
3469 runtimeRequestId: null,
3470 checkpointScopeId: null,
3471 startedAt: now,
3472 completedAt: null,
3473 },
3474 },
3475 ],
3476 });
3477 yield* Effect.forEach(Object.values(seededToolCalls), writeToolCall);
3478 const cutOffNodeStatus = Effect.gen(function* () {
3479 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
3480 const projection = yield* projectionStore.getThreadProjection(threadId);
3481 return projection.nodes.find((node) => node.id === cutOffNodeId)?.status;
3482 });
3483 // A background native subagent that outlived its completed run; Claude records no provider thread on it.
3484 const nativeSubagentRunId = idAllocator.derive.run({ threadId, ordinal: 1 });
3485 const nativeSubagentId = idAllocator.derive.nodeFromProviderItem({
3486 driver: CODEX_DRIVER,
3487 nativeItemId: "background-agent",
3488 });
3489 yield* eventSink.write({
3490 events: [
3491 {
3492 id: yield* idAllocator.allocate.event({ threadId }),
3493 type: "subagent.updated",
3494 threadId,
3495 occurredAt: now,
3496 payload: {
3497 id: nativeSubagentId,
3498 threadId,
3499 runId: nativeSubagentRunId,
3500 parentNodeId: idAllocator.derive.rootNode({ runId: nativeSubagentRunId }),
3501 origin: "provider_native",
3502 createdBy: "agent",
3503 driver: CODEX_DRIVER,
3504 providerInstanceId: modelSelection.instanceId,
3505 providerThreadId: null,
3506 childThreadId: null,
3507 nativeTaskRef: {
3508 driver: CODEX_DRIVER,
3509 nativeId: "background-agent",
3510 strength: "strong",
3511 },
3512 prompt: "sleep 150; echo done",
3513 title: "Background agent",
3514 model: null,
3515 status: "running",
3516 result: null,
3517 startedAt: now,
3518 completedAt: null,
3519 updatedAt: now,
3520 },
3521 },
3522 ],
3523 });
3524 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
3525 const nativeSubagentStatus = Effect.gen(function* () {
3526 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
3527 const projection = yield* projectionStore.getThreadProjection(threadId);
3528 return projection.subagents.find((subagent) => subagent.id === nativeSubagentId)?.status;
3529 });
3530 const toolCallStatus = (id: OrchestrationV2TurnItem["id"]) =>
3531 Effect.gen(function* () {
3532 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
3533 const projection = yield* projectionStore.getThreadProjection(threadId);
3534 return projection.turnItems.find((item) => item.id === id)?.status;
3535 });
3536 const toolCalls = Effect.gen(function* () {
3537 const statusOf = (seeded: OrchestrationV2TurnItem) => toolCallStatus(seeded.id);
3538 return {
3539 cutOff: yield* statusOf(seededToolCalls.cutOff),
3540 finished: yield* statusOf(seededToolCalls.finished),
3541 otherSession: yield* statusOf(seededToolCalls.otherSession),
3542 replacement: yield* statusOf(seededToolCalls.replacement),
3543 };
3544 });
3545 const rosters = Effect.gen(function* () {
3546 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
3547 const projection = yield* projectionStore.getThreadProjection(threadId);
3548 return providerThreads.map((seeded) =>
3549 (
3550 projection.providerThreads.find((thread) => thread.id === seeded.id)
3551 ?.pendingBackgroundTasks ?? []
3552 ).map((task) => task.taskId),
3553 );
3554 });
3555 return {
3556 threadId,
3557 providerSessionId,
3558 providerThreads,
3559 writeProviderThread,
3560 rosters,
3561 seededToolCalls,
3562 writeToolCall,
3563 toolCalls,
3564 toolCallStatus,
3565 nativeSubagentStatus,
3566 cutOffNodeStatus,
3567 };
3568 });
3569
3570 // regression: #15993 a worktree handoff left its tool call running, so the thread stayed Waiting
3571 it.effect.each(["detach", "stream failure", "provider stop", "early close"] as const)(
3572 "ProviderSessionManagerV2 clears background work after queued events drain on %s",
3573 (release) =>
3574 Effect.gen(function* () {
3575 const state = yield* Ref.make(emptyState);
3576 const effect = Effect.gen(function* () {
3577 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3578 const {
3579 threadId,
3580 providerSessionId,
3581 rosters,
3582 toolCalls,
3583 seededToolCalls,
3584 writeToolCall,
3585 nativeSubagentStatus,
3586 cutOffNodeStatus,
3587 } = yield* openSessionWithBackgroundCommand("provider-session-manager-detach-roster");
3588 const runtime = Option.getOrThrow(yield* manager.get(providerSessionId));
3589 const subscription = yield* runtime.subscribeEvents!;
3590 const consuming = yield* Deferred.make<void>();
3591 const resume = yield* Deferred.make<void>();
3592 const consumer = yield* subscription.events.pipe(
3593 Stream.tap(() =>
3594 Deferred.succeed(consuming, undefined).pipe(
3595 Effect.andThen(Deferred.await(resume)),
3596 Effect.andThen(writeToolCall(seededToolCalls.cutOff)),
3597 ),
3598 ),
3599 (events) => (release === "early close" ? events.pipe(Stream.take(1)) : events),
3600 Stream.runDrain,
3601 Effect.exit,
3602 Effect.forkScoped,
3603 );
3604 const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId))!;
3605 yield* Queue.offer(queue, {
3606 type: "provider_session.updated",
3607 driver: CODEX_DRIVER,
3608 providerSession: runtime.providerSession,
3609 });
3610 yield* Deferred.await(consuming);
3611 assert.deepStrictEqual(yield* rosters, [["dev-server"], ["dev-server"]]);
3612
3613 const eventSink = yield* EventSink.EventSinkV2;
3614 const afterSequence = yield* eventSink.latestSequence({ threadId });
3615 if (release === "detach" || release === "early close") {
3616 yield* manager.detach({ providerSessionId, threadId, detail: "Workspace changed." });
3617 } else {
3618 if (release === "provider stop") {
3619 yield* Queue.offer(queue, {
3620 type: "provider_session.updated",
3621 driver: CODEX_DRIVER,
3622 providerSession: { ...runtime.providerSession, status: "stopped" },
3623 });
3624 }
3625 yield* Queue.end(queue);
3626 }
3627 const interrupts = (count: number) =>
3628 eventSink.stream({ threadId, afterSequence }).pipe(
3629 Stream.filter(
3630 ({ event }) =>
3631 event.type === "turn-item.updated" &&
3632 event.payload.id === seededToolCalls.cutOff.id &&
3633 event.payload.status === "interrupted",
3634 ),
3635 Stream.take(count),
3636 Stream.runDrain,
3637 );
3638 yield* interrupts(1);
3639 yield* Deferred.succeed(resume, undefined);
3640 const consumed = yield* Fiber.join(consumer);
3641 assert.equal(
3642 Exit.isFailure(consumed),
3643 release !== "provider stop" && release !== "early close",
3644 );
3645 // regression: #22971 only a detach names its thread, so a handoff run can settle on it.
3646 assert.equal(
3647 Exit.isFailure(consumed)
3648 ? (Cause.squash(consumed.cause) as ProviderAdapter.ProviderAdapterEventStreamError)
3649 .detachedThreadId
3650 : undefined,
3651 release === "detach" ? threadId : undefined,
3652 );
3653 // A run ends the work it tracks only when the adapter reported its runtime failing.
3654 assert.equal(
3655 Exit.isFailure(consumed)
3656 ? (Cause.squash(consumed.cause) as ProviderAdapter.ProviderAdapterEventStreamError)
3657 .raisedByT3
3658 : undefined,
3659 Exit.isFailure(consumed) ? true : undefined,
3660 );
3661 yield* interrupts(2);
3662
3663 assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
3664 assert.deepStrictEqual(yield* rosters, [[], ["dev-server"]]);
3665 assert.deepStrictEqual(yield* toolCalls, {
3666 cutOff: "interrupted",
3667 finished: "completed",
3668 otherSession: "running",
3669 replacement: "running",
3670 });
3671 assert.equal(yield* cutOffNodeStatus, "interrupted");
3672 // regression: #36548 a native subagent the dead process ran stayed running after its run completed
3673 assert.notInclude(["pending", "running", "waiting"], yield* nativeSubagentStatus);
3674 });
3675
3676 yield* effect.pipe(
3677 Effect.provide(
3678 layerTest({ state, idleTimeoutMs: 60_000, capabilities: ExclusiveCapabilities }),
3679 ),
3680 );
3681 }),
3682 );
3683
3684 it.effect.each(["a runtime whose tasks can outlive it", "server shutdown"] as const)(
3685 "ProviderSessionManagerV2 keeps the background work after the release of %s",
3686 (release) =>
3687 Effect.gen(function* () {
3688 const state = yield* Ref.make(emptyState);
3689 const effect = Effect.gen(function* () {
3690 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3691 const { providerSessionId, rosters, toolCalls } = yield* openSessionWithBackgroundCommand(
3692 "provider-session-manager-outliving-roster",
3693 );
3694
3695 yield* release === "server shutdown"
3696 ? manager.release({ providerSessionId, reason: "server_shutdown" })
3697 : manager.close(providerSessionId);
3698
3699 assert.deepStrictEqual(yield* rosters, [["dev-server"], ["dev-server"]]);
3700 assert.equal((yield* toolCalls).cutOff, "running");
3701 });
3702
3703 yield* effect.pipe(
3704 Effect.provide(
3705 layerTest({
3706 state,
3707 idleTimeoutMs: 60_000,
3708 ...(release === "server shutdown" ? {} : { backgroundTasksEndWithProcess: false }),
3709 }),
3710 ),
3711 );
3712 }),
3713 );
3714
3715 // regression: #19355 settled and idle-released threads stayed Waiting
3716 it.effect("ProviderSessionManagerV2 keeps provider updates that land while release clears", () =>
3717 Effect.gen(function* () {
3718 const state = yield* Ref.make(emptyState);
3719 const beforeUnchangedWrite = yield* Ref.make<Effect.Effect<void>>(Effect.void);
3720 const beforeTurnItemsWrite = yield* Ref.make<ReadonlyArray<Effect.Effect<void>>>([]);
3721 const effect = Effect.gen(function* () {
3722 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3723 const {
3724 providerSessionId,
3725 providerThreads,
3726 writeProviderThread,
3727 rosters,
3728 seededToolCalls,
3729 writeToolCall,
3730 toolCallStatus,
3731 } = yield* openSessionWithBackgroundCommand("provider-session-manager-raced-roster");
3732 // Before each of the first four cleanup writes, one of these calls completes late. The
3733 // completion must win, and the conflicts must not stop the open calls from being interrupted.
3734 const lateCompleted = ["late-1", "late-2", "late-3", "late-4"].map((name) => ({
3735 ...seededToolCalls.cutOff,
3736 id: TurnItemId.make(`turn-item:${name}`),
3737 }));
3738 // Read after the late calls, so one write for all items would run out of tries first.
3739 const lastOpen = { ...seededToolCalls.cutOff, id: TurnItemId.make("turn-item:last-open") };
3740 yield* Effect.forEach([...lateCompleted, lastOpen], writeToolCall);
3741 const storedLate = {
3742 ...seededToolCalls.cutOff,
3743 id: TurnItemId.make("turn-item:stored-late"),
3744 };
3745 const storedInCleanPass = {
3746 ...seededToolCalls.cutOff,
3747 id: TurnItemId.make("turn-item:stored-in-clean-pass"),
3748 };
3749 const complete = (item: OrchestrationV2TurnItem) =>
3750 writeToolCall({ ...item, status: "completed" });
3751 // One hook runs before each cleanup write. The first pass writes the cut-off call, the
3752 // four late calls and the last open call; the second pass writes the cut-off call again
3753 // and the call stored late; the third pass writes the call stored in the clean pass.
3754 yield* Ref.set(
3755 beforeTurnItemsWrite,
3756 [
3757 // The cut-off call gets an update that keeps it open, so it needs a second pass, and
3758 // the dead session stores one more call.
3759 complete(lateCompleted[0]!).pipe(
3760 Effect.andThen(writeToolCall({ ...seededToolCalls.cutOff, title: "late output" })),
3761 Effect.andThen(writeToolCall(storedLate)),
3762 ),
3763 complete(lateCompleted[1]!),
3764 complete(lateCompleted[2]!),
3765 complete(lateCompleted[3]!),
3766 Effect.void,
3767 Effect.void,
3768 // The second pass has no conflict, but one more call lands during it.
3769 writeToolCall(storedInCleanPass),
3770 ].map(Effect.orDie),
3771 );
3772 const seeded = providerThreads[0]!;
3773 yield* Ref.set(
3774 beforeUnchangedWrite,
3775 writeProviderThread({
3776 ...seeded,
3777 pendingBackgroundTasks: [
3778 ...seeded.pendingBackgroundTasks,
3779 { taskId: "replacement-task", kind: "command" },
3780 ],
3781 }).pipe(Effect.orDie),
3782 );
3783
3784 yield* manager.close(providerSessionId);
3785
3786 assert.deepStrictEqual(yield* rosters, [["replacement-task"], ["dev-server"]]);
3787 const statuses = Object.fromEntries(
3788 yield* Effect.forEach(
3789 [seededToolCalls.cutOff, ...lateCompleted, lastOpen, storedLate, storedInCleanPass],
3790 (item) => toolCallStatus(item.id).pipe(Effect.map((status) => [item.id, status])),
3791 ),
3792 );
3793 assert.deepStrictEqual(statuses, {
3794 [seededToolCalls.cutOff.id]: "interrupted",
3795 ...Object.fromEntries(lateCompleted.map((item) => [item.id, "completed"])),
3796 [lastOpen.id]: "interrupted",
3797 [storedLate.id]: "interrupted",
3798 [storedInCleanPass.id]: "interrupted",
3799 });
3800 });
3801
3802 yield* effect.pipe(
3803 Effect.provide(
3804 layerTest({ state, idleTimeoutMs: 60_000, beforeUnchangedWrite, beforeTurnItemsWrite }),
3805 ),
3806 );
3807 }),
3808 );
3809
3810 it.effect(
3811 "ProviderSessionManagerV2 does not idle-release a session that turns busy during the pending-work check",
3812 () =>
3813 Effect.gen(function* () {
3814 const state = yield* Ref.make(emptyState);
3815 const firstCheck = yield* Ref.make(true);
3816 const checkEntered = yield* Deferred.make<void>();
3817 const checkGate = yield* Deferred.make<void>();
3818 const effect = Effect.gen(function* () {
3819 const eventSink = yield* EventSink.EventSinkV2;
3820 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3821 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3822 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
3823 const now = yield* DateTime.now;
3824 const projectId = yield* idAllocator.allocate.project({
3825 fixtureName: "provider-session-manager-busy-during-check",
3826 });
3827 const threadId = yield* idAllocator.allocate.thread({
3828 fixtureName: "provider-session-manager-busy-during-check",
3829 projectId,
3830 });
3831 const providerSessionId = yield* idAllocator.allocate.providerSession({
3832 providerInstanceId: modelSelection.instanceId,
3833 threadId,
3834 });
3835 const providerThread = makeProviderThread({
3836 idAllocator,
3837 threadId,
3838 providerSessionId,
3839 now,
3840 });
3841 const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
3842 const attemptId = idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 });
3843 const rootNodeId = idAllocator.derive.rootNode({ runId });
3844 const providerTurnId = idAllocator.derive.providerTurn({
3845 driver: CODEX_DRIVER,
3846 nativeTurnId: "native-turn-busy-during-check",
3847 });
3848
3849 yield* eventSink.write({
3850 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
3851 });
3852 const runtime = yield* manager.open({
3853 threadId,
3854 providerSessionId,
3855 modelSelection,
3856 runtimePolicy,
3857 });
3858 yield* runtime.events.pipe(Stream.runDrain, Effect.forkScoped);
3859 const appThread = (yield* projectionStore.getThreadProjection(threadId)).thread;
3860
3861 yield* TestClock.adjust("1 second");
3862 yield* Deferred.await(checkEntered);
3863
3864 const turnFiber = yield* runtime
3865 .startTurn({
3866 appThread,
3867 threadId,
3868 runId,
3869 runOrdinal: 1,
3870 providerTurnOrdinal: 1,
3871 attemptId,
3872 rootNodeId,
3873 providerThread,
3874 message: {
3875 createdBy: "user",
3876 creationSource: "web",
3877 messageId: yield* idAllocator.allocate.message({ threadId, ordinal: 1 }),
3878 text: "hello",
3879 attachments: [],
3880 },
3881 modelSelection,
3882 runtimePolicy,
3883 })
3884 .pipe(Effect.forkDetach);
3885 for (let i = 0; i < 10; i += 1) {
3886 yield* Effect.yieldNow;
3887 }
3888 yield* Deferred.succeed(checkGate, undefined);
3889 yield* Fiber.join(turnFiber);
3890 yield* Effect.yieldNow;
3891
3892 assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
3893 assert.equal((yield* Ref.get(state)).closeCount, 0);
3894
3895 const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
3896 assert.isDefined(queue);
3897 yield* Queue.offer(queue!, {
3898 type: "turn.terminal",
3899 driver: CODEX_DRIVER,
3900 providerThreadId: providerThread.id,
3901 providerTurnId,
3902 runOrdinal: 1,
3903 status: "completed",
3904 failure: null,
3905 threadDisposition: "reusable",
3906 });
3907 yield* TestClock.adjust("1 second");
3908 yield* Effect.yieldNow;
3909 assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
3910 assert.equal((yield* Ref.get(state)).closeCount, 1);
3911 });
3912
3913 yield* effect.pipe(
3914 Effect.provide(
3915 layerTest({
3916 state,
3917 idleTimeoutMs: 1000,
3918 hasPendingBackgroundWork: Effect.uninterruptible(
3919 Effect.gen(function* () {
3920 if (yield* Ref.getAndSet(firstCheck, false)) {
3921 yield* Deferred.succeed(checkEntered, undefined);
3922 yield* Deferred.await(checkGate);
3923 }
3924 return false;
3925 }),
3926 ),
3927 }),
3928 ),
3929 );
3930 }),
3931 );
3932
3933 it.effect("ProviderSessionManagerV2 releases sessions when provider event streams fail", () =>
3934 Effect.gen(function* () {
3935 const state = yield* Ref.make(emptyState);
3936 const releaseRecorded = yield* Deferred.make<void>();
3937 const effect = Effect.gen(function* () {
3938 const eventSink = yield* EventSink.EventSinkV2;
3939 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3940 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3941 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
3942 const now = yield* DateTime.now;
3943 const projectId = yield* idAllocator.allocate.project({
3944 fixtureName: "provider-session-manager-stream-error",
3945 });
3946 const threadId = yield* idAllocator.allocate.thread({
3947 fixtureName: "provider-session-manager-stream-error",
3948 projectId,
3949 });
3950 const providerSessionId = yield* idAllocator.allocate.providerSession({
3951 providerInstanceId: modelSelection.instanceId,
3952 threadId,
3953 });
3954
3955 yield* eventSink.write({
3956 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
3957 });
3958 const runtime = yield* manager.open({
3959 threadId,
3960 providerSessionId,
3961 modelSelection,
3962 runtimePolicy,
3963 });
3964 yield* runtime.events.pipe(Stream.runDrain, Effect.ignore, Effect.forkScoped);
3965 yield* Deferred.await(releaseRecorded);
3966
3967 const liveSession = yield* manager.get(providerSessionId);
3968 const runtimeState = yield* Ref.get(state);
3969 const projection = yield* projectionStore.getThreadProjection(threadId);
3970
3971 assert.isTrue(Option.isNone(liveSession));
3972 assert.equal(runtimeState.closeCount, 1);
3973 assert.equal(projection.providerSessions.at(-1)?.status, "error");
3974 assert.equal(
3975 projection.providerSessions.at(-1)?.lastError,
3976 "The provider event stream closed unexpectedly. Retry the turn; if it keeps failing, check the provider and server logs.",
3977 );
3978 });
3979
3980 yield* effect.pipe(
3981 Effect.provide(
3982 layerTest({
3983 state,
3984 idleTimeoutMs: 1000,
3985 failEventStream: true,
3986 releaseRecorded,
3987 }),
3988 ),
3989 );
3990 }),
3991 );
3992
3993 it.effect("ProviderSessionManagerV2 marks pending runtime requests non-live on release", () =>
3994 Effect.gen(function* () {
3995 const state = yield* Ref.make(emptyState);
3996 const effect = Effect.gen(function* () {
3997 const eventSink = yield* EventSink.EventSinkV2;
3998 const idAllocator = yield* IdAllocator.IdAllocatorV2;
3999 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4000 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4001 const now = yield* DateTime.now;
4002 const projectId = yield* idAllocator.allocate.project({
4003 fixtureName: "provider-session-manager-request-expire",
4004 });
4005 const threadId = yield* idAllocator.allocate.thread({
4006 fixtureName: "provider-session-manager-request-expire",
4007 projectId,
4008 });
4009 const providerSessionId = yield* idAllocator.allocate.providerSession({
4010 providerInstanceId: modelSelection.instanceId,
4011 threadId,
4012 });
4013 const providerThread = makeProviderThread({
4014 idAllocator,
4015 threadId,
4016 providerSessionId,
4017 now,
4018 });
4019
4020 yield* eventSink.write({
4021 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
4022 });
4023 const pendingRequest = yield* makePendingRuntimeRequestEvents({
4024 idAllocator,
4025 threadId,
4026 providerSessionId,
4027 providerThread,
4028 now,
4029 });
4030 yield* eventSink.write({ events: pendingRequest.events });
4031 const historical = yield* makePendingRuntimeRequestEvents({
4032 idAllocator,
4033 threadId,
4034 providerSessionId,
4035 providerThread,
4036 now,
4037 });
4038 yield* eventSink.write({
4039 events: historical.events.map((event) =>
4040 event.type === "runtime-request.updated"
4041 ? { ...event, payload: { ...event.payload, status: "resolved", resolvedAt: now } }
4042 : event,
4043 ),
4044 });
4045 assert.deepEqual(
4046 (yield* projectionStore.getThreadRecords(threadId, ["nodes", "turnItems"], {
4047 nodeIds: [pendingRequest.nodeId],
4048 turnItemRequestIds: [pendingRequest.requestId],
4049 })).turnItems.map((item) => item.id),
4050 [pendingRequest.events.find((event) => event.type === "turn-item.updated")!.payload.id],
4051 );
4052 yield* manager.open({
4053 threadId,
4054 providerSessionId,
4055 modelSelection,
4056 runtimePolicy,
4057 });
4058 yield* manager.release({
4059 providerSessionId,
4060 reason: "runtime_error",
4061 detail: "process exited",
4062 });
4063
4064 const projection = yield* projectionStore.getThreadProjection(threadId);
4065 const request = projection.runtimeRequests.find(
4066 (request) => request.id === pendingRequest.requestId,
4067 );
4068 assert.equal(
4069 projection.runtimeRequests.find((request) => request.id === historical.requestId)?.status,
4070 "resolved",
4071 );
4072 const requestNode = projection.nodes.find((node) => node.id === request?.nodeId);
4073 const requestTurnItem = projection.turnItems.find(
4074 (item) => item.type === "approval_request" && item.requestId === request?.id,
4075 );
4076
4077 assert.equal(request?.status, "expired");
4078 assert.equal(request?.responseCapability.type, "not_resumable");
4079 assert.equal(requestNode?.status, "failed");
4080 assert.equal(requestTurnItem?.status, "failed");
4081 });
4082
4083 yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
4084 }),
4085 );
4086 it.effect("ProviderSessionManagerV2 retries release records that failed to persist", () =>
4087 Effect.gen(function* () {
4088 const state = yield* Ref.make(emptyState);
4089 const flaky: FlakyReleaseWrites = {
4090 failing: yield* Ref.make<"none" | "session" | "session-and-requests">("session"),
4091 failures: yield* Queue.unbounded<void>(),
4092 };
4093 const effect = Effect.gen(function* () {
4094 const eventSink = yield* EventSink.EventSinkV2;
4095 const idAllocator = yield* IdAllocator.IdAllocatorV2;
4096 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4097 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4098 const now = yield* DateTime.now;
4099 const threadId = ThreadId.make("thread-provider-session-manager-release-retry");
4100 const providerSessionId = yield* idAllocator.allocate.providerSession({
4101 providerInstanceId: modelSelection.instanceId,
4102 threadId,
4103 });
4104 const providerThread = makeProviderThread({ idAllocator, threadId, providerSessionId, now });
4105 yield* eventSink.write({
4106 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
4107 });
4108 const pendingRequest = yield* makePendingRuntimeRequestEvents({
4109 idAllocator,
4110 threadId,
4111 providerSessionId,
4112 providerThread,
4113 now,
4114 });
4115 yield* eventSink.write({ events: pendingRequest.events });
4116 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
4117
4118 assert.isTrue(Exit.isFailure(yield* Effect.exit(manager.close(providerSessionId))));
4119 yield* Queue.take(flaky.failures);
4120 const afterClose = yield* projectionStore.getThreadProjection(threadId);
4121 assert.equal(afterClose.runtimeRequests.at(-1)?.responseCapability.type, "not_resumable");
4122 assert.equal(afterClose.providerSessions.at(-1)?.status, "ready");
4123
4124 yield* TestClock.adjust("1 second");
4125 yield* Queue.take(flaky.failures);
4126 yield* Ref.set(flaky.failing, "none");
4127 const stopped = yield* eventSink
4128 .stream({
4129 threadId,
4130 afterSequence: yield* eventSink.latestSequence({ threadId }),
4131 eventType: "provider-session.updated",
4132 })
4133 .pipe(Stream.runHead, Effect.forkScoped);
4134 yield* TestClock.adjust("1 second");
4135 yield* Fiber.join(stopped);
4136
4137 const afterRetry = yield* projectionStore.getThreadProjection(threadId);
4138 assert.equal(afterRetry.providerSessions.at(-1)?.status, "stopped");
4139 });
4140
4141 yield* effect.pipe(
4142 Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, flakyReleaseWrites: flaky })),
4143 );
4144 }),
4145 );
4146
4147 // regression: #15048 runs got stuck after a failed session release
4148 it.effect("ProviderSessionManagerV2 release retries leave a replacement session alone", () =>
4149 Effect.gen(function* () {
4150 const state = yield* Ref.make(emptyState);
4151 const flaky: FlakyReleaseWrites = {
4152 failing: yield* Ref.make<"none" | "session" | "session-and-requests">("none"),
4153 failures: yield* Queue.unbounded<void>(),
4154 };
4155 const effect = Effect.gen(function* () {
4156 const eventSink = yield* EventSink.EventSinkV2;
4157 const idAllocator = yield* IdAllocator.IdAllocatorV2;
4158 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4159 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4160 const threadId = ThreadId.make("thread-provider-session-manager-release-replacement");
4161 const providerSessionId = yield* idAllocator.allocate.providerSession({
4162 providerInstanceId: modelSelection.instanceId,
4163 threadId,
4164 });
4165 const writePendingRequest = Effect.gen(function* () {
4166 const now = yield* DateTime.now;
4167 const request = yield* makePendingRuntimeRequestEvents({
4168 idAllocator,
4169 threadId,
4170 providerSessionId,
4171 providerThread: makeProviderThread({ idAllocator, threadId, providerSessionId, now }),
4172 now,
4173 });
4174 yield* eventSink.write({ events: request.events });
4175 return request.requestId;
4176 });
4177 yield* eventSink.write({
4178 events: [
4179 yield* makeThreadCreatedEvent({ idAllocator, threadId, now: yield* DateTime.now }),
4180 ],
4181 });
4182 const oldRequestId = yield* writePendingRequest;
4183 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
4184 yield* Ref.set(flaky.failing, "session-and-requests");
4185 assert.isTrue(Exit.isFailure(yield* Effect.exit(manager.close(providerSessionId))));
4186 yield* Queue.take(flaky.failures);
4187 yield* Queue.take(flaky.failures);
4188 yield* Ref.set(flaky.failing, "none");
4189
4190 yield* TestClock.adjust("500 millis");
4191 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
4192 const newRequestId = yield* writePendingRequest;
4193 const replacementStatus = (yield* projectionStore.getThreadProjection(
4194 threadId,
4195 )).providerSessions.at(-1)?.status;
4196 const settled = yield* eventSink
4197 .stream({
4198 threadId,
4199 afterSequence: yield* eventSink.latestSequence({ threadId }),
4200 eventType: "runtime-request.updated",
4201 })
4202 .pipe(Stream.runHead, Effect.forkScoped);
4203 yield* TestClock.adjust("500 millis");
4204 yield* Fiber.join(settled);
4205
4206 const projection = yield* projectionStore.getThreadProjection(threadId);
4207 const request = (id: typeof oldRequestId) =>
4208 projection.runtimeRequests.find((candidate) => candidate.id === id);
4209 assert.equal(request(oldRequestId)?.responseCapability.type, "not_resumable");
4210 assert.equal(request(newRequestId)?.responseCapability.type, "live");
4211 assert.equal(projection.providerSessions.at(-1)?.status, replacementStatus);
4212 });
4213
4214 yield* effect.pipe(
4215 Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, flakyReleaseWrites: flaky })),
4216 );
4217 }),
4218 );
4219
4220 // regression: #15048 runs got stuck after a failed session release
4221 it.effect("ProviderSessionManagerV2 keeps each failed release's cleanup", () =>
4222 Effect.gen(function* () {
4223 const state = yield* Ref.make(emptyState);
4224 const flaky: FlakyReleaseWrites = {
4225 failing: yield* Ref.make<"none" | "session" | "session-and-requests">("none"),
4226 failures: yield* Queue.unbounded<void>(),
4227 };
4228 const effect = Effect.gen(function* () {
4229 const eventSink = yield* EventSink.EventSinkV2;
4230 const idAllocator = yield* IdAllocator.IdAllocatorV2;
4231 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4232 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4233 const now = yield* DateTime.now;
4234 const firstThreadId = ThreadId.make("thread-provider-session-manager-release-each-a");
4235 const secondThreadId = ThreadId.make("thread-provider-session-manager-release-each-b");
4236 const providerSessionId = yield* idAllocator.allocate.providerSession({
4237 providerInstanceId: modelSelection.instanceId,
4238 threadId: firstThreadId,
4239 });
4240 yield* eventSink.write({
4241 events: [
4242 yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
4243 yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
4244 ],
4245 });
4246 const secondThreadRequest = yield* makePendingRuntimeRequestEvents({
4247 idAllocator,
4248 threadId: secondThreadId,
4249 providerSessionId,
4250 providerThread: makeProviderThread({
4251 idAllocator,
4252 threadId: secondThreadId,
4253 providerSessionId,
4254 now,
4255 }),
4256 now,
4257 });
4258 yield* eventSink.write({ events: secondThreadRequest.events });
4259 const failRelease = (failedWrites: number) =>
4260 Effect.gen(function* () {
4261 yield* Ref.set(flaky.failing, "session-and-requests");
4262 assert.isTrue(Exit.isFailure(yield* Effect.exit(manager.close(providerSessionId))));
4263 yield* Effect.repeat(Queue.take(flaky.failures), { times: failedWrites - 1 });
4264 yield* Ref.set(flaky.failing, "none");
4265 });
4266
4267 yield* manager.open({
4268 threadId: firstThreadId,
4269 providerSessionId,
4270 modelSelection,
4271 runtimePolicy,
4272 });
4273 yield* manager.open({
4274 threadId: secondThreadId,
4275 providerSessionId,
4276 modelSelection,
4277 runtimePolicy,
4278 });
4279 yield* failRelease(2);
4280 yield* TestClock.adjust("500 millis");
4281 yield* manager.open({
4282 threadId: firstThreadId,
4283 providerSessionId,
4284 modelSelection,
4285 runtimePolicy,
4286 });
4287 yield* failRelease(1);
4288
4289 const settled = yield* eventSink
4290 .stream({
4291 threadId: secondThreadId,
4292 afterSequence: yield* eventSink.latestSequence({ threadId: secondThreadId }),
4293 eventType: "runtime-request.updated",
4294 })
4295 .pipe(Stream.runHead, Effect.forkScoped);
4296 yield* TestClock.adjust("500 millis");
4297 yield* Fiber.join(settled);
4298
4299 const projection = yield* projectionStore.getThreadProjection(secondThreadId);
4300 assert.equal(projection.runtimeRequests.at(-1)?.responseCapability.type, "not_resumable");
4301 });
4302
4303 yield* effect.pipe(
4304 Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, flakyReleaseWrites: flaky })),
4305 );
4306 }),
4307 );
4308
4309 it.effect("ProviderSessionManagerV2 settles a request the event pump persists during release", () =>
4310 Effect.gen(function* () {
4311 const state = yield* Ref.make(emptyState);
4312 const flaky: FlakyReleaseWrites = {
4313 failing: yield* Ref.make<"none" | "session" | "session-and-requests">("none"),
4314 failures: yield* Queue.unbounded<void>(),
4315 pauseRequestWrites: {
4316 paused: yield* Deferred.make<void>(),
4317 resume: yield* Deferred.make<void>(),
4318 },
4319 };
4320 const pause = flaky.pauseRequestWrites!;
4321 const effect = Effect.gen(function* () {
4322 const eventSink = yield* EventSink.EventSinkV2;
4323 const idAllocator = yield* IdAllocator.IdAllocatorV2;
4324 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4325 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4326 const now = yield* DateTime.now;
4327 const threadId = ThreadId.make("thread-provider-session-manager-release-pump");
4328 const providerSessionId = yield* idAllocator.allocate.providerSession({
4329 providerInstanceId: modelSelection.instanceId,
4330 threadId,
4331 });
4332 yield* eventSink.write({
4333 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
4334 });
4335 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
4336 const createdAt = DateTime.add(now, { seconds: 1 });
4337 const pendingRequest = yield* makePendingRuntimeRequestEvents({
4338 idAllocator,
4339 threadId,
4340 providerSessionId,
4341 providerThread: makeProviderThread({
4342 idAllocator,
4343 threadId,
4344 providerSessionId,
4345 now: createdAt,
4346 }),
4347 now: createdAt,
4348 });
4349 const adapterEvents = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
4350 assert.isDefined(adapterEvents);
4351 yield* Queue.offerAll(adapterEvents!, pendingRequest.providerEvents);
4352 yield* Deferred.await(pause.paused);
4353 const closed = yield* manager
4354 .close(providerSessionId)
4355 .pipe(Effect.forkScoped({ startImmediately: true }));
4356 yield* TestClock.adjust("1 second");
4357 yield* Deferred.succeed(pause.resume, undefined);
4358 yield* Fiber.join(closed);
4359
4360 const projection = yield* projectionStore.getThreadProjection(threadId);
4361 const request = projection.runtimeRequests.find(
4362 (candidate) => candidate.id === pendingRequest.requestId,
4363 );
4364 assert.equal(request?.responseCapability.type, "not_resumable");
4365 });
4366
4367 yield* effect.pipe(
4368 Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, flakyReleaseWrites: flaky })),
4369 );
4370 }),
4371 );
4372
4373 it.effect.each(["manual_shutdown", "server_shutdown"] as const)(
4374 "ProviderSessionManagerV2 preserves questions only for server shutdown (%s)",
4375 (reason) =>
4376 Effect.gen(function* () {
4377 const state = yield* Ref.make(emptyState);
4378 const effect = Effect.gen(function* () {
4379 const eventSink = yield* EventSink.EventSinkV2;
4380 const idAllocator = yield* IdAllocator.IdAllocatorV2;
4381 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4382 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4383 const now = yield* DateTime.now;
4384 const projectId = yield* idAllocator.allocate.project({
4385 fixtureName: "provider-session-manager-request-expire",
4386 });
4387 const threadId = yield* idAllocator.allocate.thread({
4388 fixtureName: "provider-session-manager-request-expire",
4389 projectId,
4390 });
4391 const providerSessionId = yield* idAllocator.allocate.providerSession({
4392 providerInstanceId: modelSelection.instanceId,
4393 threadId,
4394 });
4395 const providerThread = makeProviderThread({
4396 idAllocator,
4397 threadId,
4398 providerSessionId,
4399 now,
4400 });
4401
4402 yield* eventSink.write({
4403 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
4404 });
4405 const pendingRequest = yield* makePendingRuntimeRequestEvents({
4406 idAllocator,
4407 threadId,
4408 providerSessionId,
4409 providerThread,
4410 now,
4411 });
4412 yield* eventSink.write({
4413 events: pendingRequest.events.map((event) =>
4414 event.type === "turn-item.updated"
4415 ? {
4416 ...event,
4417 payload: {
4418 ...event.payload,
4419 type: "user_input_request",
4420 questions: [
4421 { id: "color", header: "Color", question: "Which color?", options: [] },
4422 ],
4423 },
4424 }
4425 : event.type === "runtime-request.updated"
4426 ? { ...event, payload: { ...event.payload, kind: "user_input" } }
4427 : event,
4428 ),
4429 });
4430 yield* manager.open({
4431 threadId,
4432 providerSessionId,
4433 modelSelection,
4434 runtimePolicy,
4435 });
4436 yield* manager.release({
4437 providerSessionId,
4438 reason,
4439 });
4440
4441 const projection = yield* projectionStore.getThreadProjection(threadId);
4442 const request = projection.runtimeRequests.at(-1);
4443 const requestNode = projection.nodes.find((node) => node.id === request?.nodeId);
4444 const requestTurnItem = projection.turnItems.find(
4445 (item) => item.type === "user_input_request" && item.requestId === request?.id,
4446 );
4447
4448 const preserved = reason === "server_shutdown";
4449 assert.equal(request?.status, preserved ? "pending" : "cancelled");
4450 assert.equal(request?.responseCapability.type, preserved ? "live" : "not_resumable");
4451 assert.equal(requestNode?.status, preserved ? "waiting" : "cancelled");
4452 assert.equal(requestTurnItem?.status, preserved ? "waiting" : "cancelled");
4453 });
4454
4455 yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
4456 }),
4457 );
4458
4459 it.effect(
4460 "ProviderSessionManagerV2 cancels a pending approval when a detach releases its session",
4461 () =>
4462 Effect.gen(function* () {
4463 const state = yield* Ref.make(emptyState);
4464 const effect = Effect.gen(function* () {
4465 const eventSink = yield* EventSink.EventSinkV2;
4466 const idAllocator = yield* IdAllocator.IdAllocatorV2;
4467 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4468 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4469 const now = yield* DateTime.now;
4470 const projectId = yield* idAllocator.allocate.project({
4471 fixtureName: "provider-session-manager-detach-request",
4472 });
4473 const threadId = yield* idAllocator.allocate.thread({
4474 fixtureName: "provider-session-manager-detach-request",
4475 projectId,
4476 });
4477 const providerSessionId = yield* idAllocator.allocate.providerSession({
4478 providerInstanceId: modelSelection.instanceId,
4479 threadId,
4480 });
4481 const providerThread = makeProviderThread({
4482 idAllocator,
4483 threadId,
4484 providerSessionId,
4485 now,
4486 });
4487
4488 yield* eventSink.write({
4489 events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
4490 });
4491 const pendingRequest = yield* makePendingRuntimeRequestEvents({
4492 idAllocator,
4493 threadId,
4494 providerSessionId,
4495 providerThread,
4496 now,
4497 });
4498 yield* eventSink.write({ events: pendingRequest.events });
4499 yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
4500
4501 yield* manager.detach({ providerSessionId, threadId, detail: "Workspace changed." });
4502
4503 assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
4504 const projection = yield* projectionStore.getThreadProjection(threadId);
4505 const request = projection.runtimeRequests.find(
4506 (candidate) => candidate.id === pendingRequest.requestId,
4507 );
4508 assert.equal(request?.status, "cancelled");
4509 assert.equal(request?.responseCapability.type, "not_resumable");
4510 });
4511
4512 yield* effect.pipe(
4513 Effect.provide(
4514 layerTest({ state, idleTimeoutMs: 60_000, capabilities: ExclusiveCapabilities }),
4515 ),
4516 );
4517 }),
4518 );
4519
4520 it.effect(
4521 "ProviderSessionManagerV2 persists session-scoped requests and recovered commands without a run",
4522 () =>
4523 Effect.gen(function* () {
4524 const state = yield* Ref.make(emptyState);
4525 const effect = Effect.gen(function* () {
4526 const eventSink = yield* EventSink.EventSinkV2;
4527 const idAllocator = yield* IdAllocator.IdAllocatorV2;
4528 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4529 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4530 const now = yield* DateTime.now;
4531 const projectId = yield* idAllocator.allocate.project({
4532 fixtureName: "provider-session-manager-session-request",
4533 });
4534 const threadId = yield* idAllocator.allocate.thread({
4535 fixtureName: "provider-session-manager-session-request",
4536 projectId,
4537 });
4538 const providerSessionId = yield* idAllocator.allocate.providerSession({
4539 providerInstanceId: modelSelection.instanceId,
4540 threadId,
4541 });
4542 const providerThread = makeProviderThread({
4543 idAllocator,
4544 threadId,
4545 providerSessionId,
4546 now,
4547 });
4548
4549 const otherThreadId = yield* idAllocator.allocate.thread({
4550 fixtureName: "unattached-shell-owner",
4551 projectId,
4552 });
4553 yield* eventSink.write({
4554 events: [
4555 yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
4556 yield* makeThreadCreatedEvent({ idAllocator, threadId: otherThreadId, now }),
4557 ],
4558 });
4559 yield* manager.open({
4560 threadId,
4561 providerSessionId,
4562 modelSelection,
4563 runtimePolicy,
4564 });
4565 const pendingRequest = yield* makePendingRuntimeRequestEvents({
4566 idAllocator,
4567 threadId,
4568 providerSessionId,
4569 providerThread,
4570 now,
4571 });
4572 const shellId = "sh_recovered";
4573 const command = {
4574 id: idAllocator.derive.turnItemFromProviderItem({
4575 driver: CODEX_DRIVER,
4576 nativeItemId: shellId,
4577 }),
4578 threadId,
4579 runId: null,
4580 nodeId: null,
4581 providerThreadId: providerThread.id,
4582 providerTurnId: null,
4583 nativeItemRef: { driver: CODEX_DRIVER, nativeId: shellId, strength: "strong" as const },
4584 parentItemId: null,
4585 ordinal: 0,
4586 status: "running" as const,
4587 title: null,
4588 startedAt: now,
4589 completedAt: null,
4590 updatedAt: now,
4591 type: "command_execution" as const,
4592 input: "echo retained",
4593 output: "retained",
4594 };
4595 const anchored = {
4596 ...command,
4597 id: idAllocator.derive.turnItemFromProviderItem({
4598 driver: CODEX_DRIVER,
4599 nativeItemId: "sh_anchored",
4600 }),
4601 runId: idAllocator.derive.run({ threadId, ordinal: 1 }),
4602 };
4603 const commandEvents = [
4604 {
4605 type: "turn_item.updated" as const,
4606 driver: CODEX_DRIVER,
4607 turnItem: anchored,
4608 sessionScoped: true,
4609 },
4610 {
4611 type: "turn_item.updated" as const,
4612 driver: CODEX_DRIVER,
4613 turnItem: command,
4614 sessionScoped: true,
4615 },
4616 {
4617 type: "provider_thread.updated" as const,
4618 driver: CODEX_DRIVER,
4619 providerThread: {
4620 ...providerThread,
4621 pendingBackgroundTasks: [{ taskId: shellId, kind: "command" as const }],
4622 },
4623 sessionScoped: true,
4624 },
4625 {
4626 type: "turn_item.updated" as const,
4627 driver: CODEX_DRIVER,
4628 sessionScoped: true,
4629 turnItem: {
4630 ...command,
4631 status: "completed" as const,
4632 output: "retained\nfinished",
4633 completedAt: now,
4634 },
4635 },
4636 {
4637 type: "provider_thread.updated" as const,
4638 driver: CODEX_DRIVER,
4639 providerThread: { ...providerThread, pendingBackgroundTasks: [] },
4640 sessionScoped: true,
4641 },
4642 ];
4643 const afterSequence = yield* eventSink.latestSequence({ threadId });
4644 const persistedFiber = yield* eventSink.stream({ threadId, afterSequence }).pipe(
4645 Stream.filter(
4646 (stored) =>
4647 stored.event.type === "runtime-request.updated" ||
4648 stored.event.type === "node.updated" ||
4649 (stored.event.type === "turn-item.updated" &&
4650 stored.event.payload.type === "approval_request"),
4651 ),
4652 Stream.take(3),
4653 Stream.runCollect,
4654 Effect.forkScoped,
4655 );
4656 const adapterEvents = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
4657 assert.isDefined(adapterEvents);
4658 yield* Queue.offerAll(adapterEvents!, [
4659 ...commandEvents,
4660 {
4661 type: "turn_item.updated",
4662 driver: CODEX_DRIVER,
4663 sessionScoped: true,
4664 turnItem: { ...command, threadId: otherThreadId },
4665 },
4666 {
4667 type: "provider_thread.updated",
4668 driver: CODEX_DRIVER,
4669 providerThread: { ...providerThread, appThreadId: otherThreadId },
4670 sessionScoped: true,
4671 },
4672 ...pendingRequest.providerEvents,
4673 ]);
4674 const persisted = Array.from(yield* Fiber.join(persistedFiber));
4675
4676 assert.sameMembers(
4677 persisted.map((stored) => stored.event.type),
4678 ["runtime-request.updated", "node.updated", "turn-item.updated"],
4679 );
4680 const projection = yield* projectionStore.getThreadProjection(threadId);
4681 const request = projection.runtimeRequests.find(
4682 (candidate) => candidate.id === pendingRequest.requestId,
4683 );
4684 const node = projection.nodes.find((candidate) => candidate.id === pendingRequest.nodeId);
4685 const turnItem = projection.turnItems.find(
4686 (candidate) =>
4687 candidate.type === "approval_request" &&
4688 candidate.requestId === pendingRequest.requestId,
4689 );
4690 const recovered = projection.turnItems.find((item) => item.id === command.id);
4691 assert.deepInclude(recovered, {
4692 runId: null,
4693 status: "completed",
4694 output: "retained\nfinished",
4695 });
4696 assert.deepEqual(
4697 projection.providerThreads.find((item) => item.id === providerThread.id)
4698 ?.pendingBackgroundTasks,
4699 [],
4700 );
4701 assert.deepInclude(
4702 projection.turnItems.find((item) => item.id === anchored.id),
4703 { runId: anchored.runId, output: "retained" },
4704 );
4705 assert.isEmpty(projection.runs);
4706 const unrelated = yield* projectionStore.getThreadProjection(otherThreadId);
4707 assert.isEmpty(unrelated.turnItems);
4708 assert.isEmpty(unrelated.providerThreads);
4709 assert.equal(request?.status, "pending");
4710 assert.equal(request?.providerTurnId, null);
4711 assert.equal(node?.runId, null);
4712 assert.equal(node?.status, "waiting");
4713 assert.equal(turnItem?.runId, null);
4714 assert.equal(turnItem?.status, "waiting");
4715 });
4716
4717 yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
4718 }),
4719 );
4720
4721 it.effect.each([
4722 { name: "default load key", normalizeThreadLoadModelSelection: undefined },
4723 {
4724 name: "Codex load key",
4725 normalizeThreadLoadModelSelection: normalizeCodexThreadLoadModelSelection,
4726 },
4727 ])(
4728 "ProviderSessionManagerV2 opens one shared runtime, broadcasts events, and detaches threads independently ($name)",
4729 ({ normalizeThreadLoadModelSelection }) =>
4730 Effect.gen(function* () {
4731 const state = yield* Ref.make(emptyState);
4732 const settings = yield* ServerSettings.ServerSettingsService.pipe(
4733 Effect.provide(ServerSettings.layerTest()),
4734 );
4735 const effect = Effect.gen(function* () {
4736 const eventSink = yield* EventSink.EventSinkV2;
4737 const idAllocator = yield* IdAllocator.IdAllocatorV2;
4738 const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
4739 const now = yield* DateTime.now;
4740 const projectId = yield* idAllocator.allocate.project({
4741 fixtureName: "provider-session-manager-shared-runtime",
4742 });
4743 const firstThreadId = yield* idAllocator.allocate.thread({
4744 fixtureName: "provider-session-manager-shared-runtime-a",
4745 projectId,
4746 });
4747 const secondThreadId = yield* idAllocator.allocate.thread({
4748 fixtureName: "provider-session-manager-shared-runtime-b",
4749 projectId,
4750 });
4751 const providerSessionId = idAllocator.derive.providerSession({
4752 providerInstanceId: modelSelection.instanceId,
4753 });
4754
4755 yield* eventSink.write({
4756 events: [
4757 yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
4758 yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
4759 ],
4760 });
4761 const firstProviderThread = makeProviderThread({
4762 idAllocator,
4763 threadId: firstThreadId,
4764 providerSessionId,
4765 now,
4766 });
4767 const secondProviderThread = makeProviderThread({
4768 idAllocator,
4769 threadId: secondThreadId,
4770 providerSessionId,
4771 now,
4772 });
4773 const firstRunId = idAllocator.derive.run({ threadId: firstThreadId, ordinal: 1 });
4774 yield* eventSink.write({
4775 events: [
4776 {
4777 id: yield* idAllocator.allocate.event({ threadId: firstThreadId }),
4778 type: "provider-thread.updated",
4779 threadId: firstThreadId,
4780 driver: CODEX_DRIVER,
4781 occurredAt: now,
4782 payload: firstProviderThread,
4783 },
4784 {
4785 id: yield* idAllocator.allocate.event({ threadId: firstThreadId }),
4786 type: "provider-turn.updated",
4787 threadId: firstThreadId,
4788 runId: firstRunId,
4789 driver: CODEX_DRIVER,
4790 occurredAt: now,
4791 payload: {
4792 id: idAllocator.derive.providerTurn({
4793 driver: CODEX_DRIVER,
4794 nativeTurnId: "native-turn-shared-runtime-a",
4795 }),
4796 providerThreadId: firstProviderThread.id,
4797 nodeId: idAllocator.derive.rootNode({ runId: firstRunId }),
4798 runAttemptId: null,
4799 nativeTurnRef: null,
4800 ordinal: 1,
4801 status: "running",
4802 startedAt: now,
4803 completedAt: null,
4804 },
4805 },
4806 ],
4807 });
4808 const firstRuntime = yield* manager.open({
4809 threadId: firstThreadId,
4810 providerSessionId,
4811 modelSelection,
4812 runtimePolicy,
4813 });
4814 const secondRuntime = yield* manager.open({
4815 threadId: secondThreadId,
4816 providerSessionId,
4817 modelSelection,
4818 runtimePolicy,
4819 });
4820
4821 assert.strictEqual(firstRuntime, secondRuntime);
4822 assert.equal((yield* Ref.get(state)).openCount, 1);
4823 const resumeSecondThread = secondRuntime.resumeThread({
4824 providerThread: secondProviderThread,
4825 threadId: secondThreadId,
4826 modelSelection: {
4827 ...modelSelection,
4828 options: [{ id: "reasoningEffort", value: "medium" }],
4829 },
4830 runtimePolicy,
4831 });
4832 yield* resumeSecondThread;
4833 yield* resumeSecondThread;
4834 assert.equal((yield* Ref.get(state)).resumeCount, 1);
4835 let resumeCount = 1;
4836 const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4837 const appThread = (yield* projectionStore.getThreadProjection(secondThreadId)).thread;
4838 const turnEvents = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
4839 assert.isDefined(turnEvents);
4840 for (const [index, effort] of ["medium", "high", "medium"].entries()) {
4841 const selection = {
4842 ...modelSelection,
4843 options: [{ id: "reasoningEffort", value: effort }],
4844 } satisfies ModelSelection;
4845 yield* secondRuntime.resumeThread({
4846 providerThread: secondProviderThread,
4847 threadId: secondThreadId,
4848 modelSelection: selection,
4849 runtimePolicy,
4850 });
4851 const ordinal = index + 1;
4852 const runId = idAllocator.derive.run({ threadId: secondThreadId, ordinal });
4853 yield* secondRuntime.startTurn({
4854 appThread,
4855 threadId: secondThreadId,
4856 runId,
4857 runOrdinal: ordinal,
4858 providerTurnOrdinal: ordinal,
4859 attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
4860 rootNodeId: idAllocator.derive.rootNode({ runId }),
4861 providerThread: secondProviderThread,
4862 message: {
4863 createdBy: "user",
4864 creationSource: "web",
4865 messageId: yield* idAllocator.allocate.message({
4866 threadId: secondThreadId,
4867 ordinal,
4868 }),
4869 text: "turn",
4870 attachments: [],
4871 },
4872 modelSelection: selection,
4873 runtimePolicy,
4874 });
4875 const subscription = yield* secondRuntime.subscribeEvents!;
4876 const terminal = yield* subscription.events.pipe(
4877 Stream.filter((event) => event.type === "turn.terminal"),
4878 Stream.runHead,
4879 Effect.forkScoped,
4880 );
4881 yield* Queue.offer(turnEvents!, {
4882 type: "turn.terminal",
4883 driver: CODEX_DRIVER,
4884 providerThreadId: secondProviderThread.id,
4885 providerTurnId: idAllocator.derive.providerTurn({
4886 driver: CODEX_DRIVER,
4887 nativeTurnId: `native-effort-turn-${ordinal}`,
4888 }),
4889 runOrdinal: ordinal,
4890 status: "completed",
4891 failure: null,
4892 threadDisposition: "reusable",
4893 });
4894 yield* Fiber.join(terminal);
4895 if (normalizeThreadLoadModelSelection === undefined && index > 0) resumeCount++;
4896 assert.equal((yield* Ref.get(state)).resumeCount, resumeCount, `${effort} effort reload`);
4897 }
4898 yield* secondRuntime.resumeThread({
4899 providerThread: secondProviderThread,
4900 threadId: secondThreadId,
4901 modelSelection: { ...modelSelection, model: "gpt-5.4-mini" },
4902 runtimePolicy,
4903 });
4904 assert.equal((yield* Ref.get(state)).resumeCount, ++resumeCount);
4905 yield* resumeSecondThread;
4906 assert.equal((yield* Ref.get(state)).resumeCount, ++resumeCount);
4907 // regression: #26722 a Linked environments change reloads only the idle thread's tools.
4908 yield* settings.updateSettings({ linkedEnvironmentsEnabled: true });
4909 yield* resumeSecondThread;
4910 assert.equal((yield* Ref.get(state)).resumeCount, ++resumeCount);
4911 assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, ["native-thread"]);
4912 const subscribe = firstRuntime.subscribeEvents;
4913 assert.isDefined(subscribe);
4914 if (subscribe === undefined) return;
4915 const firstSubscription = yield* subscribe;
4916 const secondSubscription = yield* subscribe;
4917 const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
4918 assert.isDefined(queue);
4919 yield* Queue.offer(queue!, {
4920 type: "provider_session.updated",
4921 driver: CODEX_DRIVER,
4922 providerSession: firstRuntime.providerSession,
4923 });
4924 const received = yield* Effect.all([
4925 firstSubscription.events.pipe(Stream.runHead),
4926 secondSubscription.events.pipe(Stream.runHead),
4927 ]);
4928 assert.isTrue(received.every(Option.isSome));
4929 assert.isTrue(
4930 received.every(
4931 (event) => Option.isSome(event) && event.value.type === "provider_session.updated",
4932 ),
4933 );
4934
4935 yield* manager.detach({ providerSessionId, threadId: secondThreadId });
4936 yield* manager.open({
4937 threadId: secondThreadId,
4938 providerSessionId,
4939 modelSelection,
4940 runtimePolicy,
4941 });
4942 yield* resumeSecondThread;
4943 assert.equal((yield* Ref.get(state)).resumeCount, ++resumeCount);
4944
4945 assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, ["native-thread"]);
4946
4947 const reloadCases = [
4948 {
4949 name: "other model options",
4950 providerThread: secondProviderThread,
4951 selection: {
4952 ...modelSelection,
4953 options: [{ id: "serviceTier", value: "priority" }],
4954 },
4955 policy: runtimePolicy,
4956 },
4957 {
4958 name: "runtime policy",
4959 providerThread: secondProviderThread,
4960 selection: modelSelection,
4961 policy: { ...runtimePolicy, interactionMode: "plan" },
4962 },
4963 ] satisfies ReadonlyArray<{
4964 name: string;
4965 providerThread: OrchestrationV2ProviderThread;
4966 selection: ModelSelection;
4967 policy: ProviderAdapter.ProviderAdapterV2RuntimePolicy;
4968 }>;
4969 for (const { name, providerThread, selection, policy } of reloadCases) {
4970 const before = (yield* Ref.get(state)).resumeCount;
4971 yield* secondRuntime.resumeThread({
4972 providerThread,
4973 threadId: secondThreadId,
4974 modelSelection: selection,
4975 runtimePolicy: policy,
4976 });
4977 assert.equal((yield* Ref.get(state)).resumeCount, before + 1, `${name} did not reload`);
4978 }
4979
4980 yield* manager.detach({ providerSessionId, threadId: firstThreadId });
4981 assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
4982 assert.equal((yield* Ref.get(state)).closeCount, 0);
4983 assert.equal((yield* Ref.get(state)).interruptCount, 1);
4984 assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, [
4985 "native-thread",
4986 "native-thread",
4987 ]);
4988
4989 yield* manager.detach({ providerSessionId, threadId: secondThreadId });
4990 yield* TestClock.adjust("1 second");
4991 yield* Effect.yieldNow;
4992 assert.equal((yield* Ref.get(state)).closeCount, 1);
4993 });
4994
4995 yield* effect.pipe(
4996 Effect.provide(
4997 layerTest({
4998 state,
4999 idleTimeoutMs: 1000,
5000 ...(normalizeThreadLoadModelSelection === undefined
Showing first 5,000 of 5,819 lines. View raw