@agi-cli/server 0.1.112 → 0.1.113

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.112",
+	"version": "0.1.113",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.112",
-		"@agi-cli/database": "0.1.112",
+		"@agi-cli/sdk": "0.1.113",
+		"@agi-cli/database": "0.1.113",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/runtime/compaction.ts

@@ -1,29 +1,32 @@
 /**
  * Context compaction module for managing token usage.
  *
- * This module implements OpenCode-style context management:
- * 1. Detects when context is overflowing (tokens > context_limit - output_limit)
- * 2. Prunes old tool outputs by marking them as "compacted"
- * 3. History builder returns "[Old tool result content cleared]" for compacted parts
+ * This module implements intelligent context management:
+ * 1. Detects /compact command and builds summarization context
+ * 2. After LLM responds with summary, marks old parts as compacted
+ * 3. History builder skips compacted parts entirely
  *
- * Pruning strategy:
- * - Protect the last PRUNE_PROTECT tokens worth of tool calls (40,000)
- * - Only prune if we'd save at least PRUNE_MINIMUM tokens (20,000)
- * - Skip the last 2 turns to preserve recent context
- * - Never prune "skill" or other protected tools
+ * Flow:
+ * - User sends "/compact" → stored as regular user message
+ * - Runner detects command, builds context for LLM to summarize
+ * - LLM streams summary response naturally
+ * - On completion, markSessionCompacted() marks old tool_call/tool_result parts
+ * - Future history builds skip compacted parts
  */
 
 import type { getDb } from '@agi-cli/database';
 import { messages, messageParts } from '@agi-cli/database/schema';
-import { eq, desc } from 'drizzle-orm';
+import { eq, desc, asc, and, lt } from 'drizzle-orm';
 import { debugLog } from './debug.ts';
+import { streamText } from 'ai';
+import { resolveModel } from './provider.ts';
+import { loadConfig } from '@agi-cli/sdk';
 
-// Token thresholds (matching OpenCode)
-export const PRUNE_MINIMUM = 20_000; // Only prune if we'd save at least this many tokens
+// Token thresholds
 export const PRUNE_PROTECT = 40_000; // Protect last N tokens worth of tool calls
 
-// Tools that should never be pruned
-const PRUNE_PROTECTED_TOOLS = ['skill'];
+// Tools that should never be compacted
+const PROTECTED_TOOLS = ['skill'];
 
 // Simple token estimation: ~4 chars per token
 export function estimateTokens(text: string): number {
@@ -44,51 +47,151 @@ export interface ModelLimits {
 }
 
 /**
- * Check if context is overflowing based on token usage and model limits.
- * Returns true if we've used more tokens than (context_limit - output_limit).
+ * Check if a message content is the /compact command.
  */
-export function isOverflow(tokens: TokenUsage, limits: ModelLimits): boolean {
-	if (limits.context === 0) return false;
+export function isCompactCommand(content: string): boolean {
+	const trimmed = content.trim().toLowerCase();
+	return trimmed === '/compact';
+}
 
-	const count = tokens.input + (tokens.cacheRead ?? 0) + tokens.output;
-	const usableContext = limits.context - limits.output;
+/**
+ * Build context for the LLM to generate a summary.
+ * Returns a prompt that describes what to summarize.
+ * Includes tool calls and results with appropriate truncation to fit within model limits.
+ * @param contextTokenLimit - Max tokens for context (uses ~4 chars per token estimate)
+ */
+export async function buildCompactionContext(
+	db: Awaited<ReturnType<typeof getDb>>,
+	sessionId: string,
+	contextTokenLimit?: number,
+): Promise<string> {
+	const allMessages = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.sessionId, sessionId))
+		.orderBy(asc(messages.createdAt));
 
-	const overflow = count > usableContext;
-	if (overflow) {
-		debugLog(
-			`[compaction] Context overflow detected: ${count} tokens used, ${usableContext} usable (${limits.context} context - ${limits.output} output)`,
-		);
+	const lines: string[] = [];
+	let totalChars = 0;
+	// Use provided limit or default to 60k chars (~15k tokens)
+	// We use ~50% of model context for compaction, leaving room for system prompt + response
+	const maxChars = contextTokenLimit ? contextTokenLimit * 4 : 60000;
+
+	for (const msg of allMessages) {
+		if (totalChars > maxChars) {
+			lines.unshift('[...earlier content truncated...]');
+			break;
+		}
+
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, msg.id))
+			.orderBy(asc(messageParts.index));
+
+		for (const part of parts) {
+			if (part.compactedAt) continue; // Skip already compacted
+
+			try {
+				const content = JSON.parse(part.content ?? '{}');
+
+				if (part.type === 'text' && content.text) {
+					const text = `[${msg.role.toUpperCase()}]: ${content.text}`;
+					lines.push(text.slice(0, 3000)); // Allow more text content
+					totalChars += text.length;
+				} else if (part.type === 'tool_call' && content.name) {
+					// Include tool name and relevant args (file paths, commands, etc.)
+					const argsStr =
+						typeof content.args === 'object'
+							? JSON.stringify(content.args).slice(0, 500)
+							: '';
+					const text = `[TOOL ${content.name}]: ${argsStr}`;
+					lines.push(text);
+					totalChars += text.length;
+				} else if (part.type === 'tool_result' && content.result !== null) {
+					// Include enough result context for the LLM to understand what happened
+					const resultStr =
+						typeof content.result === 'string'
+							? content.result.slice(0, 1500)
+							: JSON.stringify(content.result ?? '').slice(0, 1500);
+					const text = `[RESULT]: ${resultStr}`;
+					lines.push(text);
+					totalChars += text.length;
+				}
+			} catch {}
+		}
 	}
 
