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/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>;
 }