Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

make ctrl+c cancel active turns deterministically (#346)

kt5fa8ad44b446
diff --git a/packages/agent/CHANGELOG.md b/packages/agent/CHANGELOG.md
index b20612354c..6de769691b 100644
--- a/packages/agent/CHANGELOG.md
+++ b/packages/agent/CHANGELOG.md
@@ -2,6 +2,8 @@
## [Unreleased]
+- Fixed abort settling for provider streams and tool executions that ignore cancellation ([ENG-4490](https://linear.app/primeintellect/issue/ENG-4490)).
+
## [0.2.7] - 2026-07-08
- Fixed run-lifecycle failures carrying no diagnostics, so hosts can distinguish local failures from provider failures.
diff --git a/packages/agent/src/agent-loop.ts b/packages/agent/src/agent-loop.ts
index 30f9ef461b..c9d3ea70a0 100644
--- a/packages/agent/src/agent-loop.ts
+++ b/packages/agent/src/agent-loop.ts
@@ -5,6 +5,7 @@
import {
type AssistantMessage,
+ type AssistantMessageEvent,
type Context,
EventStream,
streamSimple,
@@ -24,6 +25,155 @@ import type {
export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
+const ABORT_ERROR_MESSAGE = "Request was aborted";
+const EMPTY_USAGE: AssistantMessage["usage"] = {
+ input: 0,
+ output: 0,
+ cacheRead: 0,
+ cacheWrite: 0,
+ totalTokens: 0,
+ cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+function createAbortError(): Error {
+ return new Error(ABORT_ERROR_MESSAGE);
+}
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+ if (signal?.aborted) {
+ throw createAbortError();
+ }
+}
+
+function raceWithAbort<T>(operation: Promise<T>, signal: AbortSignal | undefined, onAbort?: () => void): Promise<T> {
+ if (!signal) {
+ return operation;
+ }
+ if (signal.aborted) {
+ onAbort?.();
+ void operation.catch(() => undefined);
+ return Promise.reject(createAbortError());
+ }
+
+ return new Promise<T>((resolve, reject) => {
+ let settled = false;
+ const cleanup = () => {
+ signal.removeEventListener("abort", abort);
+ };
+ const abort = () => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ onAbort?.();
+ reject(createAbortError());
+ };
+ signal.addEventListener("abort", abort, { once: true });
+ operation.then(
+ (value) => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ resolve(value);
+ },
+ (error: unknown) => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ reject(error);
+ },
+ );
+ });
+}
+
+function maybePromiseWithAbort<T>(
+ operation: T | Promise<T>,
+ signal: AbortSignal | undefined,
+ onAbort?: () => void,
+): Promise<T> {
+ return raceWithAbort(Promise.resolve(operation), signal, onAbort);
+}
+
+function isAbortError(error: unknown): boolean {
+ return error instanceof Error && (error.message === ABORT_ERROR_MESSAGE || error.name === "AbortError");
+}
+
+type PostTurnResult<T> = { status: "completed"; value: T } | { status: "aborted" };
+
+async function settlePostTurn<T>(operation: Promise<T>, signal: AbortSignal | undefined): Promise<PostTurnResult<T>> {
+ try {
+ return { status: "completed", value: await operation };
+ } catch (error) {
+ if (signal?.aborted && isAbortError(error)) {
+ return { status: "aborted" };
+ }
+ throw error;
+ }
+}
+
+function cloneAssistantContent(content: AssistantMessage["content"]): AssistantMessage["content"] {
+ return content.map((part) => {
+ if (part.type === "toolCall") {
+ return { ...part, arguments: { ...part.arguments } };
+ }
+ return { ...part };
+ });
+}
+
+function cloneUsage(usage: AssistantMessage["usage"]): AssistantMessage["usage"] {
+ return { ...usage, cost: { ...usage.cost } };
+}
+
+function createAbortedAssistantMessage(
+ config: AgentLoopConfig,
+ partialMessage: AssistantMessage | null,
+): AssistantMessage {
+ return {
+ role: "assistant",
+ content: partialMessage ? cloneAssistantContent(partialMessage.content) : [{ type: "text", text: "" }],
+ api: partialMessage?.api ?? config.model.api,
+ provider: partialMessage?.provider ?? config.model.provider,
+ model: partialMessage?.model ?? config.model.id,
+ usage: cloneUsage(partialMessage?.usage ?? EMPTY_USAGE),
+ stopReason: "aborted",
+ errorMessage: ABORT_ERROR_MESSAGE,
+ timestamp: Date.now(),
+ };
+}
+
+function getTerminalMessage(event: Extract<AssistantMessageEvent, { type: "done" | "error" }>): AssistantMessage {
+ return event.type === "done" ? event.message : event.error;
+}
+
+function endAgentStreamOnError(
+ stream: EventStream<AgentEvent, AgentMessage[]>,
+ promise: Promise<AgentMessage[]>,
+): void {
+ void promise.then(
+ (messages) => {
+ stream.end(messages);
+ },
+ () => {
+ stream.end([]);
+ },
+ );
+}
+
+async function pollMessagesUnlessAborted(
+ poll: (() => AgentMessage[] | Promise<AgentMessage[]>) | undefined,
+ signal: AbortSignal | undefined,
+): Promise<AgentMessage[]> {
+ if (!poll || signal?.aborted) {
+ return [];
+ }
+ return (await maybePromiseWithAbort(poll(), signal)) || [];
+}
+
/**
* Start an agent loop with a new prompt message.
* The prompt is added to the context and events are emitted for it.
@@ -37,18 +187,19 @@ export function agentLoop(
): EventStream<AgentEvent, AgentMessage[]> {
const stream = createAgentStream();
- void runAgentLoop(
- prompts,
- context,
- config,
- async (event) => {
- stream.push(event);
- },
- signal,
- streamFn,
- ).then((messages) => {
- stream.end(messages);
- });
+ endAgentStreamOnError(
+ stream,
+ runAgentLoop(
+ prompts,
+ context,
+ config,
+ async (event) => {
+ stream.push(event);
+ },
+ signal,
+ streamFn,
+ ),
+ );
return stream;
}
@@ -77,17 +228,18 @@ export function agentLoopContinue(
const stream = createAgentStream();
- void runAgentLoopContinue(
- context,
- config,
- async (event) => {
- stream.push(event);
- },
- signal,
- streamFn,
- ).then((messages) => {
- stream.end(messages);
- });
+ endAgentStreamOnError(
+ stream,
+ runAgentLoopContinue(
+ context,
+ config,
+ async (event) => {
+ stream.push(event);
+ },
+ signal,
+ streamFn,
+ ),
+ );
return stream;
}
@@ -163,14 +315,16 @@ async function runLoop(
let firstTurn = true;
let lastTurn: Parameters<NonNullable<AgentLoopConfig["getContinuationMessages"]>>[0] | undefined;
// Check for steering messages at start (user may have typed while waiting)
- let pendingMessages: AgentMessage[] = (await config.getSteeringMessages?.()) || [];
+ let pendingMessages: AgentMessage[] = await pollMessagesUnlessAborted(config.getSteeringMessages, signal);
// Outer loop: continues when queued follow-up messages arrive after agent would stop
while (true) {
+ throwIfAborted(signal);
let hasMoreToolCalls = true;
// Inner loop: process tool calls and steering messages
while (hasMoreToolCalls || pendingMessages.length > 0) {
+ throwIfAborted(signal);
if (!firstTurn) {
await emit({ type: "turn_start" });
} else {
@@ -215,6 +369,10 @@ async function runLoop(
}
await emit({ type: "turn_end", message, toolResults });
+ if (signal?.aborted) {
+ await emit({ type: "agent_end", messages: newMessages });
+ return;
+ }
lastTurn = {
message,
toolResults,
@@ -222,30 +380,65 @@ async function runLoop(
newMessages,
};
- if (
- await config.shouldStopAfterTurn?.({
- message,
- toolResults,
- context: currentContext,
- newMessages,
- })
- ) {
+ const shouldStopResult = await settlePostTurn(
+ maybePromiseWithAbort(
+ config.shouldStopAfterTurn?.({
+ message,
+ toolResults,
+ context: currentContext,
+ newMessages,
+ }) ?? false,
+ signal,
+ ),
+ signal,
+ );
+ if (shouldStopResult.status === "aborted") {
+ await emit({ type: "agent_end", messages: newMessages });
+ return;
+ }
+ if (shouldStopResult.value) {
await emit({ type: "agent_end", messages: newMessages });
return;
}
- pendingMessages = (await config.getSteeringMessages?.()) || [];
+ const steeringMessagesResult = await settlePostTurn(
+ pollMessagesUnlessAborted(config.getSteeringMessages, signal),
+ signal,
+ );
+ if (steeringMessagesResult.status === "aborted") {
+ await emit({ type: "agent_end", messages: newMessages });
+ return;
+ }
+ pendingMessages = steeringMessagesResult.value;
}
// Agent would stop here. Check for follow-up messages.
- const followUpMessages = (await config.getFollowUpMessages?.()) || [];
+ const followUpMessagesResult = await settlePostTurn(
+ pollMessagesUnlessAborted(config.getFollowUpMessages, signal),
+ signal,
+ );
+ if (followUpMessagesResult.status === "aborted") {
+ await emit({ type: "agent_end", messages: newMessages });
+ return;
+ }
+ const followUpMessages = followUpMessagesResult.value;
if (followUpMessages.length > 0) {
// Set as pending so inner loop processes them
pendingMessages = followUpMessages;
continue;
}
- const continuationMessages = lastTurn ? (await config.getContinuationMessages?.(lastTurn, signal)) || [] : [];
+ const continuationMessagesResult = lastTurn
+ ? await settlePostTurn(
+ maybePromiseWithAbort(config.getContinuationMessages?.(lastTurn, signal) ?? [], signal),
+ signal,
+ )
+ : ({ status: "completed", value: [] } satisfies PostTurnResult<AgentMessage[]>);
+ if (continuationMessagesResult.status === "aborted") {
+ await emit({ type: "agent_end", messages: newMessages });
+ return;
+ }
+ const continuationMessages = continuationMessagesResult.value || [];
if (continuationMessages.length > 0) {
pendingMessages = continuationMessages;
continue;
@@ -269,92 +462,135 @@ async function streamAssistantResponse(
emit: AgentEventSink,
streamFn?: StreamFn,
): Promise<AssistantMessage> {
- // Apply context transform if configured (AgentMessage[] → AgentMessage[])
- let messages = context.messages;
- if (config.transformContext) {
- messages = await config.transformContext(messages, signal);
- }
-
- // Convert to LLM-compatible messages (AgentMessage[] → Message[])
- const llmMessages = await config.convertToLlm(messages);
-
- // Build LLM context
- const llmContext: Context = {
- systemPrompt: context.systemPrompt,
- messages: llmMessages,
- tools: context.tools,
+ let partialMessage: AssistantMessage | null = null;
+ let addedPartial = false;
+ const finishAbortedMessage = async () => {
+ const finalMessage = createAbortedAssistantMessage(config, partialMessage);
+ if (addedPartial) {
+ context.messages[context.messages.length - 1] = finalMessage;
+ } else {
+ context.messages.push(finalMessage);
+ await emit({ type: "message_start", message: { ...finalMessage } });
+ }
+ await emit({ type: "message_end", message: finalMessage });
+ return finalMessage;
};
- const streamFunction = streamFn || streamSimple;
+ try {
+ throwIfAborted(signal);
+ // Apply context transform if configured (AgentMessage[] → AgentMessage[])
+ let messages = context.messages;
+ if (config.transformContext) {
+ messages = await maybePromiseWithAbort(config.transformContext(messages, signal), signal);
+ }
- // Resolve API key (important for expiring tokens)
- const resolvedApiKey =
- (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
+ // Convert to LLM-compatible messages (AgentMessage[] → Message[])
+ const llmMessages = await maybePromiseWithAbort(config.convertToLlm(messages), signal);
- const response = await streamFunction(config.model, llmContext, {
- ...config,
- apiKey: resolvedApiKey,
- signal,
- });
+ // Build LLM context
+ const llmContext: Context = {
+ systemPrompt: context.systemPrompt,
+ messages: llmMessages,
+ tools: context.tools,
+ };
- let partialMessage: AssistantMessage | null = null;
- let addedPartial = false;
+ const streamFunction = streamFn || streamSimple;
- for await (const event of response) {
- switch (event.type) {
- case "start":
- partialMessage = event.partial;
- context.messages.push(partialMessage);
- addedPartial = true;
- await emit({ type: "message_start", message: { ...partialMessage } });
- break;
+ // Resolve API key (important for expiring tokens)
+ const resolvedApiKey =
+ (config.getApiKey
+ ? await maybePromiseWithAbort(config.getApiKey(config.model.provider), signal)
+ : undefined) || config.apiKey;
- case "text_start":
- case "text_delta":
- case "text_end":
- case "thinking_start":
- case "thinking_delta":
- case "thinking_end":
- case "toolcall_start":
- case "toolcall_delta":
- case "toolcall_end":
- if (partialMessage) {
- partialMessage = event.partial;
- context.messages[context.messages.length - 1] = partialMessage;
- await emit({
- type: "message_update",
- assistantMessageEvent: event,
- message: { ...partialMessage },
- });
- }
+ const response = await maybePromiseWithAbort(
+ streamFunction(config.model, llmContext, {
+ ...config,
+ apiKey: resolvedApiKey,
+ signal,
+ }),
+ signal,
+ );
+ const iterator = response[Symbol.asyncIterator]();
+ const closeIterator = () => {
+ void Promise.resolve(iterator.return?.()).catch(() => undefined);
+ };
+ while (true) {
+ const next = await raceWithAbort<IteratorResult<AssistantMessageEvent>>(
+ iterator.next(),
+ signal,
+ closeIterator,
+ );
+ if (next.done) {
break;
-
- case "done":
- case "error": {
- const finalMessage = await response.result();
- if (addedPartial) {
- context.messages[context.messages.length - 1] = finalMessage;
- } else {
- context.messages.push(finalMessage);
- }
- if (!addedPartial) {
- await emit({ type: "message_start", message: { ...finalMessage } });
+ }
+ const event = next.value;
+ switch (event.type) {
+ case "start":
+ partialMessage = event.partial;
+ context.messages.push(partialMessage);
+ addedPartial = true;
+ await emit({ type: "message_start", message: { ...partialMessage } });
+ break;
+
+ case "text_start":
+ case "text_delta":
+ case "text_end":
+ case "thinking_start":
+ case "thinking_delta":
+ case "thinking_end":
+ case "toolcall_start":
+ case "toolcall_delta":
+ case "toolcall_end":
+ if (partialMessage) {
+ partialMessage = event.partial;
+ context.messages[context.messages.length - 1] = partialMessage;
+ await emit({
+ type: "message_update",
+ assistantMessageEvent: event,
+ message: { ...partialMessage },
+ });
+ }
+ break;
+
+ case "done":
+ case "error": {
+ let finalMessage = getTerminalMessage(event);
+ try {
+ finalMessage = await maybePromiseWithAbort(response.result(), signal);
+ } catch (error) {
+ if (!signal?.aborted || !isAbortError(error)) {
+ throw error;
+ }
+ }
+ if (addedPartial) {
+ context.messages[context.messages.length - 1] = finalMessage;
+ } else {
+ context.messages.push(finalMessage);
+ }
+ if (!addedPartial) {
+ await emit({ type: "message_start", message: { ...finalMessage } });
+ }
+ await emit({ type: "message_end", message: finalMessage });
+ return finalMessage;
}
- await emit({ type: "message_end", message: finalMessage });
- return finalMessage;
}
}
- }
- const finalMessage = await response.result();
- if (addedPartial) {
- context.messages[context.messages.length - 1] = finalMessage;
- } else {
- context.messages.push(finalMessage);
- await emit({ type: "message_start", message: { ...finalMessage } });
+ const finalMessage = await maybePromiseWithAbort(response.result(), signal);
+ if (addedPartial) {
+ context.messages[context.messages.length - 1] = finalMessage;
+ } else {
+ context.messages.push(finalMessage);
+ await emit({ type: "message_start", message: { ...finalMessage } });
+ }
+ await emit({ type: "message_end", message: finalMessage });
+ return finalMessage;
+ } catch (error) {
+ if (signal?.aborted && isAbortError(error)) {
+ return finishAbortedMessage();
+ }
+ throw error;
}
- await emit({ type: "message_end", message: finalMessage });
- return finalMessage;
}
/**
@@ -394,6 +630,10 @@ async function executeToolCallsSequential(
const messages: ToolResultMessage[] = [];
for (const toolCall of toolCalls) {
+ if (signal?.aborted) {
+ break;
+ }
+
await emit({
type: "tool_execution_start",
toolCallId: toolCall.id,
@@ -426,6 +666,10 @@ async function executeToolCallsSequential(
await emitToolResultMessage(toolResultMessage, emit);
finalizedCalls.push(finalized);
messages.push(toolResultMessage);
+
+ if (signal?.aborted) {
+ break;
+ }
}
return {
@@ -559,13 +803,16 @@ async function prepareToolCall(
const preparedToolCall = prepareToolCallArguments(tool, toolCall);
const validatedArgs = validateToolArguments(tool, preparedToolCall);
if (config.beforeToolCall) {
- const beforeResult = await config.beforeToolCall(
- {
- assistantMessage,
- toolCall,
- args: validatedArgs,
- context: currentContext,
- },
+ const beforeResult = await maybePromiseWithAbort(
+ config.beforeToolCall(
+ {
+ assistantMessage,
+ toolCall,
+ args: validatedArgs,
+ context: currentContext,
+ },
+ signal,
+ ),
signal,
);
if (beforeResult?.block) {
@@ -597,13 +844,15 @@ async function executePreparedToolCall(
emit: AgentEventSink,
): Promise<ExecutedToolCallOutcome> {
const updateEvents: Promise<void>[] = [];
+ let acceptingUpdates = true;
try {
- const result = await prepared.tool.execute(
- prepared.toolCall.id,
- prepared.args as never,
- signal,
- (partialResult) => {
+ throwIfAborted(signal);
+ const result = await raceWithAbort(
+ prepared.tool.execute(prepared.toolCall.id, prepared.args as never, signal, (partialResult) => {
+ if (!acceptingUpdates || signal?.aborted) {
+ return;
+ }
updateEvents.push(
Promise.resolve(
emit({
@@ -615,14 +864,31 @@ async function executePreparedToolCall(
}),
),
);
- },
+ }),
+ signal,
);
- await Promise.all(updateEvents);
+ acceptingUpdates = false;
+ try {
+ await raceWithAbort(
+ Promise.all(updateEvents).then(() => undefined),
+ signal,
+ );
+ } catch (error) {
+ if (!signal?.aborted || !isAbortError(error)) {
+ throw error;
+ }
+ }
return { result, isError: false };
} catch (error) {
- await Promise.all(updateEvents);
+ acceptingUpdates = false;
+ await raceWithAbort(
+ Promise.all(updateEvents).then(() => undefined),
+ signal,
+ ).catch(() => undefined);
return {
- result: createErrorToolResult(error instanceof Error ? error.message : String(error)),
+ result: createErrorToolResult(
+ signal?.aborted ? "Tool execution aborted" : error instanceof Error ? error.message : String(error),
+ ),
isError: true,
};
}
@@ -641,15 +907,18 @@ async function finalizeExecutedToolCall(
if (config.afterToolCall) {
try {
- const afterResult = await config.afterToolCall(
- {
- assistantMessage,
- toolCall: prepared.toolCall,
- args: prepared.args,
- result,
- isError,
- context: currentContext,
- },
+ const afterResult = await maybePromiseWithAbort(
+ config.afterToolCall(
+ {
+ assistantMessage,
+ toolCall: prepared.toolCall,
+ args: prepared.args,
+ result,
+ isError,
+ context: currentContext,
+ },
+ signal,
+ ),
signal,
);
if (afterResult) {
diff --git a/packages/agent/src/agent.ts b/packages/agent/src/agent.ts
index dbf6636a0e..67ccfcdc13 100644
--- a/packages/agent/src/agent.ts
+++ b/packages/agent/src/agent.ts
@@ -531,8 +531,9 @@ export class Agent {
: [createAssistantMessageDiagnostic("agent_lifecycle_failure", error, { source: "run_with_lifecycle" })],
timestamp: Date.now(),
} satisfies AgentMessage;
- this._state.messages.push(failureMessage);
this._state.errorMessage = failureMessage.errorMessage;
+ await this.processEvents({ type: "message_start", message: failureMessage }).catch(() => undefined);
+ await this.processEvents({ type: "message_end", message: failureMessage }).catch(() => undefined);
await this.processEvents({ type: "agent_end", messages: [failureMessage] });
}
diff --git a/packages/agent/test/agent-loop.test.ts b/packages/agent/test/agent-loop.test.ts
index 785a9b366b..7121159f16 100644
--- a/packages/agent/test/agent-loop.test.ts
+++ b/packages/agent/test/agent-loop.test.ts
@@ -7,8 +7,8 @@ import {
type UserMessage,
} from "@earendil-works/pi-ai";
import { Type } from "typebox";
-import { describe, expect, it } from "vitest";
-import { agentLoop, agentLoopContinue } from "../src/agent-loop.js";
+import { describe, expect, it, vi } from "vitest";
+import { agentLoop, agentLoopContinue, runAgentLoop } from "../src/agent-loop.js";
import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, AgentTool } from "../src/types.js";
// Mock stream for testing - mimics MockAssistantStream
@@ -25,6 +25,36 @@ class MockAssistantStream extends EventStream<AssistantMessageEvent, AssistantMe
}
}
+class DelayedResultStream extends MockAssistantStream {
+ constructor(private readonly getDelayedResult: () => Promise<AssistantMessage>) {
+ super();
+ }
+
+ override result(): Promise<AssistantMessage> {
+ return this.getDelayedResult();
+ }
+}
+
+class ThrowingResultStream extends MockAssistantStream {
+ constructor(
+ private readonly onResult: () => void,
+ private readonly error: Error,
+ ) {
+ super();
+ }
+
+ override [Symbol.asyncIterator](): AsyncIterator<AssistantMessageEvent> {
+ return {
+ next: async () => ({ done: true, value: undefined as never }),
+ };
+ }
+
+ override result(): Promise<AssistantMessage> {
+ this.onResult();
+ throw this.error;
+ }
+}
+
function createUsage() {
return {
input: 0,
@@ -128,6 +158,436 @@ describe("agentLoop with AgentMessage", () => {
expect(eventTypes).toContain("agent_end");
});
+ it("should preserve a terminal response when abort fires after done", async () => {
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [],
+ };
+ const controller = new AbortController();
+ const finalMessage = createAssistantMessage([{ type: "text", text: "complete" }]);
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: identityConverter,
+ };
+ const streamFn = () => {
+ const stream = new DelayedResultStream(() => {
+ controller.abort();
+ return Promise.resolve(finalMessage);
+ });
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "stop", message: finalMessage });
+ });
+ return stream;
+ };
+
+ const stream = agentLoop([createUserMessage("Hello")], context, config, controller.signal, streamFn);
+ for await (const _event of stream) {
+ // consume
+ }
+
+ const messages = await stream.result();
+ const assistant = messages.find((message) => message.role === "assistant");
+ expect(assistant?.role).toBe("assistant");
+ if (assistant?.role === "assistant") {
+ expect(assistant.stopReason).toBe("stop");
+ expect(assistant.content).toEqual([{ type: "text", text: "complete" }]);
+ }
+ });
+
+ it("should not wait for a pending terminal result after abort", async () => {
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [],
+ };
+ const controller = new AbortController();
+ const finalMessage = createAssistantMessage([{ type: "text", text: "complete" }]);
+ let resolveResult: ((message: AssistantMessage) => void) | undefined;
+ const pendingResult = new Promise<AssistantMessage>((resolve) => {
+ resolveResult = resolve;
+ });
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: identityConverter,
+ };
+ const streamFn = () => {
+ const stream = new DelayedResultStream(() => {
+ controller.abort();
+ return pendingResult;
+ });
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "stop", message: finalMessage });
+ });
+ return stream;
+ };
+
+ const stream = agentLoop([createUserMessage("Hello")], context, config, controller.signal, streamFn);
+ const events: AgentEvent[] = [];
+ const consume = (async () => {
+ for await (const event of stream) {
+ events.push(event);
+ }
+ return stream.result();
+ })();
+ const result = await Promise.race([
+ consume,
+ new Promise<"timeout">((resolve) => {
+ setTimeout(() => resolve("timeout"), 50);
+ }),
+ ]);
+ if (result === "timeout") {
+ resolveResult?.(finalMessage);
+ await consume;
+ throw new Error("agent loop waited for a pending terminal result after abort");
+ }
+
+ const assistant = result.find((message) => message.role === "assistant");
+ expect(assistant?.role).toBe("assistant");
+ if (assistant?.role === "assistant") {
+ expect(assistant.stopReason).toBe("stop");
+ expect(assistant.content).toEqual([{ type: "text", text: "complete" }]);
+ }
+ expect(events.some((event) => event.type === "agent_end")).toBe(true);
+ });
+
+ it("should not mask stream result errors when abort is already signaled", async () => {
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [],
+ };
+ const controller = new AbortController();
+ const providerError = new Error("provider parse failed");
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: identityConverter,
+ };
+ const events: AgentEvent[] = [];
+
+ await expect(
+ runAgentLoop(
+ [createUserMessage("Hello")],
+ context,
+ config,
+ (event) => {
+ events.push(event);
+ },
+ controller.signal,
+ () =>
+ new ThrowingResultStream(() => {
+ controller.abort();
+ }, providerError),
+ ),
+ ).rejects.toThrow("provider parse failed");
+ expect(
+ events.some(
+ (event) =>
+ event.type === "message_end" &&
+ event.message.role === "assistant" &&
+ event.message.stopReason === "aborted",
+ ),
+ ).toBe(false);
+ });
+
+ it("should return an aborted assistant when abort fires before the stream starts", async () => {
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [],
+ };
+ const controller = new AbortController();
+ const streamFn = vi.fn(() => new MockAssistantStream());
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: (messages) => {
+ controller.abort();
+ return identityConverter(messages);
+ },
+ };
+
+ const stream = agentLoop([createUserMessage("Hello")], context, config, controller.signal, streamFn);
+ for await (const _event of stream) {
+ // consume
+ }
+
+ const messages = await stream.result();
+ const assistant = messages.find((message) => message.role === "assistant");
+ expect(streamFn).not.toHaveBeenCalled();
+ expect(assistant?.role).toBe("assistant");
+ if (assistant?.role === "assistant") {
+ expect(assistant.stopReason).toBe("aborted");
+ expect(assistant.errorMessage).toBe("Request was aborted");
+ }
+ });
+
+ it("should end without adding an aborted assistant when abort fires after turn completion", async () => {
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [],
+ };
+ const controller = new AbortController();
+ const finalMessage = createAssistantMessage([{ type: "text", text: "complete" }]);
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: identityConverter,
+ shouldStopAfterTurn: async () => {
+ controller.abort();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ return false;
+ },
+ };
+ const streamFn = () => {
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "stop", message: finalMessage });
+ });
+ return stream;
+ };
+
+ const events: AgentEvent[] = [];
+ const stream = agentLoop([createUserMessage("Hello")], context, config, controller.signal, streamFn);
+ for await (const event of stream) {
+ events.push(event);
+ }
+
+ const messages = await stream.result();
+ const assistantMessages = messages.filter((message) => message.role === "assistant");
+
+ expect(assistantMessages).toHaveLength(1);
+ expect(assistantMessages[0]?.role).toBe("assistant");
+ if (assistantMessages[0]?.role === "assistant") {
+ expect(assistantMessages[0].stopReason).toBe("stop");
+ expect(assistantMessages[0].content).toEqual([{ type: "text", text: "complete" }]);
+ }
+ expect(events.filter((event) => event.type === "agent_end")).toHaveLength(1);
+ });
+
+ it("should not invoke tools when the signal aborts before tool execution", async () => {
+ const controller = new AbortController();
+ const toolExecute: AgentTool["execute"] = vi.fn(async () => ({
+ content: [{ type: "text" as const, text: "should not run" }],
+ details: {},
+ }));
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [
+ {
+ name: "wait",
+ label: "Wait",
+ description: "Wait",
+ parameters: Type.Object({}),
+ execute: toolExecute,
+ },
+ ],
+ };
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: identityConverter,
+ beforeToolCall: async () => {
+ controller.abort();
+ return undefined;
+ },
+ };
+ const assistantMessage = createAssistantMessage(
+ [{ type: "toolCall", id: "tool_1", name: "wait", arguments: {} }],
+ "toolUse",
+ );
+ const streamFn = () => {
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "toolUse", message: assistantMessage });
+ });
+ return stream;
+ };
+
+ const stream = agentLoop([createUserMessage("Hello")], context, config, controller.signal, streamFn);
+ for await (const _event of stream) {
+ // consume
+ }
+ await stream.result();
+
+ expect(toolExecute).not.toHaveBeenCalled();
+ });
+
+ it("should stop a sequential tool batch after aborting a tool call", async () => {
+ const controller = new AbortController();
+ const toolSchema = Type.Object({ value: Type.String() });
+ const executed: string[] = [];
+ const tool: AgentTool<typeof toolSchema, { value: string }> = {
+ name: "work",
+ label: "Work",
+ description: "Work",
+ parameters: toolSchema,
+ execute: async (_toolCallId, params) => {
+ executed.push(params.value);
+ if (params.value === "first") {
+ controller.abort();
+ }
+ return {
+ content: [{ type: "text", text: `done:${params.value}` }],
+ details: { value: params.value },
+ };
+ },
+ };
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [tool],
+ };
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: identityConverter,
+ toolExecution: "sequential",
+ };
+ const assistantMessage = createAssistantMessage(
+ [
+ { type: "toolCall", id: "tool_1", name: "work", arguments: { value: "first" } },
+ { type: "toolCall", id: "tool_2", name: "work", arguments: { value: "second" } },
+ ],
+ "toolUse",
+ );
+ const streamFn = () => {
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "toolUse", message: assistantMessage });
+ });
+ return stream;
+ };
+ const events: AgentEvent[] = [];
+
+ await runAgentLoop(
+ [createUserMessage("Hello")],
+ context,
+ config,
+ (event) => {
+ events.push(event);
+ },
+ controller.signal,
+ streamFn,
+ );
+
+ const toolStartIds = events.flatMap((event) => (event.type === "tool_execution_start" ? [event.toolCallId] : []));
+ const toolResultIds = events.flatMap((event) =>
+ event.type === "message_end" && event.message.role === "toolResult" ? [event.message.toolCallId] : [],
+ );
+
+ expect(executed).toEqual(["first"]);
+ expect(toolStartIds).toEqual(["tool_1"]);
+ expect(toolResultIds).toEqual(["tool_1"]);
+ expect(events.some((event) => event.type === "agent_end")).toBe(true);
+ });
+
+ it("should preserve a successful tool result when abort fires during update flush", async () => {
+ const controller = new AbortController();
+ const toolSchema = Type.Object({});
+ const tool: AgentTool<typeof toolSchema, Record<string, never>> = {
+ name: "work",
+ label: "Work",
+ description: "Work",
+ parameters: toolSchema,
+ execute: async (_toolCallId, _params, _signal, onUpdate) => {
+ onUpdate?.({ content: [{ type: "text", text: "progress" }], details: {} });
+ return {
+ content: [{ type: "text", text: "done" }],
+ details: {},
+ };
+ },
+ };
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [tool],
+ };
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: identityConverter,
+ toolExecution: "sequential",
+ };
+ const assistantMessage = createAssistantMessage(
+ [{ type: "toolCall", id: "tool_1", name: "work", arguments: {} }],
+ "toolUse",
+ );
+ const streamFn = () => {
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "toolUse", message: assistantMessage });
+ });
+ return stream;
+ };
+ const events: AgentEvent[] = [];
+
+ const messages = await runAgentLoop(
+ [createUserMessage("Hello")],
+ context,
+ config,
+ (event) => {
+ events.push(event);
+ if (event.type === "tool_execution_update") {
+ return new Promise<void>(() => {
+ setTimeout(() => controller.abort(), 0);
+ });
+ }
+ },
+ controller.signal,
+ streamFn,
+ );
+
+ const toolResult = messages.find((message) => message.role === "toolResult");
+ expect(toolResult?.role).toBe("toolResult");
+ if (toolResult?.role === "toolResult") {
+ expect(toolResult.isError).toBe(false);
+ expect(toolResult.content).toEqual([{ type: "text", text: "done" }]);
+ }
+ expect(events.some((event) => event.type === "agent_end")).toBe(true);
+ });
+
+ it("should freeze synthetic aborted messages against later partial mutation", async () => {
+ const context: AgentContext = {
+ systemPrompt: "You are helpful.",
+ messages: [],
+ tools: [],
+ };
+ const controller = new AbortController();
+ const partialMessage = createAssistantMessage([{ type: "text", text: "partial" }]);
+ partialMessage.usage.cost.total = 1;
+ const config: AgentLoopConfig = {
+ model: createModel(),
+ convertToLlm: identityConverter,
+ };
+ const streamFn = () => {
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "start", partial: partialMessage });
+ });
+ return stream;
+ };
+
+ const stream = agentLoop([createUserMessage("Hello")], context, config, controller.signal, streamFn);
+ for await (const event of stream) {
+ if (event.type === "message_start" && event.message.role === "assistant") {
+ controller.abort();
+ }
+ }
+
+ const messages = await stream.result();
+ const assistant = messages.find((message) => message.role === "assistant");
+ const text = partialMessage.content[0];
+ if (text?.type === "text") {
+ text.text = "mutated";
+ }
+ partialMessage.usage.cost.total = 99;
+
+ expect(assistant?.role).toBe("assistant");
+ if (assistant?.role === "assistant") {
+ expect(assistant.stopReason).toBe("aborted");
+ expect(assistant.content).toEqual([{ type: "text", text: "partial" }]);
+ expect(assistant.usage.cost.total).toBe(1);
+ }
+ });
+
it("should handle custom message types via convertToLlm", async () => {
// Create a custom message type
interface CustomNotification {
diff --git a/packages/agent/test/agent.test.ts b/packages/agent/test/agent.test.ts
index 0ed3a7cf8f..52da79956d 100644
--- a/packages/agent/test/agent.test.ts
+++ b/packages/agent/test/agent.test.ts
@@ -1,6 +1,14 @@
import { type AssistantMessage, type AssistantMessageEvent, EventStream, getModel } from "@earendil-works/pi-ai";
-import { describe, expect, it } from "vitest";
-import { Agent } from "../src/index.js";
+import { Type } from "typebox";
+import { describe, expect, it, vi } from "vitest";
+import {
+ Agent,
+ type AgentContext,
+ type AgentLoopConfig,
+ type AgentMessage,
+ type AgentTool,
+ agentLoop,
+} from "../src/index.js";
// Mock stream that mimics AssistantMessageEventStream
class MockAssistantStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
@@ -36,6 +44,14 @@ function createAssistantMessage(text: string): AssistantMessage {
};
}
+function createToolUseMessage(toolName: string): AssistantMessage {
+ return {
+ ...createAssistantMessage(""),
+ content: [{ type: "toolCall", id: "tool-call-1", name: toolName, arguments: {} }],
+ stopReason: "toolUse",
+ };
+}
+
function createDeferred(): {
promise: Promise<void>;
resolve: () => void;
@@ -277,6 +293,170 @@ describe("Agent", () => {
expect(() => agent.abort()).not.toThrow();
});
+ it("should settle when aborting a stream that ignores the abort signal", async () => {
+ let streamStarted = () => {};
+ const streamStartedPromise = new Promise<void>((resolve) => {
+ streamStarted = resolve;
+ });
+ const agent = new Agent({
+ streamFn: () => {
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "start", partial: createAssistantMessage("") });
+ streamStarted();
+ });
+ return stream;
+ },
+ });
+
+ const promptPromise = agent.prompt("hello");
+ await streamStartedPromise;
+
+ agent.abort();
+ await agent.waitForIdle();
+ await promptPromise;
+
+ expect(agent.state.isStreaming).toBe(false);
+ const lastMessage = agent.state.messages.at(-1);
+ expect(lastMessage?.role).toBe("assistant");
+ if (lastMessage?.role === "assistant") {
+ expect(lastMessage.stopReason).toBe("aborted");
+ }
+ });
+
+ it("should settle when aborting a tool that ignores the abort signal", async () => {
+ let toolStarted = () => {};
+ const toolStartedPromise = new Promise<void>((resolve) => {
+ toolStarted = resolve;
+ });
+ const schema = Type.Object({});
+ const hangingTool: AgentTool<typeof schema, Record<string, never>> = {
+ name: "hang",
+ label: "hang",
+ description: "Never resolves",
+ parameters: schema,
+ execute: () => new Promise(() => {}),
+ };
+ const agent = new Agent({
+ initialState: {
+ tools: [hangingTool],
+ },
+ toolExecution: "sequential",
+ streamFn: () => {
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "toolUse", message: createToolUseMessage("hang") });
+ });
+ return stream;
+ },
+ });
+ agent.subscribe((event) => {
+ if (event.type === "tool_execution_start") {
+ toolStarted();
+ }
+ });
+
+ const promptPromise = agent.prompt("hello");
+ await toolStartedPromise;
+
+ agent.abort();
+ await agent.waitForIdle();
+ await promptPromise;
+
+ const toolResult = agent.state.messages.find((message) => message.role === "toolResult");
+ expect(toolResult?.role).toBe("toolResult");
+ if (toolResult?.role === "toolResult") {
+ expect(toolResult.isError).toBe(true);
+ expect(toolResult.content).toEqual([{ type: "text", text: "Tool execution aborted" }]);
+ }
+ expect(agent.state.pendingToolCalls.size).toBe(0);
+ expect(agent.state.isStreaming).toBe(false);
+ });
+
+ it("should still emit agent_end when failure recovery message listeners throw", async () => {
+ const agent = new Agent({
+ streamFn: () => {
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "stop", message: createAssistantMessage("ok") });
+ });
+ return stream;
+ },
+ });
+ const events: string[] = [];
+ agent.subscribe((event) => {
+ events.push(event.type);
+ if ((event.type === "message_start" || event.type === "message_end") && event.message.role === "assistant") {
+ throw new Error("listener failed");
+ }
+ });
+
+ await expect(agent.prompt("hello")).resolves.toBeUndefined();
+
+ expect(events).toContain("agent_end");
+ const lastMessage = agent.state.messages.at(-1);
+ expect(lastMessage?.role).toBe("assistant");
+ if (lastMessage?.role === "assistant") {
+ expect(lastMessage.stopReason).toBe("error");
+ expect(lastMessage.errorMessage).toBe("listener failed");
+ }
+ expect(agent.state.isStreaming).toBe(false);
+ });
+
+ it("should not drain steering messages when aborting before a queued poll", async () => {
+ const controller = new AbortController();
+ controller.abort();
+ const queuedMessage: AgentMessage = {
+ role: "user",
+ content: [{ type: "text", text: "queued" }],
+ timestamp: Date.now(),
+ };
+ const getSteeringMessages = vi.fn(async () => [queuedMessage]);
+ const context: AgentContext = { systemPrompt: "", messages: [], tools: [] };
+ const config: AgentLoopConfig = {
+ model: getModel("openai", "gpt-4o-mini"),
+ convertToLlm: () => [],
+ getSteeringMessages,
+ };
+
+ const stream = agentLoop(
+ [{ role: "user", content: [{ type: "text", text: "hello" }], timestamp: Date.now() }],
+ context,
+ config,
+ controller.signal,
+ );
+ for await (const _event of stream) {
+ // Drain the stream.
+ }
+
+ expect(await stream.result()).toEqual([]);
+ expect(getSteeringMessages).not.toHaveBeenCalled();
+ });
+
+ it("should end the event stream when abort rejects the loop", async () => {
+ const controller = new AbortController();
+ controller.abort();
+ const context: AgentContext = { systemPrompt: "", messages: [], tools: [] };
+ const config: AgentLoopConfig = {
+ model: getModel("openai", "gpt-4o-mini"),
+ convertToLlm: () => [],
+ };
+
+ const events: unknown[] = [];
+ const stream = agentLoop(
+ [{ role: "user", content: [{ type: "text", text: "hello" }], timestamp: Date.now() }],
+ context,
+ config,
+ controller.signal,
+ );
+ for await (const event of stream) {
+ events.push(event);
+ }
+
+ await expect(stream.result()).resolves.toEqual([]);
+ expect(events.some((event) => (event as { type?: string }).type === "agent_end")).toBe(false);
+ });
+
it("should throw when prompt() called while streaming", async () => {
let abortSignal: AbortSignal | undefined;
const agent = new Agent({
diff --git a/packages/coding-agent/CHANGELOG.md b/packages/coding-agent/CHANGELOG.md
index f51c54e232..33dec4d90c 100644
--- a/packages/coding-agent/CHANGELOG.md
+++ b/packages/coding-agent/CHANGELOG.md
@@ -11,6 +11,7 @@
- Changed `attach_image` to resize and compress large inline image attachments before storing them for rendering and replay ([#340](https://github.com/PrimeIntellect-ai/prime-agent/pull/340) by [@sethkarten](https://github.com/sethkarten)).
- Fixed heartbeat and goal continuation prompts rendering like ordinary user messages ([ENG-4482](https://linear.app/primeintellect/issue/ENG-4482/heartbeat-message-should-have-a-different-ui-from-user-message)).
- Fixed `/heartbeat` guidance to show `stop` and the `every <duration> <instruction>` interval syntax ([ENG-4484](https://linear.app/primeintellect/issue/ENG-4484/improve-heartbeat-command-syntax-guidance-in-ui)).
+- Fixed Ctrl+C canceling the active turn, bash command, and IPython kernel execution deterministically, with a compact recovery prompt and model-visible reset notice when an interrupted IPython cell keeps running ([ENG-4490](https://linear.app/primeintellect/issue/ENG-4490)).
- Fixed login dialogs in fullscreen so sign-in URLs can be selected natively ([ENG-4480](https://linear.app/primeintellect/issue/ENG-4480/new-fullscreen-tui-makes-it-impossible-to-copy-login-url)).
- Fixed provider auth failures leaving stale credentials shown as connected in `/login` ([ENG-4491](https://linear.app/primeintellect/issue/ENG-4491/mark-provider-stale-after-repeated-401s)).
- Fixed typing into the prompt after highlighting an inline subagent ([ENG-4494](https://linear.app/primeintellect/issue/ENG-4494/allow-typing-after-highlighting-a-subagent)).
diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts
index 65da448870..7805e13d44 100644
--- a/packages/coding-agent/src/core/agent-session.ts
+++ b/packages/coding-agent/src/core/agent-session.ts
@@ -668,12 +668,14 @@ export class AgentSession {
// Compaction state
private _compactionAbortController: AbortController | undefined = undefined;
private _autoCompactionAbortController: AbortController | undefined = undefined;
+ private _compactionOperation: Promise<void> | undefined = undefined;
private _overflowRecoveryAttempted = false;
private _continueAfterThresholdCompaction = false;
private _pendingRequestedCompaction: { customInstructions?: string } | undefined;
// Branch summarization state
private _branchSummaryAbortController: AbortController | undefined = undefined;
+ private _branchSummaryOperation: Promise<void> | undefined = undefined;
// Retry state
private _retryAbortController: AbortController | undefined = undefined;
@@ -3493,17 +3495,30 @@ export class AgentSession {
return this._resourceLoader;
}
+ requestAbort(): void {
+ this.abortRetry();
+ this.abortCompaction();
+ this.abortBranchSummary();
+ this.abortBash();
+ this.agent.abort();
+ }
+
/**
* Abort current operation and wait for agent to become idle.
*/
async abort(): Promise<void> {
- this.abortRetry();
+ const compactionOperation = this._compactionOperation;
+ const branchSummaryOperation = this._branchSummaryOperation;
+ this.requestAbort();
this._cancelActiveRlmChildRuns("Parent session aborted");
this._goalAbortInProgress = this._goalState.status === "active";
- this.agent.abort();
try {
- await this.agent.waitForIdle();
- await this._agentEventQueue;
+ await Promise.allSettled([
+ this.agent.waitForIdle(),
+ this._agentEventQueue,
+ ...(compactionOperation ? [compactionOperation] : []),
+ ...(branchSummaryOperation ? [branchSummaryOperation] : []),
+ ]);
} finally {
this._goalAbortInProgress = false;
}
@@ -3832,6 +3847,11 @@ export class AgentSession {
await this.abort();
let didCompact = false;
this._compactionAbortController = new AbortController();
+ let resolveCompactionOperation: () => void = () => {};
+ const compactionOperation = new Promise<void>((resolve) => {
+ resolveCompactionOperation = resolve;
+ });
+ this._compactionOperation = compactionOperation;
this._emit({ type: "compaction_start", reason: "manual", customInstructions });
try {
@@ -3879,6 +3899,10 @@ export class AgentSession {
} finally {
this._compactionAbortController = undefined;
this._reconnectToAgent();
+ if (this._compactionOperation === compactionOperation) {
+ this._compactionOperation = undefined;
+ }
+ resolveCompactionOperation();
if (didCompact) {
this._discardPendingAutoRefine({ cancelPostCompactionContinue: true });
if (hadPostCompactionContinue) {
@@ -6425,6 +6449,11 @@ export class AgentSession {
// Set up abort controller for summarization
this._branchSummaryAbortController = new AbortController();
+ let resolveBranchSummaryOperation: () => void = () => {};
+ const branchSummaryOperation = new Promise<void>((resolve) => {
+ resolveBranchSummaryOperation = resolve;
+ });
+ this._branchSummaryOperation = branchSummaryOperation;
try {
let extensionSummary: { summary: string; details?: unknown } | undefined;
@@ -6563,6 +6592,10 @@ export class AgentSession {
return { editorText, cancelled: false, summaryEntry };
} finally {
this._branchSummaryAbortController = undefined;
+ if (this._branchSummaryOperation === branchSummaryOperation) {
+ this._branchSummaryOperation = undefined;
+ }
+ resolveBranchSummaryOperation();
}
}
diff --git a/packages/coding-agent/src/core/kernel/index.ts b/packages/coding-agent/src/core/kernel/index.ts
index 9ee4cb2e98..c3b0bd900d 100644
--- a/packages/coding-agent/src/core/kernel/index.ts
+++ b/packages/coding-agent/src/core/kernel/index.ts
@@ -38,6 +38,18 @@ const SNAPSHOT_MAX_OUTPUT_CHARS = 1_000_000;
// Cap how long a graceful dispose waits on the final snapshot; the debounced
// on-disk copy is the fallback if this is exceeded.
const SNAPSHOT_DISPOSE_TIMEOUT_MS = 5000;
+const KERNEL_ABORT_GRACE_MS = 1000;
+const KERNEL_BUSY_REUSE_WAIT_MS = 5000;
+const KERNEL_BUSY_INTERRUPT_INTERVAL_MS = 500;
+const KERNEL_BUSY_AFTER_INTERRUPT_MESSAGE =
+ "IPython kernel is still running the previously interrupted cell. Wait and try again, or kill the IPython kernel to start fresh.";
+
+export class KernelBusyAfterInterruptError extends Error {
+ constructor() {
+ super(KERNEL_BUSY_AFTER_INTERRUPT_MESSAGE);
+ this.name = "KernelBusyAfterInterruptError";
+ }
+}
/** Comm target the kernel-side `rlm.host_request` shim opens for typed host requests. */
export const HOST_COMM_TARGET = "host.request";
@@ -79,6 +91,7 @@ export interface KernelManagerOptions {
export interface KernelStartOptions {
onBootstrapProgress?: KernelBootstrapProgressHandler;
+ signal?: AbortSignal;
}
export interface ExecuteOptions {
@@ -169,6 +182,50 @@ function parseAttachmentDisplay(payload: unknown): KernelAttachment | "oversized
return { mimeType, data, path: typeof path === "string" ? path : undefined };
}
+function createKernelStartupAbortError(): Error {
+ return new Error("Kernel startup aborted");
+}
+
+function raceStartupWithAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {
+ if (!signal) {
+ return promise;
+ }
+ if (signal.aborted) {
+ return Promise.reject(createKernelStartupAbortError());
+ }
+ return new Promise<T>((resolve, reject) => {
+ let settled = false;
+ const cleanup = () => signal.removeEventListener("abort", abort);
+ const abort = () => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ reject(createKernelStartupAbortError());
+ };
+ signal.addEventListener("abort", abort, { once: true });
+ promise.then(
+ (value) => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ resolve(value);
+ },
+ (error: unknown) => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ reject(error);
+ },
+ );
+ });
+}
+
interface ConnectionInfo {
ip: string;
transport: "tcp";
@@ -427,6 +484,7 @@ export class KernelManager {
/** Serializes execute() calls — Jupyter shell channel is request/reply. */
private executionQueue: Promise<unknown> = Promise.resolve();
private activeExecution?: ActiveExecution;
+ private readonly activeExecutionIdleWaiters = new Set<() => void>();
// Source of the most recently started cell, retained after it finishes so
// rlm.run spawns from detached asyncio tasks (cell already idle) can still
// attribute their spawning program.
@@ -460,10 +518,16 @@ export class KernelManager {
}
async start(options: KernelStartOptions = {}): Promise<void> {
+ if (options.signal?.aborted) {
+ throw createKernelStartupAbortError();
+ }
if (!this.startPromise) {
- this.startPromise = this.doStart(options);
+ this.startPromise = this.doStart({ onBootstrapProgress: options.onBootstrapProgress }).catch((error) => {
+ this.startPromise = undefined;
+ throw error;
+ });
}
- return this.startPromise;
+ return raceStartupWithAbort(this.startPromise, options.signal);
}
private async doStart(startOptions: KernelStartOptions): Promise<void> {
@@ -547,6 +611,7 @@ export class KernelManager {
this.appendKernelDiagnostic(`spawn error: ${err.message}`);
this.state = "shutdown";
liveKernels.delete(this);
+ this.cleanupResources();
});
kernel.on("exit", (code, signal) => {
@@ -556,6 +621,7 @@ export class KernelManager {
}
this.state = "shutdown";
liveKernels.delete(this);
+ this.cleanupResources();
});
}
@@ -699,7 +765,7 @@ export class KernelManager {
if (opts.signal?.aborted) {
return { stdout: "", stderr: "", status: "aborted", durationMs: 0 };
}
- await this.start();
+ await this.start({ signal: opts.signal });
if ((this.state as string) === "shutdown") {
throw new Error("Kernel has been shut down");
}
@@ -713,6 +779,7 @@ export class KernelManager {
const started = Date.now();
try {
+ await this.waitForActiveExecutionToClearForReuse(opts.signal);
if (opts.signal?.aborted) {
return { stdout: "", stderr: "", status: "aborted", durationMs: Date.now() - started };
}
@@ -752,35 +819,62 @@ export class KernelManager {
throw new Error("Kernel already has an active execution");
}
+ const result = createDeferred<ExecuteResult>();
+ const execution: ActiveExecution = {
+ requestMsgId,
+ code,
+ started,
+ maxChars,
+ opts,
+ stdout: "",
+ stderr: "",
+ stdoutTruncated: false,
+ stderrTruncated: false,
+ diffs: [],
+ attachments: [],
+ status: "ok",
+ resolve: result.resolve,
+ reject: result.reject,
+ };
+ let abortTimer: ReturnType<typeof globalThis.setTimeout> | undefined;
+ const clearAbortTimer = () => {
+ if (abortTimer) {
+ globalThis.clearTimeout(abortTimer);
+ abortTimer = undefined;
+ }
+ };
+ const forceAbort = () => {
+ if (this.activeExecution !== execution) {
+ return;
+ }
+ execution.status = "aborted";
+ this.resolveExecution(execution, { clearActive: false });
+ };
const onAbort = () => {
- this.interrupt().catch(() => {});
+ void this.interrupt().catch(() => undefined);
+ clearAbortTimer();
+ abortTimer = globalThis.setTimeout(forceAbort, KERNEL_ABORT_GRACE_MS);
+ if (abortTimer && typeof abortTimer === "object" && "unref" in abortTimer) {
+ abortTimer.unref();
+ }
};
- opts.signal?.addEventListener("abort", onAbort);
try {
- const result = createDeferred<ExecuteResult>();
- const execution: ActiveExecution = {
- requestMsgId,
- code,
- started,
- maxChars,
- opts,
- stdout: "",
- stderr: "",
- stdoutTruncated: false,
- stderrTruncated: false,
- diffs: [],
- attachments: [],
- status: "ok",
- resolve: result.resolve,
- reject: result.reject,
- };
this.activeExecution = execution;
+ opts.signal?.addEventListener("abort", onAbort, { once: true });
+ if (opts.signal?.aborted) {
+ onAbort();
+ }
if (!opts.internal) {
this.lastCellCode = code;
}
try {
- await shell.send(encode(msg, conn.key));
+ const sendPromise = shell.send(encode(msg, conn.key));
+ sendPromise.catch(() => undefined);
+ await Promise.race([sendPromise, result.promise.then(() => undefined)]);
+ if (this.activeExecution === execution && execution.status !== "aborted") {
+ await sendPromise;
+ }
} catch (error) {
if (this.activeExecution === execution) {
this.activeExecution = undefined;
@@ -789,6 +883,7 @@ export class KernelManager {
}
return await result.promise;
} finally {
+ clearAbortTimer();
opts.signal?.removeEventListener("abort", onAbort);
}
}
@@ -889,7 +984,14 @@ export class KernelManager {
if (this.activeExecution !== execution) {
return;
}
- this.activeExecution = undefined;
+ this.resolveExecution(execution, { clearActive: true });
+ }
+
+ private resolveExecution(execution: ActiveExecution, options: { clearActive: boolean }): void {
+ const didClearActive = options.clearActive && this.activeExecution === execution;
+ if (options.clearActive && this.activeExecution === execution) {
+ this.activeExecution = undefined;
+ }
let stdout = execution.stdout;
let stderr = execution.stderr;
@@ -913,6 +1015,9 @@ export class KernelManager {
status,
durationMs: Date.now() - execution.started,
});
+ if (didClearActive) {
+ this.notifyActiveExecutionIdle();
+ }
}
private rejectActiveExecution(error: Error): void {
@@ -922,6 +1027,65 @@ export class KernelManager {
}
this.activeExecution = undefined;
execution.reject(error);
+ this.notifyActiveExecutionIdle();
+ }
+
+ private notifyActiveExecutionIdle(): void {
+ for (const resolve of this.activeExecutionIdleWaiters) {
+ resolve();
+ }
+ this.activeExecutionIdleWaiters.clear();
+ }
+
+ private waitForActiveExecutionToClear(signal: AbortSignal | undefined, timeoutMs: number): Promise<boolean> {
+ if (!this.activeExecution) {
+ return Promise.resolve(true);
+ }
+ return new Promise<boolean>((resolve) => {
+ let settled = false;
+ let timeout: ReturnType<typeof globalThis.setTimeout> | undefined;
+ const finish = (cleared: boolean) => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ if (timeout) {
+ globalThis.clearTimeout(timeout);
+ }
+ this.activeExecutionIdleWaiters.delete(onIdle);
+ signal?.removeEventListener("abort", onAbort);
+ resolve(cleared);
+ };
+ const onIdle = () => finish(true);
+ const onAbort = () => finish(false);
+ this.activeExecutionIdleWaiters.add(onIdle);
+ signal?.addEventListener("abort", onAbort, { once: true });
+ timeout = globalThis.setTimeout(() => finish(false), timeoutMs);
+ if (timeout && typeof timeout === "object" && "unref" in timeout) {
+ timeout.unref();
+ }
+ });
+ }
+
+ private async waitForActiveExecutionToClearForReuse(signal?: AbortSignal): Promise<void> {
+ const started = Date.now();
+ while (this.activeExecution && Date.now() - started < KERNEL_BUSY_REUSE_WAIT_MS) {
+ if ((this.state as string) === "shutdown") {
+ throw new Error("Kernel has been shut down");
+ }
+ void this.interrupt().catch(() => undefined);
+ const remaining = KERNEL_BUSY_REUSE_WAIT_MS - (Date.now() - started);
+ const cleared = await this.waitForActiveExecutionToClear(
+ signal,
+ Math.max(1, Math.min(KERNEL_BUSY_INTERRUPT_INTERVAL_MS, remaining)),
+ );
+ if (cleared || signal?.aborted) {
+ return;
+ }
+ }
+ if (this.activeExecution) {
+ throw new KernelBusyAfterInterruptError();
+ }
}
private handleCommMessage(incoming: JupyterMessage): void {
@@ -1023,7 +1187,7 @@ export class KernelManager {
await this.control.send(encode(msg, this.connection.key));
}
- private cleanupResources(): void {
+ private cleanupResources(killSignal: NodeJS.Signals = "SIGTERM"): void {
this.clearSnapshotTimer();
if (this.forkedLivenessTimer) {
globalThis.clearInterval(this.forkedLivenessTimer);
@@ -1039,11 +1203,11 @@ export class KernelManager {
this.iopubPumpPromise = undefined;
try {
if (this.kernel) {
- this.kernel.kill("SIGTERM");
+ this.kernel.kill(killSignal);
} else if (this.kernelPid !== undefined && !this.forkedKernelDied()) {
// Only signal a forked kernel confirmed still alive: a dead pid may have
- // been recycled by the OS, and SIGTERM would then hit an unrelated process.
- process.kill(this.kernelPid, "SIGTERM");
+ // been recycled by the OS, and a kill would then hit an unrelated process.
+ process.kill(this.kernelPid, killSignal);
}
} catch {
// Kernel already exited.
@@ -1129,6 +1293,12 @@ export class KernelManager {
}
}
+ async kill(): Promise<void> {
+ this.state = "shutdown";
+ liveKernels.delete(this);
+ this.cleanupResources("SIGKILL");
+ }
+
/**
* Serialize the user namespace to disk (best-effort, per-variable). No-op when
* the kernel isn't running or no snapshot target was configured. Never throws.
diff --git a/packages/coding-agent/src/core/tools/ipython.ts b/packages/coding-agent/src/core/tools/ipython.ts
index ef2ff6bea9..de3382c24b 100644
--- a/packages/coding-agent/src/core/tools/ipython.ts
+++ b/packages/coding-agent/src/core/tools/ipython.ts
@@ -4,12 +4,14 @@ import type { AgentTool } from "@earendil-works/pi-agent-core";
import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
import { type Static, Type } from "typebox";
import { IMAGE_MIME_TYPES } from "../../utils/mime.js";
-import type { ToolDefinition } from "../extensions/types.js";
+import type { ExtensionContext, ToolDefinition } from "../extensions/types.js";
import { withKernelBootPermit } from "../kernel/boot-gate.js";
import type { KernelBootstrapProgressHandler } from "../kernel/bootstrap.js";
import {
+ type ExecuteResult,
type HostRequestHandlers,
type KernelAttachment,
+ KernelBusyAfterInterruptError,
type KernelDiffDisplay,
KernelManager,
} from "../kernel/index.js";
@@ -127,6 +129,102 @@ const ipythonSchema = Type.Object({
}),
});
+const BUSY_KERNEL_WAIT_CHOICE = "Wait and preserve state";
+const BUSY_KERNEL_KILL_CHOICE = "Kill kernel and restart";
+const BUSY_KERNEL_PROMPT = [
+ "Interrupted IPython cell is still running",
+ "Ctrl+C sent an interrupt, but the previous cell has not stopped yet. A new IPython command cannot start until it finishes.",
+ "Waiting preserves the current kernel state. Killing restarts IPython and loses in-memory variables, imports, and running tasks.",
+].join("\n");
+const KERNEL_RESTART_NOTICE = [
+ "<ipython_kernel_reset>",
+ "The IPython kernel was restarted after a previous interrupted cell kept running. Variables, imports, async tasks, and open resources from before the restart are no longer available; recreate them before using them.",
+ "</ipython_kernel_reset>",
+].join("\n");
+
+function createAbortError(): Error {
+ return new Error("IPython execution aborted");
+}
+
+function raceWithAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined, onAbort?: () => void): Promise<T> {
+ if (!signal) {
+ return promise;
+ }
+ if (signal.aborted) {
+ onAbort?.();
+ return Promise.reject(createAbortError());
+ }
+ return new Promise<T>((resolve, reject) => {
+ let settled = false;
+ const cleanup = () => signal.removeEventListener("abort", abort);
+ const abort = () => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ onAbort?.();
+ reject(createAbortError());
+ };
+ signal.addEventListener("abort", abort, { once: true });
+ promise.then(
+ (value) => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ resolve(value);
+ },
+ (error: unknown) => {
+ if (settled) {
+ return;
+ }
+ settled = true;
+ cleanup();
+ reject(error);
+ },
+ );
+ });
+}
+
+function createLinkedAbortSignal(sources: readonly (AbortSignal | undefined)[]): {
+ signal: AbortSignal;
+ cleanup: () => void;
+} {
+ const controller = new AbortController();
+ const cleanups: Array<() => void> = [];
+ const abort = () => controller.abort();
+ for (const source of sources) {
+ if (!source) {
+ continue;
+ }
+ if (source.aborted) {
+ controller.abort();
+ continue;
+ }
+ const listener = () => abort();
+ source.addEventListener("abort", listener, { once: true });
+ cleanups.push(() => source.removeEventListener("abort", listener));
+ }
+ return {
+ signal: controller.signal,
+ cleanup: () => {
+ for (const cleanup of cleanups) {
+ cleanup();
+ }
+ },
+ };
+}
+
+function setWorkingMessage(ctx: ExtensionContext | undefined, message?: string): void {
+ try {
+ ctx?.ui.setWorkingMessage(message);
+ } catch {
+ // Stale UI context; cosmetic only.
+ }
+}
+
export type IpythonToolInput = Static<typeof ipythonSchema>;
export interface IpythonToolDetails {
@@ -140,6 +238,8 @@ export interface IpythonToolDetails {
diffs?: KernelDiffDisplay[];
/** Media attachments loaded into context (e.g. by the attach-image skill). */
attachments?: KernelAttachment[];
+ /** True when this result came after killing and restarting a busy kernel. */
+ kernelRestarted?: boolean;
error?: {
ename: string;
evalue: string;
@@ -259,6 +359,9 @@ export class IpythonKernelProvisioner {
const pending = this.managerPromise;
this.managerPromise = undefined;
this.startedManager = undefined;
+ if (this.options?.kernelManagerRef) {
+ this.options.kernelManagerRef.current = undefined;
+ }
if (!pending) return;
try {
const m = await pending;
@@ -268,16 +371,41 @@ export class IpythonKernelProvisioner {
}
}
- ensure(onProgress?: KernelBootstrapProgressHandler): Promise<KernelManager> {
+ async kill(): Promise<void> {
+ const pending = this.managerPromise;
+ this.managerPromise = undefined;
+ this.startedManager = undefined;
+ if (this.options?.kernelManagerRef) {
+ this.options.kernelManagerRef.current = undefined;
+ }
+ if (!pending) return;
+ try {
+ const m = await pending;
+ await m.kill();
+ } catch {
+ // a failed startup already cleaned up after itself
+ }
+ }
+
+ ensure(onProgress?: KernelBootstrapProgressHandler, signal?: AbortSignal): Promise<KernelManager> {
+ if (signal?.aborted) {
+ return Promise.reject(createAbortError());
+ }
+ let cleanupProgressListener: (() => void) | undefined;
if (onProgress && !this.startedManager) {
this.startupListeners.add(onProgress);
+ cleanupProgressListener = () => {
+ this.startupListeners.delete(onProgress);
+ signal?.removeEventListener("abort", cleanupProgressListener!);
+ };
+ signal?.addEventListener("abort", cleanupProgressListener, { once: true });
// Joining an in-flight startup: replay the current stage.
if (this.managerPromise && this.lastStartupMessage) {
onProgress(this.lastStartupMessage);
}
}
if (!this.managerPromise) {
- const startup = this.startKernel();
+ const startup = this.startKernel(signal);
this.managerPromise = startup;
startup.then(
(m) => {
@@ -296,7 +424,9 @@ export class IpythonKernelProvisioner {
},
);
}
- return this.managerPromise;
+ return raceWithAbort(this.managerPromise, signal).finally(() => {
+ cleanupProgressListener?.();
+ });
}
private settleStartup(): void {
@@ -311,74 +441,140 @@ export class IpythonKernelProvisioner {
}
}
- private async startKernel(): Promise<KernelManager> {
+ private async startKernel(signal?: AbortSignal): Promise<KernelManager> {
+ const startupAbort = createLinkedAbortSignal([this.disposeController.signal, signal]);
+ const startupSignal = startupAbort.signal;
// Wait for a previous provisioner (e.g. on /reload) to finish disposing — and
// flushing its final snapshot — before we read that snapshot back, so the two
// kernels can't race over the same on-disk file. Guarded so the common
// no-gate path stays synchronous (callers rely on prompt startup progress).
- if (this.options?.readyGate) {
- await this.options.readyGate.catch(() => {});
- }
- const snapshotDir = this.options?.snapshotDir;
- const m = new KernelManager({
- python: this.options?.python,
- cwd: this.cwd,
- env: this.options?.env,
- sessionId: this.options?.sessionId,
- hostHandlers: this.options?.hostHandlers,
- pythonSkills: this.options?.pythonSkills,
- // Only persistent sessions (which have an artifact dir) get a revivable snapshot.
- snapshot: snapshotDir
- ? { path: snapshotPathIn(snapshotDir), manifestPath: manifestPathIn(snapshotDir) }
- : undefined,
- });
- // Emitted synchronously (before the permit await) so a listener attaching
- // mid-flight can replay the current stage.
- this.emitStartupProgress("Starting IPython kernel...");
- // Only the process spawn + port resolve contends for OS resources under a
- // fan-out, and it is bounded by start()'s own timeouts — so the permit
- // covers only start(). Restore/bootstrap run per-kernel afterwards and are
- // unbounded execute()s; holding the global permit across them could pin it
- // forever on a wedged bootstrap and starve every other session's boot.
- const signal = this.disposeController.signal;
- await withKernelBootPermit(() => {
- // Disposed while queued for the permit — don't spawn a kernel nobody wants.
- if (signal.aborted) throw new Error("Kernel provisioner disposed before start");
- return m.start({ onBootstrapProgress: (message) => this.emitStartupProgress(message) });
- }, signal);
- let pendingRestore: RestoreResult | undefined;
try {
- // Revive a prior session's namespace before the bootstrap, so the bootstrap
- // then overwrites live handles (rlm, skills) on top of anything restored.
- if (snapshotDir) {
- const snapshotExisted = existsSync(snapshotPathIn(snapshotDir));
- this.emitStartupProgress("Restoring IPython state...");
- const restore = await m.restoreState();
- if (snapshotExisted) {
- pendingRestore = restore ?? { restored: [], failed: [], path: snapshotPathIn(snapshotDir) };
+ if (this.options?.readyGate) {
+ await raceWithAbort(
+ this.options.readyGate.catch(() => {}),
+ startupSignal,
+ );
+ }
+ const snapshotDir = this.options?.snapshotDir;
+ const m = new KernelManager({
+ python: this.options?.python,
+ cwd: this.cwd,
+ env: this.options?.env,
+ sessionId: this.options?.sessionId,
+ hostHandlers: this.options?.hostHandlers,
+ pythonSkills: this.options?.pythonSkills,
+ // Only persistent sessions (which have an artifact dir) get a revivable snapshot.
+ snapshot: snapshotDir
+ ? { path: snapshotPathIn(snapshotDir), manifestPath: manifestPathIn(snapshotDir) }
+ : undefined,
+ });
+ let pendingRestore: RestoreResult | undefined;
+ try {
+ // Emitted synchronously (before the permit await) so a listener attaching
+ // mid-flight can replay the current stage.
+ this.emitStartupProgress("Starting IPython kernel...");
+ // Only the process spawn + port resolve contends for OS resources under a
+ // fan-out, and it is bounded by start()'s own timeouts — so the permit
+ // covers only start(). Restore/bootstrap run per-kernel afterwards and are
+ // unbounded execute()s; holding the global permit across them could pin it
+ // forever on a wedged bootstrap and starve every other session's boot.
+ await withKernelBootPermit(() => {
+ // Disposed while queued for the permit — don't spawn a kernel nobody wants.
+ if (startupSignal.aborted) throw new Error("Kernel provisioner disposed before start");
+ return m.start({
+ onBootstrapProgress: (message) => this.emitStartupProgress(message),
+ signal: startupSignal,
+ });
+ }, startupSignal);
+ // Revive a prior session's namespace before the bootstrap, so the bootstrap
+ // then overwrites live handles (rlm, skills) on top of anything restored.
+ if (snapshotDir) {
+ const snapshotExisted = existsSync(snapshotPathIn(snapshotDir));
+ this.emitStartupProgress("Restoring IPython state...");
+ const restore = await raceWithAbort(m.restoreState(), startupSignal);
+ if (snapshotExisted) {
+ pendingRestore = restore ?? { restored: [], failed: [], path: snapshotPathIn(snapshotDir) };
+ }
+ }
+ this.emitStartupProgress("Preparing IPython runtime...");
+ const bootstrap = await m.execute(buildRlmBootstrapCode(this.options?.pythonSkills), {
+ signal: startupSignal,
+ });
+ if (bootstrap.status !== "ok") {
+ const details = [bootstrap.stderr, bootstrap.error?.traceback.join("\n")].filter(Boolean).join("\n");
+ throw new Error(`Failed to initialize rlm runtime in the IPython kernel:\n${details}`);
}
+ } catch (error) {
+ // Never leak the kernel's ZMQ sockets / temp dir if startup fails after spawn.
+ void m.dispose();
+ throw error;
+ }
+ // Only tell the model what was revived once the kernel is actually usable —
+ // a notice claiming restored state must never outlive a failed bootstrap.
+ if (pendingRestore) {
+ this._lastRestore = pendingRestore;
+ this.options?.onRestore?.(pendingRestore);
}
- this.emitStartupProgress("Preparing IPython runtime...");
- const bootstrap = await m.execute(buildRlmBootstrapCode(this.options?.pythonSkills));
- if (bootstrap.status !== "ok") {
- const details = [bootstrap.stderr, bootstrap.error?.traceback.join("\n")].filter(Boolean).join("\n");
- throw new Error(`Failed to initialize rlm runtime in the IPython kernel:\n${details}`);
+ if (this.options?.kernelManagerRef) {
+ this.options.kernelManagerRef.current = m;
}
+ return m;
+ } finally {
+ startupAbort.cleanup();
+ }
+ }
+}
+
+async function chooseBusyKernelAction(
+ ctx: ExtensionContext | undefined,
+ signal: AbortSignal | undefined,
+): Promise<"wait" | "kill" | "cancel"> {
+ if (!ctx?.hasUI) {
+ return "cancel";
+ }
+ const choice = await ctx.ui.select(BUSY_KERNEL_PROMPT, [BUSY_KERNEL_WAIT_CHOICE, BUSY_KERNEL_KILL_CHOICE], {
+ signal,
+ });
+ if (choice === BUSY_KERNEL_WAIT_CHOICE) {
+ return "wait";
+ }
+ if (choice === BUSY_KERNEL_KILL_CHOICE) {
+ return "kill";
+ }
+ return "cancel";
+}
+
+async function executeWithBusyKernelChoice(
+ provisioner: IpythonKernelProvisioner,
+ reportStartupProgress: KernelBootstrapProgressHandler,
+ code: string,
+ signal: AbortSignal | undefined,
+ onStream: (chunk: string, name: "stdout" | "stderr") => void,
+ onWorkingMessage: (message?: string) => void,
+ ctx: ExtensionContext | undefined,
+): Promise<{ result: ExecuteResult; kernelRestarted: boolean }> {
+ let kernelRestarted = false;
+ while (true) {
+ const m = await provisioner.ensure(reportStartupProgress, signal);
+ try {
+ return { result: await m.execute(code, { signal, onStream }), kernelRestarted };
} catch (error) {
- // Never leak the kernel's ZMQ sockets / temp dir if startup fails after spawn.
- void m.dispose();
+ if (!(error instanceof KernelBusyAfterInterruptError) || signal?.aborted) {
+ throw error;
+ }
+ const action = await chooseBusyKernelAction(ctx, signal);
+ if (action === "wait") {
+ onWorkingMessage("Waiting for IPython kernel...");
+ continue;
+ }
+ if (action === "kill") {
+ onWorkingMessage("Restarting IPython kernel...");
+ await provisioner.kill();
+ kernelRestarted = true;
+ continue;
+ }
throw error;
}
- // Only tell the model what was revived once the kernel is actually usable —
- // a notice claiming restored state must never outlive a failed bootstrap.
- if (pendingRestore) {
- this._lastRestore = pendingRestore;
- this.options?.onRestore?.(pendingRestore);
- }
- if (this.options?.kernelManagerRef) {
- this.options.kernelManagerRef.current = m;
- }
- return m;
}
}
@@ -406,18 +602,13 @@ export function createIpythonToolDefinition(
executionMode: "sequential",
parameters: ipythonSchema,
execute: async (_toolCallId, params, signal, onUpdate, ctx) => {
- // Cosmetic; ctx.ui can throw on a stale ctx, but must never fail the cell.
- const setWorkingMessage = (message?: string) => {
- try {
- ctx?.ui.setWorkingMessage(message);
- } catch {
- // Stale ctx; cosmetic only.
- }
+ let hasWorkingMessage = false;
+ const setToolWorkingMessage = (message?: string) => {
+ setWorkingMessage(ctx, message);
+ hasWorkingMessage = message !== undefined;
};
- let reportedStartupProgress = false;
const reportStartupProgress: KernelBootstrapProgressHandler = (message) => {
- reportedStartupProgress = true;
- setWorkingMessage(message);
+ setToolWorkingMessage(message);
onUpdate?.({
content: [{ type: "text", text: message }],
details: { status: "starting" },
@@ -425,17 +616,21 @@ export function createIpythonToolDefinition(
};
try {
- const m = await provisioner.ensure(reportStartupProgress);
const code = applyShellSettingsToBashMagicCell(params.code, options);
- const r = await m.execute(code, {
+ const { result: r, kernelRestarted } = await executeWithBusyKernelChoice(
+ provisioner,
+ reportStartupProgress,
+ code,
signal,
- onStream: (chunk) => {
+ (chunk) => {
onUpdate?.({
content: [{ type: "text", text: chunk }],
details: { status: "ok" },
});
},
- });
+ setToolWorkingMessage,
+ ctx,
+ );
let text = r.stdout;
if (r.stderr) text += (text ? "\n" : "") + r.stderr;
@@ -443,6 +638,9 @@ export function createIpythonToolDefinition(
if (r.status === "error" && r.error) {
text += (text ? "\n" : "") + r.error.traceback.join("\n");
}
+ if (kernelRestarted) {
+ text = text ? `${KERNEL_RESTART_NOTICE}\n\n${text}` : KERNEL_RESTART_NOTICE;
+ }
const imageBlocks = imageBlocksFromAttachments(r.attachments);
const content: (TextContent | ImageContent)[] = [{ type: "text", text: text || "" }, ...imageBlocks];
@@ -458,13 +656,14 @@ export function createIpythonToolDefinition(
result: r.result,
diffs: r.diffs,
attachments: r.attachments,
+ kernelRestarted,
error: r.error,
},
isError: r.status === "error" || r.status === "aborted",
};
} finally {
- if (reportedStartupProgress) {
- setWorkingMessage();
+ if (hasWorkingMessage) {
+ setToolWorkingMessage();
}
}
},
diff --git a/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts b/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts
index 0ee9cb7a9f..4d18455229 100644
--- a/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts
+++ b/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts
@@ -309,6 +309,20 @@ export class DaemonAgentConnection implements AgentConnection {
});
}
+ async abortAndClearQueue(): Promise<AgentConnectionQueueState> {
+ try {
+ return await this.requestData<AgentConnectionQueueState>({
+ type: "abort_and_clear_queue",
+ activeSessionId: this.activeSessionId,
+ });
+ } catch (error) {
+ if (isUnknownDaemonCommandError(error, "abort_and_clear_queue")) {
+ throw new Error("the daemon is running an older build; restart the daemon and try again");
+ }
+ throw error;
+ }
+ }
+
async listCronJobs(options: { includeInactive?: boolean } = {}): Promise<AgentCronJob[]> {
const data = await this.requestData<{ jobs: AgentCronJob[] }>({
type: "cron_list",
diff --git a/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts b/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
index fe0334f7be..21f4d51d23 100644
--- a/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
+++ b/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
@@ -153,6 +153,12 @@ export class InProcessAgentConnection implements AgentConnection {
return this.session.clearQueue();
}
+ async abortAndClearQueue(): Promise<AgentConnectionQueueState> {
+ const queue = this.session.clearQueue();
+ this.session.requestAbort();
+ return queue;
+ }
+
async listCronJobs(_options: { includeInactive?: boolean } = {}): Promise<AgentCronJob[]> {
return [];
}
@@ -217,7 +223,7 @@ export class InProcessAgentConnection implements AgentConnection {
}
async abort(): Promise<void> {
- await this.session.abort();
+ this.session.requestAbort();
}
async cancelRlmChild(childId: string): Promise<boolean> {
diff --git a/packages/coding-agent/src/modes/agent-connection/types.ts b/packages/coding-agent/src/modes/agent-connection/types.ts
index 7d06c97dd7..7c78350645 100644
--- a/packages/coding-agent/src/modes/agent-connection/types.ts
+++ b/packages/coding-agent/src/modes/agent-connection/types.ts
@@ -519,6 +519,7 @@ export interface AgentConnection {
): Promise<AgentConnectionSavedSessionInfo[]>;
getQueue(): Promise<AgentConnectionQueueState>;
clearQueue(): Promise<AgentConnectionQueueState>;
+ abortAndClearQueue(): Promise<AgentConnectionQueueState>;
listCronJobs(options?: { includeInactive?: boolean }): Promise<AgentCronJob[]>;
addCronJob(schedule: string, prompt: string): Promise<AgentCronJob>;
cancelCronJob(jobId: string): Promise<AgentCronJob>;
@@ -536,6 +537,7 @@ export interface AgentConnection {
prompt(message: string, options?: AgentConnectionPromptOptions): Promise<void>;
steer(message: string, images?: ImageContent[]): Promise<void>;
followUp(message: string, images?: ImageContent[]): Promise<void>;
+ /** Request cancellation of the active turn and return once the request is accepted. */
abort(): Promise<void>;
cancelRlmChild(childId: string): Promise<boolean>;
waitForIdle(): Promise<void>;
diff --git a/packages/coding-agent/src/modes/daemon/daemon-mode.ts b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
index e43aa9e9cf..f1455b5b0e 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-mode.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
@@ -174,6 +174,7 @@ const DAEMON_COMMAND_TYPES: ReadonlySet<string> = new Set([
"get_available_models",
"get_queue",
"clear_queue",
+ "abort_and_clear_queue",
"cron_list",
"cron_add",
"cron_cancel",
@@ -1523,7 +1524,7 @@ export class AgentDaemon {
case "abort": {
const state = this.getSessionState(command.activeSessionId);
- await state.runtime.session.abort();
+ state.runtime.session.requestAbort();
return success(command.id, "abort");
}
@@ -1626,6 +1627,13 @@ export class AgentDaemon {
return success(command.id, "clear_queue", state.runtime.session.clearQueue());
}
+ case "abort_and_clear_queue": {
+ const state = this.getSessionState(command.activeSessionId);
+ const queue = state.runtime.session.clearQueue();
+ state.runtime.session.requestAbort();
+ return success(command.id, "abort_and_clear_queue", queue);
+ }
+
case "cron_list": {
const jobs = this.cronStore.list().filter((job) => {
if (!command.includeInactive && job.status !== "active" && job.status !== "paused") {
diff --git a/packages/coding-agent/src/modes/daemon/daemon-protocol.ts b/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
index 442a71f271..91ec320a82 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
@@ -324,6 +324,7 @@ export type DaemonCommand =
| { id?: string; type: "get_available_models"; activeSessionId: string }
| { id?: string; type: "get_queue"; activeSessionId: string }
| { id?: string; type: "clear_queue"; activeSessionId: string }
+ | { id?: string; type: "abort_and_clear_queue"; activeSessionId: string }
| { id?: string; type: "cron_list"; activeSessionId?: string; includeInactive?: boolean }
| { id?: string; type: "cron_add"; activeSessionId: string; schedule: string; prompt: string }
| { id?: string; type: "cron_cancel"; jobId: string }
diff --git a/packages/coding-agent/src/modes/interactive/components/extension-selector.ts b/packages/coding-agent/src/modes/interactive/components/extension-selector.ts
index 44d1c45ffc..c9dec2cd11 100644
--- a/packages/coding-agent/src/modes/interactive/components/extension-selector.ts
+++ b/packages/coding-agent/src/modes/interactive/components/extension-selector.ts
@@ -16,9 +16,22 @@ export interface ExtensionSelectorOptions {
}
const PREFERRED_VISIBLE_OPTIONS = 8;
-const OPTION_LIST_RESERVED_ROWS = 6;
+const OPTION_LIST_RESERVED_BASE_ROWS = 5;
const OPTION_SCROLL_INDICATOR_ROWS = 1;
+function splitTitleAndDescription(value: string): { title: string; description?: string; descriptionRows: number } {
+ const lines = value
+ .split(/\r?\n/)
+ .map((line) => line.trim())
+ .filter((line) => line.length > 0);
+ const [title = "", ...descriptionLines] = lines;
+ return {
+ title,
+ description: descriptionLines.length > 0 ? descriptionLines.join("\n") : undefined,
+ descriptionRows: descriptionLines.length,
+ };
+}
+
export class ExtensionSelectorComponent extends Container {
private options: string[];
private selectedIndex = 0;
@@ -28,10 +41,11 @@ export class ExtensionSelectorComponent extends Container {
private baseTitle: string;
private countdown: CountdownTimer | undefined;
private panel: MenuPanel;
+ private readonly reservedRows: number;
private listLayout = getMenuListLayout({
preferredVisibleItems: PREFERRED_VISIBLE_OPTIONS,
- reservedRows: OPTION_LIST_RESERVED_ROWS,
- comfortableItemRows: 2,
+ reservedRows: OPTION_LIST_RESERVED_BASE_ROWS,
+ comfortableItemRows: 1,
compactItemRows: 1,
});
private readonly viewport: MenuViewportProvider;
@@ -48,12 +62,15 @@ export class ExtensionSelectorComponent extends Container {
this.options = options;
this.onSelectCallback = onSelect;
this.onCancelCallback = onCancel;
- this.baseTitle = title;
+ const header = splitTitleAndDescription(title);
+ this.baseTitle = header.title;
+ this.reservedRows = OPTION_LIST_RESERVED_BASE_ROWS + header.descriptionRows;
const tui = opts?.tui;
this.viewport = { getRows: opts?.getRows ?? (tui ? () => tui.terminal.rows : undefined) };
this.panel = new MenuPanel({
- title,
+ title: header.title,
+ subtitle: header.description,
});
this.addChild(this.panel);
@@ -66,7 +83,7 @@ export class ExtensionSelectorComponent extends Container {
);
}
- this.listContainer = new MenuList({ compact: () => this.listLayout.compact });
+ this.listContainer = new MenuList({ compact: true });
this.panel.addChild(this.listContainer);
this.panel.addChild(new Spacer(1));
this.panel.addChild(
@@ -146,8 +163,8 @@ export class ExtensionSelectorComponent extends Container {
getRows: this.viewport.getRows,
preferredVisibleItems: PREFERRED_VISIBLE_OPTIONS,
totalItems: this.options.length,
- reservedRows: OPTION_LIST_RESERVED_ROWS,
- comfortableItemRows: 2,
+ reservedRows: this.reservedRows,
+ comfortableItemRows: 1,
compactItemRows: 1,
scrollIndicatorRows: OPTION_SCROLL_INDICATOR_ROWS,
});
diff --git a/packages/coding-agent/src/modes/interactive/components/menu-panel.ts b/packages/coding-agent/src/modes/interactive/components/menu-panel.ts
index 2733fb51e3..222edc209c 100644
--- a/packages/coding-agent/src/modes/interactive/components/menu-panel.ts
+++ b/packages/coding-agent/src/modes/interactive/components/menu-panel.ts
@@ -5,6 +5,7 @@ import {
Input,
truncateToWidth,
visibleWidth,
+ wrapTextWithAnsi,
} from "@earendil-works/pi-tui";
import { theme } from "../theme/theme.js";
@@ -190,6 +191,15 @@ function surfaceLine(text: string, width: number, paddingX = PANEL_PADDING_X): s
return theme.getEditorBackgroundColor()?.(line) ?? line;
}
+function surfaceWrappedLines(text: string, width: number, paddingX = PANEL_PADDING_X): string[] {
+ const innerWidth = Math.max(1, width - paddingX * 2);
+ return wrapTextWithAnsi(text, innerWidth).map((content) => {
+ const rightPadding = " ".repeat(Math.max(0, innerWidth - visibleWidth(content)));
+ const line = " ".repeat(paddingX) + content + rightPadding + " ".repeat(paddingX);
+ return theme.getEditorBackgroundColor()?.(line) ?? line;
+ });
+}
+
function padLine(text: string, width: number, paddingX: number): string {
const innerWidth = Math.max(1, width - paddingX * 2);
const content = truncateToWidth(text, innerWidth, "");
@@ -218,12 +228,14 @@ export class MenuPanel extends Container {
lines.push(surfaceLine("", safeWidth));
}
const hasTitle = this.title.trim().length > 0;
- const hasHeader = hasTitle || this.options.subtitle !== undefined;
+ const subtitle = this.options.subtitle?.trim();
+ const hasSubtitle = subtitle !== undefined && subtitle.length > 0;
+ const hasHeader = hasTitle || hasSubtitle;
if (hasTitle) {
lines.push(surfaceLine(theme.bold(theme.fg("text", this.title)), safeWidth));
}
- if (this.options.subtitle) {
- lines.push(surfaceLine(theme.fg("muted", this.options.subtitle), safeWidth));
+ if (hasSubtitle) {
+ lines.push(...surfaceWrappedLines(theme.fg("muted", subtitle), safeWidth));
}
if (hasHeader) {
lines.push(surfaceLine("", safeWidth));
diff --git a/packages/coding-agent/src/modes/interactive/interactive-mode.ts b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
index 6c41160a64..c793774b88 100644
--- a/packages/coding-agent/src/modes/interactive/interactive-mode.ts
+++ b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
@@ -5508,24 +5508,18 @@ export class InteractiveMode {
private interruptOrClearInput(): void {
if (this.getRetryAttempt() > 0) {
void this.agentConnection.abortRetry();
- return;
}
if (this.isAgentCompacting()) {
void this.agentConnection.abortCompaction();
void this.agentConnection.abortBranchSummary();
- return;
}
- // Bash outranks the agent stream: the already-running warning tells the user
- // this key cancels the bash command, and the stream stays one press away.
if (this.isBashRunning()) {
void this.agentConnection.abortBash();
- return;
}
if (this.isAgentStreaming()) {
void this.restoreQueuedMessagesToEditor({ abort: true }).catch((error) => {
this.showError(error instanceof Error ? error.message : String(error));
});
- return;
}
}
@@ -6007,8 +6001,12 @@ export class InteractiveMode {
* Clear all queued messages and return their contents.
* Clears both session queue and compaction queue.
*/
- private async clearAllQueues(): Promise<{ steering: string[]; followUp: string[] }> {
- const { steering, followUp } = await this.agentConnection.clearQueue();
+ private async clearAllQueues(
+ options: { abort?: boolean } = {},
+ ): Promise<{ steering: string[]; followUp: string[] }> {
+ const { steering, followUp } = options.abort
+ ? await this.agentConnection.abortAndClearQueue()
+ : await this.agentConnection.clearQueue();
this.connectionQueue = { steering: [], followUp: [] };
const compactionSteering = this.compactionQueuedMessages
.filter((msg) => msg.mode === "steer")
@@ -6061,13 +6059,10 @@ export class InteractiveMode {
}
private async restoreQueuedMessagesToEditor(options?: { abort?: boolean; currentText?: string }): Promise<number> {
- const { steering, followUp } = await this.clearAllQueues();
+ const { steering, followUp } = await this.clearAllQueues({ abort: options?.abort });
const allQueued = [...steering, ...followUp];
if (allQueued.length === 0) {
this.updatePendingMessagesDisplay();
- if (options?.abort) {
- await this.agentConnection.abort();
- }
return 0;
}
const queuedText = allQueued.join("\n\n");
@@ -6077,9 +6072,6 @@ export class InteractiveMode {
// on resubmit without any re-registration here.
this.editor.setText(combinedText);
this.updatePendingMessagesDisplay();
- if (options?.abort) {
- await this.agentConnection.abort();
- }
return allQueued.length;
}
diff --git a/packages/coding-agent/test/agent-connection-daemon.test.ts b/packages/coding-agent/test/agent-connection-daemon.test.ts
index af689c5bdc..da0f268445 100644
--- a/packages/coding-agent/test/agent-connection-daemon.test.ts
+++ b/packages/coding-agent/test/agent-connection-daemon.test.ts
@@ -28,6 +28,7 @@ class FakeDaemonClient {
attachResultFactory: ((command: Extract<DaemonCommand, { type: "attach" }>) => DaemonAttachResult) | undefined;
closeCount = 0;
abortBashUnknownCommand = false;
+ abortAndClearQueueUnknownCommand = false;
private readonly messageListeners = new Set<DaemonClientMessageListener>();
private readonly closeListeners = new Set<DaemonClientCloseListener>();
@@ -167,6 +168,21 @@ class FakeDaemonClient {
success: true,
data: { steering: ["cleared"], followUp: [] },
};
+ case "abort_and_clear_queue":
+ if (this.abortAndClearQueueUnknownCommand) {
+ return {
+ type: "response",
+ command: command.type,
+ success: false,
+ error: "Unknown daemon command: abort_and_clear_queue",
+ };
+ }
+ return {
+ type: "response",
+ command: command.type,
+ success: true,
+ data: { steering: ["aborted"], followUp: ["cleared"] },
+ };
case "list_saved_sessions":
options.onProgress?.({
id: "daemon_test",
@@ -764,6 +780,7 @@ describe("DaemonAgentConnection", () => {
await expect(connection.getQueue()).resolves.toEqual({ steering: ["steer"], followUp: ["follow"] });
await expect(connection.clearQueue()).resolves.toEqual({ steering: ["cleared"], followUp: [] });
+ await expect(connection.abortAndClearQueue()).resolves.toEqual({ steering: ["aborted"], followUp: ["cleared"] });
await connection.waitForIdle();
const model = getModel("anthropic", "claude-sonnet-4-5");
if (!model) {
@@ -775,17 +792,24 @@ describe("DaemonAgentConnection", () => {
"attach",
"get_queue",
"clear_queue",
+ "abort_and_clear_queue",
"wait_for_idle",
"set_scoped_models",
]);
expect(fakeClient.requests[1]).toMatchObject({ type: "get_queue", activeSessionId: "active-1" });
expect(fakeClient.requests[2]).toMatchObject({ type: "clear_queue", activeSessionId: "active-1" });
- expect(fakeClient.requests[3]).toMatchObject({ type: "wait_for_idle", activeSessionId: "active-1" });
- expect(fakeClient.requests[4]).toMatchObject({
+ expect(fakeClient.requests[3]).toMatchObject({ type: "abort_and_clear_queue", activeSessionId: "active-1" });
+ expect(fakeClient.requests[4]).toMatchObject({ type: "wait_for_idle", activeSessionId: "active-1" });
+ expect(fakeClient.requests[5]).toMatchObject({
type: "set_scoped_models",
activeSessionId: "active-1",
scopedModels: [{ model, thinkingLevel: "high" }],
});
+
+ fakeClient.abortAndClearQueueUnknownCommand = true;
+ await expect(connection.abortAndClearQueue()).rejects.toThrow(
+ "the daemon is running an older build; restart the daemon and try again",
+ );
});
it("cancels rlm child runs through the daemon protocol", async () => {
diff --git a/packages/coding-agent/test/agent-session-concurrent.test.ts b/packages/coding-agent/test/agent-session-concurrent.test.ts
index de2d4e55c1..075ba40072 100644
--- a/packages/coding-agent/test/agent-session-concurrent.test.ts
+++ b/packages/coding-agent/test/agent-session-concurrent.test.ts
@@ -288,7 +288,14 @@ describe("AgentSession concurrent prompt guard", () => {
await session.abort();
await firstPrompt.catch(() => {});
+ expect(sawSteeringMessage).toBe(false);
+ expect(session.getSteeringMessages()).toContain("Steer from extension");
+ expect(session.pendingMessageCount).toBe(1);
+
+ await session.prompt("After abort");
+
expect(sawSteeringMessage).toBe(true);
+ expect(session.pendingMessageCount).toBe(0);
});
it("delivers accepted agent messages without extension input interception", async () => {
diff --git a/packages/coding-agent/test/agent-session-recursion.test.ts b/packages/coding-agent/test/agent-session-recursion.test.ts
index 9bf1221ebb..4882381fed 100644
--- a/packages/coding-agent/test/agent-session-recursion.test.ts
+++ b/packages/coding-agent/test/agent-session-recursion.test.ts
@@ -482,6 +482,40 @@ describe("AgentSession rlm recursion", () => {
await expect(runPromise).rejects.toThrow("Parent session aborted");
});
+ it("does not cancel active rlm children when only the parent turn is interrupted", async () => {
+ let releaseChild: () => void = () => {};
+ const release = new Promise<void>((resolve) => {
+ releaseChild = resolve;
+ });
+ let childStarted = false;
+ const root = createSession({
+ streamFn: (_model, context) => {
+ const text = userText(context);
+ const stream = createAssistantMessageEventStream();
+ if (text === "slow shard") {
+ childStarted = true;
+ void release.then(() => {
+ stream.push({ type: "done", reason: "stop", message: assistantMessage(`child answer: ${text}`) });
+ });
+ }
+ return stream;
+ },
+ });
+
+ const runPromise = root.runRlmChild("slow shard");
+ await waitFor(() => childStarted);
+ const runs = (root as unknown as InspectableRlmSession)._activeRlmChildRuns;
+ expect(runs.size).toBe(1);
+ const run = [...runs.values()][0];
+
+ root.requestAbort();
+
+ expect(run.status).toBe("running");
+ expect(run.error).toBeUndefined();
+ releaseChild();
+ await expect(runPromise).resolves.toMatchObject({ answer: "child answer: slow shard" });
+ });
+
it("cancels a single rlm child run by id and reports unknown ids", async () => {
let releaseChild: () => void = () => {};
const release = new Promise<void>((resolve) => {
diff --git a/packages/coding-agent/test/extension-selector.test.ts b/packages/coding-agent/test/extension-selector.test.ts
new file mode 100644
index 0000000000..0081792b37
--- /dev/null
+++ b/packages/coding-agent/test/extension-selector.test.ts
@@ -0,0 +1,40 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import stripAnsi from "strip-ansi";
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { ExtensionSelectorComponent } from "../src/modes/interactive/components/extension-selector.js";
+import { initTheme } from "../src/modes/interactive/theme/theme.js";
+
+describe("ExtensionSelectorComponent", () => {
+ beforeAll(() => {
+ initTheme("dark");
+ });
+
+ it("renders a multiline prompt with compact option rows", () => {
+ const selector = new ExtensionSelectorComponent(
+ [
+ "Interrupted IPython cell is still running",
+ "Ctrl+C sent an interrupt, but the previous cell has not stopped yet.",
+ "Waiting preserves the current kernel state. Killing restarts IPython and loses in-memory variables.",
+ ].join("\n"),
+ ["Wait and preserve state", "Kill kernel and restart"],
+ vi.fn(),
+ vi.fn(),
+ { getRows: () => 24 },
+ );
+
+ const lines = selector.render(88);
+ const outputLines = lines.map((line) => stripAnsi(line));
+ const output = outputLines.join("\n");
+ const waitIndex = outputLines.findIndex((line) => line.includes("Wait and preserve state"));
+ const killIndex = outputLines.findIndex((line) => line.includes("Kill kernel and restart"));
+
+ expect(output).toContain("Interrupted IPython cell is still running");
+ expect(output).toContain("Ctrl+C sent an interrupt");
+ expect(output).toContain("Waiting preserves the current kernel state");
+ expect(waitIndex).toBeGreaterThan(-1);
+ expect(killIndex).toBe(waitIndex + 1);
+ for (const line of lines) {
+ expect(visibleWidth(line)).toBe(88);
+ }
+ });
+});
diff --git a/packages/coding-agent/test/interactive-mode-ctrl-c.test.ts b/packages/coding-agent/test/interactive-mode-ctrl-c.test.ts
index 3290cf164a..da3653eea3 100644
--- a/packages/coding-agent/test/interactive-mode-ctrl-c.test.ts
+++ b/packages/coding-agent/test/interactive-mode-ctrl-c.test.ts
@@ -18,16 +18,24 @@ type FakeInteractiveMode = {
connectionState: {
isStreaming: boolean;
isCompacting: boolean;
+ isBashRunning: boolean;
retryAttempt: number;
};
+ connectionQueue: { steering: string[]; followUp: string[] };
+ compactionQueuedMessages: Array<{ text: string; mode: "steer" | "followUp" }>;
agentConnection: {
+ abort: Mock;
+ clearQueue: Mock;
+ abortAndClearQueue: Mock;
abortRetry: Mock;
abortCompaction: Mock;
abortBranchSummary: Mock;
+ abortBash: Mock;
};
childAgentSummary: { invalidate: Mock };
ui: { requestRender: Mock; onDebug?: () => void };
restoreQueuedMessagesToEditor: Mock;
+ updatePendingMessagesDisplay: Mock;
shutdown: Mock;
updateEditorBorderColor: Mock;
defaultEditor?: {
@@ -62,6 +70,7 @@ function createInteractiveFake(options: {
editorText?: string;
streaming?: boolean;
compacting?: boolean;
+ bashRunning?: boolean;
retryAttempt?: number;
}): FakeInteractiveMode {
const editor = createEditor(options.editorText ?? "");
@@ -73,16 +82,24 @@ function createInteractiveFake(options: {
connectionState: {
isStreaming: options.streaming ?? false,
isCompacting: options.compacting ?? false,
+ isBashRunning: options.bashRunning ?? false,
retryAttempt: options.retryAttempt ?? 0,
},
+ connectionQueue: { steering: [], followUp: [] },
+ compactionQueuedMessages: [],
agentConnection: {
+ abort: vi.fn().mockResolvedValue(undefined),
+ clearQueue: vi.fn().mockResolvedValue({ steering: [], followUp: [] }),
+ abortAndClearQueue: vi.fn().mockResolvedValue({ steering: [], followUp: [] }),
abortRetry: vi.fn(),
abortCompaction: vi.fn(),
abortBranchSummary: vi.fn(),
+ abortBash: vi.fn(),
},
childAgentSummary: { invalidate: vi.fn() },
ui: { requestRender: vi.fn() },
restoreQueuedMessagesToEditor: vi.fn().mockResolvedValue(0),
+ updatePendingMessagesDisplay: vi.fn(),
shutdown: vi.fn().mockResolvedValue(undefined),
updateEditorBorderColor: vi.fn(),
};
@@ -113,6 +130,33 @@ describe("InteractiveMode Ctrl+C flow", () => {
);
});
+ it("interrupts bash and streaming on the same Ctrl+C", () => {
+ const mode = createInteractiveFake({ streaming: true, bashRunning: true });
+
+ Reflect.get(InteractiveMode.prototype, "handleCtrlC").call(mode);
+
+ expect(mode.agentConnection.abortBash).toHaveBeenCalledTimes(1);
+ expect(mode.restoreQueuedMessagesToEditor).toHaveBeenCalledWith({ abort: true });
+ expect(mode.shutdown).not.toHaveBeenCalled();
+ });
+
+ it("restores queued messages through the atomic abort-and-clear path", async () => {
+ const mode = createInteractiveFake({ editorText: "draft" });
+ mode.agentConnection.abortAndClearQueue.mockResolvedValue({
+ steering: ["steer"],
+ followUp: ["follow"],
+ });
+
+ const restoreQueuedMessagesToEditor = Reflect.get(InteractiveMode.prototype, "restoreQueuedMessagesToEditor");
+ const restored = await restoreQueuedMessagesToEditor.call(mode, { abort: true });
+
+ expect(restored).toBe(2);
+ expect(mode.agentConnection.abortAndClearQueue).toHaveBeenCalledTimes(1);
+ expect(mode.agentConnection.clearQueue).not.toHaveBeenCalled();
+ expect(mode.agentConnection.abort).not.toHaveBeenCalled();
+ expect(mode.editor.getText()).toBe("steer\n\nfollow\n\ndraft");
+ });
+
it("exits on the second Ctrl+C while the hint is visible", () => {
const mode = createInteractiveFake({ streaming: true });
const handleCtrlC = Reflect.get(InteractiveMode.prototype, "handleCtrlC");
@@ -172,6 +216,7 @@ describe("InteractiveMode Ctrl+C flow", () => {
expect(mode.agentConnection.abortRetry).not.toHaveBeenCalled();
expect(mode.agentConnection.abortCompaction).not.toHaveBeenCalled();
expect(mode.agentConnection.abortBranchSummary).not.toHaveBeenCalled();
+ expect(mode.agentConnection.abortBash).not.toHaveBeenCalled();
expect(mode.restoreQueuedMessagesToEditor).not.toHaveBeenCalled();
});
});
diff --git a/packages/coding-agent/test/ipython-provisioner.test.ts b/packages/coding-agent/test/ipython-provisioner.test.ts
index ffb6cee6ed..4370e5356b 100644
--- a/packages/coding-agent/test/ipython-provisioner.test.ts
+++ b/packages/coding-agent/test/ipython-provisioner.test.ts
@@ -3,8 +3,10 @@ import { tmpdir } from "node:os";
import { join } from "node:path";
import { cleanupSessionResources } from "@earendil-works/pi-ai";
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { KernelManager } from "../src/core/kernel/index.js";
-import { IpythonKernelProvisioner } from "../src/core/tools/ipython.js";
+import type { ExtensionContext } from "../src/core/extensions/types.js";
+import type { KernelBootstrapProgressHandler } from "../src/core/kernel/bootstrap.js";
+import { type ExecuteResult, KernelBusyAfterInterruptError, KernelManager } from "../src/core/kernel/index.js";
+import { createIpythonToolDefinition, IpythonKernelProvisioner } from "../src/core/tools/ipython.js";
let tempDir = "";
@@ -43,6 +45,32 @@ function writeFakePython(opts: { sleepSeconds?: number } = {}): { python: string
return { python, countRuns };
}
+function okExecuteResult(): ExecuteResult {
+ return { stdout: "ok", stderr: "", status: "ok", durationMs: 1 };
+}
+
+function createBusyKernelContext(
+ select: (title: string, options: string[]) => Promise<string | undefined>,
+ options: { throwWorkingMessage?: boolean } = {},
+): {
+ ctx: ExtensionContext;
+ setWorkingMessage: ReturnType<typeof vi.fn>;
+} {
+ const setWorkingMessage = vi.fn(() => {
+ if (options.throwWorkingMessage) {
+ throw new Error("stale UI context");
+ }
+ });
+ const ctx = {
+ hasUI: true,
+ ui: {
+ select,
+ setWorkingMessage,
+ },
+ } as unknown as ExtensionContext;
+ return { ctx, setWorkingMessage };
+}
+
describe("IpythonKernelProvisioner", () => {
beforeEach(() => {
tempDir = mkdtempSync(join(tmpdir(), "prime-agent-provisioner-"));
@@ -123,6 +151,25 @@ describe("IpythonKernelProvisioner", () => {
expect(countRuns()).toBe(0); // disposed boot must never spawn a kernel
});
+ it("aborting the startup owner before the boot slot prevents the kernel from spawning", async () => {
+ const { python, countRuns } = writeFakePython();
+ let release: () => void = () => {};
+ const gate = new Promise<void>((r) => {
+ release = r;
+ });
+ const provisioner = new IpythonKernelProvisioner(tempDir, { python, readyGate: gate });
+ const controller = new AbortController();
+
+ const started = provisioner.ensure(undefined, controller.signal);
+ controller.abort();
+ await expect(started).rejects.toThrow("IPython execution aborted");
+ release();
+ await new Promise((r) => setTimeout(r, 50));
+
+ expect(countRuns()).toBe(0);
+ expect(provisioner.manager).toBeUndefined();
+ });
+
it("waits for readyGate before starting the kernel", async () => {
const { python, countRuns } = writeFakePython();
let release: () => void = () => {};
@@ -145,6 +192,112 @@ describe("IpythonKernelProvisioner", () => {
expect(await provisioner.listNamespaceNames()).toBeNull();
});
+ it("does not dispose a running kernel when an ensure caller is aborted", async () => {
+ const provisioner = new IpythonKernelProvisioner(tempDir, {});
+ const dispose = vi.fn(async () => {});
+ const manager = { dispose, isRunning: true } as unknown as KernelManager;
+ Object.assign(
+ provisioner as unknown as {
+ managerPromise: Promise<KernelManager>;
+ startedManager: KernelManager;
+ },
+ {
+ managerPromise: Promise.resolve(manager),
+ startedManager: manager,
+ },
+ );
+ const controller = new AbortController();
+ controller.abort();
+
+ await expect(provisioner.ensure(undefined, controller.signal)).rejects.toThrow("IPython execution aborted");
+ expect(dispose).not.toHaveBeenCalled();
+ expect(provisioner.manager).toBe(manager);
+ });
+
+ it("removes startup progress listeners when an ensure caller is aborted", async () => {
+ const provisioner = new IpythonKernelProvisioner(tempDir, {});
+ Object.assign(
+ provisioner as unknown as {
+ managerPromise: Promise<KernelManager>;
+ },
+ {
+ managerPromise: new Promise<KernelManager>(() => {}),
+ },
+ );
+ const controller = new AbortController();
+ const onProgress = vi.fn();
+
+ const ensurePromise = provisioner.ensure(onProgress, controller.signal).catch(() => undefined);
+ controller.abort();
+ await ensurePromise;
+
+ const internals = provisioner as unknown as {
+ startupListeners: Set<KernelBootstrapProgressHandler>;
+ };
+ expect(internals.startupListeners.has(onProgress)).toBe(false);
+ });
+
+ it("lets the user wait when an interrupted kernel is still busy", async () => {
+ const execute = vi
+ .fn<KernelManager["execute"]>()
+ .mockRejectedValueOnce(new KernelBusyAfterInterruptError())
+ .mockResolvedValueOnce(okExecuteResult());
+ const manager = { execute } as unknown as KernelManager;
+ const ensure = vi.fn(async () => manager);
+ const kill = vi.fn(async () => {});
+ const provisioner = { ensure, kill } as unknown as IpythonKernelProvisioner;
+ const select = vi.fn(async () => "Wait and preserve state");
+ const { ctx, setWorkingMessage } = createBusyKernelContext(select, { throwWorkingMessage: true });
+ const tool = createIpythonToolDefinition(tempDir, { provisioner });
+
+ const result = await tool.execute("tool-call", { code: "x = 1" }, undefined, undefined, ctx);
+
+ expect(result.details.status).toBe("ok");
+ expect(result.details.kernelRestarted).toBe(false);
+ expect(ensure).toHaveBeenCalledTimes(2);
+ expect(kill).not.toHaveBeenCalled();
+ expect(select).toHaveBeenCalledWith(
+ expect.stringContaining("previous cell has not stopped"),
+ ["Wait and preserve state", "Kill kernel and restart"],
+ {
+ signal: undefined,
+ },
+ );
+ expect(setWorkingMessage).toHaveBeenCalledWith("Waiting for IPython kernel...");
+ expect(setWorkingMessage).toHaveBeenLastCalledWith(undefined);
+ });
+
+ it("lets the user kill and restart a busy interrupted kernel", async () => {
+ const busyManager = {
+ execute: vi.fn<KernelManager["execute"]>().mockRejectedValueOnce(new KernelBusyAfterInterruptError()),
+ } as unknown as KernelManager;
+ const freshManager = {
+ execute: vi.fn<KernelManager["execute"]>().mockResolvedValueOnce(okExecuteResult()),
+ } as unknown as KernelManager;
+ const ensure = vi.fn(async () => {
+ return ensure.mock.calls.length === 1 ? busyManager : freshManager;
+ });
+ const kill = vi.fn(async () => {});
+ const provisioner = { ensure, kill } as unknown as IpythonKernelProvisioner;
+ const select = vi.fn(async () => "Kill kernel and restart");
+ const { ctx, setWorkingMessage } = createBusyKernelContext(select, { throwWorkingMessage: true });
+ const tool = createIpythonToolDefinition(tempDir, { provisioner });
+
+ const result = await tool.execute("tool-call", { code: "x = 1" }, undefined, undefined, ctx);
+ const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+
+ expect(result.details.status).toBe("ok");
+ expect(result.details.kernelRestarted).toBe(true);
+ expect(text).toContain("<ipython_kernel_reset>");
+ expect(text).toContain("Variables, imports, async tasks, and open resources");
+ expect(text).toContain("ok");
+ expect(ensure).toHaveBeenCalledTimes(2);
+ expect(kill).toHaveBeenCalledTimes(1);
+ expect(freshManager.execute).toHaveBeenCalledWith("x = 1", expect.objectContaining({ signal: undefined }));
+ expect(setWorkingMessage).toHaveBeenCalledWith("Restarting IPython kernel...");
+ expect(setWorkingMessage).toHaveBeenLastCalledWith(undefined);
+ });
+
it("does not delete the on-disk snapshot (the kernel survives compaction)", async () => {
const snapshotDir = join(tempDir, "artifacts");
const provisioner = new IpythonKernelProvisioner(tempDir, { snapshotDir });
diff --git a/packages/coding-agent/test/kernel-abort.test.ts b/packages/coding-agent/test/kernel-abort.test.ts
new file mode 100644
index 0000000000..b1bd136293
--- /dev/null
+++ b/packages/coding-agent/test/kernel-abort.test.ts
@@ -0,0 +1,289 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { KernelManager } from "../src/core/kernel/index.js";
+
+async function waitForCalls(mock: { mock: { calls: unknown[][] } }, count: number): Promise<void> {
+ for (let i = 0; i < 20; i++) {
+ if (mock.mock.calls.length >= count) {
+ return;
+ }
+ await Promise.resolve();
+ }
+ expect(mock.mock.calls.length).toBeGreaterThanOrEqual(count);
+}
+
+describe("KernelManager abort handling", () => {
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+
+ it("does not poison startup after a caller starts with an aborted signal", async () => {
+ const manager = new KernelManager({ cwd: process.cwd() });
+ let startCount = 0;
+ Object.assign(
+ manager as unknown as {
+ doStart: () => Promise<void>;
+ },
+ {
+ doStart: async () => {
+ startCount++;
+ },
+ },
+ );
+ const controller = new AbortController();
+ controller.abort();
+
+ await expect(manager.start({ signal: controller.signal })).rejects.toThrow("Kernel startup aborted");
+ await expect(manager.start()).resolves.toBeUndefined();
+ expect(startCount).toBe(1);
+ });
+
+ it("does not cancel shared startup when one waiting caller aborts", async () => {
+ const manager = new KernelManager({ cwd: process.cwd() });
+ let releaseStart: () => void = () => {};
+ let startCount = 0;
+ Object.assign(
+ manager as unknown as {
+ doStart: () => Promise<void>;
+ },
+ {
+ doStart: async () => {
+ startCount++;
+ await new Promise<void>((resolve) => {
+ releaseStart = resolve;
+ });
+ },
+ },
+ );
+ const controller = new AbortController();
+
+ const firstStart = manager.start({ signal: controller.signal });
+ const secondStart = manager.start();
+ controller.abort();
+
+ await expect(firstStart).rejects.toThrow("Kernel startup aborted");
+ releaseStart();
+ await expect(secondStart).resolves.toBeUndefined();
+ expect(startCount).toBe(1);
+ });
+
+ it("settles an aborted execution when the kernel never reports idle", async () => {
+ vi.useFakeTimers();
+ const manager = new KernelManager({ cwd: process.cwd() });
+ const shellSend = vi.fn(async (_frames: Buffer[]) => {});
+ const controlSend = vi.fn(async (_frames: Buffer[]) => {});
+ const kernelKill = vi.fn((_signal?: NodeJS.Signals | number) => true);
+ Object.assign(
+ manager as unknown as {
+ state: "running";
+ connection: {
+ ip: "127.0.0.1";
+ transport: "tcp";
+ shell_port: number;
+ iopub_port: number;
+ stdin_port: number;
+ control_port: number;
+ hb_port: number;
+ signature_scheme: "hmac-sha256";
+ key: string;
+ kernel_name: string;
+ };
+ shell: { send: (frames: Buffer[]) => Promise<void>; close: () => void };
+ control: { send: (frames: Buffer[]) => Promise<void>; close: () => void };
+ kernel: { kill: (signal?: NodeJS.Signals | number) => boolean };
+ start: () => Promise<void>;
+ },
+ {
+ state: "running",
+ connection: {
+ ip: "127.0.0.1",
+ transport: "tcp",
+ shell_port: 1,
+ iopub_port: 2,
+ stdin_port: 3,
+ control_port: 4,
+ hb_port: 5,
+ signature_scheme: "hmac-sha256",
+ key: "test-key",
+ kernel_name: "python3",
+ },
+ shell: { send: shellSend, close: vi.fn() },
+ control: { send: controlSend, close: vi.fn() },
+ kernel: { kill: kernelKill },
+ start: async () => {},
+ },
+ );
+ const controller = new AbortController();
+
+ const executePromise = manager.execute("while True: pass", { signal: controller.signal });
+ await waitForCalls(shellSend, 1);
+ expect(shellSend).toHaveBeenCalledTimes(1);
+
+ controller.abort();
+ await vi.advanceTimersByTimeAsync(1000);
+
+ await expect(executePromise).resolves.toMatchObject({ status: "aborted" });
+ expect(controlSend).toHaveBeenCalled();
+ expect(kernelKill).not.toHaveBeenCalled();
+
+ const internals = manager as unknown as {
+ activeExecution?: { requestMsgId: string };
+ handleExecutionMessage: (incoming: {
+ header: { msg_type: string };
+ parent_header: Record<string, unknown>;
+ metadata: Record<string, unknown>;
+ content: Record<string, unknown>;
+ }) => void;
+ };
+ const activeExecution = internals.activeExecution;
+ expect(activeExecution).toBeDefined();
+ if (!activeExecution) {
+ throw new Error("Expected active execution to remain until kernel idle");
+ }
+ const secondExecutePromise = manager.execute("x = 1");
+ await Promise.resolve();
+ expect(shellSend).toHaveBeenCalledTimes(1);
+
+ internals.handleExecutionMessage({
+ header: { msg_type: "status" },
+ parent_header: { msg_id: activeExecution.requestMsgId },
+ metadata: {},
+ content: { execution_state: "idle" },
+ });
+ await waitForCalls(shellSend, 2);
+ expect(shellSend).toHaveBeenCalledTimes(2);
+
+ const secondExecution = internals.activeExecution;
+ expect(secondExecution).toBeDefined();
+ if (!secondExecution) {
+ throw new Error("Expected second execution to start after previous cell went idle");
+ }
+ internals.handleExecutionMessage({
+ header: { msg_type: "status" },
+ parent_header: { msg_id: secondExecution.requestMsgId },
+ metadata: {},
+ content: { execution_state: "idle" },
+ });
+ await expect(secondExecutePromise).resolves.toMatchObject({ status: "ok" });
+
+ manager.disposeSync();
+ expect(kernelKill).toHaveBeenCalledWith("SIGTERM");
+ });
+
+ it("settles an aborted execution when shell send never resolves", async () => {
+ vi.useFakeTimers();
+ const manager = new KernelManager({ cwd: process.cwd() });
+ const shellSend = vi.fn((_frames: Buffer[]) => new Promise<void>(() => {}));
+ const controlSend = vi.fn(async (_frames: Buffer[]) => {});
+ Object.assign(
+ manager as unknown as {
+ state: "running";
+ connection: {
+ ip: "127.0.0.1";
+ transport: "tcp";
+ shell_port: number;
+ iopub_port: number;
+ stdin_port: number;
+ control_port: number;
+ hb_port: number;
+ signature_scheme: "hmac-sha256";
+ key: string;
+ kernel_name: string;
+ };
+ shell: { send: (frames: Buffer[]) => Promise<void>; close: () => void };
+ control: { send: (frames: Buffer[]) => Promise<void>; close: () => void };
+ start: () => Promise<void>;
+ },
+ {
+ state: "running",
+ connection: {
+ ip: "127.0.0.1",
+ transport: "tcp",
+ shell_port: 1,
+ iopub_port: 2,
+ stdin_port: 3,
+ control_port: 4,
+ hb_port: 5,
+ signature_scheme: "hmac-sha256",
+ key: "test-key",
+ kernel_name: "python3",
+ },
+ shell: { send: shellSend, close: vi.fn() },
+ control: { send: controlSend, close: vi.fn() },
+ start: async () => {},
+ },
+ );
+ const controller = new AbortController();
+
+ const executePromise = manager.execute("while True: pass", { signal: controller.signal });
+ await waitForCalls(shellSend, 1);
+ controller.abort();
+ await vi.advanceTimersByTimeAsync(1000);
+
+ await expect(executePromise).resolves.toMatchObject({ status: "aborted" });
+ expect(controlSend).toHaveBeenCalled();
+ });
+
+ it("fails a later execution fast when the interrupted cell never idles", async () => {
+ vi.useFakeTimers();
+ const manager = new KernelManager({ cwd: process.cwd() });
+ const shellSend = vi.fn(async (_frames: Buffer[]) => {});
+ const controlSend = vi.fn(async (_frames: Buffer[]) => {});
+ Object.assign(
+ manager as unknown as {
+ state: "running";
+ connection: {
+ ip: "127.0.0.1";
+ transport: "tcp";
+ shell_port: number;
+ iopub_port: number;
+ stdin_port: number;
+ control_port: number;
+ hb_port: number;
+ signature_scheme: "hmac-sha256";
+ key: string;
+ kernel_name: string;
+ };
+ shell: { send: (frames: Buffer[]) => Promise<void>; close: () => void };
+ control: { send: (frames: Buffer[]) => Promise<void>; close: () => void };
+ start: () => Promise<void>;
+ },
+ {
+ state: "running",
+ connection: {
+ ip: "127.0.0.1",
+ transport: "tcp",
+ shell_port: 1,
+ iopub_port: 2,
+ stdin_port: 3,
+ control_port: 4,
+ hb_port: 5,
+ signature_scheme: "hmac-sha256",
+ key: "test-key",
+ kernel_name: "python3",
+ },
+ shell: { send: shellSend, close: vi.fn() },
+ control: { send: controlSend, close: vi.fn() },
+ start: async () => {},
+ },
+ );
+ const controller = new AbortController();
+
+ const executePromise = manager.execute("while True: pass", { signal: controller.signal });
+ await waitForCalls(shellSend, 1);
+ controller.abort();
+ await vi.advanceTimersByTimeAsync(1000);
+ await expect(executePromise).resolves.toMatchObject({ status: "aborted" });
+
+ const secondExecutePromise = manager.execute("x = 1");
+ const secondExecuteExpectation = expect(secondExecutePromise).rejects.toThrow(
+ "IPython kernel is still running the previously interrupted cell",
+ );
+ await Promise.resolve();
+ await vi.advanceTimersByTimeAsync(5000);
+
+ await secondExecuteExpectation;
+ expect(shellSend).toHaveBeenCalledTimes(1);
+ expect(controlSend).toHaveBeenCalled();
+ manager.disposeSync();
+ });
+});
diff --git a/packages/coding-agent/test/suite/agent-session-prompt.test.ts b/packages/coding-agent/test/suite/agent-session-prompt.test.ts
index 4dce87d1f7..2b97105228 100644
--- a/packages/coding-agent/test/suite/agent-session-prompt.test.ts
+++ b/packages/coding-agent/test/suite/agent-session-prompt.test.ts
@@ -646,6 +646,7 @@ stale extension instructions`,
// The cleared run's events are still stalled in the session event queue;
// run a newer prompt so its messages land in state before the stale cleanup.
+ harness.setResponses([fauxAssistantMessage("after clear response")]);
gateAgentStart = false;
await harness.session.prompt("after clear");
releaseGate();