@agi-cli/server 0.1.160 → 0.1.162

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.160",
+	"version": "0.1.162",
 	"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.160",
-		"@agi-cli/database": "0.1.160",
+		"@agi-cli/sdk": "0.1.162",
+		"@agi-cli/database": "0.1.162",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/runtime/agent/runner-setup.ts

@@ -237,6 +237,7 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 			}
 		} else if (underlyingProvider === 'openai') {
 			providerOptions.openai = {
+				reasoningEffort: 'high',
 				reasoningSummary: 'auto',
 			};
 		} else if (underlyingProvider === 'google') {

package/src/runtime/agent/runner.ts

@@ -187,6 +187,13 @@ async function runAssistant(opts: RunOpts) {
 			if (part.type === 'text-delta') {
 				const delta = part.text;
 				if (!delta) continue;
+
+				accumulated += delta;
+
+				if (!currentPartId && !accumulated.trim()) {
+					continue;
+				}
+
 				if (!firstDeltaSeen) {
 					firstDeltaSeen = true;
 					streamStartTimer.end();
@@ -208,7 +215,7 @@ async function runAssistant(opts: RunOpts) {
 						index: await sharedCtx.nextIndex(),
 						stepIndex: null,
 						type: 'text',
-						content: JSON.stringify({ text: '' }),
+						content: JSON.stringify({ text: accumulated }),
 						agent: opts.agent,
 						provider: opts.provider,
 						model: opts.model,
@@ -216,7 +223,6 @@ async function runAssistant(opts: RunOpts) {
 					});
 				}
 
-				accumulated += delta;
 				publish({
 					type: 'message.part.delta',
 					sessionId: opts.sessionId,

package/src/runtime/message/compaction-context.ts

@@ -1,6 +1,6 @@
 import type { getDb } from '@agi-cli/database';
 import { messages, messageParts } from '@agi-cli/database/schema';
-import { eq, asc } from 'drizzle-orm';
+import { eq, asc, desc } from 'drizzle-orm';
 
 export async function buildCompactionContext(
 	db: Awaited<ReturnType<typeof getDb>>,
@@ -11,17 +11,22 @@ export async function buildCompactionContext(
 		.select()
 		.from(messages)
 		.where(eq(messages.sessionId, sessionId))
-		.orderBy(asc(messages.createdAt));
+		.orderBy(desc(messages.createdAt));
 
-	const lines: string[] = [];
-	let totalChars = 0;
 	const maxChars = contextTokenLimit ? contextTokenLimit * 4 : 60000;
+	const recentBudget = Math.floor(maxChars * 0.65);
+	const olderBudget = maxChars - recentBudget;
+
+	const recentLines: string[] = [];
+	const olderLines: string[] = [];
+	let recentChars = 0;
+	let olderChars = 0;
+	let userTurns = 0;
+	let inRecent = true;
 
 	for (const msg of allMessages) {
-		if (totalChars > maxChars) {
-			lines.unshift('[...earlier content truncated...]');
-			break;
-		}
+		if (msg.role === 'user') userTurns++;
+		if (userTurns > 3 && inRecent) inRecent = false;
 
 		const parts = await db
 			.select()
@@ -37,28 +42,60 @@ export async function buildCompactionContext(
 
 				if (part.type === 'text' && content.text) {
 					const text = `[${msg.role.toUpperCase()}]: ${content.text}`;
-					lines.push(text.slice(0, 3000));
-					totalChars += text.length;
+					const limit = inRecent ? 3000 : 1000;
+					const line = text.slice(0, limit);
+
+					if (inRecent && recentChars < recentBudget) {
+						recentLines.unshift(line);
+						recentChars += line.length;
+					} else if (olderChars < olderBudget) {
+						olderLines.unshift(line);
+						olderChars += line.length;
+					}
 				} else if (part.type === 'tool_call' && content.name) {
-					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;
+					if (inRecent && recentChars < recentBudget) {
+						const argsStr =
+							typeof content.args === 'object'
+								? JSON.stringify(content.args).slice(0, 1000)
+								: '';
+						const line = `[TOOL ${content.name}]: ${argsStr}`;
+						recentLines.unshift(line);
+						recentChars += line.length;
+					} else if (olderChars < olderBudget) {
+						const line = `[TOOL ${content.name}]`;
+						olderLines.unshift(line);
+						olderChars += line.length;
+					}
 				} else if (part.type === 'tool_result' && content.result !== null) {
 					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;
+							? content.result
+							: JSON.stringify(content.result ?? '');
+
+					if (inRecent && recentChars < recentBudget) {
+						const line = `[RESULT]: ${resultStr.slice(0, 2000)}`;
+						recentLines.unshift(line);
+						recentChars += line.length;
+					} else if (olderChars < olderBudget) {
+						const line = `[RESULT]: ${resultStr.slice(0, 150)}...`;
+						olderLines.unshift(line);
+						olderChars += line.length;
+					}
 				}
 			} catch {}
 		}
+
+		if (olderChars >= olderBudget) break;
+	}
+
+	const result: string[] = [];
+	if (olderLines.length > 0) {
+		result.push('[...older conversation (tool data truncated)...]');
+		result.push(...olderLines);
+		result.push('');
+		result.push('[--- Recent conversation (full detail) ---]');
 	}
+	result.push(...recentLines);
 
-	return lines.join('\n');
+	return result.join('\n');
 }

package/src/runtime/message/compaction-detect.ts

@@ -5,13 +5,20 @@ export function isCompactCommand(content: string): boolean {
 
 export function getCompactionSystemPrompt(): string {
 	return `
-The user has requested to compact the conversation. Generate a comprehensive summary that captures:
+The conversation context is being compacted. The provided context is structured with
+RECENT conversation in full detail at the end, and OLDER conversation (with truncated tool data) at the start.
 
-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.
+Generate a comprehensive summary that captures:
+
+1. **Current State**: What was the most recent task? What is the current state of the work RIGHT NOW?
+2. **Key Changes Made**: What files were created, modified, or deleted? Summarize recent code changes.
+3. **Main Goals**: What is the user trying to accomplish overall?
+4. **Important Decisions**: What approaches or solutions were chosen and why?
+5. **Pending Work**: What remains to be done? Any known issues or blockers?
+6. **Critical Context**: Any gotchas, errors encountered, or important details for continuing.
+
+IMPORTANT: Prioritize the RECENT conversation. The summary must allow seamless continuation
+of work. Focus on what was just done and what comes next — not the early parts of the conversation.
 
 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.

package/src/runtime/message/compaction-limits.ts

@@ -1,60 +1,32 @@
+import { catalog, getModelInfo } from '@agi-cli/sdk';
+import type { ProviderId } from '@agi-cli/sdk';
+
 export const PRUNE_PROTECT = 40_000;
 
 export function estimateTokens(text: string): number {
 	return Math.max(0, Math.round((text || '').length / 4));
 }
 
-export interface TokenUsage {
-	input: number;
-	output: number;
-	cacheRead?: number;
-	cacheWrite?: number;
-	reasoningText?: number;
-}
-
 export interface ModelLimits {
 	context: number;
 	output: number;
 }
 
-export function isOverflow(
-	tokens: LanguageModelUsage,
-	limits: ModelLimits,
-): boolean {
-	if (limits.context === 0) return false;
-
-	const count =
-		tokens.input +
-		(tokens.cacheRead ?? 0) +
-		(tokens.cacheWrite ?? 0) +
-		tokens.output;
-	const usableContext = limits.context - limits.output;
-
-	return count > usableContext;
-}
-
 export function getModelLimits(
-	_provider: string,
+	provider: string,
 	model: string,
 ): ModelLimits | null {
-	const defaults: Record<string, ModelLimits> = {
-		'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 },
-		'gpt-4o': { context: 128000, output: 16384 },
-		'gpt-4o-mini': { context: 128000, output: 16384 },
-		o1: { context: 200000, output: 100000 },
-		'o3-mini': { context: 200000, output: 100000 },
-		'gemini-2.0-flash': { context: 1000000, output: 8192 },
-		'gemini-1.5-pro': { context: 2000000, output: 8192 },
-	};
-
-	if (defaults[model]) return defaults[model];
-
-	for (const [key, limits] of Object.entries(defaults)) {
-		if (model.includes(key) || key.includes(model)) return limits;
+	const info = getModelInfo(provider as ProviderId, model);
+	if (info?.limit?.context && info?.limit?.output) {
+		return { context: info.limit.context, output: info.limit.output };
+	}
+	for (const key of Object.keys(catalog) as ProviderId[]) {
+		const entry = catalog[key];
+		const m = entry?.models?.find((x) => x.id === model);
+		if (m?.limit?.context && m?.limit?.output) {
+			return { context: m.limit.context, output: m.limit.output };
+		}
 	}
-
 	return null;
 }
 

package/src/runtime/message/compaction-mark.ts

@@ -1,6 +1,6 @@
 import type { getDb } from '@agi-cli/database';
 import { messages, messageParts } from '@agi-cli/database/schema';
-import { eq, desc, and, lt } from 'drizzle-orm';
+import { eq, asc, and, lt } from 'drizzle-orm';
 import { debugLog } from '../debug/index.ts';
 import { estimateTokens, PRUNE_PROTECT } from './compaction-limits.ts';
 
@@ -35,33 +35,22 @@ export async function markSessionCompacted(
 				lt(messages.createdAt, cutoffTime),
 			),
 		)
-		.orderBy(desc(messages.createdAt));
+		.orderBy(asc(messages.createdAt));
 
-	let totalTokens = 0;
-	let compactedTokens = 0;
-	const toCompact: Array<{ id: string; content: string }> = [];
-	let turns = 0;
+	type PartInfo = { id: string; tokens: number };
+	const allToolParts: PartInfo[] = [];
+	let totalToolTokens = 0;
 
 	for (const msg of oldMessages) {
-		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));
+			.orderBy(asc(messageParts.index));
 
 		for (const part of parts) {
 			if (part.type !== 'tool_call' && part.type !== 'tool_result') continue;
-
-			if (part.toolName && PROTECTED_TOOLS.includes(part.toolName)) {
-				continue;
-			}
-
+			if (part.toolName && PROTECTED_TOOLS.includes(part.toolName)) continue;
 			if (part.compactedAt) continue;
 
 			let content: { result?: unknown; args?: unknown };
@@ -78,18 +67,25 @@ export async function markSessionCompacted(
 						: JSON.stringify(content.result ?? '')
 					: JSON.stringify(content.args ?? '');
 
-			const estimate = estimateTokens(contentStr);
-			totalTokens += estimate;
-
-			if (totalTokens > PRUNE_PROTECT) {
-				compactedTokens += estimate;
-				toCompact.push({ id: part.id, content: part.content ?? '{}' });
-			}
+			const tokens = estimateTokens(contentStr);
+			totalToolTokens += tokens;
+			allToolParts.push({ id: part.id, tokens });
 		}
 	}
 
+	const tokensToFree = Math.max(0, totalToolTokens - PRUNE_PROTECT);
+
+	const toCompact: PartInfo[] = [];
+	let freedTokens = 0;
+
+	for (const part of allToolParts) {
+		if (freedTokens >= tokensToFree) break;
+		freedTokens += part.tokens;
+		toCompact.push(part);
+	}
+
 	debugLog(
-		`[compaction] Found ${toCompact.length} parts to compact, saving ~${compactedTokens} tokens`,
+		`[compaction] Found ${toCompact.length} parts to compact (oldest first), saving ~${freedTokens} tokens`,
 	);
 
 	if (toCompact.length > 0) {
@@ -111,5 +107,5 @@ export async function markSessionCompacted(
 		debugLog(`[compaction] Marked ${toCompact.length} parts as compacted`);
 	}
 
-	return { compacted: toCompact.length, saved: compactedTokens };
+	return { compacted: toCompact.length, saved: freedTokens };
 }

package/src/runtime/message/compaction.ts

@@ -1,9 +1,7 @@
 export {
 	PRUNE_PROTECT,
 	estimateTokens,
-	type TokenUsage,
 	type ModelLimits,
-	isOverflow,
 	getModelLimits,
 	isCompacted,
 	COMPACTED_PLACEHOLDER,

package/src/runtime/session/branch.ts

@@ -168,6 +168,7 @@ export async function createBranch({
 		totalReasoningTokens: null,
 		totalToolTimeMs: null,
 		toolCountsJson: null,
+		currentContextTokens: null,
 		contextSummary: null,
 		lastCompactedAt: null,
 	};

package/src/runtime/session/db-operations.ts

@@ -51,13 +51,10 @@ export function normalizeUsage(
 				: undefined;
 
 	const cachedValue = cachedInputTokens ?? 0;
-	const cacheCreationValue = cacheCreationInputTokens ?? 0;
 
 	let inputTokens = rawInputTokens;
 	if (provider === 'openai') {
 		inputTokens = Math.max(0, rawInputTokens - cachedValue);
-	} else if (provider === 'anthropic') {
-		inputTokens = Math.max(0, rawInputTokens - cacheCreationValue);
 	}
 
 	return {
@@ -94,8 +91,10 @@ export function resolveUsageProvider(
 }
 
 /**
- * Updates session token counts incrementally after each step.
- * Note: onStepFinish.usage is CUMULATIVE per message, so we compute DELTA and add to session.
+ * Updates session token counts after each step.
+ * AI SDK v6: onStepFinish.usage is PER-STEP (each step = one API call).
+ * We ADD each step's tokens directly to session totals.
+ * We also track currentContextTokens = the latest step's full input context.
  */
 export async function updateSessionTokensIncremental(
 	usage: UsageData,
@@ -105,10 +104,19 @@ export async function updateSessionTokensIncremental(
 ) {
 	if (!usage || !db) return;
 
+	const currentContextTokens = Number(usage.inputTokens ?? 0);
+
 	const usageProvider = resolveUsageProvider(opts.provider, opts.model);
 	const normalizedUsage = normalizeUsage(usage, providerOptions, usageProvider);
 
-	// Read session totals
+	const stepInput = Number(normalizedUsage.inputTokens ?? 0);
+	const stepOutput = Number(normalizedUsage.outputTokens ?? 0);
+	const stepCached = Number(normalizedUsage.cachedInputTokens ?? 0);
+	const stepCacheCreation = Number(
+		normalizedUsage.cacheCreationInputTokens ?? 0,
+	);
+	const stepReasoning = Number(normalizedUsage.reasoningTokens ?? 0);
+
 	const sessRows = await db
 		.select()
 		.from(sessions)
@@ -117,73 +125,18 @@ export async function updateSessionTokensIncremental(
 	if (sessRows.length === 0 || !sessRows[0]) return;
 
 	const sess = sessRows[0];
-	const priorInputSess = Number(sess.totalInputTokens ?? 0);
-	const priorOutputSess = Number(sess.totalOutputTokens ?? 0);
-	const priorCachedSess = Number(sess.totalCachedTokens ?? 0);
-	const priorCacheCreationSess = Number(sess.totalCacheCreationTokens ?? 0);
-	const priorReasoningSess = Number(sess.totalReasoningTokens ?? 0);
-
-	// Read current message totals to compute delta
-	const msgRows = await db
-		.select()
-		.from(messages)
-		.where(eq(messages.id, opts.assistantMessageId));
-
-	const msg = msgRows[0];
-	const priorPromptMsg = Number(msg?.inputTokens ?? 0);
-	const priorCompletionMsg = Number(msg?.outputTokens ?? 0);
-	const priorCachedMsg = Number(msg?.cachedInputTokens ?? 0);
-	const priorCacheCreationMsg = Number(msg?.cacheCreationInputTokens ?? 0);
-	const priorReasoningMsg = Number(msg?.reasoningTokens ?? 0);
-
-	// Treat usage as cumulative per-message for this step
-	const cumPrompt =
-		normalizedUsage.inputTokens != null
-			? Number(normalizedUsage.inputTokens)
-			: priorPromptMsg;
-	const cumCompletion =
-		normalizedUsage.outputTokens != null
-			? Number(normalizedUsage.outputTokens)
-			: priorCompletionMsg;
-	const cumReasoning =
-		normalizedUsage.reasoningTokens != null
-			? Number(normalizedUsage.reasoningTokens)
-			: priorReasoningMsg;
-
-	const cumCached =
-		normalizedUsage.cachedInputTokens != null
-			? Number(normalizedUsage.cachedInputTokens)
-			: priorCachedMsg;
-
-	const cumCacheCreation =
-		normalizedUsage.cacheCreationInputTokens != null
-			? Number(normalizedUsage.cacheCreationInputTokens)
-			: priorCacheCreationMsg;
-
-	// Compute deltas for this step; clamp to 0 in case provider reports smaller values
-	const deltaInput = Math.max(0, cumPrompt - priorPromptMsg);
-	const deltaOutput = Math.max(0, cumCompletion - priorCompletionMsg);
-	const deltaCached = Math.max(0, cumCached - priorCachedMsg);
-	const deltaCacheCreation = Math.max(
-		0,
-		cumCacheCreation - priorCacheCreationMsg,
-	);
-	const deltaReasoning = Math.max(0, cumReasoning - priorReasoningMsg);
-
-	const nextInputSess = priorInputSess + deltaInput;
-	const nextOutputSess = priorOutputSess + deltaOutput;
-	const nextCachedSess = priorCachedSess + deltaCached;
-	const nextCacheCreationSess = priorCacheCreationSess + deltaCacheCreation;
-	const nextReasoningSess = priorReasoningSess + deltaReasoning;
 
 	await db
 		.update(sessions)
 		.set({
-			totalInputTokens: nextInputSess,
-			totalOutputTokens: nextOutputSess,
-			totalCachedTokens: nextCachedSess,
-			totalCacheCreationTokens: nextCacheCreationSess,
-			totalReasoningTokens: nextReasoningSess,
+			totalInputTokens: Number(sess.totalInputTokens ?? 0) + stepInput,
+			totalOutputTokens: Number(sess.totalOutputTokens ?? 0) + stepOutput,
+			totalCachedTokens: Number(sess.totalCachedTokens ?? 0) + stepCached,
+			totalCacheCreationTokens:
+				Number(sess.totalCacheCreationTokens ?? 0) + stepCacheCreation,
+			totalReasoningTokens:
+				Number(sess.totalReasoningTokens ?? 0) + stepReasoning,
+			currentContextTokens,
 		})
 		.where(eq(sessions.id, opts.sessionId));
 }
@@ -222,8 +175,8 @@ export async function updateSessionTokens(
 }
 
 /**
- * Updates message token counts incrementally after each step.
- * Note: onStepFinish.usage is CUMULATIVE per message, so we REPLACE values, not add.
+ * Updates message token counts after each step.
+ * AI SDK v6: onStepFinish.usage is PER-STEP. We ADD each step's tokens to message totals.
  */
 export async function updateMessageTokensIncremental(
 	usage: UsageData,
@@ -236,6 +189,14 @@ export async function updateMessageTokensIncremental(
 	const usageProvider = resolveUsageProvider(opts.provider, opts.model);
 	const normalizedUsage = normalizeUsage(usage, providerOptions, usageProvider);
 
+	const stepInput = Number(normalizedUsage.inputTokens ?? 0);
+	const stepOutput = Number(normalizedUsage.outputTokens ?? 0);
+	const stepCached = Number(normalizedUsage.cachedInputTokens ?? 0);
+	const stepCacheCreation = Number(
+		normalizedUsage.cacheCreationInputTokens ?? 0,
+	);
+	const stepReasoning = Number(normalizedUsage.reasoningTokens ?? 0);
+
 	const msgRows = await db
 		.select()
 		.from(messages)
@@ -243,48 +204,27 @@ export async function updateMessageTokensIncremental(
 
 	if (msgRows.length > 0 && msgRows[0]) {
 		const msg = msgRows[0];
-		const priorPrompt = Number(msg.inputTokens ?? 0);
-		const priorCompletion = Number(msg.outputTokens ?? 0);
-		const priorCached = Number(msg.cachedInputTokens ?? 0);
-		const priorCacheCreation = Number(msg.cacheCreationInputTokens ?? 0);
-		const priorReasoning = Number(msg.reasoningTokens ?? 0);
-
-		// Treat usage as cumulative per-message - REPLACE not ADD
-		const cumPrompt =
-			normalizedUsage.inputTokens != null
-				? Number(normalizedUsage.inputTokens)
-				: priorPrompt;
-		const cumCompletion =
-			normalizedUsage.outputTokens != null
-				? Number(normalizedUsage.outputTokens)
-				: priorCompletion;
-		const cumReasoning =
-			normalizedUsage.reasoningTokens != null
-				? Number(normalizedUsage.reasoningTokens)
-				: priorReasoning;
-
-		const cumCached =
-			normalizedUsage.cachedInputTokens != null
-				? Number(normalizedUsage.cachedInputTokens)
-				: priorCached;
-
-		const cumCacheCreation =
-			normalizedUsage.cacheCreationInputTokens != null
-				? Number(normalizedUsage.cacheCreationInputTokens)
-				: priorCacheCreation;
-
-		const cumTotal =
-			cumPrompt + cumCompletion + cumCached + cumCacheCreation + cumReasoning;
+		const nextInput = Number(msg.inputTokens ?? 0) + stepInput;
+		const nextOutput = Number(msg.outputTokens ?? 0) + stepOutput;
+		const nextCached = Number(msg.cachedInputTokens ?? 0) + stepCached;
+		const nextCacheCreation =
+			Number(msg.cacheCreationInputTokens ?? 0) + stepCacheCreation;
+		const nextReasoning = Number(msg.reasoningTokens ?? 0) + stepReasoning;
 
 		await db
 			.update(messages)
 			.set({
-				inputTokens: cumPrompt,
-				outputTokens: cumCompletion,
-				totalTokens: cumTotal,
-				cachedInputTokens: cumCached,
-				cacheCreationInputTokens: cumCacheCreation,
-				reasoningTokens: cumReasoning,
+				inputTokens: nextInput,
+				outputTokens: nextOutput,
+				totalTokens:
+					nextInput +
+					nextOutput +
+					nextCached +
+					nextCacheCreation +
+					nextReasoning,
+				cachedInputTokens: nextCached,
+				cacheCreationInputTokens: nextCacheCreation,
+				reasoningTokens: nextReasoning,
 			})
 			.where(eq(messages.id, opts.assistantMessageId));
 	}
@@ -337,7 +277,7 @@ export async function cleanupEmptyTextParts(
 			try {
 				t = JSON.parse(p.content || '{}')?.text || '';
 			} catch {}
-			if (!t || t.length === 0) {
+			if (!t || !t.trim()) {
 				await db.delete(messageParts).where(eq(messageParts.id, p.id));
 			}
 		}

package/src/runtime/session/manager.ts

@@ -55,6 +55,7 @@ export async function createSession({
 		totalReasoningTokens: null,
 		totalToolTimeMs: null,
 		toolCountsJson: null,
+		currentContextTokens: null,
 	};
 	await db.insert(sessions).values(row);
 	publish({ type: 'session.created', sessionId: id, payload: row });

package/src/runtime/session/queue.ts

@@ -16,6 +16,7 @@ export type RunOpts = {
 	isCompactCommand?: boolean;
 	compactionContext?: string;
 	toolApprovalMode?: ToolApprovalMode;
+	compactionRetries?: number;
 };
 
 export type QueuedMessage = {

package/src/runtime/stream/error-handler.ts

@@ -187,66 +187,103 @@ export function createErrorHandler(
 			debugLog(
 				'[stream-handlers] Prompt too long detected, auto-compacting...',
 			);
-			let compactionSucceeded = false;
-			try {
-				const publishWrapper = (event: {
-					type: string;
-					sessionId: string;
-					payload: Record<string, unknown>;
-				}) => {
-					publish(event as Parameters<typeof publish>[0]);
-				};
-				const compactResult = await performAutoCompaction(
-					db,
-					opts.sessionId,
-					opts.assistantMessageId,
-					publishWrapper,
-					opts.provider,
-					opts.model,
+
+			const retries = opts.compactionRetries ?? 0;
+			if (retries >= 2) {
+				debugLog(
+					'[stream-handlers] Compaction retry limit reached, surfacing error',
 				);
-				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`,
+			} else {
+				await db
+					.update(messages)
+					.set({ status: 'completed', completedAt: Date.now() })
+					.where(eq(messages.id, opts.assistantMessageId));
+
+				publish({
+					type: 'message.completed',
+					sessionId: opts.sessionId,
+					payload: {
+						id: opts.assistantMessageId,
+						autoCompacted: true,
+					},
+				});
+
+				const compactMessageId = crypto.randomUUID();
+				const compactMessageTime = Date.now();
+				await db.insert(messages).values({
+					id: compactMessageId,
+					sessionId: opts.sessionId,
+					role: 'assistant',
+					status: 'pending',
+					agent: opts.agent,
+					provider: opts.provider,
+					model: opts.model,
+					createdAt: compactMessageTime,
+				});
+
+				publish({
+					type: 'message.created',
+					sessionId: opts.sessionId,
+					payload: { id: compactMessageId, role: 'assistant' },
+				});
+
+				let compactionSucceeded = false;
+				try {
+					const publishWrapper = (event: {
+						type: string;
+						sessionId: string;
+						payload: Record<string, unknown>;
+					}) => {
+						publish(event as Parameters<typeof publish>[0]);
+					};
+					const compactResult = await performAutoCompaction(
+						db,
+						opts.sessionId,
+						compactMessageId,
+						publishWrapper,
+						opts.provider,
+						opts.model,
 					);
-					const pruneResult = await pruneSession(db, opts.sessionId);
+					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`,
+						);
+						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] Fallback pruned ${pruneResult.pruned} parts, saved ~${pruneResult.saved} tokens`,
+						`[stream-handlers] Auto-compact error: ${compactErr instanceof Error ? compactErr.message : String(compactErr)}`,
 					);
-					compactionSucceeded = pruneResult.pruned > 0;
 				}
-			} catch (compactErr) {
-				debugLog(
-					`[stream-handlers] Auto-compact error: ${compactErr instanceof Error ? compactErr.message : String(compactErr)}`,
-				);
-			}
 
-			if (compactionSucceeded) {
 				await db
 					.update(messages)
 					.set({
-						status: 'completed',
+						status: compactionSucceeded ? 'completed' : 'error',
+						completedAt: Date.now(),
 					})
-					.where(eq(messages.id, opts.assistantMessageId));
+					.where(eq(messages.id, compactMessageId));
 
 				publish({
 					type: 'message.completed',
 					sessionId: opts.sessionId,
-					payload: {
-						id: opts.assistantMessageId,
-						autoCompacted: true,
-					},
+					payload: { id: compactMessageId, autoCompacted: true },
 				});
 
-				if (retryCallback) {
+				if (compactionSucceeded && retryCallback) {
 					debugLog('[stream-handlers] Triggering retry after compaction...');
-					const newAssistantMessageId = crypto.randomUUID();
+					const retryMessageId = crypto.randomUUID();
 					await db.insert(messages).values({
-						id: newAssistantMessageId,
+						id: retryMessageId,
 						sessionId: opts.sessionId,
 						role: 'assistant',
 						status: 'pending',
@@ -259,23 +296,26 @@ export function createErrorHandler(
 					publish({
 						type: 'message.created',
 						sessionId: opts.sessionId,
-						payload: { id: newAssistantMessageId, role: 'assistant' },
+						payload: { id: retryMessageId, role: 'assistant' },
 					});
 
 					enqueueAssistantRun(
 						{
 							...opts,
-							assistantMessageId: newAssistantMessageId,
+							assistantMessageId: retryMessageId,
+							compactionRetries: retries + 1,
 						},
 						retryCallback,
 					);
-				} else {
+					return;
+				}
+
+				if (compactionSucceeded) {
 					debugLog(
 						'[stream-handlers] No retryCallback provided, cannot auto-retry',
 					);
+					return;
 				}
-
-				return;
 			}
 		}
 

package/src/runtime/stream/finish-handler.ts

@@ -4,12 +4,7 @@ import { eq } from 'drizzle-orm';
 import { publish } from '../../events/bus.ts';
 import { estimateModelCostUsd } from '@agi-cli/sdk';
 import type { RunOpts } from '../session/queue.ts';
-import {
-	pruneSession,
-	isOverflow,
-	getModelLimits,
-	markSessionCompacted,
-} from '../message/compaction.ts';
+import { markSessionCompacted } from '../message/compaction.ts';
 import { debugLog } from '../debug/index.ts';
 import type { FinishEvent } from './types.ts';
 import {
@@ -92,38 +87,6 @@ export function createFinishHandler(
 			? estimateModelCostUsd(opts.provider, opts.model, usage)
 			: undefined;
 
-		if (usage) {
-			try {
-				const limits = getModelLimits(opts.provider, opts.model);
-				if (limits) {
-					const tokenUsage: LanguageModelUsage = {
-						input: usage.inputTokens ?? 0,
-						output: usage.outputTokens ?? 0,
-						cacheRead:
-							(usage as { cachedInputTokens?: number }).cachedInputTokens ?? 0,
-						cacheWrite:
-							(usage as { cacheCreationInputTokens?: number })
-								.cacheCreationInputTokens ?? 0,
-					};
-
-					if (isOverflow(tokenUsage, limits)) {
-						debugLog(
-							`[stream-handlers] Context overflow detected, triggering prune for session ${opts.sessionId}`,
-						);
-						pruneSession(db, opts.sessionId).catch((err) => {
-							debugLog(
-								`[stream-handlers] Prune failed: ${err instanceof Error ? err.message : String(err)}`,
-							);
-						});
-					}
-				}
-			} catch (err) {
-				debugLog(
-					`[stream-handlers] Overflow check failed: ${err instanceof Error ? err.message : String(err)}`,
-				);
-			}
-		}
-
 		publish({
 			type: 'message.completed',
 			sessionId: opts.sessionId,

package/src/runtime/context/cache-optimizer.ts

@@ -1,134 +0,0 @@
-import type { ModelMessage } from 'ai';
-
-/**
- * Adds cache control to messages for prompt caching optimization.
- * Anthropic supports caching for system messages, tools, and long context.
- */
-type CachedSystemValue =
-	| string
-	| undefined
-	| Array<{
-			type: 'text';
-			text: string;
-			cache_control?: { type: 'ephemeral' };
-	  }>;
-
-type TextContentPartWithProviderOptions = {
-	providerOptions?: {
-		anthropic?: { cacheControl?: { type: 'ephemeral' } };
-		[key: string]: unknown;
-	};
-	[key: string]: unknown;
-};
-
-export function addCacheControl(
-	provider: string,
-	system: string | undefined,
-	messages: ModelMessage[],
-): {
-	system?: CachedSystemValue;
-	messages: ModelMessage[];
-} {
-	// Only Anthropic supports prompt caching currently
-	if (provider !== 'anthropic') {
-		return { system, messages };
-	}
-
-	// Convert system to cacheable format if it's long enough
-	let cachedSystem: CachedSystemValue = system;
-	if (system && system.length > 1024) {
-		// Anthropic requires 1024+ tokens for Claude Sonnet/Opus
-		cachedSystem = [
-			{
-				type: 'text',
-				text: system,
-				cache_control: { type: 'ephemeral' as const },
-			},
-		];
-	}
-
-	// Anthropic cache_control limits:
-	// - Max 4 cache blocks total
-	// - System message: 1 block
-	// - Tools: 2 blocks (read, write)
-	// - Last user message: 1 block
-	// Total: 4 blocks
-
-	// Add cache control to the last user message if conversation is long
-	// This caches the conversation history up to that point
-	if (messages.length >= 3) {
-		const cachedMessages = [...messages];
-
-		// Find second-to-last user message (not the current one)
-		const userIndices = cachedMessages
-			.map((m, i) => (m.role === 'user' ? i : -1))
-			.filter((i) => i >= 0);
-
-		if (userIndices.length >= 2) {
-			const targetIndex = userIndices[userIndices.length - 2];
-			const targetMsg = cachedMessages[targetIndex];
-
-			if (Array.isArray(targetMsg.content)) {
-				// Add cache control to the last content part of that message
-				const lastPart = targetMsg.content[targetMsg.content.length - 1];
-				if (
-					lastPart &&
-					typeof lastPart === 'object' &&
-					'type' in lastPart &&
-					lastPart.type === 'text'
-				) {
-					const textPart =
-						lastPart as unknown as TextContentPartWithProviderOptions;
-					textPart.providerOptions = {
-						...textPart.providerOptions,
-						anthropic: { cacheControl: { type: 'ephemeral' } },
-					};
-				}
-			}
-		}
-
-		return { system: cachedSystem, messages: cachedMessages };
-	}
-
-	return { system: cachedSystem, messages };
-}
-
-/**
- * Truncates old messages to reduce context size while keeping recent context.
- * Strategy: Keep system message + last N messages
- */
-export function truncateHistory(
-	messages: ModelMessage[],
-	maxMessages = 20,
-): ModelMessage[] {
-	if (messages.length <= maxMessages) {
-		return messages;
-	}
-
-	// Keep the most recent messages
-	return messages.slice(-maxMessages);
-}
-
-/**
- * Estimates token count (rough approximation: ~4 chars per token)
- */
-export function estimateTokens(text: string): number {
-	return Math.ceil(text.length / 4);
-}
-
-/**
- * Summarizes tool results if they're too long
- */
-export function summarizeToolResult(result: unknown, maxLength = 5000): string {
-	const str = typeof result === 'string' ? result : JSON.stringify(result);
-
-	if (str.length <= maxLength) {
-		return str;
-	}
-
-	// Truncate and add indicator
-	return (
-		str.slice(0, maxLength) +
-		`\n\n[... truncated ${str.length - maxLength} characters]`
-	);
-}

package/src/runtime/context/optimizer.ts

@@ -1,206 +0,0 @@
-import type { ModelMessage } from 'ai';
-
-/**
- * Optimizes message context by deduplicating file reads and pruning old tool results.
- */
-
-interface FileRead {
-	messageIndex: number;
-	partIndex: number;
-	path: string;
-}
-
-interface ToolPart {
-	type: string;
-	input?: {
-		path?: string;
-		filePattern?: string;
-		pattern?: string;
-	};
-	output?: unknown;
-	[key: string]: unknown;
-}
-
-/**
- * Deduplicates file read results, keeping only the latest version of each file.
- *
- * Strategy:
- * - Track all file reads (read, grep, glob tools)
- * - For files read multiple times, remove older results
- * - Keep only the most recent read of each file
- */
-export function deduplicateFileReads(messages: ModelMessage[]): ModelMessage[] {
-	const fileReads = new Map<string, FileRead[]>();
-
-	// First pass: identify all file reads and their locations
-	messages.forEach((msg, msgIdx) => {
-		if (msg.role !== 'assistant' || !Array.isArray(msg.content)) return;
-
-		msg.content.forEach((part, partIdx) => {
-			if (!part || typeof part !== 'object') return;
-			if (!('type' in part)) return;
-
-			const toolType = part.type as string;
-
-			// Check if this is a file read tool (read, grep, glob)
-			if (!toolType.startsWith('tool-')) return;
-
-			const toolName = toolType.replace('tool-', '');
-			if (!['read', 'grep', 'glob'].includes(toolName)) return;
-
-			// Extract file path from input
-			const toolPart = part as ToolPart;
-			const input = toolPart.input;
-			if (!input) return;
-
-			const path = input.path || input.filePattern || input.pattern;
-			if (!path) return;
-
-			// Track this file read
-			if (!fileReads.has(path)) {
-				fileReads.set(path, []);
-			}
-			fileReads
-				.get(path)
-				?.push({ messageIndex: msgIdx, partIndex: partIdx, path });
-		});
-	});
-
-	// Second pass: identify reads to remove (all but the latest for each file)
-	const readsToRemove = new Set<string>();
-
-	for (const [_path, reads] of fileReads) {
-		if (reads.length <= 1) continue;
-
-		// Sort by message index descending (latest first)
-		reads.sort((a, b) => b.messageIndex - a.messageIndex);
-
-		// Remove all but the first (latest)
-		for (let i = 1; i < reads.length; i++) {
-			const read = reads[i];
-			readsToRemove.add(`${read.messageIndex}-${read.partIndex}`);
-		}
-	}
-
-	// Third pass: rebuild messages without removed reads
-	return messages.map((msg, msgIdx) => {
-		if (msg.role !== 'assistant' || !Array.isArray(msg.content)) return msg;
-
-		const filteredContent = msg.content.filter((_part, partIdx) => {
-			const key = `${msgIdx}-${partIdx}`;
-			return !readsToRemove.has(key);
-		});
-
-		return {
-			...msg,
-			content: filteredContent,
-		};
-	});
-}
-
-/**
- * Prunes old tool results to reduce context size.
- *
- * Strategy:
- * - Keep only the last N tool results
- * - Preserve tool calls but remove their output
- * - Keep text parts intact
- */
-export function pruneToolResults(
-	messages: ModelMessage[],
-	maxToolResults = 30,
-): ModelMessage[] {
-	// Collect all tool result locations
-	const toolResults: Array<{ messageIndex: number; partIndex: number }> = [];
-
-	messages.forEach((msg, msgIdx) => {
-		if (msg.role !== 'assistant' || !Array.isArray(msg.content)) return;
-
-		msg.content.forEach((part, partIdx) => {
-			if (!part || typeof part !== 'object') return;
-			if (!('type' in part)) return;
-
-			const toolType = part.type as string;
-			if (!toolType.startsWith('tool-')) return;
-
-			// Check if this has output
-			const toolPart = part as ToolPart;
-			const hasOutput = toolPart.output !== undefined;
-			if (!hasOutput) return;
-
-			toolResults.push({ messageIndex: msgIdx, partIndex: partIdx });
-		});
-	});
-
-	// If under limit, no pruning needed
-	if (toolResults.length <= maxToolResults) {
-		return messages;
-	}
-
-	// Keep only the last N tool results
-	const toKeep = new Set<string>();
-	const keepCount = Math.min(maxToolResults, toolResults.length);
-	const keepStart = toolResults.length - keepCount;
-
-	for (let i = keepStart; i < toolResults.length; i++) {
-		const result = toolResults[i];
-		toKeep.add(`${result.messageIndex}-${result.partIndex}`);
-	}
-
-	// Rebuild messages, removing old tool outputs
-	return messages.map((msg, msgIdx) => {
-		if (msg.role !== 'assistant' || !Array.isArray(msg.content)) return msg;
-
-		const processedContent = msg.content.map((part, partIdx) => {
-			if (!part || typeof part !== 'object') return part;
-			if (!('type' in part)) return part;
-
-			const toolPart = part as ToolPart;
-			const toolType = toolPart.type;
-			if (!toolType.startsWith('tool-')) return part;
-
-			const key = `${msgIdx}-${partIdx}`;
-			const hasOutput = toolPart.output !== undefined;
-
-			// If this tool result should be pruned, remove its output
-			if (hasOutput && !toKeep.has(key)) {
-				return {
-					...part,
-					output: '[pruned to save context]',
-				};
-			}
-
-			return part;
-		});
-
-		return {
-			...msg,
-			content: processedContent,
-		};
-	});
-}
-
-/**
- * Applies all context optimizations:
- * 1. Deduplicate file reads
- * 2. Prune old tool results
- */
-export function optimizeContext(
-	messages: ModelMessage[],
-	options: {
-		deduplicateFiles?: boolean;
-		maxToolResults?: number;
-	} = {},
-): ModelMessage[] {
-	let optimized = messages;
-
-	if (options.deduplicateFiles !== false) {
-		optimized = deduplicateFileReads(optimized);
-	}
-
-	if (options.maxToolResults !== undefined) {
-		optimized = pruneToolResults(optimized, options.maxToolResults);
-	}
-
-	return optimized;
-}

package/src/runtime/message/history-truncator.ts

@@ -1,26 +0,0 @@
-import type { ModelMessage } from 'ai';
-
-/**
- * Truncates conversation history to keep only the most recent messages.
- * This helps manage context window size and improves performance.
- *
- * Strategy:
- * - Keep only the last N messages
- * - Preserve message pairs (assistant + user responses) when possible
- * - Always keep at least the system message if present
- */
-export function truncateHistory(
-	messages: ModelMessage[],
-	maxMessages: number,
-): ModelMessage[] {
-	if (messages.length <= maxMessages) {
-		return messages;
-	}
-
-	// Calculate how many messages to keep
-	const keepCount = Math.min(maxMessages, messages.length);
-	const startIndex = messages.length - keepCount;
-
-	// Return the most recent messages
-	return messages.slice(startIndex);
-}