-	return overflow;
+	return lines.join('\n');
 }
 
 /**
- * Prune old tool outputs from a session to reduce context size.
+ * Get the system prompt addition for compaction.
+ */
+export function getCompactionSystemPrompt(): string {
+	return `
+The user has requested to compact the conversation. Generate a comprehensive summary that captures:
+
+1. **Main Goals**: What was the user trying to accomplish?
+2. **Key Actions**: What files were created, modified, or deleted?
+3. **Important Decisions**: What approaches or solutions were chosen and why?
+4. **Current State**: What is done and what might be pending?
+5. **Critical Context**: Any gotchas, errors encountered, or important details for continuing.
+
+Format your response as a clear, structured summary. Start with "📦 **Context Compacted**" header.
+Keep under 2000 characters but be thorough. This summary will replace detailed tool history.
+`;
+}
+
+/**
+ * Mark old tool_call and tool_result parts as compacted.
+ * Called after the compaction summary response is complete.
  *
- * Goes backwards through tool results, protecting the last PRUNE_PROTECT tokens.
- * Marks older tool results as "compacted" so history builder returns placeholder text.
+ * Protects:
+ * - Last N tokens of tool results (PRUNE_PROTECT)
+ * - Last 2 user turns
+ * - Protected tool names (skill, etc.)
  */
