Skip to content

Commit 891ab7d

Browse files
committed
fix(server): close sessions when provider turns abort
1 parent e9c4775 commit 891ab7d

2 files changed

Lines changed: 205 additions & 4 deletions

File tree

‎apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts‎

Lines changed: 183 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -921,6 +921,189 @@ describe("ProviderRuntimeIngestion", () => {
921921
await waitForThread(harness.readModel, (thread) => thread.session?.status === "ready");
922922
});
923923

924+
it("closes the session lifecycle when the active turn is aborted", async () => {
925+
const harness = await createHarness();
926+
const now = "2026-01-01T00:00:00.000Z";
927+
928+
// Regression: an interrupt whose abort lands while the provider is already
929+
// idle emits `turn.aborted` instead of `turn.completed`. Without an
930+
// ingestion handler the thread stayed "running" with a dangling active
931+
// turn forever: stop looked like a no-op and settling was refused.
932+
harness.emit({
933+
type: "turn.started",
934+
eventId: asEventId("evt-turn-started-abort-lifecycle"),
935+
provider: ProviderDriverKind.make("opencode"),
936+
createdAt: now,
937+
threadId: asThreadId("thread-1"),
938+
turnId: asTurnId("turn-abort-lifecycle"),
939+
});
940+
941+
await waitForThread(
942+
harness.readModel,
943+
(thread) =>
944+
thread.session?.status === "running" &&
945+
thread.session?.activeTurnId === "turn-abort-lifecycle",
946+
);
947+
948+
harness.emit({
949+
type: "content.delta",
950+
eventId: asEventId("evt-message-delta-abort-lifecycle"),
951+
provider: ProviderDriverKind.make("opencode"),
952+
createdAt: now,
953+
threadId: asThreadId("thread-1"),
954+
turnId: asTurnId("turn-abort-lifecycle"),
955+
itemId: asItemId("item-abort-lifecycle"),
956+
payload: { streamKind: "assistant_text", delta: "partial answer" },
957+
});
958+
harness.emit({
959+
type: "turn.proposed.delta",
960+
eventId: asEventId("evt-plan-delta-abort-lifecycle"),
961+
provider: ProviderDriverKind.make("opencode"),
962+
createdAt: now,
963+
threadId: asThreadId("thread-1"),
964+
turnId: asTurnId("turn-abort-lifecycle"),
965+
payload: { delta: "## Partial plan\n\n- keep this" },
966+
});
967+
968+
harness.emit({
969+
type: "turn.aborted",
970+
eventId: asEventId("evt-turn-aborted-lifecycle"),
971+
provider: ProviderDriverKind.make("opencode"),
972+
createdAt: now,
973+
threadId: asThreadId("thread-1"),
974+
turnId: asTurnId("turn-abort-lifecycle"),
975+
payload: { reason: "Interrupted by user." },
976+
});
977+
978+
const thread = await waitForThread(
979+
harness.readModel,
980+
(entry) =>
981+
entry.session?.status === "ready" &&
982+
entry.session?.activeTurnId === null &&
983+
entry.messages.some(
984+
(message: ProviderRuntimeTestMessage) =>
985+
message.id === "assistant:item-abort-lifecycle" && !message.streaming,
986+
) &&
987+
entry.proposedPlans.some(
988+
(plan: ProviderRuntimeTestProposedPlan) =>
989+
plan.id === "plan:thread-1:turn:turn-abort-lifecycle",
990+
),
991+
);
992+
expect(
993+
thread.messages.find(
994+
(message: ProviderRuntimeTestMessage) => message.id === "assistant:item-abort-lifecycle",
995+
)?.text,
996+
).toBe("partial answer");
997+
expect(
998+
thread.proposedPlans.find(
999+
(plan: ProviderRuntimeTestProposedPlan) =>
1000+
plan.id === "plan:thread-1:turn:turn-abort-lifecycle",
1001+
)?.planMarkdown,
1002+
).toBe("## Partial plan\n\n- keep this");
1003+
});
1004+
1005+
it("ignores stale turn.aborted events", async () => {
1006+
const harness = await createHarness();
1007+
const now = "2026-01-01T00:00:00.000Z";
1008+
1009+
harness.emit({
1010+
type: "turn.started",
1011+
eventId: asEventId("evt-turn-started-abort-guarded"),
1012+
provider: ProviderDriverKind.make("opencode"),
1013+
createdAt: now,
1014+
threadId: asThreadId("thread-1"),
1015+
turnId: asTurnId("turn-abort-guarded-main"),
1016+
});
1017+
1018+
await waitForThread(
1019+
harness.readModel,
1020+
(thread) =>
1021+
thread.session?.status === "running" &&
1022+
thread.session?.activeTurnId === "turn-abort-guarded-main",
1023+
);
1024+
1025+
harness.emit({
1026+
type: "content.delta",
1027+
eventId: asEventId("evt-message-delta-abort-guarded"),
1028+
provider: ProviderDriverKind.make("opencode"),
1029+
createdAt: now,
1030+
threadId: asThreadId("thread-1"),
1031+
turnId: asTurnId("turn-abort-guarded-main"),
1032+
itemId: asItemId("item-abort-guarded-main"),
1033+
payload: { streamKind: "assistant_text", delta: "still running" },
1034+
});
1035+
harness.emit({
1036+
type: "turn.proposed.delta",
1037+
eventId: asEventId("evt-plan-delta-abort-guarded"),
1038+
provider: ProviderDriverKind.make("opencode"),
1039+
createdAt: now,
1040+
threadId: asThreadId("thread-1"),
1041+
turnId: asTurnId("turn-abort-guarded-main"),
1042+
payload: { delta: "## Active plan\n\n- do not finalize" },
1043+
});
1044+
1045+
harness.emit({
1046+
type: "turn.aborted",
1047+
eventId: asEventId("evt-turn-aborted-guarded-stale"),
1048+
provider: ProviderDriverKind.make("opencode"),
1049+
createdAt: now,
1050+
threadId: asThreadId("thread-1"),
1051+
turnId: asTurnId("turn-abort-guarded-stale"),
1052+
payload: { reason: "Interrupted by user." },
1053+
});
1054+
1055+
await harness.drain();
1056+
const readModel = await harness.readModel();
1057+
const thread = readModel.threads.find((entry) => entry.id === ThreadId.make("thread-1"));
1058+
expect(thread?.session?.status).toBe("running");
1059+
expect(thread?.session?.activeTurnId).toBe("turn-abort-guarded-main");
1060+
expect(
1061+
thread?.messages.some(
1062+
(message: ProviderRuntimeTestMessage) => message.id === "assistant:item-abort-guarded-main",
1063+
),
1064+
).toBe(false);
1065+
expect(
1066+
thread?.proposedPlans.some(
1067+
(plan: ProviderRuntimeTestProposedPlan) =>
1068+
plan.id === "plan:thread-1:turn:turn-abort-guarded-main",
1069+
),
1070+
).toBe(false);
1071+
1072+
harness.emit({
1073+
type: "session.exited",
1074+
eventId: asEventId("evt-session-exited-abort-guarded"),
1075+
provider: ProviderDriverKind.make("opencode"),
1076+
createdAt: now,
1077+
threadId: asThreadId("thread-1"),
1078+
payload: { reason: "Provider stopped", exitKind: "graceful" },
1079+
});
1080+
1081+
await waitForThread(
1082+
harness.readModel,
1083+
(entry) => entry.session?.status === "stopped" && entry.session?.activeTurnId === null,
1084+
);
1085+
1086+
// The formerly active turn is no longer authoritative after session exit.
1087+
// A delayed or duplicate abort must not revive the stopped session as ready.
1088+
harness.emit({
1089+
type: "turn.aborted",
1090+
eventId: asEventId("evt-turn-aborted-guarded-late"),
1091+
provider: ProviderDriverKind.make("opencode"),
1092+
createdAt: now,
1093+
threadId: asThreadId("thread-1"),
1094+
turnId: asTurnId("turn-abort-guarded-main"),
1095+
payload: { reason: "Interrupted by user." },
1096+
});
1097+
1098+
await harness.drain();
1099+
const finalReadModel = await harness.readModel();
1100+
const finalThread = finalReadModel.threads.find(
1101+
(entry) => entry.id === ThreadId.make("thread-1"),
1102+
);
1103+
expect(finalThread?.session?.status).toBe("stopped");
1104+
expect(finalThread?.session?.activeTurnId).toBeNull();
1105+
});
1106+
9241107
it("ignores non-active turn completion when runtime omits thread id", async () => {
9251108
const harness = await createHarness();
9261109
const now = "2026-01-01T00:00:00.000Z";

‎apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts‎

Lines changed: 22 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1534,6 +1534,12 @@ const make = Effect.gen(function* () {
15341534
: false;
15351535

15361536
const shouldApplyThreadLifecycle = (() => {
1537+
if (event.type === "turn.aborted") {
1538+
// Delayed or duplicate aborts must not overwrite newer lifecycle state.
1539+
return (
1540+
activeTurnId !== null && eventTurnId !== undefined && sameId(activeTurnId, eventTurnId)
1541+
);
1542+
}
15371543
if (!STRICT_PROVIDER_LIFECYCLE_GUARD) {
15381544
return true;
15391545
}
@@ -1576,7 +1582,8 @@ const make = Effect.gen(function* () {
15761582
event.type === "session.exited" ||
15771583
event.type === "thread.started" ||
15781584
event.type === "turn.started" ||
1579-
event.type === "turn.completed"
1585+
event.type === "turn.completed" ||
1586+
event.type === "turn.aborted"
15801587
) {
15811588
const status = (() => {
15821589
switch (event.type) {
@@ -1592,6 +1599,9 @@ const make = Effect.gen(function* () {
15921599
return normalizeRuntimeTurnState(event.payload.state) === "failed"
15931600
? "error"
15941601
: "ready";
1602+
case "turn.aborted":
1603+
// The provider session remains alive and reusable after an abort.
1604+
return "ready";
15951605
case "session.started":
15961606
case "thread.started":
15971607
// Provider thread/session start notifications can arrive during an
@@ -1602,7 +1612,9 @@ const make = Effect.gen(function* () {
16021612
const nextActiveTurnId =
16031613
event.type === "turn.started"
16041614
? (eventTurnId ?? null)
1605-
: event.type === "turn.completed" || event.type === "session.exited"
1615+
: event.type === "turn.completed" ||
1616+
event.type === "turn.aborted" ||
1617+
event.type === "session.exited"
16061618
? null
16071619
: event.type === "session.state.changed" &&
16081620
!sessionStatusAllowsActiveTurn(
@@ -1843,7 +1855,10 @@ const make = Effect.gen(function* () {
18431855
});
18441856
}
18451857

1846-
if (event.type === "turn.completed") {
1858+
if (
1859+
event.type === "turn.completed" ||
1860+
(event.type === "turn.aborted" && shouldApplyThreadLifecycle)
1861+
) {
18471862
const detailedThread = yield* getLoadedThreadDetail();
18481863
const messages = detailedThread?.messages ?? [];
18491864
const proposedPlans = detailedThread?.proposedPlans ?? [];
@@ -1976,7 +1991,10 @@ const make = Effect.gen(function* () {
19761991
} else if (!conflictsWithActiveTurn) {
19771992
if (event.type === "turn.plan.updated") {
19781993
threadPlanProgress.recordPlanProgress(thread.id, event.payload.plan);
1979-
} else if (event.type === "turn.completed" || event.type === "turn.aborted") {
1994+
} else if (
1995+
event.type === "turn.completed" ||
1996+
(event.type === "turn.aborted" && shouldApplyThreadLifecycle)
1997+
) {
19801998
threadPlanProgress.clearThreadPlanProgress(thread.id);
19811999
}
19822000
}

0 commit comments

Comments
 (0)