@agi-cli/server 0.1.160 → 0.1.161

package/package.json

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

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-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/session/db-operations.ts

@@ -337,7 +337,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/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;
 			}
 		}