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.mdindex 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.tsindex 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 stopwhile (true) {+ throwIfAborted(signal);let hasMoreToolCalls = true;// Inner loop: process tool calls and steering messageswhile (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 thempendingMessages = 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.tsindex 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.tsindex 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 typeinterface CustomNotification {diff --git a/packages/agent/test/agent.test.ts b/packages/agent/test/agent.test.tsindex 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 AssistantMessageEventStreamclass 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.mdindex 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.tsindex 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 stateprivate _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 stateprivate _branchSummaryAbortController: AbortController | undefined = undefined;+ private _branchSummaryOperation: Promise<void> | undefined = undefined;// Retry stateprivate _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 summarizationthis._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.tsindex 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 | "oversizedreturn { 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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): sreturn 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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: stringreturn { 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.tsnew file mode 100644index 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.tsindex 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();