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,
});