Skip to content

Commit c9d0bcb

Browse files
committed
fix(server): keep turn interrupts responsive
1 parent bad1143 commit c9d0bcb

6 files changed

Lines changed: 250 additions & 11 deletions

File tree

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

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2486,6 +2486,82 @@ describe("ProviderCommandReactor", () => {
24862486
});
24872487
});
24882488

2489+
it("interrupts an active turn while the general provider worker is blocked", async () => {
2490+
const blockedStart = await Effect.runPromise(Deferred.make<ProviderSession>());
2491+
const harness = await createHarness({
2492+
startSessionEffect: (session) =>
2493+
session.threadId === ThreadId.make("thread-2")
2494+
? Deferred.await(blockedStart)
2495+
: Effect.succeed(session),
2496+
});
2497+
const now = "2026-01-01T00:00:00.000Z";
2498+
2499+
await Effect.runPromise(
2500+
harness.engine.dispatch({
2501+
type: "thread.turn.start",
2502+
commandId: CommandId.make("cmd-running-turn-start"),
2503+
threadId: ThreadId.make("thread-1"),
2504+
message: {
2505+
messageId: asMessageId("running-user-message"),
2506+
role: "user",
2507+
text: "keep working",
2508+
attachments: [],
2509+
},
2510+
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
2511+
createdAt: now,
2512+
}),
2513+
);
2514+
await waitFor(() => harness.sendTurn.mock.calls.length === 1);
2515+
2516+
await Effect.runPromise(
2517+
harness.engine.dispatch({
2518+
type: "thread.create",
2519+
commandId: CommandId.make("cmd-blocked-thread-create"),
2520+
threadId: ThreadId.make("thread-2"),
2521+
projectId: asProjectId("project-1"),
2522+
title: "Blocked thread",
2523+
modelSelection: {
2524+
instanceId: ProviderInstanceId.make("codex"),
2525+
model: "gpt-5-codex",
2526+
},
2527+
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
2528+
runtimeMode: "approval-required",
2529+
branch: null,
2530+
worktreePath: null,
2531+
createdAt: now,
2532+
}),
2533+
);
2534+
await Effect.runPromise(
2535+
harness.engine.dispatch({
2536+
type: "thread.turn.start",
2537+
commandId: CommandId.make("cmd-blocked-turn-start"),
2538+
threadId: ThreadId.make("thread-2"),
2539+
message: {
2540+
messageId: asMessageId("blocked-user-message"),
2541+
role: "user",
2542+
text: "block the general worker",
2543+
attachments: [],
2544+
},
2545+
interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
2546+
createdAt: now,
2547+
}),
2548+
);
2549+
await waitFor(() => harness.startSession.mock.calls.length === 2);
2550+
2551+
await Effect.runPromise(
2552+
harness.engine.dispatch({
2553+
type: "thread.turn.interrupt",
2554+
commandId: CommandId.make("cmd-urgent-turn-interrupt"),
2555+
threadId: ThreadId.make("thread-1"),
2556+
turnId: asTurnId("turn-1"),
2557+
createdAt: now,
2558+
}),
2559+
);
2560+
2561+
await waitFor(() => harness.interruptTurn.mock.calls.length === 1);
2562+
expect(harness.interruptTurn.mock.calls[0]?.[0]).toEqual({ threadId: "thread-1" });
2563+
});
2564+
24892565
it("starts a fresh session when only projected session state exists", async () => {
24902566
const harness = await createHarness();
24912567
const now = "2026-01-01T00:00:00.000Z";

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

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1386,6 +1386,11 @@ const make = Effect.gen(function* () {
13861386
);
13871387

13881388
const worker = yield* makeDrainableWorker(processDomainEventSafely);
1389+
// Interrupts are latency-sensitive and must not wait behind provider
1390+
// lifecycle work on the general worker. A session start/stop or recovery can
1391+
// block on an unhealthy provider indefinitely; serializing Stop behind it
1392+
// leaves the active turn running even though the command was accepted.
1393+
const interruptWorker = yield* makeDrainableWorker(processDomainEventSafely);
13891394

13901395
const start: ProviderCommandReactorShape["start"] = Effect.fn("start")(function* () {
13911396
const interruptedTitleRegenerations = yield* findInterruptedThreadTitleRegenerations().pipe(
@@ -1409,7 +1414,9 @@ const make = Effect.gen(function* () {
14091414
event.type === "thread.user-input-response-requested" ||
14101415
event.type === "thread.session-stop-requested"
14111416
) {
1412-
return yield* worker.enqueue(event);
1417+
return yield* event.type === "thread.turn-interrupt-requested"
1418+
? interruptWorker.enqueue(event)
1419+
: worker.enqueue(event);
14131420
}
14141421
});
14151422

@@ -1445,6 +1452,7 @@ const make = Effect.gen(function* () {
14451452
start,
14461453
drain: Effect.gen(function* () {
14471454
yield* worker.drain;
1455+
yield* interruptWorker.drain;
14481456
yield* threadTitleRegenerationWorker.drain;
14491457
}),
14501458
} satisfies ProviderCommandReactorShape;

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

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -497,6 +497,42 @@ describe("ProviderRuntimeIngestion", () => {
497497
expect(thread.session?.lastError).toBeNull();
498498
});
499499

500+
it("settles the active turn when the provider reports it was aborted", async () => {
501+
const harness = await createHarness();
502+
const now = "2026-01-01T00:00:00.000Z";
503+
const turnId = asTurnId("turn-aborted");
504+
505+
harness.emit({
506+
type: "turn.started",
507+
eventId: asEventId("evt-turn-started-aborted"),
508+
provider: ProviderDriverKind.make("opencode"),
509+
threadId: asThreadId("thread-1"),
510+
turnId,
511+
createdAt: now,
512+
});
513+
514+
await waitForThread(
515+
harness.readModel,
516+
(thread) => thread.session?.status === "running" && thread.session?.activeTurnId === turnId,
517+
);
518+
519+
harness.emit({
520+
type: "turn.aborted",
521+
eventId: asEventId("evt-turn-aborted"),
522+
provider: ProviderDriverKind.make("opencode"),
523+
threadId: asThreadId("thread-1"),
524+
turnId,
525+
createdAt: "2026-01-01T00:00:01.000Z",
526+
payload: { reason: "Interrupted by user." },
527+
});
528+
529+
const thread = await waitForThread(
530+
harness.readModel,
531+
(entry) => entry.session?.status === "ready" && entry.session?.activeTurnId === null,
532+
);
533+
expect(thread.session?.lastError).toBeNull();
534+
});
535+
500536
effectIt.effect(
501537
"keeps a reconnecting pending turn starting while ready clears stale active state",
502538
() =>

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

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1525,6 +1525,7 @@ const make = Effect.gen(function* () {
15251525
case "turn.started":
15261526
return !conflictsWithActiveTurn || conflictingTurnStartIsPendingTurnStart;
15271527
case "turn.completed":
1528+
case "turn.aborted":
15281529
if (conflictsWithActiveTurn || missingTurnForActiveTurn) {
15291530
return false;
15301531
}
@@ -1555,7 +1556,8 @@ const make = Effect.gen(function* () {
15551556
event.type === "session.exited" ||
15561557
event.type === "thread.started" ||
15571558
event.type === "turn.started" ||
1558-
event.type === "turn.completed"
1559+
event.type === "turn.completed" ||
1560+
event.type === "turn.aborted"
15591561
) {
15601562
const status = (() => {
15611563
switch (event.type) {
@@ -1571,6 +1573,8 @@ const make = Effect.gen(function* () {
15711573
return normalizeRuntimeTurnState(event.payload.state) === "failed"
15721574
? "error"
15731575
: "ready";
1576+
case "turn.aborted":
1577+
return "ready";
15741578
case "session.started":
15751579
case "thread.started":
15761580
// Provider thread/session start notifications can arrive during an
@@ -1581,7 +1585,9 @@ const make = Effect.gen(function* () {
15811585
const nextActiveTurnId =
15821586
event.type === "turn.started"
15831587
? (eventTurnId ?? null)
1584-
: event.type === "turn.completed" || event.type === "session.exited"
1588+
: event.type === "turn.completed" ||
1589+
event.type === "turn.aborted" ||
1590+
event.type === "session.exited"
15851591
? null
15861592
: event.type === "session.state.changed" &&
15871593
!sessionStatusAllowsActiveTurn(
@@ -1822,7 +1828,7 @@ const make = Effect.gen(function* () {
18221828
});
18231829
}
18241830

1825-
if (event.type === "turn.completed") {
1831+
if (event.type === "turn.completed" || event.type === "turn.aborted") {
18261832
const detailedThread = yield* getLoadedThreadDetail();
18271833
const messages = detailedThread?.messages ?? [];
18281834
const proposedPlans = detailedThread?.proposedPlans ?? [];

‎apps/server/src/provider/Layers/OpenCodeAdapter.test.ts‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -65,6 +65,7 @@ const runtimeMock = {
6565
revertCalls: [] as Array<{ sessionID: string; messageID?: string }>,
6666
promptCalls: [] as Array<unknown>,
6767
promptAsyncError: null as Error | null,
68+
abortError: null as Error | null,
6869
closeError: null as Error | null,
6970
messages: [] as MessageEntry[],
7071
subscribedEvents: [] as unknown[],
@@ -85,6 +86,7 @@ const runtimeMock = {
8586
this.state.revertCalls.length = 0;
8687
this.state.promptCalls.length = 0;
8788
this.state.promptAsyncError = null;
89+
this.state.abortError = null;
8890
this.state.closeError = null;
8991
this.state.messages = [];
9092
this.state.subscribedEvents = [];
@@ -176,6 +178,9 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = {
176178
},
177179
abort: async ({ sessionID }: { sessionID: string }) => {
178180
runtimeMock.state.abortCalls.push(sessionID);
181+
if (runtimeMock.state.abortError) {
182+
throw runtimeMock.state.abortError;
183+
}
179184
},
180185
promptAsync: async (input: unknown) => {
181186
runtimeMock.state.promptCalls.push(input);
@@ -809,6 +814,64 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
809814
}),
810815
);
811816

817+
it.effect("settles an interrupt before a remote abort failure can block it", () =>
818+
Effect.gen(function* () {
819+
const adapter = yield* OpenCodeAdapter;
820+
const threadId = asThreadId("thread-interrupt-failure");
821+
yield* adapter.startSession({
822+
provider: ProviderDriverKind.make("opencode"),
823+
threadId,
824+
runtimeMode: "full-access",
825+
});
826+
827+
const turn = yield* adapter.sendTurn({
828+
threadId,
829+
input: "stop this turn",
830+
modelSelection: {
831+
instanceId: ProviderInstanceId.make("opencode"),
832+
model: "openai/gpt-5",
833+
},
834+
});
835+
836+
runtimeMock.state.abortError = new Error("abort request failed");
837+
yield* adapter.interruptTurn(threadId, turn.turnId);
838+
839+
const session = (yield* adapter.listSessions()).find((entry) => entry.threadId === threadId);
840+
NodeAssert.equal(session?.status, "ready");
841+
NodeAssert.equal(session?.activeTurnId, undefined);
842+
}),
843+
);
844+
845+
it.effect("keeps an interrupted OpenCode session ready after its abort event", () =>
846+
Effect.gen(function* () {
847+
const adapter = yield* OpenCodeAdapter;
848+
const threadId = asThreadId("thread-interrupt-abort-event");
849+
runtimeMock.state.subscribedEvents = [
850+
{
851+
type: "session.error",
852+
properties: {
853+
sessionID: "http://127.0.0.1:9999/session",
854+
error: {
855+
name: "MessageAbortedError",
856+
data: { message: "Aborted" },
857+
},
858+
},
859+
},
860+
];
861+
862+
yield* adapter.startSession({
863+
provider: ProviderDriverKind.make("opencode"),
864+
threadId,
865+
runtimeMode: "full-access",
866+
});
867+
yield* advanceTestClock(10);
868+
869+
const session = (yield* adapter.listSessions()).find((entry) => entry.threadId === threadId);
870+
NodeAssert.equal(session?.status, "ready");
871+
NodeAssert.equal(session?.lastError, undefined);
872+
}),
873+
);
874+
812875
it.effect("passes agent and variant options for the adapter's bound custom instance id", () => {
813876
const instanceId = ProviderInstanceId.make("opencode_zen");
814877
const adapterLayer = Layer.effect(

‎apps/server/src/provider/Layers/OpenCodeAdapter.ts‎

Lines changed: 57 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -511,6 +511,12 @@ function sessionErrorMessage(error: unknown): string {
511511
: "OpenCode session failed.";
512512
}
513513

514+
function isSessionAbortError(error: unknown): boolean {
515+
return Boolean(
516+
error && typeof error === "object" && "name" in error && error.name === "MessageAbortedError",
517+
);
518+
}
519+
514520
function updateProviderSession(
515521
context: OpenCodeSessionContext,
516522
patch: Partial<ProviderSession>,
@@ -1075,9 +1081,35 @@ export function makeOpenCodeAdapter(
10751081
}
10761082

10771083
case "session.error": {
1078-
const message = sessionErrorMessage(event.properties.error);
1084+
const error = event.properties.error;
10791085
const activeTurnId = context.activeTurnId;
10801086
context.activeTurnId = undefined;
1087+
context.activeAgent = undefined;
1088+
context.activeVariant = undefined;
1089+
1090+
if (isSessionAbortError(error)) {
1091+
yield* updateProviderSession(
1092+
context,
1093+
{ status: "ready" },
1094+
{ clearActiveTurnId: true, clearLastError: true },
1095+
);
1096+
if (activeTurnId) {
1097+
yield* emit({
1098+
...(yield* buildEventBase({
1099+
threadId: context.session.threadId,
1100+
turnId: activeTurnId,
1101+
raw: event,
1102+
})),
1103+
type: "turn.aborted",
1104+
payload: {
1105+
reason: "Interrupted by user.",
1106+
},
1107+
});
1108+
}
1109+
break;
1110+
}
1111+
1112+
const message = sessionErrorMessage(error);
10811113
yield* updateProviderSession(
10821114
context,
10831115
{
@@ -1109,7 +1141,7 @@ export function makeOpenCodeAdapter(
11091141
payload: {
11101142
message,
11111143
class: "provider_error",
1112-
detail: event.properties.error,
1144+
detail: error,
11131145
},
11141146
});
11151147
break;
@@ -1540,21 +1572,39 @@ export function makeOpenCodeAdapter(
15401572
const interruptTurn: OpenCodeAdapterShape["interruptTurn"] = Effect.fn("interruptTurn")(
15411573
function* (threadId, turnId) {
15421574
const context = yield* ensureSessionContext(sessions, threadId);
1543-
yield* runOpenCodeSdk("session.abort", () =>
1544-
context.client.session.abort({ sessionID: context.openCodeSessionId }),
1545-
).pipe(Effect.mapError(toRequestError));
1546-
if (turnId ?? context.activeTurnId) {
1575+
const targetTurnId = turnId ?? context.activeTurnId;
1576+
if (targetTurnId) {
15471577
yield* emit({
15481578
...(yield* buildEventBase({
15491579
threadId,
1550-
turnId: turnId ?? context.activeTurnId,
1580+
turnId: targetTurnId,
15511581
})),
15521582
type: "turn.aborted",
15531583
payload: {
15541584
reason: "Interrupted by user.",
15551585
},
15561586
});
15571587
}
1588+
// Publish the local lifecycle transition before waiting on the remote
1589+
// abort. OpenCode can sit in a provider retry (for example after a
1590+
// monthly usage limit) long enough for session.abort to hang, but the
1591+
// user must still be able to stop the turn immediately.
1592+
context.activeTurnId = undefined;
1593+
context.activeAgent = undefined;
1594+
context.activeVariant = undefined;
1595+
yield* updateProviderSession(context, { status: "ready" }, { clearActiveTurnId: true });
1596+
1597+
// Best effort: the lifecycle event above is the authoritative UI
1598+
// transition, while this request stops the provider's in-flight work
1599+
// when the OpenCode server is responsive. Run it in the session scope
1600+
// so a later session stop also cancels a hung abort request.
1601+
yield* runOpenCodeSdk("session.abort", () =>
1602+
context.client.session.abort({ sessionID: context.openCodeSessionId }),
1603+
).pipe(
1604+
Effect.mapError(toRequestError),
1605+
Effect.ignore({ log: true }),
1606+
Effect.forkIn(context.sessionScope),
1607+
);
15581608
},
15591609
);
15601610

0 commit comments

Comments
 (0)