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/web-ui/src/agent/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 { clearAuthToken, getAuthToken } from "../../utils/auth-token.js";
@@ -315,51 +315,57 @@ function streamSimpleProxy(
 	return stream;
 }
 
-// Proxy transport executes the turn using a remote proxy server
 /**
  * Transport that uses an app server with user authentication tokens.
  * The server manages user accounts and proxies requests to LLM providers.
  */
 export class AppTransport implements AgentTransport {
-	// Hardcoded proxy URL for now - will be made configurable later
 	private readonly proxyUrl = "https://genai.mariozechner.at";
 
-	async *run(messages: Message[], userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
+	private async getStreamFn() {
 		const authToken = await getAuthToken();
 		if (!authToken) {
 			throw new Error(i18n("Auth token is required for proxy transport"));
 		}
 
-		// Use proxy - no local API key needed
-		const streamFn = <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => {
-			return streamSimpleProxy(
-				model,
-				context,
-				{
-					...options,
-					authToken,
-				},
-				this.proxyUrl,
-			);
+		return <TApi extends Api>(model: Model<TApi>, context: Context, options?: SimpleStreamOptions) => {
+			return streamSimpleProxy(model, context, { ...options, authToken }, this.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 streamFn = await this.getStreamFn();
+		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 streamFn = await this.getStreamFn();
+		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/web-ui/src/agent/transports/ProviderTransport.ts

@@ -2,6 +2,7 @@ import {
 	type AgentContext,
 	type AgentLoopConfig,
 	agentLoop,
+	agentLoopContinue,
 	type Message,
 	type UserMessage,
 } from "@mariozechner/pi-ai";
@@ -14,37 +15,53 @@ import type { AgentRunConfig, AgentTransport } from "./types.js";
  * Uses CORS proxy only for providers that require it (Anthropic OAuth, Z-AI).
  */
 export class ProviderTransport implements AgentTransport {
-	async *run(messages: Message[], userMessage: Message, cfg: AgentRunConfig, signal?: AbortSignal) {
-		// Get API key from storage
+	private async getModelAndKey(cfg: AgentRunConfig) {
 		const apiKey = await getAppStorage().providerKeys.get(cfg.model.provider);
 		if (!apiKey) {
 			throw new Error("no-api-key");
 		}
 
-		// Get proxy URL from settings (if available)
 		const proxyEnabled = await getAppStorage().settings.get<boolean>("proxy.enabled");
 		const proxyUrl = await getAppStorage().settings.get<string>("proxy.url");
-
-		// Apply proxy only if this provider/key combination requires it
 		const model = applyProxyIfNeeded(cfg.model, apiKey, proxyEnabled ? proxyUrl || undefined : undefined);
 
-		// 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/web-ui/src/agent/transports/types.ts

@@ -13,10 +13,14 @@ export interface AgentRunConfig {
 // We re-export the Message type above; consumers should use the upstream AgentEvent type.
 
 export interface AgentTransport {
+	/** Run with a new user message */
 	run(
 		messages: Message[],
 		userMessage: Message,
 		config: AgentRunConfig,
 		signal?: AbortSignal,
-	): AsyncIterable<AgentEvent>; // passthrough of AgentEvent from upstream
+	): AsyncIterable<AgentEvent>;
+
+	/** Continue from current context (no new user message) */
+	continue(messages: Message[], config: AgentRunConfig, signal?: AbortSignal): AsyncIterable<AgentEvent>;
 }