import { assert, it } from "@effect/vitest";
import {
CheckpointScopeId,
ChatAttachmentId,
ChatFileAttachment,
CommandId,
MessageId,
NodeId,
type OrchestrationV2AppThread,
type OrchestrationV2CheckpointScope,
type OrchestrationV2DomainEvent,
type OrchestrationV2ExecutionNode,
type OrchestrationV2ProviderThread,
type OrchestrationV2ProviderTurn,
type OrchestrationV2Run,
type OrchestrationV2RunAttempt,
type OrchestrationV2Subagent,
type OrchestrationV2TurnItem,
ProviderDriverKind,
ProviderInstanceId,
ProviderSessionId,
ProviderThreadId,
ProviderTurnId,
RunAttemptId,
RunId,
ServerSettingsError,
ThreadId,
TurnItemId,
} from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import * as Exit from "effect/Exit";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
import * as Stream from "effect/Stream";
import { CodexAppServerRequestError } from "effect-codex-app-server/errors";
import { SqlError, classifySqliteError } from "effect/sql/SqlError";
import { toPersistenceSqlError } from "../persistence/Errors.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as CheckpointService from "./CheckpointService.ts";
import type { PendingOrchestrationEffectV2 } from "./EffectOutbox.ts";
import * as EventSink from "./EventSink.ts";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
import * as ProjectionStore from "./ProjectionStore.ts";
import * as ProviderEventIngestor from "./ProviderEventIngestor.ts";
import * as ProviderUsageAnalytics from "../telemetry/ProviderUsageAnalytics.ts";
import * as McpAppModelContext from "../mcpApps/McpAppModelContext.ts";
import * as PreviewAgentActivity from "../preview/PreviewAgentActivity.ts";
import * as RunExecutionService from "./RunExecutionService.ts";
import * as RunFinalizationService from "./RunFinalizationService.ts";
import * as TurnItemPositionStore from "./TurnItemPositionStore.ts";
const mockEventSink = (implementation: Partial<EventSink.EventSinkV2["Service"]>) =>
Layer.mock(EventSink.EventSinkV2)({
consumeProviderEvents: (source, process, after) =>
source.pipe(
Stream.mapEffect((event) => process(event).pipe(Effect.andThen(after))),
Stream.takeUntil(Boolean),
Stream.runDrain,
),
...implementation,
});
const driver = ProviderDriverKind.make("codex");
const rootAppThread = (id: ThreadId) =>
({
id,
lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: id },
}) as OrchestrationV2AppThread;
const layerTurnItemPositionsTest = Layer.mock(TurnItemPositionStore.TurnItemPositionStoreV2)({
allocate: () => Effect.succeed(1),
});
const layerRunExecutionTest = RunExecutionService.layer.pipe(
Layer.provide(
Layer.mergeAll(
McpAppModelContext.layerEmpty,
PreviewAgentActivity.layer,
Layer.mock(CheckpointService.CheckpointServiceV2)({ captureBaseline: () => Effect.void }),
layerTurnItemPositionsTest,
mockEventSink({}),
IdAllocator.layer,
Layer.mock(ProviderEventIngestor.ProviderEventIngestorV2)({
ingestNormalized: () => Effect.succeed([]),
}),
ServerSettings.layerTest(),
),
),
);
it.effect("routes shared-runtime events only to their owning root run", () =>
Effect.gen(function* () {
const now = yield* DateTime.now;
const first: RunExecutionService.ProviderEventRouteIdentity = {
threadId: ThreadId.make("thread:shared-runtime:first"),
runId: RunId.make("run:shared-runtime:first"),
attemptId: RunAttemptId.make("attempt:shared-runtime:first"),
providerThreadId: ProviderThreadId.make("provider-thread:shared-runtime:first"),
};
const second: RunExecutionService.ProviderEventRouteIdentity = {
threadId: ThreadId.make("thread:shared-runtime:second"),
runId: RunId.make("run:shared-runtime:second"),
attemptId: RunAttemptId.make("attempt:shared-runtime:second"),
providerThreadId: ProviderThreadId.make("provider-thread:shared-runtime:second"),
};
const firstTurnId = ProviderTurnId.make("provider-turn:shared-runtime:first");
const turnEvent: ProviderAdapter.ProviderAdapterV2Event = {
type: "provider_turn.updated",
driver,
threadId: first.threadId,
providerTurn: {
id: firstTurnId,
providerThreadId: first.providerThreadId,
nodeId: NodeId.make("node:shared-runtime:first"),
runAttemptId: first.attemptId,
nativeTurnRef: null,
ordinal: 1,
status: "running",
startedAt: now,
completedAt: null,
},
};
const messageEvent: ProviderAdapter.ProviderAdapterV2Event = {
type: "message.updated",
driver,
message: {
createdBy: "agent",
creationSource: "provider",
id: MessageId.make("message:shared-runtime:first"),
threadId: first.threadId,
runId: first.runId,
nodeId: NodeId.make("node:shared-runtime:first"),
role: "assistant",
text: "first only",
attachments: [],
streaming: false,
createdAt: now,
updatedAt: now,
},
};
const terminalEvent: ProviderAdapter.ProviderAdapterV2Event = {
type: "turn.terminal",
driver,
providerThreadId: first.providerThreadId,
providerTurnId: firstTurnId,
runOrdinal: 1,
status: "completed",
failure: null,
threadDisposition: "reusable",
};
const firstInitial = RunExecutionService.makeProviderEventRoutingState({
identity: first,
providerTurnId: null,
});
const secondInitial = RunExecutionService.makeProviderEventRoutingState({
identity: second,
providerTurnId: null,
});
const [firstTurnAccepted, firstAfterTurn] = RunExecutionService.routeProviderEvent(
turnEvent,
first,
firstInitial,
);
const [secondTurnAccepted, secondAfterTurn] = RunExecutionService.routeProviderEvent(
turnEvent,
second,
secondInitial,
);
assert.isTrue(firstTurnAccepted);
assert.isFalse(secondTurnAccepted);
assert.isTrue(RunExecutionService.routeProviderEvent(messageEvent, first, firstAfterTurn)[0]);
assert.isFalse(
RunExecutionService.routeProviderEvent(messageEvent, second, secondAfterTurn)[0],
);
assert.isTrue(RunExecutionService.routeProviderEvent(terminalEvent, first, firstAfterTurn)[0]);
assert.isFalse(
RunExecutionService.routeProviderEvent(terminalEvent, second, secondAfterTurn)[0],
);
}),
);
it("routes only enrolled workflow members after the root turn ends", () => {
const threadId = ThreadId.make("thread:late-child");
const rootProviderTurnId = ProviderTurnId.make("provider-turn:late-child");
const identity: RunExecutionService.ProviderEventRouteIdentity = {
threadId,
runId: RunId.make("run:late-child"),
attemptId: RunAttemptId.make("attempt:late-child"),
providerThreadId: ProviderThreadId.make("provider-thread:late-child"),
};
const childCreated = (
childThreadId: ThreadId,
parentThreadId = threadId,
): ProviderAdapter.ProviderAdapterV2Event =>
({
type: "app_thread.created",
driver,
appThread: {
id: childThreadId,
lineage: {
parentThreadId,
relationshipToParent: "subagent",
rootThreadId: threadId,
},
},
}) as ProviderAdapter.ProviderAdapterV2Event;
const earlyChild = ThreadId.make("thread:late-child:early");
const lateChild = ThreadId.make("thread:late-child:late");
const initial = RunExecutionService.makeProviderEventRoutingState({
identity,
providerTurnId: rootProviderTurnId,
});
const [earlyAccepted, live] = RunExecutionService.routeProviderEvent(
childCreated(earlyChild),
identity,
initial,
);
assert.isTrue(earlyAccepted);
const existingDescendant = ThreadId.make("thread:late-child:existing-descendant");
const [descendantAccepted, withDescendant] = RunExecutionService.routeProviderEvent(
childCreated(existingDescendant, earlyChild),
identity,
live,
);
assert.isTrue(descendantAccepted);
const [terminalAccepted, ended] = RunExecutionService.routeProviderEvent(
{
type: "turn.terminal",
driver,
providerThreadId: identity.providerThreadId,
providerTurnId: rootProviderTurnId,
runOrdinal: 1,
status: "completed",
failure: null,
threadDisposition: "reusable",
},
identity,
withDescendant,
);
assert.isTrue(terminalAccepted);
assert.isTrue(ended.ownedThreadIds.has(earlyChild));
const [lateAccepted, afterLate] = RunExecutionService.routeProviderEvent(
childCreated(lateChild),
identity,
ended,
);
assert.isFalse(lateAccepted);
assert.isFalse(afterLate.ownedThreadIds.has(lateChild));
const memberId = ThreadId.make("thread:late-child:workflow-member");
assert.isFalse(
RunExecutionService.routeProviderEvent(childCreated(memberId, earlyChild), identity, ended)[0],
);
const coordinator: OrchestrationV2Subagent = {
id: NodeId.make("node:late-child:workflow"),
threadId,
runId: identity.runId,
parentNodeId: NodeId.make("node:late-child"),
origin: "provider_native",
createdBy: "agent",
driver,
providerInstanceId: ProviderInstanceId.make("codex"),
providerThreadId: null,
childThreadId: earlyChild,
nativeTaskRef: null,
prompt: "Review the code",
title: "Review",
model: null,
status: "running",
result: null,
startedAt: null,
completedAt: null,
updatedAt: DateTime.makeUnsafe(0),
workflow: {
phases: [],
agents: [{ index: 0, label: "Reviewer", state: "running", childThreadId: memberId }],
},
};
const [foreignAccepted, afterForeign] = RunExecutionService.routeProviderEvent(
{
type: "subagent.updated",
driver,
subagent: {
...coordinator,
threadId: earlyChild,
childThreadId: existingDescendant,
runId: RunId.make("run:late-child:new"),
},
},
identity,
ended,
);
assert.isTrue(foreignAccepted);
assert.isFalse(
RunExecutionService.routeProviderEvent(
childCreated(memberId, existingDescendant),
identity,
afterForeign,
)[0],
);
const [workflowAccepted, afterWorkflow] = RunExecutionService.routeProviderEvent(
{ type: "subagent.updated", driver, subagent: coordinator },
identity,
ended,
);
assert.isTrue(workflowAccepted);
assert.isFalse(
RunExecutionService.routeProviderEvent(childCreated(memberId), identity, afterWorkflow)[0],
);
const [memberAccepted, afterMember] = RunExecutionService.routeProviderEvent(
childCreated(memberId, earlyChild),
identity,
afterWorkflow,
);
assert.isTrue(memberAccepted);
assert.isTrue(afterMember.ownedThreadIds.has(memberId));
const [unrelatedAccepted] = RunExecutionService.routeProviderEvent(
childCreated(ThreadId.make("thread:late-child:unrelated-member"), lateChild),
identity,
ended,
);
assert.isFalse(unrelatedAccepted);
const [unrelatedDescendantAccepted, afterUnrelatedDescendant] =
RunExecutionService.routeProviderEvent(
childCreated(ThreadId.make("thread:late-child:unrelated-descendant"), earlyChild),
identity,
afterWorkflow,
);
assert.isFalse(unrelatedDescendantAccepted);
assert.isFalse(
afterUnrelatedDescendant.ownedThreadIds.has(
ThreadId.make("thread:late-child:unrelated-descendant"),
),
);
});
it("moves a child thread to the run that shows its subagent now", () => {
const threadId = ThreadId.make("thread:handoff");
const rootProviderTurnId = ProviderTurnId.make("provider-turn:handoff");
const identity: RunExecutionService.ProviderEventRouteIdentity = {
threadId,
runId: RunId.make("run:handoff:1"),
attemptId: RunAttemptId.make("attempt:handoff:1"),
providerThreadId: ProviderThreadId.make("provider-thread:handoff"),
};
const resumedChild = ThreadId.make("thread:handoff:resumed");
const siblingChild = ThreadId.make("thread:handoff:sibling");
const providerThreadOf = (childThreadId: ThreadId) =>
ProviderThreadId.make(`provider-thread:${childThreadId}`);
const subagent = (childThreadId: ThreadId, runId: RunId): OrchestrationV2Subagent => ({
id: NodeId.make(`node:${childThreadId}`),
threadId,
runId,
parentNodeId: NodeId.make("node:handoff"),
origin: "provider_native",
createdBy: "agent",
driver,
providerInstanceId: ProviderInstanceId.make("codex"),
providerThreadId: providerThreadOf(childThreadId),
childThreadId,
nativeTaskRef: null,
prompt: "Work",
title: "Work",
model: null,
status: "running",
result: null,
startedAt: null,
completedAt: null,
updatedAt: DateTime.makeUnsafe(0),
});
const childMessage = (childThreadId: ThreadId) =>
({
type: "message.updated",
driver,
message: {
id: MessageId.make(`message:${childThreadId}`),
threadId: childThreadId,
runId: null,
},
}) as ProviderAdapter.ProviderAdapterV2Event;
const childTurn = (childThreadId: ThreadId, ordinal: number) =>
({
type: "provider_turn.updated",
driver,
providerTurn: {
id: ProviderTurnId.make(`provider-turn:${childThreadId}:${ordinal}`),
providerThreadId: providerThreadOf(childThreadId),
runAttemptId: null,
status: "running",
},
}) as ProviderAdapter.ProviderAdapterV2Event;
const ended = RunExecutionService.routeProviderEvent(
{
type: "turn.terminal",
driver,
providerThreadId: identity.providerThreadId,
providerTurnId: rootProviderTurnId,
runOrdinal: 1,
status: "completed",
failure: null,
threadDisposition: "reusable",
},
identity,
RunExecutionService.makeProviderEventRoutingState({
identity,
providerTurnId: rootProviderTurnId,
relatedThreadIds: [resumedChild, siblingChild],
relatedProviderThreadIds: [providerThreadOf(resumedChild), providerThreadOf(siblingChild)],
}),
)[1];
const [firstTurnAccepted, withChildTurn] = RunExecutionService.routeProviderEvent(
childTurn(resumedChild, 1),
identity,
ended,
);
assert.isTrue(firstTurnAccepted);
const [movedAccepted, afterMove] = RunExecutionService.routeProviderEvent(
{
type: "subagent.updated",
driver,
subagent: subagent(resumedChild, RunId.make("run:handoff:2")),
},
identity,
withChildTurn,
);
assert.isFalse(movedAccepted);
assert.isFalse(
RunExecutionService.routeProviderEvent(childMessage(resumedChild), identity, afterMove)[0],
);
assert.isTrue(
RunExecutionService.routeProviderEvent(childMessage(siblingChild), identity, afterMove)[0],
);
assert.isFalse(
RunExecutionService.routeProviderEvent(childTurn(resumedChild, 1), identity, afterMove)[0],
);
assert.isFalse(
RunExecutionService.routeProviderEvent(childTurn(resumedChild, 2), identity, afterMove)[0],
);
assert.isTrue(
RunExecutionService.routeProviderEvent(childTurn(siblingChild, 1), identity, afterMove)[0],
);
assert.isTrue(
RunExecutionService.routeProviderEvent(
{ type: "subagent.updated", driver, subagent: subagent(siblingChild, identity.runId) },
identity,
afterMove,
)[0],
);
const resuming: RunExecutionService.ProviderEventRouteIdentity = {
...identity,
runId: RunId.make("run:handoff:2"),
attemptId: RunAttemptId.make("attempt:handoff:2"),
};
const resumingState = RunExecutionService.makeProviderEventRoutingState({
identity: resuming,
providerTurnId: ProviderTurnId.make("provider-turn:handoff:2"),
});
assert.isFalse(
RunExecutionService.routeProviderEvent(childMessage(resumedChild), resuming, resumingState)[0],
);
const [moveAccepted, afterTake] = RunExecutionService.routeProviderEvent(
{ type: "subagent.updated", driver, subagent: subagent(resumedChild, resuming.runId) },
resuming,
resumingState,
);
assert.isTrue(moveAccepted);
assert.isTrue(
RunExecutionService.routeProviderEvent(childMessage(resumedChild), resuming, afterTake)[0],
);
});
it("does not route a superseded attempt through a reused provider thread", () => {
const threadId = ThreadId.make("thread:shared-runtime:restart");
const providerThreadId = ProviderThreadId.make("provider-thread:shared-runtime:restart");
const oldAttempt: RunExecutionService.ProviderEventRouteIdentity = {
threadId,
runId: RunId.make("run:shared-runtime:restart"),
attemptId: RunAttemptId.make("attempt:shared-runtime:restart:old"),
providerThreadId,
};
const newAttempt: RunExecutionService.ProviderEventRouteIdentity = {
...oldAttempt,
attemptId: RunAttemptId.make("attempt:shared-runtime:restart:new"),
};
const oldTurnEvent: ProviderAdapter.ProviderAdapterV2Event = {
type: "provider_turn.updated",
driver,
threadId,
providerTurn: {
id: ProviderTurnId.make("provider-turn:shared-runtime:restart:old"),
providerThreadId,
nodeId: NodeId.make("node:shared-runtime:restart:old"),
runAttemptId: oldAttempt.attemptId,
nativeTurnRef: null,
ordinal: 1,
status: "interrupted",
startedAt: null,
completedAt: null,
},
};
const newState = RunExecutionService.makeProviderEventRoutingState({
identity: newAttempt,
providerTurnId: null,
});
assert.isFalse(RunExecutionService.routeProviderEvent(oldTurnEvent, newAttempt, newState)[0]);
});
it("routes only exact same-thread background items inherited from settled runs", () => {
const threadId = ThreadId.make("thread:inherited-background-routing");
const otherThreadId = ThreadId.make("thread:inherited-background-routing:other");
const priorRunId = RunId.make("run:inherited-background-routing:prior");
const currentRunId = RunId.make("run:inherited-background-routing:current");
const itemId = TurnItemId.make("turn-item:inherited-background-routing");
const identity: RunExecutionService.ProviderEventRouteIdentity = {
threadId,
runId: currentRunId,
attemptId: RunAttemptId.make("attempt:inherited-background-routing:current"),
providerThreadId: ProviderThreadId.make("provider-thread:inherited-background-routing:current"),
};
const initial = RunExecutionService.makeProviderEventRoutingState({
identity,
inheritedBackgroundTurnItems: [{ id: itemId, runId: priorRunId }],
providerTurnId: null,
});
const inheritedRunning = {
type: "turn_item.updated",
driver,
turnItem: {
id: itemId,
threadId,
runId: priorRunId,
providerTurnId: null,
ordinal: 1,
type: "subagent",
status: "running",
},
} as Extract<ProviderAdapter.ProviderAdapterV2Event, { type: "turn_item.updated" }>;
const unrelatedRunItem = {
...inheritedRunning,
turnItem: {
...inheritedRunning.turnItem,
runId: RunId.make("run:inherited-background-routing:unrelated"),
},
} as ProviderAdapter.ProviderAdapterV2Event;
const unlistedPriorItem = {
...inheritedRunning,
turnItem: {
...inheritedRunning.turnItem,
id: TurnItemId.make("turn-item:inherited-background-routing:unrelated"),
},
} as ProviderAdapter.ProviderAdapterV2Event;
const unrelatedThreadItem = {
...inheritedRunning,
turnItem: { ...inheritedRunning.turnItem, threadId: otherThreadId },
} as ProviderAdapter.ProviderAdapterV2Event;
const ordinaryItem = {
...inheritedRunning,
turnItem: { ...inheritedRunning.turnItem, type: "reasoning" as const },
} as ProviderAdapter.ProviderAdapterV2Event;
const inheritedTerminal = {
...inheritedRunning,
turnItem: { ...inheritedRunning.turnItem, status: "completed" as const },
} as ProviderAdapter.ProviderAdapterV2Event;
const [runningAccepted, afterRunning] = RunExecutionService.routeProviderEvent(
inheritedRunning,
identity,
initial,
);
assert.isTrue(runningAccepted);
assert.isFalse(
RunExecutionService.routeProviderEvent(unrelatedRunItem, identity, afterRunning)[0],
);
assert.isFalse(
RunExecutionService.routeProviderEvent(unlistedPriorItem, identity, afterRunning)[0],
);
assert.isFalse(
RunExecutionService.routeProviderEvent(unrelatedThreadItem, identity, afterRunning)[0],
);
assert.isFalse(RunExecutionService.routeProviderEvent(ordinaryItem, identity, afterRunning)[0]);
const [terminalAccepted, afterTerminal] = RunExecutionService.routeProviderEvent(
inheritedTerminal,
identity,
afterRunning,
);
assert.isTrue(terminalAccepted);
assert.isFalse(
RunExecutionService.routeProviderEvent(inheritedRunning, identity, afterTerminal)[0],
"a nonterminal replay must not resurrect an inherited terminal",
);
});
it("selects only live background items from non-completed settled prior runs", () => {
const threadId = ThreadId.make("thread:inherited-background-selection");
const otherThreadId = ThreadId.make("thread:inherited-background-selection:other");
const currentProviderThreadId = ProviderThreadId.make(
"provider-thread:inherited-background-selection:current",
);
const foreignProviderThreadId = ProviderThreadId.make(
"provider-thread:inherited-background-selection:foreign-session",
);
const interruptedRunId = RunId.make("run:inherited-background-selection:interrupted");
const failedRunId = RunId.make("run:inherited-background-selection:failed");
const cancelledRunId = RunId.make("run:inherited-background-selection:cancelled");
const completedRunId = RunId.make("run:inherited-background-selection:completed");
const rolledBackRunId = RunId.make("run:inherited-background-selection:rolled-back");
const currentRunId = RunId.make("run:inherited-background-selection:current");
const inheritedItemId = TurnItemId.make("turn-item:inherited-background-selection:live");
const failedItemId = TurnItemId.make("turn-item:inherited-background-selection:failed");
const cancelledItemId = TurnItemId.make("turn-item:inherited-background-selection:cancelled");
const makeRun = (
id: RunId,
ordinal: number,
status: OrchestrationV2Run["status"],
runThreadId = threadId,
) =>
({
id,
threadId: runThreadId,
ordinal,
status,
}) as OrchestrationV2Run;
const makeItem = (
id: TurnItemId,
runId: RunId,
status: OrchestrationV2TurnItem["status"],
type: OrchestrationV2TurnItem["type"] = "subagent",
itemThreadId = threadId,
providerThreadId = currentProviderThreadId,
) =>
({
id,
threadId: itemThreadId,
runId,
providerThreadId,
type,
status,
}) as OrchestrationV2TurnItem;
const selected = RunExecutionService.selectInheritedBackgroundTurnItems({
threadId,
currentProviderThreadId,
currentRunOrdinal: 6,
runs: [
makeRun(interruptedRunId, 1, "interrupted"),
makeRun(failedRunId, 2, "failed"),
makeRun(cancelledRunId, 3, "cancelled"),
makeRun(completedRunId, 4, "completed"),
makeRun(rolledBackRunId, 5, "rolled_back"),
makeRun(currentRunId, 6, "running"),
makeRun(
RunId.make("run:inherited-background-selection:other"),
1,
"interrupted",
otherThreadId,
),
],
turnItems: [
makeItem(inheritedItemId, interruptedRunId, "running"),
makeItem(failedItemId, failedRunId, "running"),
makeItem(cancelledItemId, cancelledRunId, "running"),
makeItem(
TurnItemId.make("turn-item:inherited-background-selection:completed-run"),
completedRunId,
"running",
),
makeItem(
TurnItemId.make("turn-item:inherited-background-selection:terminal"),
interruptedRunId,
"completed",
),
makeItem(
TurnItemId.make("turn-item:inherited-background-selection:ordinary"),
interruptedRunId,
"running",
"reasoning",
),
makeItem(
TurnItemId.make("turn-item:inherited-background-selection:rolled-back"),
rolledBackRunId,
"running",
),
makeItem(
TurnItemId.make("turn-item:inherited-background-selection:other-thread"),
interruptedRunId,
"running",
"subagent",
otherThreadId,
),
makeItem(
TurnItemId.make("turn-item:inherited-background-selection:foreign-provider"),
interruptedRunId,
"running",
"subagent",
threadId,
foreignProviderThreadId,
),
],
});
assert.deepEqual(selected, [
{ id: inheritedItemId, runId: interruptedRunId },
{ id: failedItemId, runId: failedRunId },
{ id: cancelledItemId, runId: cancelledRunId },
]);
});
it("does not carry interrupted or still-running child ownership into later attempts", () => {
assert.isFalse(RunExecutionService.canRouteRelatedSubagent("interrupted"));
assert.isFalse(RunExecutionService.canRouteRelatedSubagent("failed"));
assert.isFalse(RunExecutionService.canRouteRelatedSubagent("cancelled"));
assert.isTrue(RunExecutionService.canRouteRelatedSubagent("completed"));
assert.isFalse(RunExecutionService.canRouteRelatedSubagent("running"));
const threadId = ThreadId.make("thread:related-child:next-attempt");
const childThreadId = ThreadId.make("thread:related-child:interrupted");
const identity: RunExecutionService.ProviderEventRouteIdentity = {
threadId,
runId: RunId.make("run:related-child:next-attempt"),
attemptId: RunAttemptId.make("attempt:related-child:next-attempt"),
providerThreadId: ProviderThreadId.make("provider-thread:related-child:next-attempt"),
};
const state = RunExecutionService.makeProviderEventRoutingState({
identity,
providerTurnId: null,
relatedThreadIds: RunExecutionService.canRouteRelatedSubagent("interrupted")
? [childThreadId]
: [],
});
const childNodeId = NodeId.make("node:related-child:interrupted");
const lateChildNode = {
type: "node.updated",
driver,
node: {
id: childNodeId,
threadId: childThreadId,
runId: null,
parentNodeId: null,
rootNodeId: childNodeId,
kind: "root_turn",
status: "completed",
countsForRun: false,
providerThreadId: null,
providerTurnId: null,
nativeItemRef: null,
runtimeRequestId: null,
checkpointScopeId: null,
startedAt: null,
completedAt: null,
},
} satisfies ProviderAdapter.ProviderAdapterV2Event;
assert.isFalse(RunExecutionService.routeProviderEvent(lateChildNode, identity, state)[0]);
});
it.effect("rechecks run ownership immediately before calling the provider", () =>
Effect.gen(function* () {
const runExecution = yield* RunExecutionService.RunExecutionServiceV2;
const guardCalls = yield* Ref.make(0);
const providerStarts = yield* Ref.make(0);
const threadId = ThreadId.make("thread:run-execution-start-guard");
const runId = RunId.make("run:run-execution-start-guard");
const attemptId = RunAttemptId.make("attempt:run-execution-start-guard");
const providerThreadId = ProviderThreadId.make("provider-thread:run-execution-start-guard");
const providerInstanceId = ProviderInstanceId.make("codex");
const providerSessionId = ProviderSessionId.make("session:run-execution-start-guard");
const rootNodeId = NodeId.make("node:run-execution-start-guard");
const run = {
id: runId,
threadId,
ordinal: 1,
providerInstanceId,
} as OrchestrationV2Run;
const rootNode = { id: rootNodeId } as OrchestrationV2ExecutionNode;
const providerThread = {
id: providerThreadId,
driver,
} as OrchestrationV2ProviderThread;
const attempt = {
id: attemptId,
providerTurnId: null,
} as OrchestrationV2RunAttempt;
const session = {
events: Stream.never,
startTurn: () => Ref.update(providerStarts, (count) => count + 1),
} as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime;
yield* runExecution.startRootRun({
commandId: CommandId.make("command:run-execution-start-guard"),
appThread: rootAppThread(threadId),
providerSessionId,
session,
run,
rootNode,
checkpointScope: {
id: CheckpointScopeId.make("checkpoint-scope:run-execution-start-guard"),
} as OrchestrationV2CheckpointScope,
providerThread,
attempt,
attemptId,
providerTurnOrdinal: 1,
shouldStartProviderTurn: () =>
Ref.modify(guardCalls, (calls) => [calls === 0, calls + 1] as const),
message: {
messageId: MessageId.make("message:run-execution-start-guard"),
text: "Do not start after ownership changes.",
attachments: [],
createdBy: "user",
creationSource: "web",
},
modelSelection: { instanceId: providerInstanceId, model: "gpt-5.4" },
runtimePolicy: {
runtimeMode: "full-access",
interactionMode: "default",
cwd: process.cwd(),
approvalPolicy: "never",
sandboxPolicy: {
type: "readOnly",
access: { type: "fullAccess" },
networkAccess: false,
},
},
});
assert.equal(yield* Ref.get(guardCalls), 2);
assert.equal(yield* Ref.get(providerStarts), 0);
}).pipe(Effect.provide(layerRunExecutionTest)),
);
it.effect("passes the thread's MCP app context to the provider under a safe key", () =>
Effect.gen(function* () {
const runExecution = yield* RunExecutionService.RunExecutionServiceV2;
const started = yield* Deferred.make<ProviderAdapter.ProviderAdapterV2TurnInput>();
const threadId = ThreadId.make("thread:run-execution-app-context");
const providerInstanceId = ProviderInstanceId.make("codex");
const attemptId = RunAttemptId.make("attempt:run-execution-app-context");
const session = {
events: Stream.never,
startTurn: (input: ProviderAdapter.ProviderAdapterV2TurnInput) =>
Deferred.succeed(started, input),
} as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime;
yield* runExecution.startRootRun({
commandId: CommandId.make("command:run-execution-app-context"),
appThread: rootAppThread(threadId),
providerSessionId: ProviderSessionId.make("session:run-execution-app-context"),
session,
run: {
id: RunId.make("run:run-execution-app-context"),
threadId,
ordinal: 1,
providerInstanceId,
} as OrchestrationV2Run,
rootNode: {
id: NodeId.make("node:run-execution-app-context"),
} as OrchestrationV2ExecutionNode,
checkpointScope: {
id: CheckpointScopeId.make("checkpoint-scope:run-execution-app-context"),
} as OrchestrationV2CheckpointScope,
providerThread: {
id: ProviderThreadId.make("provider-thread:run-execution-app-context"),
driver,
} as OrchestrationV2ProviderThread,
attempt: { id: attemptId, providerTurnId: null } as OrchestrationV2RunAttempt,
attemptId,
providerTurnOrdinal: 1,
message: {
messageId: MessageId.make("message:run-execution-app-context"),
text: "What is on my list?",
attachments: [],
createdBy: "user",
creationSource: "web",
},
modelSelection: { instanceId: providerInstanceId, model: "gpt-5.4" },
runtimePolicy: { runtimeMode: "full-access", interactionMode: "default", cwd: process.cwd() },
});
const input = yield* Deferred.await(started);
assert.deepEqual(input.appContext, [
{ key: "mcp_app_turn-item_provider_codex_native-item_call-1", text: "2 overdue" },
]);
}).pipe(
Effect.provide(
RunExecutionService.layer.pipe(
Layer.provide(
Layer.mergeAll(
PreviewAgentActivity.layer,
Layer.mock(McpAppModelContext.McpAppModelContext)({
forThread: () =>
Effect.succeed([
{
itemId: "turn-item:provider:codex:native-item:call-1",
server: "my tools>",
tool: "list",
text: "2 overdue",
},
]),
}),
Layer.mock(CheckpointService.CheckpointServiceV2)({
captureBaseline: () => Effect.void,
}),
layerTurnItemPositionsTest,
mockEventSink({}),
IdAllocator.layer,
Layer.mock(ProviderEventIngestor.ProviderEventIngestorV2)({
ingestNormalized: () => Effect.succeed([]),
}),
ServerSettings.layerTest(),
),
),
),
),
),
);
it.effect("fails the run when its ownership check cannot be read before calling the provider", () =>
Effect.gen(function* () {
const guardCalls = yield* Ref.make(0);
const providerStarts = yield* Ref.make(0);
const writes = yield* Ref.make<ReadonlyArray<OrchestrationV2DomainEvent>>([]);
const threadId = ThreadId.make("thread:run-execution-start-guard-read");
const runId = RunId.make("run:run-execution-start-guard-read");
const attemptId = RunAttemptId.make("attempt:run-execution-start-guard-read");
const providerInstanceId = ProviderInstanceId.make("codex");
const layerTest = RunExecutionService.layer.pipe(
Layer.provide(
Layer.mergeAll(
McpAppModelContext.layerEmpty,
PreviewAgentActivity.layer,
Layer.mock(CheckpointService.CheckpointServiceV2)({ captureBaseline: () => Effect.void }),
layerTurnItemPositionsTest,
mockEventSink({
writeIfRunCurrent: (input) =>
Ref.update(writes, (current) => [...current, ...input.events]).pipe(
Effect.as({ committed: true, storedEvents: [] }),
),
}),
IdAllocator.layer,
Layer.mock(ProviderEventIngestor.ProviderEventIngestorV2)({
ingestNormalized: () => Effect.succeed([]),
}),
ServerSettings.layerTest(),
),
),
);
yield* Effect.gen(function* () {
const runExecution = yield* RunExecutionService.RunExecutionServiceV2;
yield* runExecution.startRootRun({
commandId: CommandId.make("command:run-execution-start-guard-read"),
appThread: rootAppThread(threadId),
providerSessionId: ProviderSessionId.make("session:run-execution-start-guard-read"),
session: {
events: Stream.never,
startTurn: () => Ref.update(providerStarts, (count) => count + 1),
} as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime,
run: { id: runId, threadId, ordinal: 1, providerInstanceId } as OrchestrationV2Run,
rootNode: {
id: NodeId.make("node:run-execution-start-guard-read"),
} as OrchestrationV2ExecutionNode,
checkpointScope: {
id: CheckpointScopeId.make("checkpoint-scope:run-execution-start-guard-read"),
} as OrchestrationV2CheckpointScope,
providerThread: {
id: ProviderThreadId.make("provider-thread:run-execution-start-guard-read"),
driver,
} as OrchestrationV2ProviderThread,
attempt: { id: attemptId, providerTurnId: null } as OrchestrationV2RunAttempt,
attemptId,
providerTurnOrdinal: 1,
shouldStartProviderTurn: () =>
Ref.getAndUpdate(guardCalls, (calls) => calls + 1).pipe(
Effect.flatMap((calls) =>
calls === 0
? Effect.succeed(true)
: Effect.fail(
new ProjectionStore.ProjectionStoreReadError({
threadId,
cause: "database unavailable",
}),
),
),
),
shouldFinalizeRun: () =>
Effect.fail(
new ProjectionStore.ProjectionStoreReadError({
threadId,
cause: "database unavailable",
}),
),
message: {
messageId: MessageId.make("message:run-execution-start-guard-read"),
text: "Start while the store is down.",
attachments: [],
createdBy: "user",
creationSource: "web",
},
modelSelection: { instanceId: providerInstanceId, model: "gpt-5.4" },
runtimePolicy: {
runtimeMode: "full-access",
interactionMode: "default",
cwd: process.cwd(),
approvalPolicy: "never",
sandboxPolicy: {
type: "readOnly",
access: { type: "fullAccess" },
networkAccess: false,
},
},
});
}).pipe(Effect.provide(layerTest));
assert.equal(yield* Ref.get(guardCalls), 2);
assert.equal(yield* Ref.get(providerStarts), 0);
const runUpdate = (yield* Ref.get(writes)).find((event) => event.type === "run.updated");
assert.equal(
runUpdate?.type === "run.updated" ? runUpdate.payload.status : undefined,
"failed",
);
}),
);
it.effect(
"dispatches only attachment-free compact commands through the native compaction path",
() =>
Effect.gen(function* () {
const runExecution = yield* RunExecutionService.RunExecutionServiceV2;
const calls: Array<string> = [];
const attachment = ChatFileAttachment.make({
type: "file",
id: ChatAttachmentId.make("compact-file-12345678-1234-1234-1234-123456789abc"),
name: "notes.txt",
mimeType: "text/plain",
sizeBytes: 1,
});
const cases = [
{ text: " /compact ", attachments: [], expected: "compact" },
{ text: "/compact", attachments: [attachment], expected: "prompt" },
{ text: "Continue the work", attachments: [], expected: "prompt" },
];
for (const [index, testCase] of cases.entries()) {
const threadId = ThreadId.make(`thread:compact-routing:${index}`);
const attemptId = RunAttemptId.make(`attempt:compact-routing:${index}`);
yield* runExecution.startRootRun({
commandId: CommandId.make(`command:compact-routing:${index}`),
appThread: rootAppThread(threadId),
providerSessionId: ProviderSessionId.make(`session:compact-routing:${index}`),
session: {
events: Stream.never,
startTurn: () =>
Effect.sync(() => {
calls.push("prompt");
}),
compactThread: () =>
Effect.sync(() => {
calls.push("compact");
}),
} as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime,
run: {
id: RunId.make(`run:compact-routing:${index}`),
threadId,
ordinal: 1,
providerInstanceId: ProviderInstanceId.make("codex"),
} as OrchestrationV2Run,
rootNode: {
id: NodeId.make(`node:compact-routing:${index}`),
} as OrchestrationV2ExecutionNode,
checkpointScope: {
id: CheckpointScopeId.make(`checkpoint:compact-routing:${index}`),
} as OrchestrationV2CheckpointScope,
providerThread: {
id: ProviderThreadId.make(`provider-thread:compact-routing:${index}`),
driver,
} as OrchestrationV2ProviderThread,
attempt: { id: attemptId, providerTurnId: null } as OrchestrationV2RunAttempt,
attemptId,
providerTurnOrdinal: 1,
message: {
messageId: MessageId.make(`message:compact-routing:${index}`),
text: testCase.text,
attachments: testCase.attachments,
createdBy: "user",
creationSource: "web",
},
modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" },
runtimePolicy: {
runtimeMode: "full-access",
interactionMode: "default",
cwd: process.cwd(),
approvalPolicy: "never",
sandboxPolicy: {
type: "readOnly",
access: { type: "fullAccess" },
networkAccess: false,
},
},
});
}
assert.deepEqual(
calls,
cases.map((testCase) => testCase.expected),
);
}).pipe(Effect.provide(layerRunExecutionTest)),
);
it.effect("starts the provider when checkpoint baseline capture fails", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("thread:run-execution-baseline-failure");
const runId = RunId.make("run:run-execution-baseline-failure");
const attemptId = RunAttemptId.make("attempt:run-execution-baseline-failure");
const providerThreadId = ProviderThreadId.make(
"provider-thread:run-execution-baseline-failure",
);
const providerInstanceId = ProviderInstanceId.make("codex");
const providerSessionId = ProviderSessionId.make("session:run-execution-baseline-failure");
const rootNodeId = NodeId.make("node:run-execution-baseline-failure");
const checkpointScope = {
id: CheckpointScopeId.make("checkpoint-scope:run-execution-baseline-failure"),
} as OrchestrationV2CheckpointScope;
const providerStarts = yield* Ref.make(0);
const writes = yield* Ref.make<
ReadonlyArray<{
events: ReadonlyArray<OrchestrationV2DomainEvent>;
effects: ReadonlyArray<PendingOrchestrationEffectV2>;
}>
>([]);
const layerTest = RunExecutionService.layer.pipe(
Layer.provide(
Layer.mergeAll(
McpAppModelContext.layerEmpty,
PreviewAgentActivity.layer,
Layer.mock(CheckpointService.CheckpointServiceV2)({
captureBaseline: () =>
Effect.fail(
new CheckpointService.CheckpointBaselineCaptureError({
scopeId: checkpointScope.id,
ordinalWithinScope: 0,
cause: new Error("VCS process timed out"),
}),
),
}),
layerTurnItemPositionsTest,
mockEventSink({
writeWithEffects: (input) =>
Ref.update(writes, (current) => [
...current,
{ events: input.events, effects: input.effects },
]).pipe(Effect.as([])),
}),
IdAllocator.layer,
Layer.mock(ProviderEventIngestor.ProviderEventIngestorV2)({
ingestNormalized: () => Effect.succeed([]),
}),
ServerSettings.layerTest(),
),
),
);
yield* Effect.gen(function* () {
const runExecution = yield* RunExecutionService.RunExecutionServiceV2;
yield* runExecution.startRootRun({
commandId: CommandId.make("command:run-execution-baseline-failure"),
appThread: rootAppThread(threadId),
providerSessionId,
session: {
events: Stream.never,
startTurn: () => Ref.update(providerStarts, (count) => count + 1),
} as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime,
run: {
id: runId,
threadId,
ordinal: 1,
providerInstanceId,
} as OrchestrationV2Run,
rootNode: { id: rootNodeId } as OrchestrationV2ExecutionNode,
checkpointScope,
providerThread: {
id: providerThreadId,
driver,
} as OrchestrationV2ProviderThread,
attempt: {
id: attemptId,
providerTurnId: null,
} as OrchestrationV2RunAttempt,
attemptId,
providerTurnOrdinal: 1,
message: {
messageId: MessageId.make("message:run-execution-baseline-failure"),
text: "Start the provider without a baseline.",
attachments: [],
createdBy: "user",
creationSource: "web",
},
modelSelection: { instanceId: providerInstanceId, model: "gpt-5.4" },
runtimePolicy: {
runtimeMode: "full-access",
interactionMode: "default",
cwd: process.cwd(),
approvalPolicy: "never",
sandboxPolicy: {
type: "readOnly",
access: { type: "fullAccess" },
networkAccess: false,
},
},
});
}).pipe(Effect.provide(layerTest));
assert.equal(yield* Ref.get(providerStarts), 1);
const events = (yield* Ref.get(writes)).flatMap((write) => [...write.events]);
const failedEvent = events.find(
(event) =>
(event.type === "run.updated" ||
event.type === "run-attempt.updated" ||
event.type === "node.updated") &&
event.payload.status === "failed",
);
assert.isUndefined(failedEvent);
const errorItem = events.find(
(event) => event.type === "turn-item.updated" && event.payload.type === "error",
);
assert.isUndefined(errorItem);
}),
);
it.effect.each(["failure", "interruption", "stale-attempt", "start-guard"] as const)(
"handles %s before the provider turn starts",
(scenario) =>
Effect.gen(function* () {
const threadId = ThreadId.make("thread:run-execution-settings-failure");
const runId = RunId.make("run:run-execution-settings-failure");
const attemptId = RunAttemptId.make("attempt:run-execution-settings-failure");
const providerInstanceId = ProviderInstanceId.make("codex");
const providerSessionId = ProviderSessionId.make("session:run-execution-settings-failure");
const providerThreadId = ProviderThreadId.make(
"provider-thread:run-execution-settings-failure",
);
const rootNodeId = NodeId.make("node:run-execution-settings-failure");
const checkpointScope = {
id: CheckpointScopeId.make("checkpoint-scope:run-execution-settings-failure"),
} as OrchestrationV2CheckpointScope;
const providerStarts = yield* Ref.make(0);
const refreshes = yield* Ref.make(0);
const guardedWrites = yield* Ref.make(0);
const writes = yield* Ref.make<ReadonlyArray<ReadonlyArray<OrchestrationV2DomainEvent>>>([]);
const layerTest = RunExecutionService.layer.pipe(
Layer.provide(
Layer.mergeAll(
McpAppModelContext.layerEmpty,
PreviewAgentActivity.layer,
Layer.mock(CheckpointService.CheckpointServiceV2)({
captureBaseline: () =>
scenario === "start-guard" ? Effect.void : Effect.die("not reached"),
}),
layerTurnItemPositionsTest,
mockEventSink({
writeIfRunCurrent: (input) =>
Effect.gen(function* () {
assert.equal(input.threadId, threadId);
assert.equal(input.runId, runId);
assert.equal(input.activeAttemptId, attemptId);
assert.equal(input.expectedStatus, "running");
yield* Ref.update(guardedWrites, (count) => count + 1);
if (scenario === "stale-attempt") {
return { committed: false, storedEvents: [] };
}
yield* Ref.update(writes, (current) => [...current, input.events]);
return { committed: true, storedEvents: [] };
}),
}),
IdAllocator.layer,
Layer.mock(ProviderEventIngestor.ProviderEventIngestorV2)({
ingestNormalized: () => Effect.succeed([]),
}),
scenario === "start-guard"
? ServerSettings.layerTest()
: Layer.mock(ServerSettings.ServerSettingsService)({
getSettings:
scenario === "interruption"
? Effect.interrupt
: Effect.fail(
new ServerSettingsError({
settingsPath: "<test>",
operation: "read-file",
cause: new Error("settings read failed"),
}),
),
}),
Layer.succeed(RunFinalizationService.RunFinalizationObserver, {
refresh: () => Effect.void,
refreshAfterTurn: () => Ref.update(refreshes, (count) => count + 1),
}),
),
),
);
const result = yield* Effect.gen(function* () {
const runExecution = yield* RunExecutionService.RunExecutionServiceV2;
yield* runExecution.startRootRun({
commandId: CommandId.make("command:run-execution-settings-failure"),
appThread: rootAppThread(threadId),
providerSessionId,
session: {
events: Stream.never,
startTurn: () => Ref.update(providerStarts, (count) => count + 1),
} as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime,
run: {
id: runId,
threadId,
ordinal: 1,
providerInstanceId,
status: "running",
} as OrchestrationV2Run,
rootNode: { id: rootNodeId, status: "running" } as OrchestrationV2ExecutionNode,
checkpointScope,
providerThread: {
id: providerThreadId,
driver,
} as OrchestrationV2ProviderThread,
attempt: {
id: attemptId,
providerTurnId: null,
status: "running",
} as OrchestrationV2RunAttempt,
attemptId,
providerTurnOrdinal: 1,
...(scenario === "start-guard"
? { shouldStartProviderTurn: () => Effect.succeed(false) }
: {}),
message: {
messageId: MessageId.make("message:run-execution-settings-failure"),
text: "Start after settings fail.",
attachments: [],
createdBy: "user",
creationSource: "web",
},
modelSelection: { instanceId: providerInstanceId, model: "gpt-5.4" },
runtimePolicy: {
runtimeMode: "full-access",
interactionMode: "default",
cwd: process.cwd(),
approvalPolicy: "never",
sandboxPolicy: {
type: "readOnly",
access: { type: "fullAccess" },
networkAccess: false,
},
},
});
}).pipe(Effect.provide(layerTest), Effect.exit);
assert.equal(yield* Ref.get(providerStarts), 0);
const events = (yield* Ref.get(writes)).flat();
if (scenario === "interruption") {
assert.isTrue(Exit.isFailure(result));
if (Exit.isFailure(result)) assert.isTrue(Cause.hasInterruptsOnly(result.cause));
assert.equal(yield* Ref.get(guardedWrites), 0);
assert.equal(yield* Ref.get(refreshes), 0);
assert.isEmpty(events);
return;
}
assert.isTrue(Exit.isSuccess(result));
if (scenario === "start-guard") {
assert.equal(yield* Ref.get(guardedWrites), 0);
assert.equal(yield* Ref.get(refreshes), 0);
assert.isEmpty(events);
return;
}
assert.equal(yield* Ref.get(guardedWrites), 1);
if (scenario === "stale-attempt") {
assert.equal(yield* Ref.get(refreshes), 0);
assert.isEmpty(events);
return;
}
assert.equal(yield* Ref.get(refreshes), 1);
assert.deepEqual(
events
.filter(
(event) =>
event.type === "run.updated" ||
event.type === "run-attempt.updated" ||
event.type === "node.updated",
)
.map((event) => event.payload.status),
["failed", "failed", "failed"],
);
const errorItem = events.find(
(event) => event.type === "turn-item.updated" && event.payload.type === "error",
);
assert.isDefined(errorItem);
if (errorItem?.type === "turn-item.updated" && errorItem.payload.type === "error") {
assert.equal(errorItem.payload.failure.message, "Run preparation failed.");
}
}),
);
it.effect("ingests new member threads of an owned child after the root turn terminalizes", () =>
Effect.gen(function* () {
const threadId = ThreadId.make("thread:run-execution-late-child");
const childThreadId = ThreadId.make("thread:run-execution-late-child:child");
const memberThreadId = ThreadId.make("thread:run-execution-late-child:member");
const runId = RunId.make("run:run-execution-late-child");
const attemptId = RunAttemptId.make("attempt:run-execution-late-child");
const providerInstanceId = ProviderInstanceId.make("codex");
const providerSessionId = ProviderSessionId.make("session:run-execution-late-child");
const providerThreadId = ProviderThreadId.make("provider-thread:run-execution-late-child");
const childProviderThreadId = ProviderThreadId.make(
"provider-thread:run-execution-late-child:child",
);
const rootProviderTurnId = ProviderTurnId.make("provider-turn:run-execution-late-child");
const childProviderTurnId = ProviderTurnId.make("provider-turn:run-execution-late-child:child");
const rootNodeId = NodeId.make("node:run-execution-late-child");
const childNodeId = NodeId.make("node:run-execution-late-child:child");
const subagentNodeId = NodeId.make("node:run-execution-late-child:subagent");
const childMessageIngested = yield* Deferred.make<void>();
const order = yield* Ref.make<ReadonlyArray<string>>([]);
const origins = yield* Ref.make<ReadonlyArray<readonly [string, unknown, unknown]>>([]);
const requests = yield* Ref.make<ReadonlyArray<string>>([]);
const layerTest = RunExecutionService.layer.pipe(
Layer.provide(
Layer.mergeAll(
Layer.succeed(ProviderUsageAnalytics.ProviderTurnAnalytics, {
runStarted: (input) =>
Ref.update(requests, (current) => [...current, `started:${input.runId}`]),
turnCompleted: () => Effect.void,
runSettled: (input) =>
Ref.update(requests, (current) => [
...current,
`settled:${input.runId}:${input.status}:children-running=${input.childrenRunning}`,
]),
}),
McpAppModelContext.layerEmpty,
PreviewAgentActivity.layer,
Layer.mock(CheckpointService.CheckpointServiceV2)({ captureBaseline: () => Effect.void }),
layerTurnItemPositionsTest,
mockEventSink({
write: () => Effect.succeed([]),
writeWithEffects: (input) =>
Effect.gen(function* () {
if (
input.events.some(
(event) => event.type === "run.updated" && event.runId === runId,
)
) {
yield* Ref.update(order, (current) => [...current, "root-finalized"]);
}
return [];
}),
writeIfRunCurrent: () => Effect.succeed({ committed: true, storedEvents: [] }),
}),
IdAllocator.layer,
Layer.mock(ProviderEventIngestor.ProviderEventIngestorV2)({
ingestNormalized: (input) =>
Effect.gen(function* () {
const eventType = input.event.type;
yield* Ref.update(origins, (current) => [
...current,
[
eventType,
input.analyticsContext?.origin,
input.analyticsContext?.segment,
] as const,
]);
if (
input.event.type === "app_thread.created" &&
input.event.appThread.id === memberThreadId
) {
yield* Ref.update(order, (current) => [...current, "member-thread"]);
}
if (
input.event.type === "message.updated" &&
input.event.message.threadId === memberThreadId
) {
yield* Ref.update(order, (current) => [...current, "child-message"]);
yield* Deferred.succeed(childMessageIngested, undefined).pipe(Effect.ignore);
}
return [];
}),
}),
ServerSettings.layerTest(),
),
),
);
const events: ReadonlyArray<ProviderAdapter.ProviderAdapterV2Event> = [
{
type: "app_thread.created",
driver,
appThread: {
id: childThreadId,
lineage: {
parentThreadId: threadId,
relationshipToParent: "subagent",
rootThreadId: threadId,
},
},
} as ProviderAdapter.ProviderAdapterV2Event,
{
type: "provider_thread.updated",
driver,
providerThread: {
id: childProviderThreadId,
appThreadId: childThreadId,
},
} as ProviderAdapter.ProviderAdapterV2Event,
{
type: "subagent.updated",
driver,
subagent: {
...makeRunOwnedSubagentFixture({
ids: backgroundScenarioIds("run-execution-late-child"),
providerInstanceId,
childThreadId,
driver,
status: "running",
}),
workflow: {
phases: [],
agents: [
{ index: 0, label: "Reviewer", state: "running", childThreadId: memberThreadId },
],
},
},
},
{
type: "provider_turn.updated",
driver,
threadId: childThreadId,
providerTurn: {
id: childProviderTurnId,
providerThreadId: childProviderThreadId,
nodeId: childNodeId,
runAttemptId: null,
status: "running",
},
} as ProviderAdapter.ProviderAdapterV2Event,
{
type: "turn.terminal",
driver,
providerThreadId,
providerTurnId: rootProviderTurnId,
runOrdinal: 1,
status: "completed",
failure: null,
threadDisposition: "reusable",
},
{
type: "app_thread.created",
driver,
appThread: {
id: memberThreadId,
lineage: {
parentThreadId: childThreadId,
relationshipToParent: "subagent",
rootThreadId: threadId,
},
},
} as ProviderAdapter.ProviderAdapterV2Event,
{
type: "message.updated",
driver,
message: {
id: MessageId.make("message:run-execution-late-child:child"),
threadId: memberThreadId,
runId: null,
nodeId: childNodeId,
role: "assistant",
text: "Hello.",
streaming: false,
},
} as ProviderAdapter.ProviderAdapterV2Event,
{
type: "provider_turn.updated",
driver,
threadId: childThreadId,
providerTurn: {
id: childProviderTurnId,
providerThreadId: childProviderThreadId,
nodeId: childNodeId,
runAttemptId: null,
status: "completed",
},
} as ProviderAdapter.ProviderAdapterV2Event,
{
type: "subagent.updated",
driver,
subagent: {
id: subagentNodeId,
threadId,
runId,
status: "completed",
},
} as ProviderAdapter.ProviderAdapterV2Event,
];
yield* Effect.gen(function* () {
const runExecution = yield* RunExecutionService.RunExecutionServiceV2;
yield* runExecution.startRootRun({
commandId: CommandId.make("command:run-execution-late-child"),
appThread: rootAppThread(threadId),
providerSessionId,
session: {
events: Stream.fromIterable(events),
startTurn: () => Effect.void,
} as unknown as ProviderAdapter.ProviderAdapterV2SessionRuntime,
run: {
id: runId,
threadId,
ordinal: 1,
providerInstanceId,
} as OrchestrationV2Run,
rootNode: { id: rootNodeId } as OrchestrationV2ExecutionNode,
checkpointScope: {
id: CheckpointScopeId.make("checkpoint-scope:run-execution-late-child"),
} as OrchestrationV2CheckpointScope,
providerThread: {
id: providerThreadId,
driver,
} as OrchestrationV2ProviderThread,
attempt: {
id: attemptId,
providerTurnId: rootProviderTurnId,
reason: "initial",
} as OrchestrationV2RunAttempt,
attemptId,
providerTurnOrdinal: 1,
message: {
messageId: MessageId.make("message:run-execution-late-child:user"),
text: "Spawn a child and finish.",
attachments: [],
createdBy: "user",
creationSource: "web",
},
modelSelection: { instanceId: providerInstanceId, model: "gpt-5.4" },
runtimePolicy: {
runtimeMode: "full-access",
interactionMode: "default",
cwd: process.cwd(),
approvalPolicy: "never",
sandboxPolicy: {
type: "readOnly",
access: { type: "fullAccess" },
networkAccess: false,
},
},
});
}).pipe(Effect.provide(layerTest));
const observed = yield* Deferred.await(childMessageIngested).pipe(
Effect.timeoutOption("2 seconds"),
);
assert.isTrue(Option.isSome(observed), "child message was not ingested after root terminal");
assert.deepEqual(yield* Ref.get(order), ["root-finalized", "member-thread", "child-message"]);
// The run's message started the root; the parent agent started the child's turn.
const recorded = yield* Ref.get(origins);
assert.deepEqual(recorded[0]?.slice(0, 2), [
"app_thread.created",
{ createdBy: "user", creationSource: "web", scheduled: false, subagent: false },
]);
assert.deepEqual(
recorded.find(([type]) => type === "provider_turn.updated"),
[
"provider_turn.updated",
{ createdBy: "agent", creationSource: "provider", scheduled: false, subagent: true },
"native_child",
],
);
// The child outlives the root, so the request summary says its later turns are missing.
assert.deepEqual(yield* Ref.get(requests), [
`started:${runId}`,
`settled:${runId}:completed:children-running=true`,
]);
}),
);
it.effect("ends a nested native subagent and its thread when the root run is interrupted", () =>
Effect.gen(function* () {
const key = "run-execution-nested-native";
const threadId = ThreadId.make(`thread:${key}`);
const childThreadId = ThreadId.make(`thread:${key}:child`);
const grandchildThreadId = ThreadId.make(`thread:${key}:grandchild`);
const runId = RunId.make(`run:${key}`);
const attemptId = RunAttemptId.make(`attempt:${key}`);
const providerInstanceId = ProviderInstanceId.make("codex");
const providerThreadId = ProviderThreadId.make(`provider-thread:${key}`);
const rootProviderTurnId = ProviderTurnId.make(`provider-turn:${key}`);
const nestedId = NodeId.make(`node:${key}:nested`);
const grandchildRootId = NodeId.make(`node:${key}:grandchild-root`);
const finalized = yield* Deferred.make<ReadonlyArray<OrchestrationV2DomainEvent>>();
const layerTest = RunExecutionService.layer.pipe(
Layer.provide(
Layer.mergeAll(
McpAppModelContext.layerEmpty,
PreviewAgentActivity.layer,
Layer.mock(CheckpointService.CheckpointServiceV2)({ captureBaseline: () => Effect.void }),
layerTurnItemPositionsTest,
mockEventSink({
write: () => Effect.succeed([]),
writeWithEffects: (input) =>
Effect.as(
input.events.some((event) => event.type === "run.updated")
? Deferred.succeed(finalized, input.events)
: Effect.void,
[],
),
}),
IdAllocator.layer,
Layer.mock(ProviderEventIngestor.ProviderEventIngestorV2)({
ingestNormalized: () => Effect.succeed([]),
}),
ServerSettings.layerTest(),
),
),
);
const subagentThread = (id: ThreadId, parentThreadId: ThreadId) =>
({
type: "app_thread.created",
driver,
appThread: {
id,
lineage: { parentThreadId, relationshipToParent: "subagent", rootThreadId: threadId },
},
}) as ProviderAdapter.ProviderAdapterV2Event;
const events: ReadonlyArray<ProviderAdapter.ProviderAdapterV2Event> = [
subagentThread(childThreadId, threadId),
subagentThread(grandchildThreadId, childThreadId),
{
type: "subagent.updated",
driver,
subagent: {
id: nestedId,
threadId: childThreadId,
runId: null,
origin: "provider_native",
childThreadId: grandchildThreadId,
status: "running",
},
} as ProviderAdapter.ProviderAdapterV2Event,
{
type: "node.updated",
driver,
node: {
id: grandchildRootId,
threadId: grandchildThreadId,