Simplify compaction: remove proactive abort, use Agent.continue() for retry

- Add agentLoopContinue() to pi-ai for resuming from existing context
- Add Agent.continue() method and transport.continue() interface
- Simplify AgentSession compaction to two cases: overflow (auto-retry) and threshold (no retry)
- Remove proactive mid-turn compaction abort
- Merge turn prefix summary into main summary
- Add isCompacting property to AgentSession and RPC state
- Block input during compaction in interactive mode
- Show compaction count on session resume
- Rename RPC.md to rpc.md for consistency

Related to #128

packages/agent/src/agent.ts

@@ -176,11 +176,6 @@ export class Agent {
 			throw new Error("No model configured");
 		}
 
-		// Set up running prompt tracking
-		this.runningPrompt = new Promise<void>((resolve) => {
-			this.resolveRunningPrompt = resolve;
-		});
-
 		// Build user message with attachments
 		const content: Array<TextContent | ImageContent> = [{ type: "text", text: input }];
 		if (attachments?.length) {
@@ -204,6 +199,62 @@ export class Agent {
 			timestamp: Date.now(),
 		};
 
+		await this._runAgentLoop(userMessage);
+	}
+
+	/**
+	 * Continue from the current context without adding a new user message.
+	 * Used for retry after overflow recovery when context already has user message or tool results.
+	 */
+	async continue() {
+		const messages = this._state.messages;
+		if (messages.length === 0) {
+			throw new Error("No messages to continue from");
+		}
+
+		const lastMessage = messages[messages.length - 1];
+		if (lastMessage.role !== "user" && lastMessage.role !== "toolResult") {
+			throw new Error(`Cannot continue from message role: ${lastMessage.role}`);
+		}
+
+		await this._runAgentLoopContinue();
+	}
+
+	/**
+	 * Internal: Run the agent loop with a new user message.
+	 */
+	private async _runAgentLoop(userMessage: AppMessage) {
+		const { llmMessages, cfg } = await this._prepareRun();
+
+		const events = this.transport.run(llmMessages, userMessage as Message, cfg, this.abortController!.signal);
+
+		await this._processEvents(events);
+	}
+
+	/**
+	 * Internal: Continue the agent loop from current context.
+	 */
+	private async _runAgentLoopContinue() {
+		const { llmMessages, cfg } = await this._prepareRun();
+
+		const events = this.transport.continue(llmMessages, cfg, this.abortController!.signal);
+
+		await this._processEvents(events);
+	}
+
+	/**
+	 * Prepare for running the agent loop.
+	 */
+	private async _prepareRun() {
+		const model = this._state.model;
+		if (!model) {
+			throw new Error("No model configured");
+		}
+
+		this.runningPrompt = new Promise<void>((resolve) => {
+			this.resolveRunningPrompt = resolve;
+		});
+
 		this.abortController = new AbortController();
 		this._state.isStreaming = true;
 		this._state.streamMessage = null;
@@ -222,9 +273,7 @@ export class Agent {
 			model,
 			reasoning,
 			getQueuedMessages: async <T>() => {
-				// Return queued messages based on queue mode
 				if (this.queueMode === "one-at-a-time") {
-					// Return only first message
 					if (this.messageQueue.length > 0) {
 						const first = this.messageQueue[0];
 						this.messageQueue = this.messageQueue.slice(1);
@@ -232,7 +281,6 @@ export class Agent {
 					}
 					return [];
 				} else {
-					// Return all queued messages at once
 					const queued = this.messageQueue.slice();
 					this.messageQueue = [];
 					return queued as QueuedMessage<T>[];
@@ -240,32 +288,30 @@ export class Agent {
 			},
 		};
 
-		// Track all messages generated in this prompt
+		const llmMessages = await this.messageTransformer(this._state.messages);
+
+		return { llmMessages, cfg, model };
+	}
+
+	/**
+	 * Process events from the transport.
+	 */
+	private async _processEvents(events: AsyncIterable<AgentEvent>) {
+		const model = this._state.model!;
 		const generatedMessages: AppMessage[] = [];
+		let partial: AppMessage | null = null;
 
 		try {
-			let partial: Message | null = null;
-
-			// Transform app messages to LLM-compatible messages (initial set)
-			const llmMessages = await this.messageTransformer(this._state.messages);
-
-			for await (const ev of this.transport.run(
-				llmMessages,
-				userMessage as Message,
-				cfg,
-				this.abortController.signal,
-			)) {
-				// Update internal state BEFORE emitting events
-				// so handlers see consistent state
+			for await (const ev of events) {
 				switch (ev.type) {
 					case "message_start": {
-						partial = ev.message;
-						this._state.streamMessage = ev.message;
+						partial = ev.message as AppMessage;
+						this._state.streamMessage = ev.message as Message;
 						break;
 					}
 					case "message_update": {
-						partial = ev.message;
-						this._state.streamMessage = ev.message;
+						partial = ev.message as AppMessage;
+						this._state.streamMessage = ev.message as Message;
 						break;
 					}
 					case "message_end": {
@@ -299,7 +345,6 @@ export class Agent {
 					}
 				}
 
-				// Emit after state is updated
 				this.emit(ev as AgentEvent);
 			}
 

packages/agent/src/transports/AppTransport.ts

@@ -11,7 +11,7 @@ import type {
 	ToolCall,
 	UserMessage,
 } from "@mariozechner/pi-ai";
-import { agentLoop } from "@mariozechner/pi-ai";
+import { agentLoop, agentLoopContinue } from "@mariozechner/pi-ai";
 import { AssistantMessageEventStream } from "@mariozechner/pi-ai/dist/utils/event-stream.js";
 import { parseStreamingJson } from "@mariozechner/pi-ai/dist/utils/json-parse.js";
 import type { ProxyAssistantMessageEvent } from "./proxy-types.js";
@@ -335,14 +335,8 @@ export class AppTransport implements AgentTransport {
 		this.options = options;
 	}
 
-	async *run(messages: Message[], userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
-		const authToken = await this.options.getAuthToken();
-		if (!authToken) {
-			throw new Error("Auth token is required for AppTransport");
-		}
-
-		// Use proxy - no local API key needed
-		const streamFn = <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => {
+	private async getStreamFn(authToken: string) {
+		return <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => {
 			return streamSimpleProxy(
 				model,
 				context,
@@ -353,24 +347,51 @@ export class AppTransport implements AgentTransport {
 				this.options.proxyUrl,
 			);
 		};
+	}
 
-		// Messages are already LLM-compatible (filtered by Agent)
-		const context: AgentContext = {
+	private buildContext(messages: Message[], cfg: AgentRunConfig): AgentContext {
+		return {
 			systemPrompt: cfg.systemPrompt,
 			messages,
 			tools: cfg.tools,
 		};
+	}
 
-		const pc: AgentLoopConfig = {
+	private buildLoopConfig(cfg: AgentRunConfig): AgentLoopConfig {
+		return {
 			model: cfg.model,
 			reasoning: cfg.reasoning,
 			getQueuedMessages: cfg.getQueuedMessages,
 		};
+	}
+
+	async *run(messages: Message[], userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
+		const authToken = await this.options.getAuthToken();
+		if (!authToken) {
+			throw new Error("Auth token is required for AppTransport");
+		}
+
+		const streamFn = await this.getStreamFn(authToken);
+		const context = this.buildContext(messages, cfg);
+		const pc = this.buildLoopConfig(cfg);
 
-		// Yield events from the upstream agentLoop iterator
-		// Pass streamFn as the 5th parameter to use proxy
 		for await (const ev of agentLoop(userMessage as unknown as UserMessage, context, pc, signal, streamFn as any)) {
 			yield ev;
 		}
 	}
+
+	async *continue(messages: Message[], cfg: AgentRunConfig, signal?: AbortSignal) {
+		const authToken = await this.options.getAuthToken();
+		if (!authToken) {
+			throw new Error("Auth token is required for AppTransport");
+		}
+
+		const streamFn = await this.getStreamFn(authToken);
+		const context = this.buildContext(messages, cfg);
+		const pc = this.buildLoopConfig(cfg);
+
+		for await (const ev of agentLoopContinue(context, pc, signal, streamFn as any)) {
+			yield ev;
+		}
+	}
 }

packages/agent/src/transports/ProviderTransport.ts

@@ -2,6 +2,7 @@ import {
 	type AgentContext,
 	type AgentLoopConfig,
 	agentLoop,
+	agentLoopContinue,
 	type Message,
 	type UserMessage,
 } from "@mariozechner/pi-ai";
@@ -33,18 +34,15 @@ export class ProviderTransport implements AgentTransport {
 		this.options = options;
 	}
 
-	async *run(messages: Message[], userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
-		// Get API key
+	private async getModelAndKey(cfg: AgentRunConfig) {
 		let apiKey: string | undefined;
 		if (this.options.getApiKey) {
 			apiKey = await this.options.getApiKey(cfg.model.provider);
 		}
-
 		if (!apiKey) {
 			throw new Error(`No API key found for provider: ${cfg.model.provider}`);
 		}
 
-		// Clone model and modify baseUrl if CORS proxy is enabled
 		let model = cfg.model;
 		if (this.options.corsProxyUrl && cfg.model.baseUrl) {
 			model = {
@@ -53,23 +51,43 @@ export class ProviderTransport implements AgentTransport {
 			};
 		}
 
-		// Messages are already LLM-compatible (filtered by Agent)
-		const context: AgentContext = {
+		return { model, apiKey };
+	}
+
+	private buildContext(messages: Message[], cfg: AgentRunConfig): AgentContext {
+		return {
 			systemPrompt: cfg.systemPrompt,
 			messages,
 			tools: cfg.tools,
 		};
+	}
 
-		const pc: AgentLoopConfig = {
+	private buildLoopConfig(model: typeof cfg.model, apiKey: string, cfg: AgentRunConfig): AgentLoopConfig {
+		return {
 			model,
 			reasoning: cfg.reasoning,
 			apiKey,
 			getQueuedMessages: cfg.getQueuedMessages,
 		};
+	}
+
+	async *run(messages: Message[], userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
+		const { model, apiKey } = await this.getModelAndKey(cfg);
+		const context = this.buildContext(messages, cfg);
+		const pc = this.buildLoopConfig(model, apiKey, cfg);
 
-		// Yield events from agentLoop
 		for await (const ev of agentLoop(userMessage as unknown as UserMessage, context, pc, signal)) {
 			yield ev;
 		}
 	}
+
+	async *continue(messages: Message[], cfg: AgentRunConfig, signal?: AbortSignal) {
+		const { model, apiKey } = await this.getModelAndKey(cfg);
+		const context = this.buildContext(messages, cfg);
+		const pc = this.buildLoopConfig(model, apiKey, cfg);
+
+		for await (const ev of agentLoopContinue(context, pc, signal)) {
+			yield ev;
+		}
+	}
 }

packages/agent/src/transports/types.ts

@@ -19,10 +19,14 @@ export interface AgentRunConfig {
  * Events yielded must match the @mariozechner/pi-ai AgentEvent types.
  */
 export interface AgentTransport {
+	/** Run with a new user message */
 	run(
 		messages: Message[],
 		userMessage: Message,
 		config: AgentRunConfig,
 		signal?: AbortSignal,
 	): AsyncIterable<AgentEvent>;
+
+	/** Continue from current context (no new user message) */
+	continue(messages: Message[], config: AgentRunConfig, signal?: AbortSignal): AsyncIterable<AgentEvent>;
 }