-export async function pruneSession(
+export async function markSessionCompacted(
 	db: Awaited<ReturnType<typeof getDb>>,
 	sessionId: string,
-): Promise<{ pruned: number; saved: number }> {
-	debugLog(`[compaction] Starting prune for session ${sessionId}`);
+	compactMessageId: string,
+): Promise<{ compacted: number; saved: number }> {
+	debugLog(`[compaction] Marking session ${sessionId} as compacted`);
 
-	// Get all messages in the session ordered by creation time
-	const allMessages = await db
+	// Get the compact message to find the cutoff point
+	const compactMsg = await db
 		.select()
 		.from(messages)
-		.where(eq(messages.sessionId, sessionId))
+		.where(eq(messages.id, compactMessageId))
+		.limit(1);
+
+	if (!compactMsg.length) {
+		debugLog('[compaction] Compact message not found');
+		return { compacted: 0, saved: 0 };
+	}
+
+	const cutoffTime = compactMsg[0].createdAt;
+
+	// Get all messages before the compact command
+	const oldMessages = await db
+		.select()
+		.from(messages)
+		.where(
+			and(
+				eq(messages.sessionId, sessionId),
+				lt(messages.createdAt, cutoffTime),
+			),
+		)
 		.orderBy(desc(messages.createdAt));
 
 	let totalTokens = 0;
-	let prunedTokens = 0;
-	const toPrune: Array<{ id: string; content: string }> = [];
+	let compactedTokens = 0;
+	const toCompact: Array<{ id: string; content: string }> = [];
 	let turns = 0;
 
 	// Go backwards through messages
-	for (const msg of allMessages) {
+	for (const msg of oldMessages) {
 		// Count user messages as turns
 		if (msg.role === 'user') {
 			turns++;
@@ -105,31 +208,113 @@ export async function pruneSession(
 			.orderBy(desc(messageParts.index));
 
 		for (const part of parts) {
-			// Only process tool results
-			if (part.type !== 'tool_result') continue;
+			// Only compact tool_call and tool_result
+			if (part.type !== 'tool_call' && part.type !== 'tool_result') continue;
 
 			// Skip protected tools
-			if (part.toolName && PRUNE_PROTECTED_TOOLS.includes(part.toolName)) {
+			if (part.toolName && PROTECTED_TOOLS.includes(part.toolName)) {
 				continue;
 			}
 
-			// Parse content to check if already compacted
-			let content: { result?: unknown; compactedAt?: number };
+			// Skip already compacted
+			if (part.compactedAt) continue;
+
+			// Parse content
+			let content: { result?: unknown; args?: unknown };
 			try {
 				content = JSON.parse(part.content ?? '{}');
 			} catch {
 				continue;
 			}
 
-			// Stop if we hit already compacted content (we've pruned before)
-			if (content.compactedAt) {
+			// Estimate tokens
+			const contentStr =
+				part.type === 'tool_result'
+					? typeof content.result === 'string'
+						? content.result
+						: JSON.stringify(content.result ?? '')
+					: JSON.stringify(content.args ?? '');
+
+			const estimate = estimateTokens(contentStr);
+			totalTokens += estimate;
+
+			// If we've exceeded the protection threshold, mark for compaction
+			if (totalTokens > PRUNE_PROTECT) {
+				compactedTokens += estimate;
+				toCompact.push({ id: part.id, content: part.content ?? '{}' });
+			}
+		}
+	}
+
+	debugLog(
+		`[compaction] Found ${toCompact.length} parts to compact, saving ~${compactedTokens} tokens`,
+	);
+
+	if (toCompact.length > 0) {
+		const compactedAt = Date.now();
+
+		for (const part of toCompact) {
+			try {
+				await db
+					.update(messageParts)
+					.set({ compactedAt })
+					.where(eq(messageParts.id, part.id));
+			} catch (err) {
 				debugLog(
-					`[compaction] Hit previously compacted content, stopping prune`,
+					`[compaction] Failed to mark part ${part.id}: ${err instanceof Error ? err.message : String(err)}`,
 				);
-				break;
+			}
+		}
+
+		debugLog(`[compaction] Marked ${toCompact.length} parts as compacted`);
+	}
+
+	return { compacted: toCompact.length, saved: compactedTokens };
+}
+
+/**
+ * Legacy prune function - marks tool results as compacted.
+ * Used for automatic overflow-triggered compaction.
+ */
+export async function pruneSession(
+	db: Awaited<ReturnType<typeof getDb>>,
+	sessionId: string,
+): Promise<{ pruned: number; saved: number }> {
+	debugLog(`[compaction] Auto-pruning session ${sessionId}`);
+
+	const allMessages = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.sessionId, sessionId))
+		.orderBy(desc(messages.createdAt));
+
+	let totalTokens = 0;
+	let prunedTokens = 0;
+	const toPrune: Array<{ id: string }> = [];
+	let turns = 0;
+
+	for (const msg of allMessages) {
+		if (msg.role === 'user') turns++;
+		if (turns < 2) continue;
+
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, msg.id))
+			.orderBy(desc(messageParts.index));
+
+		for (const part of parts) {
+			if (part.type !== 'tool_result') continue;
+			if (part.toolName && PROTECTED_TOOLS.includes(part.toolName)) continue;
+			if (part.compactedAt) continue;
+
+			let content: { result?: unknown };
+			try {
+				content = JSON.parse(part.content ?? '{}');
+			} catch {
+				continue;
 			}
 
-			// Estimate tokens for this result
 			const estimate = estimateTokens(
 				typeof content.result === 'string'
 					? content.result
@@ -137,118 +322,215 @@ export async function pruneSession(
 			);
 			totalTokens += estimate;
 
-			// If we've exceeded the protection threshold, mark for pruning
 			if (totalTokens > PRUNE_PROTECT) {
 				prunedTokens += estimate;
-				toPrune.push({ id: part.id, content: part.content ?? '{}' });
+				toPrune.push({ id: part.id });
 			}
 		}
 	}
 
-	debugLog(
-		`[compaction] Found ${toPrune.length} tool results to prune, saving ~${prunedTokens} tokens`,
-	);
-
-	// Only prune if we'd save enough tokens to be worthwhile
-	if (prunedTokens > PRUNE_MINIMUM) {
+	if (toPrune.length > 0) {
 		const compactedAt = Date.now();
-
 		for (const part of toPrune) {
 			try {
-				const content = JSON.parse(part.content);
-				// Keep the structure but mark as compacted
-				content.compactedAt = compactedAt;
-				// Keep a small summary if it was a string result
-				if (typeof content.result === 'string' && content.result.length > 100) {
-					content.resultSummary = `${content.result.slice(0, 100)}...`;
-				}
-				// Clear the actual result to save space
-				content.result = null;
-
 				await db
 					.update(messageParts)
-					.set({ content: JSON.stringify(content) })
+					.set({ compactedAt })
 					.where(eq(messageParts.id, part.id));
-			} catch (err) {
-				debugLog(
-					`[compaction] Failed to prune part ${part.id}: ${err instanceof Error ? err.message : String(err)}`,
-				);
-			}
+			} catch {}
 		}
-
-		debugLog(
-			`[compaction] Pruned ${toPrune.length} tool results, saved ~${prunedTokens} tokens`,
-		);
-	} else {
-		debugLog(
-			`[compaction] Skipping prune, would only save ${prunedTokens} tokens (min: ${PRUNE_MINIMUM})`,
-		);
 	}
 
 	return { pruned: toPrune.length, saved: prunedTokens };
 }
 
+/**
+ * Check if context is overflowing based on token usage and model limits.
+ */
+export function isOverflow(tokens: TokenUsage, limits: ModelLimits): boolean {
+	if (limits.context === 0) return false;
+
+	const count = tokens.input + (tokens.cacheRead ?? 0) + tokens.output;
+	const usableContext = limits.context - limits.output;
+
+	return count > usableContext;
+}
+
 /**
  * Get model limits from provider catalog or use defaults.
  */
 export function getModelLimits(
-	provider: string,
+	_provider: string,
 	model: string,
 ): ModelLimits | null {
-	// Default limits for common models
-	// These should ideally come from the provider catalog
 	const defaults: Record<string, ModelLimits> = {
-		// Anthropic
 		'claude-sonnet-4-20250514': { context: 200000, output: 16000 },
 		'claude-3-5-sonnet-20241022': { context: 200000, output: 8192 },
 		'claude-3-5-haiku-20241022': { context: 200000, output: 8192 },
-		'claude-3-opus-20240229': { context: 200000, output: 4096 },
-		// OpenAI
 		'gpt-4o': { context: 128000, output: 16384 },
 		'gpt-4o-mini': { context: 128000, output: 16384 },
-		'gpt-4-turbo': { context: 128000, output: 4096 },
 		o1: { context: 200000, output: 100000 },
-		'o1-mini': { context: 128000, output: 65536 },
-		'o1-pro': { context: 200000, output: 100000 },
 		'o3-mini': { context: 200000, output: 100000 },
-		// Google
 		'gemini-2.0-flash': { context: 1000000, output: 8192 },
 		'gemini-1.5-pro': { context: 2000000, output: 8192 },
-		'gemini-1.5-flash': { context: 1000000, output: 8192 },
 	};
 
-	// Try exact match first
-	if (defaults[model]) {
-		return defaults[model];
-	}
+	if (defaults[model]) return defaults[model];
 
-	// Try partial match (e.g., "claude-3-5-sonnet" matches "claude-3-5-sonnet-20241022")
 	for (const [key, limits] of Object.entries(defaults)) {
-		if (model.includes(key) || key.includes(model)) {
-			return limits;
-		}
+		if (model.includes(key) || key.includes(model)) return limits;
 	}
 
-	// Return null if no match - caller should handle
-	debugLog(
-		`[compaction] No model limits found for ${provider}/${model}, skipping overflow check`,
-	);
 	return null;
 }
 
 /**
- * Check if a tool result content is compacted.
+ * Check if a part is compacted.
  */
-export function isCompacted(content: string): boolean {
-	try {
-		const parsed = JSON.parse(content);
-		return !!parsed.compactedAt;
-	} catch {
-		return false;
-	}
+export function isCompacted(part: { compactedAt?: number | null }): boolean {
+	return !!part.compactedAt;
 }
 
+export const COMPACTED_PLACEHOLDER = '[Compacted]';
+
 /**
- * Get the placeholder text for compacted tool results.
+ * Perform auto-compaction when context overflows.
+ * Streams the compaction summary (like /compact does), marks old parts as compacted.
+ * Returns info needed for caller to trigger a retry.
+ * Uses the session's model for consistency with /compact command.
  */
-export const COMPACTED_PLACEHOLDER = '[Old tool result content cleared]';
+export async function performAutoCompaction(
+	db: Awaited<ReturnType<typeof getDb>>,
+	sessionId: string,
+	assistantMessageId: string,
+	publishFn: (event: {
+		type: string;
+		sessionId: string;
+		payload: Record<string, unknown>;
+	}) => void,
+	provider: string,
+	modelId: string,
+): Promise<{
+	success: boolean;
+	summary?: string;
+	error?: string;
+	compactMessageId?: string;
+}> {
+	debugLog(`[compaction] Starting auto-compaction for session ${sessionId}`);
+
+	try {
+		// 1. Get model limits and build compaction context
+		const limits = getModelLimits(provider, modelId);
+		// Use 50% of context window for compaction, minimum 15k tokens
+		const contextTokenLimit = limits
+			? Math.max(Math.floor(limits.context * 0.5), 15000)
+			: 15000;
+		debugLog(
+			`[compaction] Model ${modelId} context limit: ${limits?.context ?? 'unknown'}, using ${contextTokenLimit} tokens for compaction`,
+		);
+
+		const context = await buildCompactionContext(
+			db,
+			sessionId,
+			contextTokenLimit,
+		);
+		if (!context || context.length < 100) {
+			debugLog('[compaction] Not enough context to compact');
+			return { success: false, error: 'Not enough context to compact' };
+		}
+
+		// 2. Stream the compaction summary
+
+		// Use the session's model for consistency
+		const cfg = await loadConfig();
+		debugLog(
+			`[compaction] Using session model ${provider}/${modelId} for auto-compaction`,
+		);
+		const model = await resolveModel(
+			provider as Parameters<typeof resolveModel>[0],
+			modelId,
+			cfg,
+		);
+
+		// Create a text part for the compaction summary (after model created successfully)
+		const compactPartId = crypto.randomUUID();
+		const now = Date.now();
+
+		await db.insert(messageParts).values({
+			id: compactPartId,
+			messageId: assistantMessageId,
+			index: 0,
+			stepIndex: 0,
+			type: 'text',
+			content: JSON.stringify({ text: '' }),
+			agent: 'system',
+			provider: provider,
+			model: modelId,
+			startedAt: now,
+		});
+
+		const prompt = getCompactionSystemPrompt();
+		const result = streamText({
+			model,
+			system: `${prompt}\n\nIMPORTANT: Generate a comprehensive summary. This will replace the detailed conversation history.`,
+			messages: [
+				{
+					role: 'user',
+					content: `Please summarize this conversation:\n\n<conversation-to-summarize>\n${context}\n</conversation-to-summarize>`,
+				},
+			],
+			maxTokens: 2000,
+		});
+
+		// Stream the summary
+		let summary = '';
+		for await (const chunk of result.textStream) {
+			summary += chunk;
+
+			// Publish delta event so UI updates in real-time
+			publishFn({
+				type: 'message.part.delta',
+				sessionId,
+				payload: {
+					messageId: assistantMessageId,
+					partId: compactPartId,
+					stepIndex: 0,
+					type: 'text',
+					delta: chunk,
+				},
+			});
+		}
+
+		// Update the part with final content
+		await db
+			.update(messageParts)
+			.set({
+				content: JSON.stringify({ text: summary }),
+				completedAt: Date.now(),
+			})
+			.where(eq(messageParts.id, compactPartId));
+
+		if (!summary || summary.length < 50) {
+			debugLog('[compaction] Failed to generate summary');
+			return { success: false, error: 'Failed to generate summary' };
+		}
+
+		debugLog(`[compaction] Generated summary: ${summary.slice(0, 100)}...`);
+
+		// 3. Mark old parts as compacted (using the assistant message as the cutoff)
+		const compactResult = await markSessionCompacted(
+			db,
+			sessionId,
+			assistantMessageId,
+		);
+		debugLog(
+			`[compaction] Marked ${compactResult.compacted} parts as compacted, saved ~${compactResult.saved} tokens`,
+		);
+
+		return { success: true, summary, compactMessageId: assistantMessageId };
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : String(err);
+		debugLog(`[compaction] Auto-compaction failed: ${errorMsg}`);
+		return { success: false, error: errorMsg };
+	}
+}

package/src/runtime/history-builder.ts

@@ -4,7 +4,6 @@ import { messages, messageParts } from '@agi-cli/database/schema';
 import { eq, asc } from 'drizzle-orm';
 import { debugLog } from './debug.ts';
 import { ToolHistoryTracker } from './history/tool-history-tracker.ts';
-import { COMPACTED_PLACEHOLDER } from './compaction.ts';
 
 /**
  * Builds the conversation history for a session from the database,
@@ -89,6 +88,9 @@ export async function buildHistoryMessages(
 						if (t) assistantParts.push({ type: 'text', text: t });
 					} catch {}
 				} else if (p.type === 'tool_call') {
+					// Skip compacted tool calls entirely
+					if (p.compactedAt) continue;
+
 					try {
 						const obj = JSON.parse(p.content ?? '{}') as {
 							name?: string;
@@ -104,22 +106,20 @@ export async function buildHistoryMessages(
 						}
 					} catch {}
 				} else if (p.type === 'tool_result') {
+					// Skip compacted tool results entirely
+					if (p.compactedAt) continue;
+
 					try {
 						const obj = JSON.parse(p.content ?? '{}') as {
 							name?: string;
 							callId?: string;
 							result?: unknown;
-							compactedAt?: number;
 						};
 						if (obj.callId) {
-							// If this tool result was compacted, return placeholder instead
-							const result = obj.compactedAt
-								? COMPACTED_PLACEHOLDER
-								: obj.result;
 							toolResults.push({
 								name: obj.name ?? 'tool',
 								callId: obj.callId,
-								result,
+								result: obj.result,
 							});
 						}
 					} catch {}

package/src/runtime/message-service.ts

@@ -1,4 +1,4 @@
-import { generateText } from 'ai';
+import { generateText, streamText } from 'ai';
 import { eq } from 'drizzle-orm';
 import type { AGIConfig } from '@agi-cli/sdk';
 import type { DB } from '@agi-cli/database';
@@ -9,6 +9,7 @@ import { runSessionLoop } from './runner.ts';
 import { resolveModel } from './provider.ts';
 import { getFastModel, type ProviderId } from '@agi-cli/sdk';
 import { debugLog } from './debug.ts';
+import { isCompactCommand, buildCompactionContext } from './compaction.ts';
 
 type SessionRow = typeof sessions.$inferSelect;
 
@@ -119,6 +120,28 @@ export async function dispatchAssistantMessage(
 		`[MESSAGE_SERVICE] Enqueuing assistant run with userContext: ${userContext ? `${userContext.substring(0, 50)}...` : 'NONE'}`,
 	);
 
+	// Detect /compact command and build context with model-aware limits
+	const isCompact = isCompactCommand(content);
+	let compactionContext: string | undefined;
+
+	if (isCompact) {
+		debugLog('[MESSAGE_SERVICE] Detected /compact command, building context');
+		const { getModelLimits } = await import('./compaction.ts');
+		const limits = getModelLimits(provider, model);
+		// Use 50% of context window for compaction, minimum 15k tokens
+		const contextTokenLimit = limits
+			? Math.max(Math.floor(limits.context * 0.5), 15000)
+			: 15000;
+		compactionContext = await buildCompactionContext(
+			db,
+			sessionId,
+			contextTokenLimit,
+		);
+		debugLog(
+			`[message-service] /compact context length: ${compactionContext.length}, limit: ${contextTokenLimit} tokens`,
+		);
+	}
+
 	enqueueAssistantRun(
 		{
 			sessionId,
@@ -130,6 +153,8 @@ export async function dispatchAssistantMessage(
 			oneShot: Boolean(oneShot),
 			userContext,
 			reasoning,
+			isCompactCommand: isCompact,
+			compactionContext,
 		},
 		runSessionLoop,
 	);
@@ -240,7 +265,11 @@ async function generateSessionTitle(args: {
 
 		// Use a smaller, faster model for title generation
 		// Look up the cheapest/fastest model from the catalog for this provider
-		const titleModel = getFastModel(provider) ?? modelName;
+		// For OpenAI OAuth, use codex-mini as it works with ChatGPT backend
+		const titleModel =
+			needsSpoof && provider === 'openai'
+				? 'gpt-5.1-codex-mini'
+				: (getFastModel(provider) ?? modelName);
 		debugLog(`[TITLE_GEN] Using title model: ${titleModel}`);
 		const model = await resolveModel(provider, titleModel, cfg);
 
@@ -291,15 +320,29 @@ async function generateSessionTitle(args: {
 			);
 		}
 
-		debugLog('[TITLE_GEN] Calling generateText...');
 		let modelTitle = '';
 		try {
-			const out = await generateText({
-				model,
-				system,
-				messages: messagesArray,
-			});
-			modelTitle = (out?.text || '').trim();
+			// ChatGPT backend requires streaming - use streamText for OAuth
+			if (needsSpoof) {
+				debugLog('[TITLE_GEN] Using streamText for OAuth...');
+				const result = streamText({
+					model,
+					system,
+					messages: messagesArray,
+				});
+				for await (const chunk of result.textStream) {
+					modelTitle += chunk;
+				}
+				modelTitle = modelTitle.trim();
+			} else {
+				debugLog('[TITLE_GEN] Using generateText...');
+				const out = await generateText({
+					model,
+					system,
+					messages: messagesArray,
+				});
+				modelTitle = (out?.text || '').trim();
+			}
 
 			debugLog('[TITLE_GEN] Raw response from model:');
 			debugLog(`[TITLE_GEN] "${modelTitle}"`);

package/src/runtime/prompt.ts

@@ -28,6 +28,7 @@ export async function composeSystemPrompt(options: {
 	includeEnvironment?: boolean;
 	includeProjectTree?: boolean;
 	userContext?: string;
+	contextSummary?: string;
 }): Promise<ComposedSystemPrompt> {
 	const components: string[] = [];
 	if (options.spoofPrompt) {
@@ -105,6 +106,19 @@ export async function composeSystemPrompt(options: {
 		components.push('user-context');
 	}
 
+	// Add compacted conversation summary if present
+	if (options.contextSummary?.trim()) {
+		const summaryBlock = [
+			'<compacted-conversation-summary>',
+			'The conversation was compacted to save context. Here is a summary of the previous context:',
+			'',
+			options.contextSummary.trim(),
+			'</compacted-conversation-summary>',
+		].join('\n');
+		parts.push(summaryBlock);
+		components.push('context-summary');
+	}
+
 	// Add terminal context if available
 	const terminalManager = getTerminalManager();
 	if (terminalManager) {

package/src/runtime/runner.ts

@@ -1,7 +1,7 @@
 import { hasToolCall, streamText } from 'ai';
 import { loadConfig } from '@agi-cli/sdk';
 import { getDb } from '@agi-cli/database';
-import { messageParts } from '@agi-cli/database/schema';
+import { messageParts, sessions } from '@agi-cli/database/schema';
 import { eq } from 'drizzle-orm';
 import { resolveModel } from './provider.ts';
 import { resolveAgentConfig } from './agent-registry.ts';
@@ -32,6 +32,7 @@ import {
 	createAbortHandler,
 	createFinishHandler,
 } from './stream-handlers.ts';
+import { getCompactionSystemPrompt, pruneSession } from './compaction.ts';
 
 export { enqueueAssistantRun, abortSession } from './session-queue.ts';
 export { getRunnerState } from './session-queue.ts';
@@ -78,10 +79,30 @@ async function runAssistant(opts: RunOpts) {
 
 	const agentPrompt = agentCfg.prompt || '';
 
+	// For /compact command, use minimal history - the compaction context has everything needed
 	const historyTimer = time('runner:buildHistory');
-	const history = await buildHistoryMessages(db, opts.sessionId);
+	let history: Awaited<ReturnType<typeof buildHistoryMessages>>;
+	if (opts.isCompactCommand && opts.compactionContext) {
+		debugLog('[RUNNER] Using minimal history for /compact command');
+		history = [];
+	} else {
+		history = await buildHistoryMessages(db, opts.sessionId);
+	}
 	historyTimer.end({ messages: history.length });
 
+	// Fetch session to get context summary for compaction
+	const sessionRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, opts.sessionId))
+		.limit(1);
+	const contextSummary = sessionRows[0]?.contextSummary ?? undefined;
+	if (contextSummary) {
+		debugLog(
+			`[RUNNER] Using context summary from compaction (${contextSummary.length} chars)`,
+		);
+	}
+
 	// FIX: For OAuth, we need to check if this is the first ASSISTANT message
 	// The user message is already in history by this point, so history.length will be > 0
 	// We need to add additionalSystemMessages on the first assistant turn
@@ -127,6 +148,7 @@ async function runAssistant(opts: RunOpts) {
 			spoofPrompt: undefined,
 			includeProjectTree: isFirstMessage,
 			userContext: opts.userContext,
+			contextSummary,
 		});
 		oauthFullPromptComponents = fullPrompt.components;
 
@@ -157,6 +179,7 @@ async function runAssistant(opts: RunOpts) {
 			spoofPrompt: undefined,
 			includeProjectTree: isFirstMessage,
 			userContext: opts.userContext,
+			contextSummary,
 		});
 		system = composed.prompt;
 		systemComponents = composed.components;
@@ -169,6 +192,23 @@ async function runAssistant(opts: RunOpts) {
 		})}`,
 	);
 
+	// Inject compaction prompt if this is a /compact command
+	if (opts.isCompactCommand && opts.compactionContext) {
+		debugLog('[RUNNER] Injecting compaction context for /compact command');
+		const compactPrompt = getCompactionSystemPrompt();
+		// Add compaction instructions as system message
+		// Don't modify `system` directly as it may contain OAuth spoof prompt
+		additionalSystemMessages.push({
+			role: 'system',
+			content: compactPrompt,
+		});
+		// Add the conversation context as a USER message (Anthropic requires at least one user message)
+		additionalSystemMessages.push({
+			role: 'user',
+			content: `Please summarize this conversation:\n\n<conversation-to-summarize>\n${opts.compactionContext}\n</conversation-to-summarize>`,
+		});
+	}
+
 	const toolsTimer = time('runner:discoverTools');
 	const allTools = await discoverProjectTools(cfg.projectRoot);
 	toolsTimer.end({ count: allTools.length });
@@ -286,7 +326,13 @@ async function runAssistant(opts: RunOpts) {
 		updateMessageTokensIncremental,
 	);
 
-	const onError = createErrorHandler(opts, db, getStepIndex, sharedCtx);
+	const onError = createErrorHandler(
+		opts,
+		db,
+		getStepIndex,
+		sharedCtx,
+		runSessionLoop,
+	);
 
 	const onAbort = createAbortHandler(opts, db, getStepIndex, sharedCtx);
 
@@ -491,6 +537,67 @@ async function runAssistant(opts: RunOpts) {
 	} catch (err) {
 		unsubscribeFinish();
 		const payload = toErrorPayload(err);
+
+		// Check if this is a "prompt too long" error and auto-compact
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		const errorCode = (err as { code?: string })?.code ?? '';
+		const responseBody = (err as { responseBody?: string })?.responseBody ?? '';
+		const apiErrorType = (err as { apiErrorType?: string })?.apiErrorType ?? '';
+		const combinedError = `${errorMessage} ${responseBody}`.toLowerCase();
+		debugLog(`[RUNNER] Error caught - message: ${errorMessage.slice(0, 100)}`);
+		debugLog(
+			`[RUNNER] Error caught - code: ${errorCode}, apiErrorType: ${apiErrorType}`,
+		);
+		debugLog(
+			`[RUNNER] Error caught - responseBody: ${responseBody.slice(0, 200)}`,
+		);
+		const isPromptTooLong =
+			combinedError.includes('prompt is too long') ||
+			combinedError.includes('maximum context length') ||
+			combinedError.includes('too many tokens') ||
+			combinedError.includes('context_length_exceeded') ||
+			combinedError.includes('request too large') ||
+			combinedError.includes('exceeds the model') ||
+			combinedError.includes('input is too long') ||
+			errorCode === 'context_length_exceeded' ||
+			apiErrorType === 'invalid_request_error';
+		debugLog(
+			`[RUNNER] isPromptTooLong: ${isPromptTooLong}, isCompactCommand: ${opts.isCompactCommand}`,
+		);
+
+		if (isPromptTooLong && !opts.isCompactCommand) {
+			debugLog(
+				'[RUNNER] Prompt too long - auto-compacting and will retry on next user message',
+			);
+			try {
+				const pruneResult = await pruneSession(db, opts.sessionId);
+				debugLog(
+					`[RUNNER] Auto-pruned ${pruneResult.pruned} parts, saved ~${pruneResult.saved} tokens`,
+				);
+
+				// Publish a system message to inform the user
+				publish({
+					type: 'error',
+					sessionId: opts.sessionId,
+					payload: {
+						...payload,
+						message: `Context too large (${errorMessage.match(/\d+/)?.[0] || 'many'} tokens). Auto-compacted old tool results. Please retry your message.`,
+						name: 'ContextOverflow',
+					},
+				});
+
+				// Complete the message as failed
+				try {
+					await completeAssistantMessage({}, opts, db);
+				} catch {}
+				return;
+			} catch (pruneErr) {
+				debugLog(
+					`[RUNNER] Auto-prune failed: ${pruneErr instanceof Error ? pruneErr.message : String(pruneErr)}`,
+				);
+			}
+		}
+
 		debugLog(`[RUNNER] Error during stream: ${payload.message}`);
 		debugLog(
 			`[RUNNER] Error stack: ${err instanceof Error ? err.stack : 'no stack'}`,

package/src/runtime/session-queue.ts

@@ -11,6 +11,8 @@ export type RunOpts = {
 	userContext?: string;
 	reasoning?: boolean;
 	abortSignal?: AbortSignal;
+	isCompactCommand?: boolean;
+	compactionContext?: string;
 };
 
 type RunnerState = { queue: RunOpts[]; running: boolean };

package/src/runtime/stream-handlers.ts

@@ -13,8 +13,11 @@ import {
 	isOverflow,
 	getModelLimits,
 	type TokenUsage,
+	markSessionCompacted,
+	performAutoCompaction,
 } from './compaction.ts';
 import { debugLog } from './debug.ts';
+import { enqueueAssistantRun } from './session-queue.ts';
 
 type StepFinishEvent = {
 	usage?: UsageData;
@@ -131,14 +134,143 @@ export function createErrorHandler(
 	db: Awaited<ReturnType<typeof getDb>>,
 	getStepIndex: () => number,
 	sharedCtx: ToolAdapterContext,
+	retryCallback?: (sessionId: string) => Promise<void>,
 ) {
 	return async (err: unknown) => {
 		const errorPayload = toErrorPayload(err);
 		const isApiError = APICallError.isInstance(err);
 		const stepIndex = getStepIndex();
 
+		// Check if this is a prompt-too-long error and auto-compact
+		// Handle nested error structures from AI SDK
+		const errObj = err as Record<string, unknown>;
+		const nestedError = (errObj?.error as Record<string, unknown>)?.error as
+			| Record<string, unknown>
+			| undefined;
+		const errorCode =
+			(errObj?.code as string) ?? (nestedError?.code as string) ?? '';
+		const errorType =
+			(errObj?.apiErrorType as string) ?? (nestedError?.type as string) ?? '';
+		const fullErrorStr = JSON.stringify(err).toLowerCase();
+
+		const isPromptTooLong =
+			fullErrorStr.includes('prompt is too long') ||
+			fullErrorStr.includes('maximum context length') ||
+			fullErrorStr.includes('too many tokens') ||
+			fullErrorStr.includes('context_length_exceeded') ||
+			fullErrorStr.includes('request too large') ||
+			fullErrorStr.includes('exceeds the model') ||
+			fullErrorStr.includes('context window') ||
+			fullErrorStr.includes('input is too long') ||
+			errorCode === 'context_length_exceeded' ||
+			errorType === 'invalid_request_error';
+
+		debugLog(
+			`[stream-handlers] isPromptTooLong: ${isPromptTooLong}, errorCode: ${errorCode}, errorType: ${errorType}`,
+		);
+
+		if (isPromptTooLong && !opts.isCompactCommand) {
+			debugLog(
+				'[stream-handlers] Prompt too long detected, auto-compacting...',
+			);
+			let compactionSucceeded = false;
+			try {
+				// Stream the compaction summary with proper publish function
+				const compactResult = await performAutoCompaction(
+					db,
+					opts.sessionId,
+					opts.assistantMessageId,
+					publish,
+					opts.provider,
+					opts.model,
+				);
+				if (compactResult.success) {
+					debugLog(
+						`[stream-handlers] Auto-compaction succeeded: ${compactResult.summary?.slice(0, 100)}...`,
+					);
+					compactionSucceeded = true;
+				} else {
+					debugLog(
+						`[stream-handlers] Auto-compaction failed: ${compactResult.error}, falling back to prune`,
+					);
+					// Fall back to simple prune
+					const pruneResult = await pruneSession(db, opts.sessionId);
+					debugLog(
+						`[stream-handlers] Fallback pruned ${pruneResult.pruned} parts, saved ~${pruneResult.saved} tokens`,
+					);
+					compactionSucceeded = pruneResult.pruned > 0;
+				}
+			} catch (compactErr) {
+				debugLog(
+					`[stream-handlers] Auto-compact error: ${compactErr instanceof Error ? compactErr.message : String(compactErr)}`,
+				);
+			}
+
+			// If compaction succeeded, complete this message and trigger retry
+			if (compactionSucceeded) {
+				// Mark this compaction message as completed
+				await db
+					.update(messages)
+					.set({
+						status: 'completed',
+					})
+					.where(eq(messages.id, opts.assistantMessageId));
+
+				// Publish completion event for the compaction message
+				publish({
+					type: 'message.completed',
+					sessionId: opts.sessionId,
+					payload: {
+						id: opts.assistantMessageId,
+						autoCompacted: true,
+					},
+				});
+
+				// Trigger retry - create a new assistant message and enqueue the run
+				if (retryCallback) {
+					debugLog('[stream-handlers] Triggering retry after compaction...');
+					const newAssistantMessageId = crypto.randomUUID();
+					await db.insert(messages).values({
+						id: newAssistantMessageId,
+						sessionId: opts.sessionId,
+						role: 'assistant',
+						status: 'pending',
+						agent: opts.agent,
+						provider: opts.provider,
+						model: opts.model,
+						createdAt: Date.now(),
+					});
+
+					publish({
+						type: 'message.created',
+						sessionId: opts.sessionId,
+						payload: { id: newAssistantMessageId, role: 'assistant' },
+					});
+
+					// Enqueue the retry with the new assistant message
+					enqueueAssistantRun(
+						{
+							...opts,
+							assistantMessageId: newAssistantMessageId,
+						},
+						retryCallback,
+					);
+				} else {
+					debugLog(
+						'[stream-handlers] No retryCallback provided, cannot auto-retry',
+					);
+				}
+
+				return; // Don't show error, compaction and retry handled it
+			}
+		}
+
 		// Create error part for UI display
 		const errorPartId = crypto.randomUUID();
+		const displayMessage =
+			isPromptTooLong && !opts.isCompactCommand
+				? `${errorPayload.message}. Context auto-compacted - please retry your message.`
+				: errorPayload.message;
 		await db.insert(messageParts).values({
 			id: errorPartId,
 			messageId: opts.assistantMessageId,
@@ -146,7 +278,7 @@ export function createErrorHandler(
 			stepIndex,
 			type: 'error',
 			content: JSON.stringify({
-				message: errorPayload.message,
+				message: displayMessage,
 				type: errorPayload.type,
 				details: errorPayload.details,
 				isAborted: false,
@@ -163,11 +295,12 @@ export function createErrorHandler(
 			.update(messages)
 			.set({
 				status: 'error',
-				error: errorPayload.message,
+				error: displayMessage,
 				errorType: errorPayload.type,
 				errorDetails: JSON.stringify({
 					...errorPayload.details,
 					isApiError,
+					autoCompacted: isPromptTooLong && !opts.isCompactCommand,
 				}),
 				isAborted: false,
 			})
@@ -180,10 +313,11 @@ export function createErrorHandler(
 			payload: {
 				messageId: opts.assistantMessageId,
 				partId: errorPartId,
-				error: errorPayload.message,
+				error: displayMessage,
 				errorType: errorPayload.type,
 				details: errorPayload.details,
 				isAborted: false,
+				autoCompacted: isPromptTooLong && !opts.isCompactCommand,
 			},
 		});
 	};
@@ -273,6 +407,43 @@ export function createFinishHandler(
 			await completeAssistantMessageFn(fin, opts, db);
 		} catch {}
 
+		// If this was a /compact command, mark old parts as compacted
+		// Only mark as compacted if the response was successful and has content
+		if (opts.isCompactCommand && fin.finishReason !== 'error') {
+			// Verify the assistant actually generated text content (the summary)
+			const assistantParts = await db
+				.select()
+				.from(messageParts)
+				.where(eq(messageParts.messageId, opts.assistantMessageId));
+			const hasTextContent = assistantParts.some(
+				(p) => p.type === 'text' && p.content && p.content !== '{"text":""}',
+			);
+
+			if (!hasTextContent) {
+				debugLog(
+					'[stream-handlers] /compact finished but no summary generated, skipping compaction marking',
+				);
+			} else {
+				try {
+					debugLog(
+						`[stream-handlers] /compact complete, marking session compacted`,
+					);
+					const result = await markSessionCompacted(
+						db,
+						opts.sessionId,
+						opts.assistantMessageId,
+					);
+					debugLog(
+						`[stream-handlers] Compacted ${result.compacted} parts, saved ~${result.saved} tokens`,
+					);
+				} catch (err) {
+					debugLog(
+						`[stream-handlers] Compaction failed: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
+			}
+		}
+
 		// Use session totals from DB for accurate cost calculation
 		const sessRows = await db
 			.select()