Skip to content

Commit 94f92a7

Browse files
authored
fix(server): let Claude abort turns before closing sessions (#13999)
1 parent de251fc commit 94f92a7

2 files changed

Lines changed: 109 additions & 0 deletions

File tree

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

Lines changed: 79 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,8 @@ class FakeClaudeQuery implements AsyncIterable<SDKMessage> {
7373
public readonly setMaxThinkingTokensCalls: Array<number | null> = [];
7474
public closeCalls = 0;
7575
public closeError: unknown | undefined;
76+
/** Set by tests that exercise Claude's graceful interrupt. */
77+
public interrupt?: () => Promise<unknown>;
7678

7779
emit(message: SDKMessage): void {
7880
if (this.done) {
@@ -3255,6 +3257,83 @@ describe("ClaudeAdapterLive", () => {
32553257
);
32563258
});
32573259

3260+
it.effect("interruptTurn lets Claude abort the turn before closing the session", () => {
3261+
const harness = makeHarness();
3262+
return Effect.gen(function* () {
3263+
const adapter = yield* ClaudeAdapter;
3264+
const session = yield* adapter.startSession({
3265+
threadId: THREAD_ID,
3266+
provider: ProviderDriverKind.make("claudeAgent"),
3267+
runtimeMode: "full-access",
3268+
});
3269+
yield* adapter.sendTurn({
3270+
threadId: session.threadId,
3271+
input: "hello",
3272+
attachments: [],
3273+
});
3274+
3275+
const turnCompletedFiber = yield* adapter.streamEvents.pipe(
3276+
Stream.filter((event) => event.type === "turn.completed"),
3277+
Stream.take(1),
3278+
Stream.runCollect,
3279+
Effect.forkChild,
3280+
);
3281+
let closeCallsAtInterrupt: number | undefined;
3282+
harness.query.interrupt = async () => {
3283+
closeCallsAtInterrupt = harness.query.closeCalls;
3284+
harness.query.emit({
3285+
type: "result",
3286+
subtype: "error_during_execution",
3287+
is_error: false,
3288+
errors: ["Error: Request was aborted."],
3289+
session_id: "sdk-session",
3290+
uuid: "result-interrupted",
3291+
} as unknown as SDKMessage);
3292+
};
3293+
3294+
yield* adapter.interruptTurn(session.threadId);
3295+
3296+
assert.equal(closeCallsAtInterrupt, 0);
3297+
assert.equal(harness.query.closeCalls, 1);
3298+
const [turnCompleted] = Array.from(yield* Fiber.join(turnCompletedFiber));
3299+
assert.equal(turnCompleted?.type, "turn.completed");
3300+
if (turnCompleted?.type === "turn.completed") {
3301+
assert.equal(turnCompleted.payload.state, "interrupted");
3302+
}
3303+
}).pipe(
3304+
Effect.provideService(Random.Random, makeDeterministicRandomService()),
3305+
Effect.provide(harness.layer),
3306+
);
3307+
});
3308+
3309+
it.effect("interruptTurn closes the session when Claude never aborts the turn", () => {
3310+
const harness = makeHarness();
3311+
return Effect.gen(function* () {
3312+
const adapter = yield* ClaudeAdapter;
3313+
const session = yield* adapter.startSession({
3314+
threadId: THREAD_ID,
3315+
provider: ProviderDriverKind.make("claudeAgent"),
3316+
runtimeMode: "full-access",
3317+
});
3318+
yield* adapter.sendTurn({
3319+
threadId: session.threadId,
3320+
input: "hello",
3321+
attachments: [],
3322+
});
3323+
harness.query.interrupt = () => new Promise(() => {});
3324+
3325+
const interruptFiber = yield* adapter.interruptTurn(session.threadId).pipe(Effect.forkChild);
3326+
yield* TestClock.adjust("3 seconds");
3327+
yield* Fiber.join(interruptFiber);
3328+
3329+
assert.equal(harness.query.closeCalls, 1);
3330+
assert.equal(yield* adapter.hasSession(session.threadId), false);
3331+
}).pipe(
3332+
Effect.provideService(Random.Random, makeDeterministicRandomService()),
3333+
Effect.provide(harness.layer),
3334+
);
3335+
});
3336+
32583337
it.effect("keeps the session available when process close fails", () => {
32593338
const harness = makeHarness();
32603339
return Effect.gen(function* () {

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

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -385,6 +385,8 @@ interface ClaudeTaskAgentState {
385385
* lifetime; oldest entries evict first.
386386
*/
387387
const PENDING_TASK_MODEL_CAP = 64;
388+
/** How long Stop waits for Claude to abort a turn before killing the process. */
389+
const CLAUDE_INTERRUPT_GRACE = "3 seconds";
388390

389391
/**
390392
* Buffers a subagent snapshot's authoritative model under its
@@ -453,10 +455,14 @@ interface ClaudeSessionContext {
453455
lastThreadStartedId: string | undefined;
454456
/** Limits already announced for the running turn, keyed `window:resetsAt`. */
455457
announcedUsageLimits: { turnId: string; keys: Set<string> } | undefined;
458+
/** Resolved by completeTurn while Stop waits for Claude to abort the turn. */
459+
interruptedTurnSettled: Deferred.Deferred<void> | undefined;
456460
stopped: boolean;
457461
}
458462

459463
interface ClaudeQueryRuntime extends AsyncIterable<SDKMessage> {
464+
/** SDK Query.interrupt — present on real queries; optional for test doubles. */
465+
readonly interrupt?: () => Promise<unknown>;
460466
readonly setModel: (model?: string) => Promise<void>;
461467
readonly setPermissionMode: (mode: PermissionMode) => Promise<void>;
462468
readonly setMaxThinkingTokens: (maxThinkingTokens: number | null) => Promise<void>;
@@ -2836,6 +2842,9 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
28362842

28372843
const updatedAt = yield* nowIso;
28382844
context.turnState = undefined;
2845+
if (context.interruptedTurnSettled) {
2846+
yield* Deferred.succeed(context.interruptedTurnSettled, undefined);
2847+
}
28392848
context.session = {
28402849
...context.session,
28412850
status: "ready",
@@ -5045,6 +5054,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
50455054
lastAssistantUuid: resumeState?.resumeSessionAt,
50465055
lastThreadStartedId: undefined,
50475056
announcedUsageLimits: undefined,
5057+
interruptedTurnSettled: undefined,
50485058
stopped: false,
50495059
};
50505060
yield* Ref.set(contextRef, context);
@@ -5276,13 +5286,33 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
52765286
const interruptTurn: ClaudeAdapterShape["interruptTurn"] = Effect.fn("interruptTurn")(
52775287
function* (threadId, _turnId) {
52785288
const context = yield* requireSession(threadId);
5289+
yield* settleInterruptedTurn(context);
52795290
// interrupt() can acknowledge while resumed background tasks keep the
52805291
// CLI alive. Stop is a hard session boundary for Claude, so close the
52815292
// query and let the SDK escalate to SIGKILL when graceful exit fails.
52825293
yield* stopSessionInternal(context);
52835294
},
52845295
);
52855296

5297+
// Lets Claude abort the running turn through its own path before Stop kills
5298+
// the process, so the prompt reaches the transcript. Killing a first turn
5299+
// before Claude writes it leaves a resume cursor for a session Claude never
5300+
// saved, and every later message fails with "No conversation found".
5301+
const settleInterruptedTurn = Effect.fn("settleInterruptedTurn")(function* (
5302+
context: ClaudeSessionContext,
5303+
) {
5304+
const interrupt = context.query.interrupt?.bind(context.query);
5305+
if (context.stopped || !context.turnState || !interrupt) return;
5306+
const settled = yield* Deferred.make<void>();
5307+
context.interruptedTurnSettled = settled;
5308+
yield* Effect.tryPromise(interrupt).pipe(
5309+
Effect.ignore,
5310+
Effect.andThen(Deferred.await(settled)),
5311+
Effect.timeoutOption(CLAUDE_INTERRUPT_GRACE),
5312+
);
5313+
context.interruptedTurnSettled = undefined;
5314+
});
5315+
52865316
const readThread: ClaudeAdapterShape["readThread"] = Effect.fn("readThread")(
52875317
function* (threadId) {
52885318
const context = yield* requireSession(threadId);

0 commit comments

Comments
 (0)