TypeScript
import * as NetAddress from "effect/net/NetAddress";
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, it } from "@effect/vitest";
import { AgentScope } from "@t3tools/shared/AgentScope";
import {
EnvironmentId,
type ModelSelection,
type OrchestrationV2AppThread,
type OrchestrationV2DomainEvent,
type OrchestrationV2ProviderCapabilities,
type OrchestrationV2ProviderSession,
type OrchestrationV2ProviderThread,
type Project,
ProjectId,
ProviderDriverKind,
ProviderInstanceId,
type ProviderSessionId,
ThreadId,
} from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import { TestClock } from "effect/testing";
import { HttpServer } from "effect/http";
import { ProviderWorkspaceMissingError } from "../provider/Errors.ts";
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
import * as ProjectService from "../project/ProjectService.ts";
import * as McpProviderSession from "@t3tools/provider-core/server/mcpSession";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts";
import * as SqlitePersistence from "../persistence/Sqlite.ts";
import * as ServerSettings from "../serverSettings.ts";
import { CodexProviderCapabilitiesV2 } from "./Adapters/CodexAdapterV2.ts";
import * as EventSink from "./EventSink.ts";
import * as EventStore from "./EventStore.ts";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as ProjectionStore from "./ProjectionStore.ts";
import * as ProviderAdapterRegistry from "./ProviderAdapterRegistry.ts";
import * as ProviderEventIngestor from "./ProviderEventIngestor.ts";
import * as ProviderInstanceRegistry from "../provider/ProviderInstanceRegistry.ts";
import * as GitVcsDriver from "../vcs/GitVcsDriver.ts";
import * as ThreadCommandExecutor from "./ThreadCommandExecutor.ts";
import * as ProviderSessionManager from "./ProviderSessionManager.ts";
import * as CommandOutputHub from "./CommandOutputHub.ts";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
const layerTestDatabase = SqlitePersistence.layerMemory;
const layerTestStores = Layer.merge(EventStore.layer, ProjectionStore.layer).pipe(
Layer.provide(layerTestDatabase),
);
const layerTestEventSink = EventSink.layer.pipe(
Layer.provide(Layer.mergeAll(layerTestStores, layerTestDatabase)),
);
const layerFailingReleaseEventSink = Layer.effect(
EventSink.EventSinkV2,
Effect.gen(function* () {
const delegate = yield* EventSink.EventSinkV2;
return EventSink.EventSinkV2.of({
...delegate,
write: (input) =>
input.events.some(
(event) =>
event.type === "provider-session.updated" &&
(event.payload.status === "stopped" || event.payload.status === "error"),
)
? Effect.fail(new EventSink.EventSinkWriteError({ eventCount: input.events.length }))
: delegate.write(input),
});
}),
).pipe(Layer.provide(layerTestEventSink));
interface FlakyReleaseWrites {
readonly failing: Ref.Ref<"none" | "session" | "session-and-requests">;
readonly failures: Queue.Queue<void>;
readonly pauseRequestWrites?: {
readonly paused: Deferred.Deferred<void>;
readonly resume: Deferred.Deferred<void>;
};
}
const layerFlakyReleaseEventSink = (flaky: FlakyReleaseWrites) =>
Layer.effect(
EventSink.EventSinkV2,
Effect.gen(function* () {
const delegate = yield* EventSink.EventSinkV2;
return EventSink.EventSinkV2.of({
...delegate,
write: (input) =>
Effect.gen(function* () {
const failing = yield* Ref.get(flaky.failing);
const fails = input.events.some(
(event) =>
(failing !== "none" &&
event.type === "provider-session.updated" &&
(event.payload.status === "stopped" || event.payload.status === "error")) ||
(failing === "session-and-requests" && event.type === "runtime-request.updated"),
);
const pause = flaky.pauseRequestWrites;
if (
pause !== undefined &&
input.events.some((event) => event.type === "runtime-request.updated")
) {
yield* Deferred.succeed(pause.paused, undefined);
yield* Deferred.await(pause.resume);
}
if (!fails) return yield* delegate.write(input);
yield* Queue.offer(flaky.failures, undefined);
return yield* Effect.die(new Error("simulated commit failure"));
}),
});
}),
).pipe(Layer.provide(layerTestEventSink));
const layerPausingAttachEventSink = (pause: {
readonly armed: Ref.Ref<boolean>;
readonly paused: Deferred.Deferred<void>;
}) =>
Layer.effect(
EventSink.EventSinkV2,
Effect.gen(function* () {
const delegate = yield* EventSink.EventSinkV2;
return EventSink.EventSinkV2.of({
...delegate,
write: (input) =>
Effect.gen(function* () {
const attach = input.events.some((event) => event.type === "provider-session.attached");
if (attach && (yield* Ref.getAndSet(pause.armed, false))) {
yield* Deferred.succeed(pause.paused, undefined);
return yield* Effect.never;
}
return yield* delegate.write(input);
}),
});
}),
).pipe(Layer.provide(layerTestEventSink));
const layerBeforeUnchangedWriteEventSink = (before: Ref.Ref<Effect.Effect<void>>) =>
Layer.effect(
EventSink.EventSinkV2,
Effect.gen(function* () {
const delegate = yield* EventSink.EventSinkV2;
return EventSink.EventSinkV2.of({
...delegate,
writeIfProviderThreadUnchanged: (input) =>
Ref.getAndSet(before, Effect.void).pipe(
Effect.flatten,
Effect.andThen(delegate.writeIfProviderThreadUnchanged(input)),
),
});
}),
).pipe(Layer.provide(layerTestEventSink));
const CodexCapabilities: OrchestrationV2ProviderCapabilities = CodexProviderCapabilitiesV2;
const ExclusiveCapabilities: OrchestrationV2ProviderCapabilities = {
...CodexCapabilities,
sessions: {
...CodexCapabilities.sessions,
supportsMultipleProviderThreadsPerSession: false,
},
};
interface TestProviderRuntimeState {
readonly openCount: number;
readonly closeCount: number;
readonly interruptCount: number;
readonly resumeCount: number;
readonly unloadedNativeThreadIds: ReadonlyArray<string>;
readonly eventQueues: ReadonlyMap<
string,
Queue.Queue<ProviderAdapter.ProviderAdapterV2Event, Cause.Done>
>;
}
const emptyState: TestProviderRuntimeState = {
openCount: 0,
closeCount: 0,
interruptCount: 0,
resumeCount: 0,
unloadedNativeThreadIds: [],
eventQueues: new Map(),
};
const modelSelection = {
instanceId: ProviderInstanceId.make("codex"),
model: "gpt-5.4",
} satisfies ModelSelection;
const CODEX_DRIVER = ProviderDriverKind.make("codex");
const runtimePolicy = {
runtimeMode: "full-access",
interactionMode: "default",
cwd: process.cwd(),
} satisfies ProviderAdapter.ProviderAdapterV2RuntimePolicy;
function makeProviderSession(input: {
readonly providerSessionId: ProviderSessionId;
readonly now: DateTime.Utc;
readonly capabilities?: OrchestrationV2ProviderCapabilities;
}): OrchestrationV2ProviderSession {
return {
id: input.providerSessionId,
driver: CODEX_DRIVER,
providerInstanceId: modelSelection.instanceId,
status: "ready",
cwd: process.cwd(),
model: "gpt-5.4",
capabilities: input.capabilities ?? CodexCapabilities,
createdAt: input.now,
updatedAt: input.now,
lastError: null,
};
}
function makeThreadCreatedEvent(input: {
readonly idAllocator: IdAllocator.IdAllocatorV2["Service"];
readonly threadId: ThreadId;
readonly now: DateTime.Utc;
readonly projectId?: ProjectId;
readonly delegatedBy?: ThreadId;
}) {
return Effect.gen(function* () {
const projectId =
input.projectId ??
(yield* input.idAllocator.allocate.project({
fixtureName: "provider-session-manager",
}));
const providerThreadId = input.idAllocator.derive.providerThread({
driver: CODEX_DRIVER,
nativeThreadId: "native-thread",
});
const thread: OrchestrationV2AppThread = {
createdBy: "user",
creationSource: "web",
id: input.threadId,
projectId,
title: "Provider session manager",
providerInstanceId: modelSelection.instanceId,
modelSelection,
runtimeMode: "full-access",
interactionMode: "default",
branch: null,
worktreePath: null,
activeProviderThreadId: providerThreadId,
lineage:
input.delegatedBy === undefined
? { parentThreadId: null, relationshipToParent: null, rootThreadId: input.threadId }
: {
parentThreadId: input.delegatedBy,
relationshipToParent: "subagent",
rootThreadId: input.delegatedBy,
},
forkedFrom: null,
createdAt: input.now,
updatedAt: input.now,
archivedAt: null,
settledOverride: null,
settledAt: null,
lastVisitedAt: null,
deletedAt: null,
};
return {
id: yield* input.idAllocator.allocate.event({ threadId: input.threadId }),
type: "thread.created" as const,
threadId: input.threadId,
occurredAt: input.now,
payload: thread,
};
});
}
function makeProviderThread(input: {
readonly idAllocator: IdAllocator.IdAllocatorV2["Service"];
readonly threadId: ThreadId;
readonly providerSessionId: ProviderSessionId;
readonly now: DateTime.Utc;
readonly nativeThreadId?: string;
}): OrchestrationV2ProviderThread {
const nativeThreadId = input.nativeThreadId ?? "native-thread";
return {
id: input.idAllocator.derive.providerThread({
driver: CODEX_DRIVER,
nativeThreadId,
}),
driver: CODEX_DRIVER,
providerInstanceId: modelSelection.instanceId,
providerSessionId: input.providerSessionId,
appThreadId: input.threadId,
ownerNodeId: null,
nativeThreadRef: {
driver: CODEX_DRIVER,
nativeId: nativeThreadId,
strength: "strong",
},
nativeConversationHeadRef: null,
status: "idle",
firstRunOrdinal: null,
lastRunOrdinal: null,
handoffIds: [],
forkedFrom: null,
createdAt: input.now,
updatedAt: input.now,
};
}
// A Codex native subagent's provider thread is owned by its child app thread
// but reachable from the parent's projection through the subagent record.
const makeNativeChildFixture = Effect.fnUntraced(function* () {
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const eventSink = yield* EventSink.EventSinkV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const parentThreadId = ThreadId.make("native-parent");
const childThreadId = ThreadId.make("native-child");
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
const childThreadEvent = yield* makeThreadCreatedEvent({
idAllocator,
threadId: childThreadId,
now,
});
const childProviderThread = makeProviderThread({
idAllocator,
threadId: childThreadId,
providerSessionId,
nativeThreadId: "native-child-thread",
now,
});
const parentRunId = idAllocator.derive.run({ threadId: parentThreadId, ordinal: 1 });
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: parentThreadId, now }),
{
...childThreadEvent,
payload: {
...childThreadEvent.payload,
createdBy: "agent",
creationSource: "provider",
activeProviderThreadId: null,
lineage: {
parentThreadId,
relationshipToParent: "subagent",
rootThreadId: parentThreadId,
},
},
},
{
id: yield* idAllocator.allocate.event({ threadId: childThreadId }),
type: "provider-thread.updated",
threadId: childThreadId,
occurredAt: now,
payload: childProviderThread,
},
{
id: yield* idAllocator.allocate.event({ threadId: parentThreadId }),
type: "subagent.updated",
threadId: parentThreadId,
occurredAt: now,
payload: {
id: idAllocator.derive.nodeFromProviderItem({
driver: CODEX_DRIVER,
nativeItemId: "native-child-task",
}),
threadId: parentThreadId,
runId: parentRunId,
parentNodeId: idAllocator.derive.rootNode({ runId: parentRunId }),
origin: "provider_native",
createdBy: "agent",
driver: CODEX_DRIVER,
providerInstanceId: modelSelection.instanceId,
providerThreadId: childProviderThread.id,
childThreadId,
nativeTaskRef: {
driver: CODEX_DRIVER,
nativeId: "native-child-task",
strength: "strong",
},
prompt: "Reply READY",
title: "Native child",
model: null,
status: "completed",
result: "READY",
startedAt: now,
completedAt: now,
updatedAt: now,
},
},
],
});
const parent = { threadId: parentThreadId, providerSessionId };
const runtime = yield* manager.open({ ...parent, modelSelection, runtimePolicy });
const resumeChild = runtime.resumeThread({
providerThread: childProviderThread,
threadId: childThreadId,
modelSelection,
runtimePolicy,
});
return { manager, parent, resumeChild };
});
function unimplemented(detail: string) {
return Effect.fail(
new ProviderAdapter.ProviderAdapterProtocolError({
driver: CODEX_DRIVER,
detail,
}),
);
}
const makeProviderAdapter = Effect.fnUntraced(function* (
state: Ref.Ref<TestProviderRuntimeState>,
options: {
readonly failEventStream?: boolean;
readonly capabilities?: OrchestrationV2ProviderCapabilities;
readonly extensionStatuses?: OrchestrationV2ProviderSession["extensionStatuses"];
readonly mcpConfigs?: Ref.Ref<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>;
readonly beforeOpen?: (input: {
readonly providerSessionId: ProviderSessionId;
readonly initialProviderItemIdentityVersion?: 2;
}) => Effect.Effect<void>;
readonly hasPendingBackgroundWork?: Effect.Effect<boolean>;
readonly hasPendingBackgroundWorkForThread?: Effect.Effect<boolean>;
readonly backgroundTasksEndWithProcess?: boolean;
readonly hangSessionScopeClose?: boolean;
readonly startTurn?: Effect.Effect<void>;
readonly interruptTurn?: Effect.Effect<void>;
readonly beforeUnload?: Effect.Effect<void>;
readonly spawnBeforeOpen?: boolean;
readonly scopeCloseReached?: Deferred.Deferred<void>;
} = {},
) {
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const countClose = Effect.addFinalizer(() =>
Ref.update(state, (current) => ({
...current,
closeCount: current.closeCount + 1,
})),
);
// Register after countClose to wedge teardown before its finalizer, matching a provider stream that never yields.
const hangClose = Effect.addFinalizer(() =>
(options.scopeCloseReached === undefined
? Effect.void
: Deferred.succeed(options.scopeCloseReached, undefined)
).pipe(Effect.andThen(Effect.never)),
);
return ProviderAdapter.ProviderAdapterV2.of({
instanceId: ProviderInstanceId.make("codex"),
driver: CODEX_DRIVER,
getCapabilities: () => Effect.succeed(options.capabilities ?? CodexCapabilities),
planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" }),
openSession: (input) =>
Effect.gen(function* () {
if (options.spawnBeforeOpen === true) {
yield* countClose;
if (options.hangSessionScopeClose === true) yield* hangClose;
}
if (options.mcpConfigs !== undefined && options.spawnBeforeOpen === true) {
const mcpConfig = yield* mcpSessions.read(input.threadId);
yield* Ref.update(options.mcpConfigs, (configs) => [...configs, mcpConfig]);
}
if (options.beforeOpen !== undefined) {
yield* options.beforeOpen(input);
}
if (options.mcpConfigs !== undefined && options.spawnBeforeOpen !== true) {
const mcpConfig = yield* mcpSessions.read(input.threadId);
yield* Ref.update(options.mcpConfigs, (configs) => [...configs, mcpConfig]);
}
const now = yield* DateTime.now;
const events = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event, Cause.Done>();
let session: OrchestrationV2ProviderSession = {
...makeProviderSession({
providerSessionId: input.providerSessionId,
now,
...(options.capabilities === undefined ? {} : { capabilities: options.capabilities }),
}),
...(options.extensionStatuses === undefined
? {}
: { extensionStatuses: options.extensionStatuses }),
};
yield* Ref.update(state, (current) => {
const eventQueues = new Map(current.eventQueues);
eventQueues.set(String(input.providerSessionId), events);
return {
...current,
openCount: current.openCount + 1,
eventQueues,
};
});
if (options.spawnBeforeOpen !== true) {
yield* countClose;
if (options.hangSessionScopeClose === true) yield* hangClose;
}
return {
instanceId: ProviderInstanceId.make("codex"),
driver: CODEX_DRIVER,
providerSessionId: input.providerSessionId,
get providerSession() {
return session;
},
events: options.failEventStream
? Stream.fail(
new ProviderAdapter.ProviderAdapterEventStreamError({
driver: CODEX_DRIVER,
providerSessionId: input.providerSessionId,
cause: "process exited",
}),
)
: Stream.fromQueue(events).pipe(
Stream.tap((event) =>
Effect.sync(() => {
if (event.type === "provider_session.updated") session = event.providerSession;
}),
),
),
...(options.backgroundTasksEndWithProcess === false
? {}
: { backgroundTasksEndWithProcess: true as const }),
...(options.hasPendingBackgroundWork === undefined
? {}
: { hasPendingBackgroundWork: options.hasPendingBackgroundWork }),
...(options.hasPendingBackgroundWorkForThread === undefined
? {}
: {
hasPendingBackgroundWorkForThread: () => options.hasPendingBackgroundWorkForThread!,
}),
ensureThread: () => unimplemented("ensureThread unused in test"),
resumeThread: (threadInput) =>
Ref.update(state, (current) => ({
...current,
resumeCount: current.resumeCount + 1,
})).pipe(Effect.as(threadInput.providerThread)),
startTurn: () => options.startTurn ?? Effect.void,
steerTurn: () => Effect.void,
interruptTurn: () =>
Ref.update(state, (current) => ({
...current,
interruptCount: current.interruptCount + 1,
})).pipe(Effect.andThen(options.interruptTurn ?? Effect.void)),
unloadThread: ({ providerThread }) =>
(options.beforeUnload ?? Effect.void).pipe(
Effect.andThen(
Ref.update(state, (current) => ({
...current,
unloadedNativeThreadIds: [
...current.unloadedNativeThreadIds,
providerThread.nativeThreadRef?.nativeId ?? "",
],
})),
),
),
respondToRuntimeRequest: () => Effect.void,
readThreadSnapshot: () => unimplemented("readThreadSnapshot unused in test"),
rollbackThread: () => unimplemented("rollbackThread unused in test"),
forkThread: () => unimplemented("forkThread unused in test"),
} satisfies ProviderAdapter.ProviderAdapterV2SessionRuntime;
}),
});
});
function layerTest(input: {
readonly state: Ref.Ref<TestProviderRuntimeState>;
readonly idleTimeoutMs: number;
readonly maxIdlePinMs?: number;
readonly failEventStream?: boolean;
readonly capabilities?: OrchestrationV2ProviderCapabilities;
readonly extensionStatuses?: OrchestrationV2ProviderSession["extensionStatuses"];
readonly mcpConfigs?: Ref.Ref<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>;
readonly beforeOpen?: (input: {
readonly providerSessionId: ProviderSessionId;
readonly initialProviderItemIdentityVersion?: 2;
}) => Effect.Effect<void>;
readonly failReleaseEventWrites?: boolean;
readonly flakyReleaseWrites?: FlakyReleaseWrites;
readonly pauseAttachWrite?: Parameters<typeof layerPausingAttachEventSink>[0];
readonly beforeUnchangedWrite?: Ref.Ref<Effect.Effect<void>>;
readonly pauseResolve?: {
readonly armed: Ref.Ref<boolean>;
readonly paused: Deferred.Deferred<void>;
};
readonly hasPendingBackgroundWork?: Effect.Effect<boolean>;
readonly hasPendingBackgroundWorkForThread?: Effect.Effect<boolean>;
readonly backgroundTasksEndWithProcess?: boolean;
readonly hangSessionScopeClose?: boolean;
readonly startTurn?: Effect.Effect<void>;
readonly interruptTurn?: Effect.Effect<void>;
readonly beforeUnload?: Effect.Effect<void>;
readonly spawnBeforeOpen?: boolean;
readonly scopeCloseReached?: Deferred.Deferred<void>;
readonly serverSettingsLayer?: ReturnType<typeof ServerSettings.layerTest>;
readonly projectServiceLayer?: Layer.Layer<ProjectService.ProjectService>;
}) {
const layerConfiguredEventSink =
input.flakyReleaseWrites !== undefined
? layerFlakyReleaseEventSink(input.flakyReleaseWrites)
: input.pauseAttachWrite !== undefined
? layerPausingAttachEventSink(input.pauseAttachWrite)
: input.beforeUnchangedWrite !== undefined
? layerBeforeUnchangedWriteEventSink(input.beforeUnchangedWrite)
: input.failReleaseEventWrites
? layerFailingReleaseEventSink
: layerTestEventSink;
const layerRegistry = Layer.unwrap(
makeProviderAdapter(input.state, {
failEventStream: input.failEventStream ?? false,
...(input.capabilities === undefined ? {} : { capabilities: input.capabilities }),
...(input.extensionStatuses === undefined
? {}
: { extensionStatuses: input.extensionStatuses }),
...(input.mcpConfigs === undefined ? {} : { mcpConfigs: input.mcpConfigs }),
...(input.beforeOpen === undefined ? {} : { beforeOpen: input.beforeOpen }),
...(input.hasPendingBackgroundWork === undefined
? {}
: { hasPendingBackgroundWork: input.hasPendingBackgroundWork }),
...(input.hasPendingBackgroundWorkForThread === undefined
? {}
: { hasPendingBackgroundWorkForThread: input.hasPendingBackgroundWorkForThread }),
...(input.backgroundTasksEndWithProcess === undefined
? {}
: { backgroundTasksEndWithProcess: input.backgroundTasksEndWithProcess }),
...(input.hangSessionScopeClose === undefined
? {}
: { hangSessionScopeClose: input.hangSessionScopeClose }),
...(input.startTurn === undefined ? {} : { startTurn: input.startTurn }),
...(input.interruptTurn === undefined ? {} : { interruptTurn: input.interruptTurn }),
...(input.beforeUnload === undefined ? {} : { beforeUnload: input.beforeUnload }),
...(input.spawnBeforeOpen === undefined ? {} : { spawnBeforeOpen: input.spawnBeforeOpen }),
...(input.scopeCloseReached === undefined
? {}
: { scopeCloseReached: input.scopeCloseReached }),
}).pipe(Effect.map(ProviderAdapterRegistry.layerSingle)),
);
const layerConfiguredMcpRegistry =
input.pauseResolve === undefined
? layerTestMcpRegistry
: layerPausingMcpRegistry(input.pauseResolve);
const layerProviderEventIngestorTest = ProviderEventIngestor.layer.pipe(
Layer.provide(
Layer.mergeAll(
Layer.mock(ProviderInstanceRegistry.ProviderInstanceRegistry)({
getInstance: () => Effect.undefined,
}),
layerConfiguredEventSink,
IdAllocator.layer,
layerTestStores,
ThreadCommandExecutor.layer,
Layer.mock(GitVcsDriver.GitVcsDriver)({
resolveBranchName: () => Effect.succeed(null),
}),
),
),
);
return Layer.mergeAll(
layerTestStores,
layerConfiguredEventSink,
IdAllocator.layer,
layerConfiguredMcpRegistry,
McpProviderSessions.layer,
ProviderSessionManager.layerWithOptions({
idleTimeoutMs: input.idleTimeoutMs,
...(input.maxIdlePinMs === undefined ? {} : { maxIdlePinMs: input.maxIdlePinMs }),
}).pipe(
Layer.provide(
Layer.mergeAll(
layerRegistry.pipe(Layer.provideMerge(McpProviderSessions.layer)),
CommandOutputHub.layer.pipe(
Layer.provide(Layer.merge(layerConfiguredEventSink, layerTestStores)),
),
layerConfiguredEventSink,
IdAllocator.layer,
layerProviderEventIngestorTest,
layerConfiguredMcpRegistry,
layerTestStores,
...(input.serverSettingsLayer === undefined ? [] : [input.serverSettingsLayer]),
...(input.projectServiceLayer === undefined ? [] : [input.projectServiceLayer]),
),
),
),
).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
}
const fakeHttpServer = HttpServer.HttpServer.of({
address: NetAddress.inetAddressFromIpStringUnsafe("127.0.0.1", 43123),
serve: (() => Effect.void) as HttpServer.HttpServer["Service"]["serve"],
});
const fakeEnvironment = ServerEnvironment.ServerEnvironment.of({
getEnvironmentId: Effect.succeed(EnvironmentId.make("environment-provider-session-manager")),
getDescriptor: Effect.die("unused"),
});
const layerTestMcpRegistry = Layer.effect(
McpSessionRegistry.McpSessionRegistry,
McpSessionRegistry.__testing.make(),
).pipe(
Layer.provide(Layer.succeed(HttpServer.HttpServer, fakeHttpServer)),
Layer.provide(Layer.succeed(ServerEnvironment.ServerEnvironment, fakeEnvironment)),
Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
);
const layerPausingMcpRegistry = (pause: {
readonly armed: Ref.Ref<boolean>;
readonly paused: Deferred.Deferred<void>;
}) =>
Layer.effect(
McpSessionRegistry.McpSessionRegistry,
Effect.gen(function* () {
const delegate = yield* McpSessionRegistry.McpSessionRegistry;
return McpSessionRegistry.McpSessionRegistry.of({
...delegate,
resolve: (rawToken) =>
Ref.getAndSet(pause.armed, false).pipe(
Effect.flatMap((armed) =>
armed
? Deferred.succeed(pause.paused, undefined).pipe(Effect.andThen(Effect.never))
: delegate.resolve(rawToken),
),
),
});
}),
).pipe(Layer.provide(layerTestMcpRegistry));
function makeBrowserAccessProject(projectId: ProjectId): Project {
return {
id: projectId,
title: "Browser access project",
workspaceRoot: process.cwd(),
repositoryIdentity: null,
faviconPath: null,
projectIcon: null,
defaultModelSelection: null,
defaultThreadEnvMode: null,
autoPull: false,
scripts: [],
createdAt: "2026-01-01T00:00:00.000Z",
updatedAt: "2026-01-01T00:00:00.000Z",
deletedAt: null,
};
}
function runBrowserAccessScenario(input: {
readonly enableAgentBrowserAccess: boolean;
readonly projectOverride: boolean;
readonly deviceOverride?: boolean;
readonly createThread?: boolean;
readonly projectExists?: boolean;
readonly delegatedBy?: ThreadId;
}) {
return Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const projectId = ProjectId.make("project-provider-session-manager-browser-access");
const threadId = ThreadId.make("thread-provider-session-manager-browser-access");
const layerProjectService = Layer.mock(ProjectService.ProjectService)({
getById: (requestedProjectId) =>
Effect.succeed(
input.projectExists === false
? Option.none()
: Option.some(makeBrowserAccessProject(requestedProjectId)),
),
});
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
if (input.createThread !== false) {
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({
idAllocator,
threadId,
now,
projectId,
...(input.delegatedBy === undefined ? {} : { delegatedBy: input.delegatedBy }),
}),
],
});
}
yield* manager
.open({ threadId, providerSessionId, modelSelection, runtimePolicy })
.pipe(Effect.ignore);
}).pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1_000,
mcpConfigs,
projectServiceLayer: layerProjectService,
serverSettingsLayer: ServerSettings.layerTest({
enableAgentBrowserAccess: input.enableAgentBrowserAccess,
projectSettingsOverrides: {
[projectId]: {
enableAgentBrowserAccess: input.projectOverride,
...(input.deviceOverride === undefined
? {}
: { enableAgentDeviceAccess: input.deviceOverride }),
},
},
}),
}),
),
);
return (yield* Ref.get(mcpConfigs))[0];
});
}
function makePendingRuntimeRequestEvents(input: {
readonly idAllocator: IdAllocator.IdAllocatorV2["Service"];
readonly threadId: ThreadId;
readonly providerSessionId: ProviderSessionId;
readonly providerThread: OrchestrationV2ProviderThread;
readonly now: DateTime.Utc;
}) {
return Effect.gen(function* () {
const requestId = yield* input.idAllocator.allocate.runtimeRequest({
driver: CODEX_DRIVER,
nativeRequestId: "pending-approval",
});
const nodeId = input.idAllocator.derive.approvalNode({ requestId });
const node = {
id: nodeId,
threadId: input.threadId,
runId: null,
parentNodeId: null,
rootNodeId: nodeId,
kind: "approval_request" as const,
status: "waiting" as const,
countsForRun: false,
providerThreadId: input.providerThread.id,
providerTurnId: null,
nativeItemRef: null,
runtimeRequestId: requestId,
checkpointScopeId: null,
startedAt: input.now,
completedAt: null,
};
const request = {
id: requestId,
nodeId,
providerTurnId: null,
nativeRequestRef: {
driver: CODEX_DRIVER,
nativeId: "pending-approval",
strength: "strong" as const,
},
kind: "command" as const,
status: "pending" as const,
responseCapability: {
type: "live" as const,
providerSessionId: input.providerSessionId,
},
createdAt: input.now,
resolvedAt: null,
};
const turnItem = {
id: input.idAllocator.derive.approvalTurnItem({ requestId }),
threadId: input.threadId,
runId: null,
nodeId,
providerThreadId: input.providerThread.id,
providerTurnId: null,
nativeItemRef: null,
parentItemId: null,
ordinal: 1,
status: "waiting" as const,
title: null,
startedAt: input.now,
completedAt: null,
updatedAt: input.now,
type: "approval_request" as const,
requestId,
requestKind: "command" as const,
};
const events = [
{
id: yield* input.idAllocator.allocate.event({
threadId: input.threadId,
providerSessionId: input.providerSessionId,
}),
type: "node.updated" as const,
threadId: input.threadId,
nodeId,
driver: CODEX_DRIVER,
occurredAt: input.now,
payload: node,
},
{
id: yield* input.idAllocator.allocate.event({
threadId: input.threadId,
providerSessionId: input.providerSessionId,
}),
type: "runtime-request.updated" as const,
threadId: input.threadId,
nodeId,
driver: CODEX_DRIVER,
occurredAt: input.now,
payload: request,
},
{
id: yield* input.idAllocator.allocate.event({
threadId: input.threadId,
providerSessionId: input.providerSessionId,
}),
type: "turn-item.updated" as const,
threadId: input.threadId,
nodeId,
driver: CODEX_DRIVER,
occurredAt: input.now,
payload: turnItem,
},
] satisfies ReadonlyArray<OrchestrationV2DomainEvent>;
const providerEvents = [
{
type: "runtime_request.updated" as const,
driver: CODEX_DRIVER,
threadId: input.threadId,
runtimeRequest: request,
},
{
type: "node.updated" as const,
driver: CODEX_DRIVER,
node,
},
{
type: "turn_item.updated" as const,
driver: CODEX_DRIVER,
turnItem,
},
] satisfies ReadonlyArray<ProviderAdapter.ProviderAdapterV2Event>;
return { events, providerEvents, requestId, nodeId };
});
}
it.effect("ProviderSessionManagerV2 opens independent sessions concurrently", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const openStartedCount = yield* Ref.make(0);
const firstOpenStarted = yield* Deferred.make<void>();
const secondOpenStarted = yield* Deferred.make<void>();
const releaseOpens = yield* Deferred.make<void>();
const beforeOpen = () =>
Effect.gen(function* () {
const openNumber = yield* Ref.modify(openStartedCount, (count) => [count + 1, count + 1]);
yield* Deferred.succeed(openNumber === 1 ? firstOpenStarted : secondOpenStarted, undefined);
yield* Deferred.await(releaseOpens);
});
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const firstThreadId = ThreadId.make("thread-provider-session-manager-concurrent-a");
const secondThreadId = ThreadId.make("thread-provider-session-manager-concurrent-b");
const firstProviderSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId: firstThreadId,
});
const secondProviderSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId: secondThreadId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
],
});
const firstFiber = yield* manager
.open({
threadId: firstThreadId,
providerSessionId: firstProviderSessionId,
modelSelection,
runtimePolicy,
})
.pipe(Effect.forkScoped);
yield* Deferred.await(firstOpenStarted);
const secondFiber = yield* manager
.open({
threadId: secondThreadId,
providerSessionId: secondProviderSessionId,
modelSelection,
runtimePolicy,
})
.pipe(Effect.forkScoped);
yield* Deferred.await(secondOpenStarted);
assert.equal(yield* Ref.get(openStartedCount), 2);
yield* Deferred.succeed(releaseOpens, undefined);
const [firstRuntime, secondRuntime] = yield* Effect.all([
Fiber.join(firstFiber),
Fiber.join(secondFiber),
]);
assert.notStrictEqual(firstRuntime, secondRuntime);
assert.equal((yield* Ref.get(state)).openCount, 2);
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 60_000,
beforeOpen,
}),
),
);
}),
);
it.effect("ProviderSessionManagerV2 closes every live session for a provider instance", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const firstThreadId = ThreadId.make("thread-provider-session-manager-logout-a");
const secondThreadId = ThreadId.make("thread-provider-session-manager-logout-b");
const firstProviderSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId: firstThreadId,
});
const secondProviderSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId: secondThreadId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
],
});
yield* manager.open({
threadId: firstThreadId,
providerSessionId: firstProviderSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.open({
threadId: secondThreadId,
providerSessionId: secondProviderSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.closeInstance(modelSelection.instanceId);
assert.isTrue(Option.isNone(yield* manager.get(firstProviderSessionId)));
assert.isTrue(Option.isNone(yield* manager.get(secondProviderSessionId)));
assert.equal((yield* Ref.get(state)).closeCount, 2);
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 60_000,
}),
),
);
}),
);
it.effect("ProviderSessionManagerV2 opens a duplicate session only once", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const openStartedCount = yield* Ref.make(0);
const firstOpenStarted = yield* Deferred.make<void>();
const releaseOpen = yield* Deferred.make<void>();
const beforeOpen = () =>
Ref.updateAndGet(openStartedCount, (count) => count + 1).pipe(
Effect.tap(() => Deferred.succeed(firstOpenStarted, undefined)),
Effect.andThen(Deferred.await(releaseOpen)),
);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-single-flight");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const open = manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const firstFiber = yield* open.pipe(Effect.forkScoped);
yield* Deferred.await(firstOpenStarted);
const secondFiber = yield* open.pipe(Effect.forkScoped);
yield* Effect.yieldNow;
yield* Effect.yieldNow;
assert.equal(yield* Ref.get(openStartedCount), 1);
yield* Deferred.succeed(releaseOpen, undefined);
const [firstRuntime, secondRuntime] = yield* Effect.all([
Fiber.join(firstFiber),
Fiber.join(secondFiber),
]);
assert.strictEqual(firstRuntime, secondRuntime);
assert.equal((yield* Ref.get(state)).openCount, 1);
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 60_000,
beforeOpen,
}),
),
);
}),
);
it.effect(
"ProviderSessionManagerV2 starts a thread's session without its last agent's OOM kill",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const owner = ThreadId.make("thread-provider-session-manager-oom-owner");
const joiner = ThreadId.make("thread-provider-session-manager-oom-joiner");
const oomKilledThreads = new Set<string>([owner, joiner]);
const agentScope = {
...AgentScope.defaultValue(),
oomKilled: (id: string) => Effect.sync(() => oomKilledThreads.has(id)),
clear: (id: string) => Effect.sync(() => void oomKilledThreads.delete(id)),
};
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId: owner,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: owner, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: joiner, now }),
],
});
yield* manager.open({ threadId: owner, providerSessionId, modelSelection, runtimePolicy });
assert.isFalse(yield* agentScope.oomKilled(owner));
yield* manager.open({ threadId: joiner, providerSessionId, modelSelection, runtimePolicy });
assert.isFalse(yield* agentScope.oomKilled(joiner));
oomKilledThreads.add(owner);
yield* manager.open({ threadId: owner, providerSessionId, modelSelection, runtimePolicy });
assert.isTrue(yield* agentScope.oomKilled(owner));
assert.equal((yield* Ref.get(state)).openCount, 1);
});
yield* effect.pipe(
Effect.provide(layerTest({ state, idleTimeoutMs: 60_000 })),
Effect.provideService(AgentScope, agentScope),
);
}),
);
it.effect("ProviderSessionManagerV2 cleans up an open interrupted mid-handshake", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const handshakeStarted = yield* Deferred.make<void>();
const holdHandshake = yield* Ref.make(true);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-interrupted-open");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const opening = yield* manager
.open({ threadId, providerSessionId, modelSelection, runtimePolicy })
.pipe(Effect.forkScoped);
yield* Deferred.await(handshakeStarted);
const issued = (yield* Ref.get(mcpConfigs)).at(-1);
const token = issued?.authorizationHeader.replace(/^Bearer\s+/, "");
assert.isDefined(token);
assert.isDefined(yield* registry.resolve(token!));
yield* Fiber.interrupt(opening);
assert.equal((yield* Ref.get(state)).closeCount, 1);
assert.isUndefined(yield* registry.resolve(token!));
assert.isUndefined(yield* mcpSessions.read(threadId));
assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
yield* Ref.set(holdHandshake, false);
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
const replacement = (yield* Ref.get(mcpConfigs)).at(-1);
const replacementToken = replacement?.authorizationHeader.replace(/^Bearer\s+/, "");
assert.isDefined(replacementToken);
assert.notEqual(replacementToken, token);
const projection = yield* projectionStore.getThreadProjection(threadId);
assert.equal(projection.providerSessions.at(-1)?.status, "ready");
yield* manager.close(providerSessionId);
assert.isUndefined(yield* registry.resolve(replacementToken!));
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 60_000,
mcpConfigs,
beforeOpen: () =>
Ref.get(holdHandshake).pipe(
Effect.flatMap((hold) =>
hold
? Deferred.succeed(handshakeStarted, undefined).pipe(Effect.andThen(Effect.never))
: Effect.void,
),
),
spawnBeforeOpen: true,
}),
),
);
}),
);
it.effect(
"ProviderSessionManagerV2 keeps a shared session busy when another thread's start is stopped early",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const projectId = ProjectId.make("project-provider-session-manager-shared-stopped-start");
const holdProjectRead = yield* Ref.make(false);
const projectReadHeld = yield* Deferred.make<void>();
const projectServiceLayer = Layer.mock(ProjectService.ProjectService)({
getById: (requestedProjectId) =>
Ref.get(holdProjectRead).pipe(
Effect.flatMap((hold) =>
hold
? Deferred.succeed(projectReadHeld, undefined).pipe(Effect.andThen(Effect.never))
: Effect.succeedSome(makeBrowserAccessProject(requestedProjectId)),
),
),
});
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const threadA = ThreadId.make("thread-provider-session-manager-shared-stopped-a");
const threadB = ThreadId.make("thread-provider-session-manager-shared-stopped-b");
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: threadA, now, projectId }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: threadB, now, projectId }),
],
});
const runtime = yield* manager.open({
threadId: threadA,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.open({
threadId: threadB,
providerSessionId,
modelSelection,
runtimePolicy,
});
const startTurn = (threadId: ThreadId) =>
Effect.gen(function* () {
const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
return yield* runtime.startTurn({
appThread: (yield* projectionStore.getThreadProjection(threadId)).thread,
threadId,
runId,
runOrdinal: 1,
providerTurnOrdinal: 1,
attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
rootNodeId: idAllocator.derive.rootNode({ runId }),
providerThread: makeProviderThread({ idAllocator, threadId, providerSessionId, now }),
message: {
createdBy: "user",
creationSource: "web",
messageId: yield* idAllocator.allocate.message({ threadId, ordinal: 1 }),
text: "turn",
attachments: [],
},
modelSelection,
runtimePolicy,
});
});
yield* startTurn(threadB);
yield* manager.detach({ providerSessionId, threadId: threadA });
yield* Ref.set(holdProjectRead, true);
const startingA = yield* startTurn(threadA).pipe(Effect.forkChild);
yield* Deferred.await(projectReadHeld);
yield* Fiber.interrupt(startingA);
yield* TestClock.adjust("2 seconds");
yield* Effect.yieldNow;
assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
assert.equal((yield* Ref.get(state)).closeCount, 0);
}).pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1000,
projectServiceLayer,
serverSettingsLayer: ServerSettings.layerTest({
projectSettingsOverrides: { [projectId]: { enableAgentBrowserAccess: true } },
}),
}),
),
);
}),
);
// regression: #15571 an interrupted session start did not clean up
it.effect(
"ProviderSessionManagerV2 keeps a shared session busy when a stopped start still ends its turn",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
// Like OpenCode2, a stopped start can still emit turn.terminal later.
const holdStart = yield* Ref.make(false);
const startHeld = yield* Deferred.make<void>();
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const threadA = ThreadId.make("thread-provider-session-manager-stopped-ended-a");
const threadB = ThreadId.make("thread-provider-session-manager-stopped-ended-b");
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: threadA, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: threadB, now }),
],
});
const runtime = yield* manager.open({
threadId: threadA,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.open({
threadId: threadB,
providerSessionId,
modelSelection,
runtimePolicy,
});
const providerThreadOf = (threadId: ThreadId) =>
makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
nativeThreadId: `native-${threadId}`,
});
const startTurn = (threadId: ThreadId) =>
Effect.gen(function* () {
const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
return yield* runtime.startTurn({
appThread: (yield* projectionStore.getThreadProjection(threadId)).thread,
threadId,
runId,
runOrdinal: 1,
providerTurnOrdinal: 1,
attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
rootNodeId: idAllocator.derive.rootNode({ runId }),
providerThread: providerThreadOf(threadId),
message: {
createdBy: "user",
creationSource: "web",
messageId: yield* idAllocator.allocate.message({ threadId, ordinal: 1 }),
text: "turn",
attachments: [],
},
modelSelection,
runtimePolicy,
});
});
yield* startTurn(threadB);
yield* Ref.set(holdStart, true);
const startingA = yield* startTurn(threadA).pipe(Effect.forkChild);
yield* Deferred.await(startHeld);
yield* Fiber.interrupt(startingA);
const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(queue);
yield* Queue.offer(queue!, {
type: "turn.terminal",
driver: CODEX_DRIVER,
providerThreadId: providerThreadOf(threadA).id,
providerTurnId: idAllocator.derive.providerTurn({
driver: CODEX_DRIVER,
nativeTurnId: "native-turn-stopped-a",
}),
runOrdinal: 1,
status: "completed",
failure: null,
threadDisposition: "reusable",
});
yield* TestClock.adjust("2 seconds");
yield* Effect.yieldNow;
assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
assert.equal((yield* Ref.get(state)).closeCount, 0);
}).pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1000,
startTurn: Ref.get(holdStart).pipe(
Effect.flatMap((hold) =>
hold
? Deferred.succeed(startHeld, undefined).pipe(Effect.andThen(Effect.never))
: Effect.void,
),
),
}),
),
);
}),
);
it.effect("ProviderSessionManagerV2 gives up on a provider that never confirms a Stop", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-unresponsive-stop");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const stopping = yield* runtime
.interruptTurn({
providerThread: makeProviderThread({ idAllocator, threadId, providerSessionId, now }),
providerTurnId: idAllocator.derive.providerTurn({
driver: CODEX_DRIVER,
nativeTurnId: "native-turn-unresponsive",
}),
})
.pipe(Effect.flip, Effect.forkChild);
yield* TestClock.adjust(ProviderSessionManager.PROVIDER_INTERRUPT_TIMEOUT_MS);
assert.equal((yield* Fiber.join(stopping))._tag, "ProviderAdapterInterruptTimeoutError");
}).pipe(
Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, interruptTurn: Effect.never })),
);
}),
);
it.effect(
"ProviderSessionManagerV2 keeps a shared session a sibling is busy on when releasing",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const stopping = ThreadId.make("thread-provider-session-manager-release-stopping");
const sibling = ThreadId.make("thread-provider-session-manager-release-sibling");
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: stopping, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: sibling, now }),
],
});
const runtime = yield* manager.open({
threadId: stopping,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.open({
threadId: sibling,
providerSessionId,
modelSelection,
runtimePolicy,
});
const providerThreadOf = (threadId: ThreadId) =>
makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
nativeThreadId: `native-${threadId}`,
});
const runId = idAllocator.derive.run({ threadId: sibling, ordinal: 1 });
yield* runtime.startTurn({
appThread: (yield* projectionStore.getThreadProjection(sibling)).thread,
threadId: sibling,
runId,
runOrdinal: 1,
providerTurnOrdinal: 1,
attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
rootNodeId: idAllocator.derive.rootNode({ runId }),
providerThread: providerThreadOf(sibling),
message: {
createdBy: "user",
creationSource: "web",
messageId: yield* idAllocator.allocate.message({ threadId: sibling, ordinal: 1 }),
text: "turn",
attachments: [],
},
modelSelection,
runtimePolicy,
});
const release = (own: ThreadId) =>
manager.releaseUnlessBusy({
providerSessionId,
ownProviderThreadIds: [providerThreadOf(own).id],
reason: "manual_shutdown",
});
assert.isFalse(yield* release(stopping));
assert.isTrue(yield* manager.isLive(providerSessionId));
assert.isTrue(yield* release(sibling));
assert.isFalse(yield* manager.isLive(providerSessionId));
// A turn that starts on a runtime released meanwhile fails instead of running on it.
const startOnReleasedRuntime = Effect.gen(function* () {
const lateRunId = idAllocator.derive.run({ threadId: stopping, ordinal: 1 });
return yield* Effect.flip(
runtime.startTurn({
appThread: (yield* projectionStore.getThreadProjection(stopping)).thread,
threadId: stopping,
runId: lateRunId,
runOrdinal: 1,
providerTurnOrdinal: 1,
attemptId: idAllocator.derive.runAttempt({ runId: lateRunId, attemptOrdinal: 1 }),
rootNodeId: idAllocator.derive.rootNode({ runId: lateRunId }),
providerThread: providerThreadOf(stopping),
message: {
createdBy: "user",
creationSource: "web",
messageId: yield* idAllocator.allocate.message({ threadId: stopping, ordinal: 1 }),
text: "turn",
attachments: [],
},
modelSelection,
runtimePolicy,
}),
);
});
assert.equal((yield* startOnReleasedRuntime)._tag, "ProviderAdapterTurnStartError");
// Nor may it leave its turn busy on a replacement opened under the same id.
yield* manager.open({
threadId: sibling,
providerSessionId,
modelSelection,
runtimePolicy,
});
assert.equal((yield* startOnReleasedRuntime)._tag, "ProviderAdapterTurnStartError");
assert.isTrue(yield* release(sibling));
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60 * 60_000 })));
}),
);
it.effect("ProviderSessionManagerV2 stops a session still opening when its layer shuts down", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const handshakeStarted = yield* Deferred.make<void>();
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-shutdown-during-open");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager
.open({ threadId, providerSessionId, modelSelection, runtimePolicy })
.pipe(Effect.forkDetach);
yield* Deferred.await(handshakeStarted);
assert.equal((yield* Ref.get(state)).closeCount, 0);
}).pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 60_000,
beforeOpen: () =>
Deferred.succeed(handshakeStarted, undefined).pipe(Effect.andThen(Effect.never)),
spawnBeforeOpen: true,
}),
),
);
assert.equal((yield* Ref.get(state)).closeCount, 1);
}),
);
it.effect(
"ProviderSessionManagerV2 projects idle extension statuses and rejects a retired runtime's updates",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const threadId = ThreadId.make("thread-extension-status");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId, now: yield* DateTime.now }),
],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const firstClient = yield* runtime.subscribeEvents!;
const secondClient = yield* runtime.subscribeEvents!;
const oldQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(oldQueue);
const statuses = [{ key: "watch", text: "Watching 4 files" }];
yield* Queue.offer(oldQueue!, {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: { ...runtime.providerSession, extensionStatuses: statuses },
});
yield* Effect.all([
firstClient.events.pipe(Stream.runHead),
secondClient.events.pipe(Stream.runHead),
]);
assert.deepEqual(
(yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
?.extensionStatuses,
statuses,
);
const reused = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
assert.deepEqual(reused.providerSession.extensionStatuses, statuses);
yield* eventSink.write({
events: [
{
id: yield* idAllocator.allocate.event({ threadId, providerSessionId }),
type: "provider-session.updated",
threadId,
driver: CODEX_DRIVER,
providerInstanceId: modelSelection.instanceId,
occurredAt: yield* DateTime.now,
payload: reused.providerSession,
},
],
});
assert.deepEqual(
(yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
?.extensionStatuses,
statuses,
);
yield* manager.close(providerSessionId);
assert.deepEqual(
(yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
?.extensionStatuses,
[],
);
const replacement = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const replacementClient = yield* replacement.subscribeEvents!;
const newQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(newQueue);
yield* Queue.offer(oldQueue!, {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: {
...runtime.providerSession,
extensionStatuses: [{ key: "stale", text: "Old session" }],
},
});
yield* Queue.offer(newQueue!, {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: {
...replacement.providerSession,
extensionStatuses: [{ key: "new", text: "New session" }],
},
});
yield* replacementClient.events.pipe(Stream.runHead);
assert.deepEqual(
(yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
?.extensionStatuses,
[{ key: "new", text: "New session" }],
);
assert.lengthOf((yield* projectionStore.getThreadProjection(threadId)).messages, 0);
assert.lengthOf((yield* projectionStore.getThreadProjection(threadId)).turnItems, 0);
}).pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 60_000,
extensionStatuses: [{ key: "initial", text: "Watching" }],
}),
),
);
}),
);
it.effect.each(["session metadata", "session status changes", "provider work"] as const)(
"ProviderSessionManagerV2 expires idle sessions according to %s",
(activity) =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const threadId = ThreadId.make("thread-session-metadata-idle");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId, now: yield* DateTime.now }),
],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const subscriber = yield* runtime.subscribeEvents!;
const observed = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
yield* subscriber.events.pipe(
Stream.runForEach((event) => Queue.offer(observed, event)),
Effect.ignore,
Effect.forkScoped,
);
const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(queue);
const waitingSession = { ...runtime.providerSession, status: "waiting" as const };
yield* Queue.offer(queue!, {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: waitingSession,
});
yield* Queue.take(observed);
for (const text of ["Watching 1 file", "Watching 2 files"]) {
yield* TestClock.adjust("300 millis");
yield* Queue.offer(queue!, {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: {
...waitingSession,
extensionStatuses: [{ key: "watch", text }],
},
});
yield* Queue.take(observed);
}
yield* TestClock.adjust("300 millis");
const statuses = [{ key: "watch", text: "Watching 3 files" }];
yield* Queue.offer(
queue!,
activity === "provider work"
? {
type: "provider_thread.updated",
driver: CODEX_DRIVER,
providerThread: makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now: yield* DateTime.now,
}),
}
: {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: {
...waitingSession,
status: activity === "session status changes" ? "ready" : "waiting",
extensionStatuses: statuses,
},
},
);
yield* Queue.take(observed);
if (activity !== "provider work") {
assert.deepEqual(
(yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
?.extensionStatuses,
statuses,
);
}
const afterSequence = yield* eventSink.latestSequence({ threadId });
yield* TestClock.adjust("100 millis");
assert.equal(yield* manager.isLive(providerSessionId), activity !== "session metadata");
if (activity !== "session metadata") {
yield* TestClock.adjust("900 millis");
}
assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
yield* eventSink
.stream({ threadId, afterSequence, eventType: "provider-session.updated" })
.pipe(
Stream.filter(
(stored) =>
stored.event.type === "provider-session.updated" &&
stored.event.payload.status === "stopped",
),
Stream.runHead,
);
assert.deepEqual(
(yield* projectionStore.getThreadProjection(threadId)).providerSessions.at(-1)
?.extensionStatuses,
[],
);
assert.equal((yield* Ref.get(state)).closeCount, 1);
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1_000 })));
}),
);
it.effect("ProviderSessionManagerV2 interrupts event subscriptions on server shutdown", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-shutdown-subscription");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const bufferedSubscription = yield* runtime.subscribeEvents!;
const activeSubscription = yield* runtime.subscribeEvents!;
const adapterQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(adapterQueue);
yield* Queue.offer(adapterQueue!, {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: runtime.providerSession,
});
assert.isTrue(Option.isSome(yield* activeSubscription.events.pipe(Stream.runHead)));
yield* manager.shutdown;
const exit = yield* bufferedSubscription.events.pipe(Stream.runCollect, Effect.exit);
assert.isTrue(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause));
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60_000 })));
}),
);
it.effect("ProviderSessionManagerV2 drains subscribers when the provider stops", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-provider-stop");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const subscription = yield* runtime.subscribeEvents!;
const collected = yield* subscription.events.pipe(Stream.runCollect, Effect.forkScoped);
const adapterQueue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(adapterQueue);
const providerThreadId = idAllocator.derive.providerThread({
driver: CODEX_DRIVER,
nativeThreadId: "provider-stop-thread",
});
const providerTurnId = idAllocator.derive.providerTurn({
driver: CODEX_DRIVER,
nativeTurnId: "provider-stop-turn",
});
yield* Queue.offer(adapterQueue!, {
type: "turn.terminal",
driver: CODEX_DRIVER,
providerThreadId,
providerTurnId,
runOrdinal: 1,
status: "completed",
failure: null,
threadDisposition: "reusable",
});
yield* Queue.offer(adapterQueue!, {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: {
...runtime.providerSession,
status: "stopped",
updatedAt: now,
},
});
yield* Queue.end(adapterQueue!);
const events = Array.from(yield* Fiber.join(collected));
assert.deepEqual(
events.map((event) => event.type),
["turn.terminal", "provider_session.updated"],
);
assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
assert.equal((yield* Ref.get(state)).closeCount, 1);
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60_000 })));
}),
);
it.effect(
"ProviderSessionManagerV2 issues MCP credentials before opening and revokes them on close",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-mcp");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const captured = (yield* Ref.get(mcpConfigs))[0];
assert.isDefined(captured);
assert.equal(captured?.threadId, threadId);
assert.equal(captured?.providerInstanceId, modelSelection.instanceId);
assert.equal(captured?.endpoint, "http://127.0.0.1:43123/mcp");
const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");
assert.isDefined(token);
const resolved = yield* registry.resolve(token!);
assert.equal(resolved?.thread.threadId, threadId);
assert.deepEqual(
resolved?.capabilities,
new Set(["preview", "orchestration", "worktree", "pull-requests"]),
);
yield* manager.close(providerSessionId);
assert.isUndefined(yield* mcpSessions.read(threadId));
assert.isUndefined(yield* registry.resolve(token!));
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1_000,
mcpConfigs,
}),
),
);
}),
);
it.effect.each([
{ relationshipToParent: null, subagent: false },
{ relationshipToParent: "subagent", subagent: true },
] as const)(
"ProviderSessionManagerV2 marks MCP credentials of delegated children ($relationshipToParent)",
({ relationshipToParent, subagent }) =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-mcp-lineage");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const created = yield* makeThreadCreatedEvent({ idAllocator, threadId, now });
const parentThreadId = ThreadId.make("thread-provider-session-manager-mcp-parent");
yield* eventSink.write({
events: [
{
...created,
payload: {
...created.payload,
lineage:
relationshipToParent === null
? created.payload.lineage
: { parentThreadId, relationshipToParent, rootThreadId: parentThreadId },
},
},
],
});
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
const token = (yield* Ref.get(mcpConfigs))[0]?.authorizationHeader.replace(
/^Bearer\s+/,
"",
);
assert.isDefined(token);
assert.equal((yield* registry.resolve(token!))?.thread.subagent, subagent);
yield* manager.close(providerSessionId);
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1_000, mcpConfigs })));
}),
);
it.effect(
"ProviderSessionManagerV2 withholds the preview capability when agent browser access is off",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-no-browser");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const captured = (yield* Ref.get(mcpConfigs))[0];
assert.isDefined(captured);
assert.equal(captured?.browserToolsAvailable, false);
const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");
const resolved = yield* registry.resolve(token!);
assert.deepEqual(
resolved?.capabilities,
new Set(["orchestration", "worktree", "pull-requests"]),
);
yield* manager.close(providerSessionId);
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1_000,
mcpConfigs,
serverSettingsLayer: ServerSettings.layerTest({
enableAgentBrowserAccess: false,
}).pipe(Layer.orDie),
}),
),
);
}),
);
it.effect("ProviderSessionManagerV2 honors a project browser-access opt-out", () =>
Effect.gen(function* () {
const captured = yield* runBrowserAccessScenario({
enableAgentBrowserAccess: true,
projectOverride: false,
});
assert.isDefined(captured);
assert.equal(captured?.browserToolsAvailable, false);
}),
);
it.effect("ProviderSessionManagerV2 fails browser access closed for a missing project", () =>
Effect.gen(function* () {
const captured = yield* runBrowserAccessScenario({
enableAgentBrowserAccess: true,
projectOverride: true,
projectExists: false,
});
assert.isDefined(captured);
assert.equal(captured?.browserToolsAvailable, false);
}),
);
it.effect("ProviderSessionManagerV2 revokes MCP credentials when release persistence fails", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-mcp-release-failure");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const captured = (yield* Ref.get(mcpConfigs))[0];
const token = captured?.authorizationHeader.replace(/^Bearer\s+/, "");
assert.isDefined(token);
assert.isDefined(yield* registry.resolve(token!));
const closeError = yield* manager.close(providerSessionId).pipe(Effect.flip);
assert.equal(closeError._tag, "ProviderSessionCloseError");
assert.isUndefined(yield* mcpSessions.read(threadId));
assert.isUndefined(yield* registry.resolve(token!));
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1_000,
mcpConfigs,
failReleaseEventWrites: true,
}),
),
);
}),
);
it.effect(
"ProviderSessionManagerV2 keeps a thread attached when an earlier attach of it is interrupted",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const armed = yield* Ref.make(false);
const paused = yield* Deferred.make<void>();
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const now = yield* DateTime.now;
const owner = ThreadId.make("thread-provider-session-manager-attach-race-owner");
const threadId = ThreadId.make("thread-provider-session-manager-attach-race");
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: owner, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
],
});
const runtime = yield* manager.open({
threadId: owner,
providerSessionId,
modelSelection,
runtimePolicy,
});
const resume = runtime.resumeThread({
threadId,
providerThread: makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
nativeThreadId: "native-attach-race",
}),
});
yield* Ref.set(armed, true);
const first = yield* resume.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(paused);
const second = yield* resume.pipe(Effect.forkChild({ startImmediately: true }));
yield* Fiber.interrupt(first);
yield* Fiber.join(second);
const config = yield* mcpSessions.read(threadId);
assert.isDefined(config);
const token = config!.authorizationHeader.replace(/^Bearer\s+/, "");
assert.equal((yield* registry.resolve(token))?.thread.threadId, threadId);
}).pipe(
Effect.provide(
layerTest({ state, idleTimeoutMs: 60_000, pauseAttachWrite: { armed, paused } }),
),
);
}),
);
// regression: #15571 an interrupted session start did not clean up
it.effect(
"ProviderSessionManagerV2 keeps a replacement session's attachment when a stale attach is interrupted",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const armed = yield* Ref.make(false);
const paused = yield* Deferred.make<void>();
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const eventStore = yield* EventStore.EventStoreV2;
const now = yield* DateTime.now;
const owner = ThreadId.make("thread-provider-session-manager-stale-attach-owner");
const threadId = ThreadId.make("thread-provider-session-manager-stale-attach");
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: owner, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
],
});
const runtime = yield* manager.open({
threadId: owner,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* Ref.set(armed, true);
const stale = yield* runtime
.resumeThread({
threadId,
providerThread: makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
nativeThreadId: "native-stale-attach",
}),
})
.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(paused);
yield* manager.release({ providerSessionId, reason: "runtime_error" });
const replacement = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const config = yield* mcpSessions.read(threadId);
assert.isDefined(config);
yield* Fiber.interrupt(stale);
assert.equal(
(yield* mcpSessions.read(threadId))?.providerSessionId,
config!.providerSessionId,
);
const token = config!.authorizationHeader.replace(/^Bearer\s+/, "");
assert.equal((yield* registry.resolve(token))?.thread.threadId, threadId);
const attachedEvents = eventStore
.read({ threadId, eventType: "provider-session.attached" })
.pipe(
Stream.runCollect,
Effect.map((events) => events.length),
);
const attachedBefore = yield* attachedEvents;
yield* replacement.resumeThread({
threadId,
providerThread: makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
nativeThreadId: "native-stale-attach",
}),
});
assert.equal(yield* attachedEvents, attachedBefore);
}).pipe(
Effect.provide(
layerTest({ state, idleTimeoutMs: 60_000, pauseAttachWrite: { armed, paused } }),
),
);
}),
);
// regression: #15571 an interrupted session start did not clean up
it.effect(
"ProviderSessionManagerV2 revokes a reused credential after a resume stopped while checking it",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const armed = yield* Ref.make(false);
const paused = yield* Deferred.make<void>();
yield* Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const now = yield* DateTime.now;
const owner = ThreadId.make("thread-provider-session-manager-resolve-stop-owner");
const threadId = ThreadId.make("thread-provider-session-manager-resolve-stop");
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: owner, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
],
});
const runtime = yield* manager.open({
threadId: owner,
providerSessionId,
modelSelection,
runtimePolicy,
});
const resume = runtime.resumeThread({
threadId,
providerThread: makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
nativeThreadId: "native-resolve-stop",
}),
});
yield* resume;
yield* manager.detach({ providerSessionId, threadId });
const config = yield* mcpSessions.read(threadId);
assert.isDefined(config);
const token = config!.authorizationHeader.replace(/^Bearer\s+/, "");
yield* Ref.set(armed, true);
const stopped = yield* resume.pipe(Effect.forkChild({ startImmediately: true }));
yield* Deferred.await(paused);
yield* Fiber.interrupt(stopped);
yield* manager.release({ providerSessionId, reason: "manual_shutdown" });
assert.isUndefined(yield* registry.resolve(token));
}).pipe(
Effect.provide(
layerTest({ state, idleTimeoutMs: 60_000, pauseResolve: { armed, paused } }),
),
);
}),
);
it.effect("ProviderSessionManagerV2 duplicate detach preserves replacement MCP credentials", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-replacement-mcp");
const oldSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const replacementSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({
threadId,
providerSessionId: oldSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.detach({ providerSessionId: oldSessionId, threadId });
yield* manager.open({
threadId,
providerSessionId: replacementSessionId,
modelSelection,
runtimePolicy,
});
const replacement = (yield* Ref.get(mcpConfigs)).at(-1);
assert.isDefined(replacement);
const replacementToken = replacement?.authorizationHeader.replace(/^Bearer\s+/, "");
assert.isDefined(replacementToken);
assert.equal(
(yield* mcpSessions.read(threadId))?.providerSessionId,
replacement?.providerSessionId,
);
yield* manager.detach({ providerSessionId: oldSessionId, threadId });
assert.equal(
(yield* mcpSessions.read(threadId))?.providerSessionId,
replacement?.providerSessionId,
);
assert.equal((yield* registry.resolve(replacementToken!))?.thread.threadId, threadId);
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1_000,
capabilities: ExclusiveCapabilities,
mcpConfigs,
}),
),
);
}),
);
it.effect(
"ProviderSessionManagerV2 keeps a thread's MCP credential stable across detach and re-attach on a shared session",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-stable-mcp");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const original = (yield* Ref.get(mcpConfigs)).at(-1);
assert.isDefined(original);
const originalToken = original?.authorizationHeader.replace(/^Bearer\s+/, "");
assert.isDefined(originalToken);
yield* manager.detach({ providerSessionId, threadId, detail: "Workspace changed." });
assert.equal(
(yield* registry.resolve(originalToken!))?.thread.threadId,
threadId,
"detach must not revoke the credential the live provider process still holds",
);
yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
assert.equal(
(yield* mcpSessions.read(threadId))?.providerSessionId,
original?.providerSessionId,
"re-attach must reuse the existing credential, not rotate it",
);
assert.equal((yield* registry.resolve(originalToken!))?.thread.threadId, threadId);
yield* manager.close(providerSessionId);
assert.isUndefined(yield* registry.resolve(originalToken!));
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1_000,
mcpConfigs,
}),
),
);
}),
);
it.effect(
"ProviderSessionManagerV2 protects a reused credential from a predecessor release during open",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const duringOpen = yield* Ref.make<Effect.Effect<void>>(Effect.void);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-open-race");
const s1 = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const s2 = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({ threadId, providerSessionId: s1, modelSelection, runtimePolicy });
const original = (yield* Ref.get(mcpConfigs)).at(-1);
const originalToken = original?.authorizationHeader.replace(/^Bearer\s+/, "");
assert.isDefined(originalToken);
yield* manager.detach({ providerSessionId: s1, threadId });
// ACP and OpenCode consume credentials during openSession; predecessor release must not revoke them before entry publication.
yield* Ref.set(duringOpen, manager.close(s1).pipe(Effect.orDie));
yield* manager.open({ threadId, providerSessionId: s2, modelSelection, runtimePolicy });
const slot = yield* mcpSessions.read(threadId);
assert.equal(
slot?.providerSessionId,
original?.providerSessionId,
"the credential the adapter was configured with must remain current",
);
assert.equal(
(yield* registry.resolve(originalToken!))?.thread.threadId,
threadId,
"the predecessor release must not revoke a credential reserved by an in-flight open",
);
yield* manager.close(s2);
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1_000,
mcpConfigs,
beforeOpen: (input) =>
input.providerSessionId === undefined
? Effect.void
: Ref.get(duringOpen).pipe(
Effect.flatten,
Effect.tap(() => Ref.set(duringOpen, Effect.void)),
),
}),
),
);
}),
);
it.effect("ProviderSessionManagerV2 terminal detach revokes the thread's MCP credential", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const mcpConfigs = yield* Ref.make<
ReadonlyArray<McpProviderSession.McpProviderSessionConfig | undefined>
>([]);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const registry = yield* McpSessionRegistry.McpSessionRegistry;
const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-terminal-detach");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
const issued = (yield* Ref.get(mcpConfigs)).at(-1);
const token = issued?.authorizationHeader.replace(/^Bearer\s+/, "");
assert.isDefined(yield* registry.resolve(token!));
yield* manager.detach({
providerSessionId,
threadId,
detail: "Thread deleted.",
revokeMcpCredential: true,
});
assert.isUndefined(yield* registry.resolve(token!));
assert.isUndefined(yield* mcpSessions.read(threadId));
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1_000, mcpConfigs })));
}),
);
const openSessionWithBackgroundCommand = (fixtureName: string) =>
Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const threadId = yield* idAllocator.allocate.thread({
fixtureName,
projectId: yield* idAllocator.allocate.project({ fixtureName }),
});
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const otherProviderSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const pendingBackgroundTasks = [
{ taskId: "dev-server", kind: "command", description: "python3 -m http.server" },
] as const;
const providerThreads = [
{
...makeProviderThread({ idAllocator, threadId, providerSessionId, now }),
pendingBackgroundTasks,
},
{
...makeProviderThread({
idAllocator,
threadId,
providerSessionId: otherProviderSessionId,
now,
nativeThreadId: "native-thread-other-session",
}),
pendingBackgroundTasks,
},
];
const writeProviderThread = (payload: OrchestrationV2ProviderThread) =>
Effect.gen(function* () {
yield* eventSink.write({
events: [
{
id: yield* idAllocator.allocate.event({ threadId }),
type: "provider-thread.updated",
threadId,
driver: CODEX_DRIVER,
occurredAt: now,
payload,
},
],
});
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* Effect.forEach(providerThreads, writeProviderThread);
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
const rosters = Effect.gen(function* () {
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const projection = yield* projectionStore.getThreadProjection(threadId);
return providerThreads.map((seeded) =>
(
projection.providerThreads.find((thread) => thread.id === seeded.id)
?.pendingBackgroundTasks ?? []
).map((task) => task.taskId),
);
});
return { threadId, providerSessionId, providerThreads, writeProviderThread, rosters };
});
it.effect(
"ProviderSessionManagerV2 clears the background roster of a session a detach releases",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const { threadId, providerSessionId, rosters } = yield* openSessionWithBackgroundCommand(
"provider-session-manager-detach-roster",
);
assert.deepStrictEqual(yield* rosters, [["dev-server"], ["dev-server"]]);
yield* manager.detach({ providerSessionId, threadId, detail: "Thread settled." });
assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
assert.deepStrictEqual(yield* rosters, [[], ["dev-server"]]);
});
yield* effect.pipe(
Effect.provide(
layerTest({ state, idleTimeoutMs: 60_000, capabilities: ExclusiveCapabilities }),
),
);
}),
);
it.effect("ProviderSessionManagerV2 keeps the roster of a runtime whose tasks can outlive it", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const { providerSessionId, rosters } = yield* openSessionWithBackgroundCommand(
"provider-session-manager-outliving-roster",
);
yield* manager.close(providerSessionId);
assert.deepStrictEqual(yield* rosters, [["dev-server"], ["dev-server"]]);
});
yield* effect.pipe(
Effect.provide(
layerTest({ state, idleTimeoutMs: 60_000, backgroundTasksEndWithProcess: false }),
),
);
}),
);
// regression: #19355 settled and idle-released threads stayed Waiting
it.effect("ProviderSessionManagerV2 keeps a provider update that lands while release clears", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const beforeUnchangedWrite = yield* Ref.make<Effect.Effect<void>>(Effect.void);
const effect = Effect.gen(function* () {
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const { providerSessionId, providerThreads, writeProviderThread, rosters } =
yield* openSessionWithBackgroundCommand("provider-session-manager-raced-roster");
const seeded = providerThreads[0]!;
yield* Ref.set(
beforeUnchangedWrite,
writeProviderThread({
...seeded,
pendingBackgroundTasks: [
...seeded.pendingBackgroundTasks,
{ taskId: "replacement-task", kind: "command" },
],
}).pipe(Effect.orDie),
);
yield* manager.close(providerSessionId);
assert.deepStrictEqual(yield* rosters, [["replacement-task"], ["dev-server"]]);
});
yield* effect.pipe(
Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, beforeUnchangedWrite })),
);
}),
);
it.effect(
"ProviderSessionManagerV2 does not idle-release a session that turns busy during the pending-work check",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const firstCheck = yield* Ref.make(true);
const checkEntered = yield* Deferred.make<void>();
const checkGate = yield* Deferred.make<void>();
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-busy-during-check",
});
const threadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-busy-during-check",
projectId,
});
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const providerThread = makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
});
const runId = idAllocator.derive.run({ threadId, ordinal: 1 });
const attemptId = idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 });
const rootNodeId = idAllocator.derive.rootNode({ runId });
const providerTurnId = idAllocator.derive.providerTurn({
driver: CODEX_DRIVER,
nativeTurnId: "native-turn-busy-during-check",
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* runtime.events.pipe(Stream.runDrain, Effect.forkScoped);
const appThread = (yield* projectionStore.getThreadProjection(threadId)).thread;
yield* TestClock.adjust("1 second");
yield* Deferred.await(checkEntered);
const turnFiber = yield* runtime
.startTurn({
appThread,
threadId,
runId,
runOrdinal: 1,
providerTurnOrdinal: 1,
attemptId,
rootNodeId,
providerThread,
message: {
createdBy: "user",
creationSource: "web",
messageId: yield* idAllocator.allocate.message({ threadId, ordinal: 1 }),
text: "hello",
attachments: [],
},
modelSelection,
runtimePolicy,
})
.pipe(Effect.forkDetach);
for (let i = 0; i < 10; i += 1) {
yield* Effect.yieldNow;
}
yield* Deferred.succeed(checkGate, undefined);
yield* Fiber.join(turnFiber);
yield* Effect.yieldNow;
assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
assert.equal((yield* Ref.get(state)).closeCount, 0);
const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(queue);
yield* Queue.offer(queue!, {
type: "turn.terminal",
driver: CODEX_DRIVER,
providerThreadId: providerThread.id,
providerTurnId,
runOrdinal: 1,
status: "completed",
failure: null,
threadDisposition: "reusable",
});
yield* TestClock.adjust("1 second");
yield* Effect.yieldNow;
assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
assert.equal((yield* Ref.get(state)).closeCount, 1);
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1000,
hasPendingBackgroundWork: Effect.uninterruptible(
Effect.gen(function* () {
if (yield* Ref.getAndSet(firstCheck, false)) {
yield* Deferred.succeed(checkEntered, undefined);
yield* Deferred.await(checkGate);
}
return false;
}),
),
}),
),
);
}),
);
it.effect("ProviderSessionManagerV2 releases sessions when provider event streams fail", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-stream-error",
});
const threadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-stream-error",
projectId,
});
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* runtime.events.pipe(Stream.runDrain, Effect.ignore, Effect.forkScoped);
yield* Effect.yieldNow;
const liveSession = yield* manager.get(providerSessionId);
const runtimeState = yield* Ref.get(state);
const projection = yield* projectionStore.getThreadProjection(threadId);
assert.isTrue(Option.isNone(liveSession));
assert.equal(runtimeState.closeCount, 1);
assert.equal(projection.providerSessions.at(-1)?.status, "error");
assert.equal(
projection.providerSessions.at(-1)?.lastError,
"The provider event stream closed unexpectedly. Retry the turn; if it keeps failing, check the provider and server logs.",
);
});
yield* effect.pipe(
Effect.provide(
layerTest({
state,
idleTimeoutMs: 1000,
failEventStream: true,
}),
),
);
}),
);
it.effect("ProviderSessionManagerV2 marks pending runtime requests non-live on release", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-request-expire",
});
const threadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-request-expire",
projectId,
});
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const providerThread = makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const pendingRequest = yield* makePendingRuntimeRequestEvents({
idAllocator,
threadId,
providerSessionId,
providerThread,
now,
});
yield* eventSink.write({ events: pendingRequest.events });
const historical = yield* makePendingRuntimeRequestEvents({
idAllocator,
threadId,
providerSessionId,
providerThread,
now,
});
yield* eventSink.write({
events: historical.events.map((event) =>
event.type === "runtime-request.updated"
? { ...event, payload: { ...event.payload, status: "resolved", resolvedAt: now } }
: event,
),
});
assert.deepEqual(
(yield* projectionStore.getThreadRecords(threadId, ["nodes", "turnItems"], {
nodeIds: [pendingRequest.nodeId],
turnItemRequestIds: [pendingRequest.requestId],
})).turnItems.map((item) => item.id),
[pendingRequest.events.find((event) => event.type === "turn-item.updated")!.payload.id],
);
yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.release({
providerSessionId,
reason: "runtime_error",
detail: "process exited",
});
const projection = yield* projectionStore.getThreadProjection(threadId);
const request = projection.runtimeRequests.find(
(request) => request.id === pendingRequest.requestId,
);
assert.equal(
projection.runtimeRequests.find((request) => request.id === historical.requestId)?.status,
"resolved",
);
const requestNode = projection.nodes.find((node) => node.id === request?.nodeId);
const requestTurnItem = projection.turnItems.find(
(item) => item.type === "approval_request" && item.requestId === request?.id,
);
assert.equal(request?.status, "expired");
assert.equal(request?.responseCapability.type, "not_resumable");
assert.equal(requestNode?.status, "failed");
assert.equal(requestTurnItem?.status, "failed");
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
}),
);
it.effect("ProviderSessionManagerV2 retries release records that failed to persist", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const flaky: FlakyReleaseWrites = {
failing: yield* Ref.make<"none" | "session" | "session-and-requests">("session"),
failures: yield* Queue.unbounded<void>(),
};
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-release-retry");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const providerThread = makeProviderThread({ idAllocator, threadId, providerSessionId, now });
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const pendingRequest = yield* makePendingRuntimeRequestEvents({
idAllocator,
threadId,
providerSessionId,
providerThread,
now,
});
yield* eventSink.write({ events: pendingRequest.events });
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
assert.isTrue(Exit.isFailure(yield* Effect.exit(manager.close(providerSessionId))));
yield* Queue.take(flaky.failures);
const afterClose = yield* projectionStore.getThreadProjection(threadId);
assert.equal(afterClose.runtimeRequests.at(-1)?.responseCapability.type, "not_resumable");
assert.equal(afterClose.providerSessions.at(-1)?.status, "ready");
yield* TestClock.adjust("1 second");
yield* Queue.take(flaky.failures);
yield* Ref.set(flaky.failing, "none");
const stopped = yield* eventSink
.stream({
threadId,
afterSequence: yield* eventSink.latestSequence({ threadId }),
eventType: "provider-session.updated",
})
.pipe(Stream.runHead, Effect.forkScoped);
yield* TestClock.adjust("1 second");
yield* Fiber.join(stopped);
const afterRetry = yield* projectionStore.getThreadProjection(threadId);
assert.equal(afterRetry.providerSessions.at(-1)?.status, "stopped");
});
yield* effect.pipe(
Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, flakyReleaseWrites: flaky })),
);
}),
);
// regression: #15048 runs got stuck after a failed session release
it.effect("ProviderSessionManagerV2 release retries leave a replacement session alone", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const flaky: FlakyReleaseWrites = {
failing: yield* Ref.make<"none" | "session" | "session-and-requests">("none"),
failures: yield* Queue.unbounded<void>(),
};
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const threadId = ThreadId.make("thread-provider-session-manager-release-replacement");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const writePendingRequest = Effect.gen(function* () {
const now = yield* DateTime.now;
const request = yield* makePendingRuntimeRequestEvents({
idAllocator,
threadId,
providerSessionId,
providerThread: makeProviderThread({ idAllocator, threadId, providerSessionId, now }),
now,
});
yield* eventSink.write({ events: request.events });
return request.requestId;
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId, now: yield* DateTime.now }),
],
});
const oldRequestId = yield* writePendingRequest;
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
yield* Ref.set(flaky.failing, "session-and-requests");
assert.isTrue(Exit.isFailure(yield* Effect.exit(manager.close(providerSessionId))));
yield* Queue.take(flaky.failures);
yield* Queue.take(flaky.failures);
yield* Ref.set(flaky.failing, "none");
yield* TestClock.adjust("500 millis");
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
const newRequestId = yield* writePendingRequest;
const replacementStatus = (yield* projectionStore.getThreadProjection(
threadId,
)).providerSessions.at(-1)?.status;
const settled = yield* eventSink
.stream({
threadId,
afterSequence: yield* eventSink.latestSequence({ threadId }),
eventType: "runtime-request.updated",
})
.pipe(Stream.runHead, Effect.forkScoped);
yield* TestClock.adjust("500 millis");
yield* Fiber.join(settled);
const projection = yield* projectionStore.getThreadProjection(threadId);
const request = (id: typeof oldRequestId) =>
projection.runtimeRequests.find((candidate) => candidate.id === id);
assert.equal(request(oldRequestId)?.responseCapability.type, "not_resumable");
assert.equal(request(newRequestId)?.responseCapability.type, "live");
assert.equal(projection.providerSessions.at(-1)?.status, replacementStatus);
});
yield* effect.pipe(
Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, flakyReleaseWrites: flaky })),
);
}),
);
// regression: #15048 runs got stuck after a failed session release
it.effect("ProviderSessionManagerV2 keeps each failed release's cleanup", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const flaky: FlakyReleaseWrites = {
failing: yield* Ref.make<"none" | "session" | "session-and-requests">("none"),
failures: yield* Queue.unbounded<void>(),
};
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const firstThreadId = ThreadId.make("thread-provider-session-manager-release-each-a");
const secondThreadId = ThreadId.make("thread-provider-session-manager-release-each-b");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId: firstThreadId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
],
});
const secondThreadRequest = yield* makePendingRuntimeRequestEvents({
idAllocator,
threadId: secondThreadId,
providerSessionId,
providerThread: makeProviderThread({
idAllocator,
threadId: secondThreadId,
providerSessionId,
now,
}),
now,
});
yield* eventSink.write({ events: secondThreadRequest.events });
const failRelease = (failedWrites: number) =>
Effect.gen(function* () {
yield* Ref.set(flaky.failing, "session-and-requests");
assert.isTrue(Exit.isFailure(yield* Effect.exit(manager.close(providerSessionId))));
yield* Effect.repeat(Queue.take(flaky.failures), { times: failedWrites - 1 });
yield* Ref.set(flaky.failing, "none");
});
yield* manager.open({
threadId: firstThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.open({
threadId: secondThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* failRelease(2);
yield* TestClock.adjust("500 millis");
yield* manager.open({
threadId: firstThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* failRelease(1);
const settled = yield* eventSink
.stream({
threadId: secondThreadId,
afterSequence: yield* eventSink.latestSequence({ threadId: secondThreadId }),
eventType: "runtime-request.updated",
})
.pipe(Stream.runHead, Effect.forkScoped);
yield* TestClock.adjust("500 millis");
yield* Fiber.join(settled);
const projection = yield* projectionStore.getThreadProjection(secondThreadId);
assert.equal(projection.runtimeRequests.at(-1)?.responseCapability.type, "not_resumable");
});
yield* effect.pipe(
Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, flakyReleaseWrites: flaky })),
);
}),
);
it.effect("ProviderSessionManagerV2 settles a request the event pump persists during release", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const flaky: FlakyReleaseWrites = {
failing: yield* Ref.make<"none" | "session" | "session-and-requests">("none"),
failures: yield* Queue.unbounded<void>(),
pauseRequestWrites: {
paused: yield* Deferred.make<void>(),
resume: yield* Deferred.make<void>(),
},
};
const pause = flaky.pauseRequestWrites!;
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const threadId = ThreadId.make("thread-provider-session-manager-release-pump");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({ threadId, providerSessionId, modelSelection, runtimePolicy });
const createdAt = DateTime.add(now, { seconds: 1 });
const pendingRequest = yield* makePendingRuntimeRequestEvents({
idAllocator,
threadId,
providerSessionId,
providerThread: makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now: createdAt,
}),
now: createdAt,
});
const adapterEvents = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(adapterEvents);
yield* Queue.offerAll(adapterEvents!, pendingRequest.providerEvents);
yield* Deferred.await(pause.paused);
const closed = yield* manager
.close(providerSessionId)
.pipe(Effect.forkScoped({ startImmediately: true }));
yield* TestClock.adjust("1 second");
yield* Deferred.succeed(pause.resume, undefined);
yield* Fiber.join(closed);
const projection = yield* projectionStore.getThreadProjection(threadId);
const request = projection.runtimeRequests.find(
(candidate) => candidate.id === pendingRequest.requestId,
);
assert.equal(request?.responseCapability.type, "not_resumable");
});
yield* effect.pipe(
Effect.provide(layerTest({ state, idleTimeoutMs: 60_000, flakyReleaseWrites: flaky })),
);
}),
);
it.effect.each(["manual_shutdown", "server_shutdown"] as const)(
"ProviderSessionManagerV2 preserves questions only for server shutdown (%s)",
(reason) =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-request-expire",
});
const threadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-request-expire",
projectId,
});
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const providerThread = makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const pendingRequest = yield* makePendingRuntimeRequestEvents({
idAllocator,
threadId,
providerSessionId,
providerThread,
now,
});
yield* eventSink.write({
events: pendingRequest.events.map((event) =>
event.type === "turn-item.updated"
? {
...event,
payload: {
...event.payload,
type: "user_input_request",
questions: [
{ id: "color", header: "Color", question: "Which color?", options: [] },
],
},
}
: event.type === "runtime-request.updated"
? { ...event, payload: { ...event.payload, kind: "user_input" } }
: event,
),
});
yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.release({
providerSessionId,
reason,
});
const projection = yield* projectionStore.getThreadProjection(threadId);
const request = projection.runtimeRequests.at(-1);
const requestNode = projection.nodes.find((node) => node.id === request?.nodeId);
const requestTurnItem = projection.turnItems.find(
(item) => item.type === "user_input_request" && item.requestId === request?.id,
);
const preserved = reason === "server_shutdown";
assert.equal(request?.status, preserved ? "pending" : "cancelled");
assert.equal(request?.responseCapability.type, preserved ? "live" : "not_resumable");
assert.equal(requestNode?.status, preserved ? "waiting" : "cancelled");
assert.equal(requestTurnItem?.status, preserved ? "waiting" : "cancelled");
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
}),
);
it.effect("ProviderSessionManagerV2 persists session-scoped runtime requests without a run", () =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-session-request",
});
const threadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-session-request",
projectId,
});
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
const providerThread = makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
});
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const pendingRequest = yield* makePendingRuntimeRequestEvents({
idAllocator,
threadId,
providerSessionId,
providerThread,
now,
});
const afterSequence = yield* eventSink.latestSequence({ threadId });
const persistedFiber = yield* eventSink.stream({ threadId, afterSequence }).pipe(
Stream.filter(
(stored) =>
stored.event.type === "runtime-request.updated" ||
stored.event.type === "node.updated" ||
stored.event.type === "turn-item.updated",
),
Stream.take(3),
Stream.runCollect,
Effect.forkScoped,
);
const adapterEvents = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(adapterEvents);
yield* Queue.offerAll(adapterEvents!, pendingRequest.providerEvents);
const persisted = Array.from(yield* Fiber.join(persistedFiber));
assert.sameMembers(
persisted.map((stored) => stored.event.type),
["runtime-request.updated", "node.updated", "turn-item.updated"],
);
const projection = yield* projectionStore.getThreadProjection(threadId);
const request = projection.runtimeRequests.find(
(candidate) => candidate.id === pendingRequest.requestId,
);
const node = projection.nodes.find((candidate) => candidate.id === pendingRequest.nodeId);
const turnItem = projection.turnItems.find(
(candidate) =>
candidate.type === "approval_request" && candidate.requestId === pendingRequest.requestId,
);
assert.equal(request?.status, "pending");
assert.equal(request?.providerTurnId, null);
assert.equal(node?.runId, null);
assert.equal(node?.status, "waiting");
assert.equal(turnItem?.runId, null);
assert.equal(turnItem?.status, "waiting");
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
}),
);
it.effect(
"ProviderSessionManagerV2 opens one shared runtime, broadcasts events, and detaches threads independently",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-shared-runtime",
});
const firstThreadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-shared-runtime-a",
projectId,
});
const secondThreadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-shared-runtime-b",
projectId,
});
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
],
});
const firstProviderThread = makeProviderThread({
idAllocator,
threadId: firstThreadId,
providerSessionId,
now,
});
const secondProviderThread = makeProviderThread({
idAllocator,
threadId: secondThreadId,
providerSessionId,
now,
});
const firstRunId = idAllocator.derive.run({ threadId: firstThreadId, ordinal: 1 });
yield* eventSink.write({
events: [
{
id: yield* idAllocator.allocate.event({ threadId: firstThreadId }),
type: "provider-thread.updated",
threadId: firstThreadId,
driver: CODEX_DRIVER,
occurredAt: now,
payload: firstProviderThread,
},
{
id: yield* idAllocator.allocate.event({ threadId: firstThreadId }),
type: "provider-turn.updated",
threadId: firstThreadId,
runId: firstRunId,
driver: CODEX_DRIVER,
occurredAt: now,
payload: {
id: idAllocator.derive.providerTurn({
driver: CODEX_DRIVER,
nativeTurnId: "native-turn-shared-runtime-a",
}),
providerThreadId: firstProviderThread.id,
nodeId: idAllocator.derive.rootNode({ runId: firstRunId }),
runAttemptId: null,
nativeTurnRef: null,
ordinal: 1,
status: "running",
startedAt: now,
completedAt: null,
},
},
],
});
const firstRuntime = yield* manager.open({
threadId: firstThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const secondRuntime = yield* manager.open({
threadId: secondThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
assert.strictEqual(firstRuntime, secondRuntime);
assert.equal((yield* Ref.get(state)).openCount, 1);
const resumeSecondThread = secondRuntime.resumeThread({
providerThread: secondProviderThread,
threadId: secondThreadId,
modelSelection,
runtimePolicy,
});
yield* resumeSecondThread;
yield* resumeSecondThread;
assert.equal((yield* Ref.get(state)).resumeCount, 1);
yield* secondRuntime.resumeThread({
providerThread: secondProviderThread,
threadId: secondThreadId,
modelSelection: { ...modelSelection, model: "gpt-5.4-mini" },
runtimePolicy,
});
assert.equal((yield* Ref.get(state)).resumeCount, 2);
yield* resumeSecondThread;
assert.equal((yield* Ref.get(state)).resumeCount, 3);
const subscribe = firstRuntime.subscribeEvents;
assert.isDefined(subscribe);
if (subscribe === undefined) return;
const firstSubscription = yield* subscribe;
const secondSubscription = yield* subscribe;
const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
assert.isDefined(queue);
yield* Queue.offer(queue!, {
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: firstRuntime.providerSession,
});
const received = yield* Effect.all([
firstSubscription.events.pipe(Stream.runHead),
secondSubscription.events.pipe(Stream.runHead),
]);
assert.isTrue(received.every(Option.isSome));
assert.isTrue(
received.every(
(event) => Option.isSome(event) && event.value.type === "provider_session.updated",
),
);
yield* manager.detach({ providerSessionId, threadId: secondThreadId });
yield* manager.open({
threadId: secondThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* resumeSecondThread;
assert.equal((yield* Ref.get(state)).resumeCount, 4);
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, []);
yield* manager.detach({ providerSessionId, threadId: firstThreadId });
assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
assert.equal((yield* Ref.get(state)).closeCount, 0);
assert.equal((yield* Ref.get(state)).interruptCount, 1);
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, ["native-thread"]);
yield* manager.detach({ providerSessionId, threadId: secondThreadId });
yield* TestClock.adjust("1 second");
yield* Effect.yieldNow;
assert.equal((yield* Ref.get(state)).closeCount, 1);
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
}),
);
it.effect(
"ProviderSessionManagerV2 detaching a parent keeps an attached delegated child's thread loaded",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-delegated-child",
});
const parentThreadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-delegated-child-parent",
projectId,
});
const childThreadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-delegated-child-child",
projectId,
});
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
const parentProviderThread = makeProviderThread({
idAllocator,
threadId: parentThreadId,
providerSessionId,
now,
nativeThreadId: "native-parent",
});
const childProviderThread = makeProviderThread({
idAllocator,
threadId: childThreadId,
providerSessionId,
now,
nativeThreadId: "native-child",
});
const childRunId = idAllocator.derive.run({ threadId: childThreadId, ordinal: 2 });
const parentRunId = idAllocator.derive.run({ threadId: parentThreadId, ordinal: 1 });
const subagentId = idAllocator.derive.rootNode({ runId: childRunId });
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: parentThreadId, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: childThreadId, now }),
{
id: yield* idAllocator.allocate.event({ threadId: parentThreadId }),
type: "provider-thread.updated",
threadId: parentThreadId,
driver: CODEX_DRIVER,
occurredAt: now,
payload: parentProviderThread,
},
{
id: yield* idAllocator.allocate.event({ threadId: childThreadId }),
type: "provider-thread.updated",
threadId: childThreadId,
driver: CODEX_DRIVER,
occurredAt: now,
payload: childProviderThread,
},
// The delegated task record already finished; the child was then sent a
// follow-up and is running a later turn of its own.
{
id: yield* idAllocator.allocate.event({ threadId: parentThreadId }),
type: "subagent.updated",
threadId: parentThreadId,
nodeId: subagentId,
providerInstanceId: modelSelection.instanceId,
occurredAt: now,
payload: {
id: subagentId,
threadId: parentThreadId,
runId: null,
parentNodeId: idAllocator.derive.rootNode({ runId: parentRunId }),
origin: "app_owned",
createdBy: "agent",
driver: CODEX_DRIVER,
providerInstanceId: modelSelection.instanceId,
providerThreadId: childProviderThread.id,
childThreadId,
nativeTaskRef: null,
prompt: "Delegated work",
title: "Delegated child",
model: modelSelection.model,
status: "completed",
result: "first result",
startedAt: now,
completedAt: now,
updatedAt: now,
},
},
{
id: yield* idAllocator.allocate.event({ threadId: childThreadId }),
type: "provider-turn.updated",
threadId: childThreadId,
runId: childRunId,
driver: CODEX_DRIVER,
occurredAt: now,
payload: {
id: idAllocator.derive.providerTurn({
driver: CODEX_DRIVER,
nativeTurnId: "native-child-turn",
}),
providerThreadId: childProviderThread.id,
nodeId: idAllocator.derive.rootNode({ runId: childRunId }),
runAttemptId: null,
nativeTurnRef: null,
ordinal: 2,
status: "running",
startedAt: now,
completedAt: null,
},
},
],
});
yield* manager.open({
threadId: parentThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.open({
threadId: childThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.detach({ providerSessionId, threadId: parentThreadId });
const afterParentDetach = yield* Ref.get(state);
assert.equal(afterParentDetach.interruptCount, 0);
assert.deepEqual(afterParentDetach.unloadedNativeThreadIds, ["native-parent"]);
yield* manager.detach({ providerSessionId, threadId: childThreadId });
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, [
"native-parent",
"native-child",
]);
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
}),
);
it.effect(
"ProviderSessionManagerV2 invalidates only errored threads and keeps reusable session errors cached",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const openCachedRuntime = Effect.fnUntraced(function* (
threadId: ThreadId,
sharedSessionId?: ProviderSessionId,
) {
const providerSessionId =
sharedSessionId ??
(yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
}));
yield* eventSink.write({
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const providerThread = makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
nativeThreadId: String(threadId),
});
const resume = runtime.resumeThread({
providerThread,
threadId,
modelSelection,
runtimePolicy,
});
yield* resume;
yield* resume;
return { runtime, providerThread, resume };
});
const failed = yield* openCachedRuntime(ThreadId.make("idle-failed-runtime"));
const healthy = yield* openCachedRuntime(ThreadId.make("idle-healthy-runtime"));
const sibling = yield* openCachedRuntime(
ThreadId.make("idle-healthy-sibling"),
failed.runtime.providerSessionId,
);
assert.strictEqual(sibling.runtime, failed.runtime);
assert.equal((yield* Ref.get(state)).openCount, 2);
assert.equal((yield* Ref.get(state)).resumeCount, 3);
const queue = (yield* Ref.get(state)).eventQueues.get(
String(failed.runtime.providerSessionId),
);
assert.isDefined(queue);
const publish = Effect.fnUntraced(function* (
event: ProviderAdapter.ProviderAdapterV2Event,
) {
const subscription = yield* failed.runtime.subscribeEvents!;
yield* Queue.offer(queue!, event);
// Observing the exact event ensures the manager has handled it before resuming.
assert.deepEqual(yield* subscription.events.pipe(Stream.runHead), Option.some(event));
});
const countRawResumes = Effect.fnUntraced(function* (cached: typeof failed) {
const before = (yield* Ref.get(state)).resumeCount;
yield* cached.resume;
return (yield* Ref.get(state)).resumeCount - before;
});
yield* publish({
type: "provider_thread.updated",
driver: CODEX_DRIVER,
providerThread: failed.providerThread,
});
yield* publish({
type: "provider_session.updated",
driver: CODEX_DRIVER,
providerSession: {
...failed.runtime.providerSession,
status: "error",
lastError: "Reusable turn failure",
},
});
const afterSessionError = {
reusableThread: yield* countRawResumes(failed),
siblingThread: yield* countRawResumes(sibling),
};
yield* publish({
type: "provider_thread.updated",
driver: CODEX_DRIVER,
providerThread: { ...failed.providerThread, status: "error" },
});
const afterThreadError = {
healthyRuntime: yield* countRawResumes(healthy),
siblingThread: yield* countRawResumes(sibling),
failedThread: yield* countRawResumes(failed),
failedThreadAgain: yield* countRawResumes(failed),
};
assert.deepEqual(
{ afterSessionError, afterThreadError },
{
afterSessionError: { reusableThread: 0, siblingThread: 0 },
afterThreadError: {
healthyRuntime: 0,
siblingThread: 0,
failedThread: 1,
failedThreadAgain: 0,
},
},
);
});
yield* effect.pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })));
}),
);
it.effect(
"ProviderSessionManagerV2 keeps an attached native child loaded when its parent detaches",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
yield* Effect.gen(function* () {
const { manager, parent, resumeChild } = yield* makeNativeChildFixture();
yield* resumeChild;
yield* manager.detach(parent);
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, []);
// The child's next turn trusts the manager's loaded cache, so the
// native thread must still be loaded for that turn to be heard.
yield* resumeChild;
assert.equal((yield* Ref.get(state)).resumeCount, 1);
assert.isTrue(yield* manager.isLive(parent.providerSessionId));
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })), Effect.scoped);
}),
);
it.effect(
"ProviderSessionManagerV2 unloads an unattached native child when its parent detaches",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
yield* Effect.gen(function* () {
const { manager, parent } = yield* makeNativeChildFixture();
yield* manager.detach(parent);
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, ["native-child-thread"]);
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000 })), Effect.scoped);
}),
);
it.effect(
"ProviderSessionManagerV2 re-attaching a thread waits for its in-flight unload, then reloads it",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const unloadStarted = yield* Deferred.make<void>();
const releaseUnload = yield* Deferred.make<void>();
let resumesBeforeUnload: number | undefined;
const beforeUnload = Effect.gen(function* () {
yield* Deferred.succeed(unloadStarted, undefined);
yield* Deferred.await(releaseUnload);
resumesBeforeUnload = (yield* Ref.get(state)).resumeCount;
});
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-unload-race",
});
const threadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-unload-race-a",
projectId,
});
const otherThreadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-unload-race-b",
projectId,
});
const providerSessionId = idAllocator.derive.providerSession({
providerInstanceId: modelSelection.instanceId,
});
const providerThread = makeProviderThread({
idAllocator,
threadId,
providerSessionId,
now,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: otherThreadId, now }),
{
id: yield* idAllocator.allocate.event({ threadId }),
type: "provider-thread.updated",
threadId,
driver: CODEX_DRIVER,
occurredAt: now,
payload: providerThread,
},
],
});
const runtime = yield* manager.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
yield* manager.open({
threadId: otherThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const resume = runtime.resumeThread({
providerThread,
threadId,
modelSelection,
runtimePolicy,
});
yield* resume;
const detach = yield* manager
.detach({ providerSessionId, threadId })
.pipe(Effect.forkScoped);
yield* Deferred.await(unloadStarted);
const reattach = yield* resume.pipe(Effect.forkScoped);
yield* Effect.yieldNow;
yield* Effect.yieldNow;
yield* Deferred.succeed(releaseUnload, undefined);
yield* Fiber.join(detach);
yield* Fiber.join(reattach);
assert.equal(resumesBeforeUnload, 1);
assert.equal((yield* Ref.get(state)).resumeCount, 2);
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, ["native-thread"]);
assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
});
yield* effect.pipe(
Effect.provide(layerTest({ state, idleTimeoutMs: 1000, beforeUnload })),
Effect.scoped,
);
}),
);
it.effect(
"ProviderSessionManagerV2 rejects a second thread when the provider runtime is exclusive",
() =>
Effect.gen(function* () {
const state = yield* Ref.make(emptyState);
const effect = Effect.gen(function* () {
const eventSink = yield* EventSink.EventSinkV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const now = yield* DateTime.now;
const projectId = yield* idAllocator.allocate.project({
fixtureName: "provider-session-manager-exclusive-runtime",
});
const firstThreadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-exclusive-runtime-a",
projectId,
});
const secondThreadId = yield* idAllocator.allocate.thread({
fixtureName: "provider-session-manager-exclusive-runtime-b",
projectId,
});
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId: firstThreadId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({ idAllocator, threadId: firstThreadId, now }),
yield* makeThreadCreatedEvent({ idAllocator, threadId: secondThreadId, now }),
],
});
yield* manager.open({
threadId: firstThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
});
const error = yield* manager
.open({
threadId: secondThreadId,
providerSessionId,
modelSelection,
runtimePolicy,
})
.pipe(Effect.flip);
assert.equal(error._tag, "ProviderSessionOpenError");
assert.equal((yield* Ref.get(state)).openCount, 1);
});
yield* effect.pipe(
Effect.provide(
layerTest({ state, idleTimeoutMs: 1000, capabilities: ExclusiveCapabilities }),
),
);
}),
);
it.effect.each(["missing", "file"] as const)(
"rejects a %s workspace before opening a provider session",
(workspaceState) =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const root = yield* fileSystem.makeTempDirectoryScoped();
const cwd = `${root}/workspace`;
if (workspaceState === "file") yield* fileSystem.writeFileString(cwd, "not a directory");
const state = yield* Ref.make(emptyState);
yield* Effect.gen(function* () {
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const eventSink = yield* EventSink.EventSinkV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const threadId = ThreadId.make(`thread-${workspaceState}-workspace`);
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({
idAllocator,
threadId,
now: yield* DateTime.now,
}),
],
});
const error = yield* manager
.open({
threadId,
providerSessionId,
modelSelection,
runtimePolicy: { ...runtimePolicy, cwd },
})
.pipe(Effect.flip);
assert.instanceOf(error, ProviderWorkspaceMissingError);
assert.include(error.message, cwd);
assert.include(error.message, "Restore the folder at this path before retrying.");
assert.equal((yield* Ref.get(state)).openCount, 0);
assert.isTrue(Option.isNone(yield* manager.get(providerSessionId)));
assert.deepEqual(
(yield* projectionStore.getThreadProjection(threadId)).providerSessions,
[],
);
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60_000 })));
}).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);
it.effect(
"rejects a deleted workspace before reusing a live session without changing its state",
() =>
Effect.gen(function* () {
const fileSystem = yield* FileSystem.FileSystem;
const root = yield* fileSystem.makeTempDirectoryScoped();
const cwd = `${root}/workspace`;
yield* fileSystem.makeDirectory(cwd);
const state = yield* Ref.make(emptyState);
yield* Effect.gen(function* () {
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
const eventSink = yield* EventSink.EventSinkV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const threadId = ThreadId.make("thread-deleted-live-workspace");
const providerSessionId = yield* idAllocator.allocate.providerSession({
providerInstanceId: modelSelection.instanceId,
threadId,
});
yield* eventSink.write({
events: [
yield* makeThreadCreatedEvent({
idAllocator,
threadId,
now: yield* DateTime.now,
}),
],
});
const input = {
threadId,
providerSessionId,
modelSelection,
runtimePolicy: { ...runtimePolicy, cwd },
};
const runtime = yield* manager.open(input);
const before = yield* projectionStore.getThreadProjection(threadId);
yield* fileSystem.remove(cwd, { recursive: true });
const error = yield* manager.open(input).pipe(Effect.flip);
assert.instanceOf(error, ProviderWorkspaceMissingError);
assert.equal((yield* Ref.get(state)).openCount, 1);
assert.equal((yield* Ref.get(state)).closeCount, 0);
assert.strictEqual(Option.getOrThrow(yield* manager.get(providerSessionId)), runtime);
assert.deepEqual(
(yield* projectionStore.getThreadProjection(threadId)).providerSessions,
before.providerSessions,
);
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 60_000 })));
}).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);
it.effect(
"ProviderSessionManagerV2 applies project device access independently of browser access",
() =>
Effect.gen(function* () {
const enabled = yield* runBrowserAccessScenario({
enableAgentBrowserAccess: false,
projectOverride: false,
deviceOverride: true,
});
assert.isTrue(enabled?.capabilities?.has("device"));
assert.isFalse(enabled?.browserToolsAvailable);
const denied = yield* runBrowserAccessScenario({
enableAgentBrowserAccess: false,
projectOverride: false,
deviceOverride: true,
projectExists: false,
});
assert.isFalse(denied?.capabilities?.has("device"));
}),
);
// Device instructions reach delegated children only because their own sessions hold `device`.
it.effect("ProviderSessionManagerV2 gives a delegated child its project's device access", () =>
Effect.gen(function* () {
const child = yield* runBrowserAccessScenario({
enableAgentBrowserAccess: false,
projectOverride: false,
deviceOverride: true,
delegatedBy: ThreadId.make("thread-provider-session-manager-parent"),
});
assert.isTrue(child?.capabilities?.has("device"));
}),
);