@ottocode/server 0.1.173

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

@@ -0,0 +1,101 @@
+import type { getDb } from '@ottocode/database';
+import { messages, messageParts } from '@ottocode/database/schema';
+import { eq, asc, desc } from 'drizzle-orm';
+
+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(desc(messages.createdAt));
+
+	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 (msg.role === 'user') userTurns++;
+		if (userTurns > 3 && inRecent) inRecent = false;
+
+		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;
+
+			try {
+				const content = JSON.parse(part.content ?? '{}');
+
+				if (part.type === 'text' && content.text) {
+					const text = `[${msg.role.toUpperCase()}]: ${content.text}`;
+					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) {
+					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
+							: 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 result.join('\n');
+}

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

@@ -0,0 +1,26 @@
+export function isCompactCommand(content: string): boolean {
+	const trimmed = content.trim().toLowerCase();
+	return trimmed === '/compact';
+}
+
+export function getCompactionSystemPrompt(): string {
+	return `
+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.
+
+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

@@ -0,0 +1,37 @@
+import { catalog, getModelInfo } from '@ottocode/sdk';
+import type { ProviderId } from '@ottocode/sdk';
+
+export const PRUNE_PROTECT = 40_000;
+
+export function estimateTokens(text: string): number {
+	return Math.max(0, Math.round((text || '').length / 4));
+}
+
+export interface ModelLimits {
+	context: number;
+	output: number;
+}
+
+export function getModelLimits(
+	provider: string,
+	model: string,
+): ModelLimits | null {
+	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;
+}
+
+export function isCompacted(part: { compactedAt?: number | null }): boolean {
+	return !!part.compactedAt;
+}
+
+export const COMPACTED_PLACEHOLDER = '[Compacted]';

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

@@ -0,0 +1,111 @@
+import type { getDb } from '@ottocode/database';
+import { messages, messageParts } from '@ottocode/database/schema';
+import { eq, asc, and, lt } from 'drizzle-orm';
+import { debugLog } from '../debug/index.ts';
+import { estimateTokens, PRUNE_PROTECT } from './compaction-limits.ts';
+
+const PROTECTED_TOOLS = ['skill'];
+
+export async function markSessionCompacted(
+	db: Awaited<ReturnType<typeof getDb>>,
+	sessionId: string,
+	compactMessageId: string,
+): Promise<{ compacted: number; saved: number }> {
+	debugLog(`[compaction] Marking session ${sessionId} as compacted`);
+
+	const compactMsg = await db
+		.select()
+		.from(messages)
+		.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;
+
+	const oldMessages = await db
+		.select()
+		.from(messages)
+		.where(
+			and(
+				eq(messages.sessionId, sessionId),
+				lt(messages.createdAt, cutoffTime),
+			),
+		)
+		.orderBy(asc(messages.createdAt));
+
+	type PartInfo = { id: string; tokens: number };
+	const allToolParts: PartInfo[] = [];
+	let totalToolTokens = 0;
+
+	for (const msg of oldMessages) {
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, msg.id))
+			.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.compactedAt) continue;
+
+			let content: { result?: unknown; args?: unknown };
+			try {
+				content = JSON.parse(part.content ?? '{}');
+			} catch {
+				continue;
+			}
+
+			const contentStr =
+				part.type === 'tool_result'
+					? typeof content.result === 'string'
+						? content.result
+						: JSON.stringify(content.result ?? '')
+					: JSON.stringify(content.args ?? '');
+
+			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 (oldest first), saving ~${freedTokens} 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] Failed to mark part ${part.id}: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			}
+		}
+
+		debugLog(`[compaction] Marked ${toCompact.length} parts as compacted`);
+	}
+
+	return { compacted: toCompact.length, saved: freedTokens };
+}

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

@@ -0,0 +1,75 @@
+import type { getDb } from '@ottocode/database';
+import { messages, messageParts } from '@ottocode/database/schema';
+import { eq, desc } from 'drizzle-orm';
+import { debugLog } from '../debug/index.ts';
+import { estimateTokens, PRUNE_PROTECT } from './compaction-limits.ts';
+
+const PROTECTED_TOOLS = ['skill'];
+
+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;
+			}
+
+			const estimate = estimateTokens(
+				typeof content.result === 'string'
+					? content.result
+					: JSON.stringify(content.result ?? ''),
+			);
+			totalTokens += estimate;
+
+			if (totalTokens > PRUNE_PROTECT) {
+				prunedTokens += estimate;
+				toPrune.push({ id: part.id });
+			}
+		}
+	}
+
+	if (toPrune.length > 0) {
+		const compactedAt = Date.now();
+		for (const part of toPrune) {
+			try {
+				await db
+					.update(messageParts)
+					.set({ compactedAt })
+					.where(eq(messageParts.id, part.id));
+			} catch {}
+		}
+	}
+
+	return { pruned: toPrune.length, saved: prunedTokens };
+}

package/src/runtime/message/compaction.ts

@@ -0,0 +1,21 @@
+export {
+	PRUNE_PROTECT,
+	estimateTokens,
+	type ModelLimits,
+	getModelLimits,
+	isCompacted,
+	COMPACTED_PLACEHOLDER,
+} from './compaction-limits.ts';
+
+export {
+	isCompactCommand,
+	getCompactionSystemPrompt,
+} from './compaction-detect.ts';
+
+export { buildCompactionContext } from './compaction-context.ts';
+
+export { markSessionCompacted } from './compaction-mark.ts';
+
+export { pruneSession } from './compaction-prune.ts';
+
+export { performAutoCompaction } from './compaction-auto.ts';

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

@@ -0,0 +1,266 @@
+import { convertToModelMessages, type ModelMessage, type UIMessage } from 'ai';
+import type { getDb } from '@ottocode/database';
+import { messages, messageParts } from '@ottocode/database/schema';
+import { eq, asc } from 'drizzle-orm';
+import { debugLog } from '../debug/index.ts';
+import { ToolHistoryTracker } from './tool-history-tracker.ts';
+
+/**
+ * Builds the conversation history for a session from the database,
+ * converting it to the format expected by the AI SDK.
+ */
+export async function buildHistoryMessages(
+	db: Awaited<ReturnType<typeof getDb>>,
+	sessionId: string,
+): Promise<ModelMessage[]> {
+	const rows = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.sessionId, sessionId))
+		.orderBy(asc(messages.createdAt));
+
+	const ui: UIMessage[] = [];
+	const toolHistory = new ToolHistoryTracker();
+
+	for (const m of rows) {
+		if (m.role === 'assistant' && m.status !== 'complete') {
+			debugLog(
+				`[buildHistoryMessages] Skipping assistant message ${m.id} with status ${m.status} (current turn still in progress)`,
+			);
+			logPendingToolParts(db, m.id);
+			continue;
+		}
+
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, m.id))
+			.orderBy(asc(messageParts.index));
+
+		if (m.role === 'user') {
+			const uparts: UIMessage['parts'] = [];
+			for (const p of parts) {
+				if (p.type === 'text') {
+					try {
+						const obj = JSON.parse(p.content ?? '{}');
+						const t = String(obj.text ?? '');
+						if (t) uparts.push({ type: 'text', text: t });
+					} catch {}
+				} else if (p.type === 'image') {
+					try {
+						const obj = JSON.parse(p.content ?? '{}') as {
+							data?: string;
+							mediaType?: string;
+						};
+						if (obj.data && obj.mediaType) {
+							uparts.push({
+								type: 'file',
+								mediaType: obj.mediaType,
+								url: `data:${obj.mediaType};base64,${obj.data}`,
+							} as never);
+						}
+					} catch {}
+				} else if (p.type === 'file') {
+					try {
+						const obj = JSON.parse(p.content ?? '{}') as {
+							type?: 'image' | 'pdf' | 'text';
+							name?: string;
+							data?: string;
+							mediaType?: string;
+							textContent?: string;
+						};
+						if (obj.type === 'text' && obj.textContent) {
+							uparts.push({
+								type: 'text',
+								text: `<file name="${obj.name || 'file'}">\n${obj.textContent}\n</file>`,
+							});
+						} else if (obj.type === 'pdf' && obj.data && obj.mediaType) {
+							uparts.push({
+								type: 'file',
+								mediaType: obj.mediaType,
+								url: `data:${obj.mediaType};base64,${obj.data}`,
+							} as never);
+						} else if (obj.type === 'image' && obj.data && obj.mediaType) {
+							uparts.push({
+								type: 'file',
+								mediaType: obj.mediaType,
+								url: `data:${obj.mediaType};base64,${obj.data}`,
+							} as never);
+						}
+					} catch {}
+				}
+			}
+			if (uparts.length) {
+				ui.push({ id: m.id, role: 'user', parts: uparts });
+			}
+			continue;
+		}
+
+		if (m.role === 'assistant') {
+			const assistantParts: UIMessage['parts'] = [];
+			const toolCalls: Array<{ name: string; callId: string; args: unknown }> =
+				[];
+			const toolResults: Array<{
+				name: string;
+				callId: string;
+				result: unknown;
+			}> = [];
+
+			for (const p of parts) {
+				if (p.type === 'reasoning') continue;
+
+				if (p.type === 'text') {
+					try {
+						const obj = JSON.parse(p.content ?? '{}');
+						const t = String(obj.text ?? '');
+						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;
+							callId?: string;
+							args?: unknown;
+						};
+						if (obj.callId && obj.name) {
+							toolCalls.push({
+								name: obj.name,
+								callId: obj.callId,
+								args: obj.args,
+							});
+						}
+					} 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;
+						};
+						if (obj.callId) {
+							toolResults.push({
+								name: obj.name ?? 'tool',
+								callId: obj.callId,
+								result: obj.result,
+							});
+						}
+					} catch {}
+				}
+				// Skip error parts in history
+			}
+
+			const toolResultsById = new Map(
+				toolResults.map((result) => [result.callId, result]),
+			);
+
+			for (const call of toolCalls) {
+				// Skip finish tool from history - it's internal loop control
+				if (call.name === 'finish') continue;
+
+				const toolType = `tool-${call.name}` as `tool-${string}`;
+				let result = toolResultsById.get(call.callId);
+
+				if (!result) {
+					// Synthesize a result for incomplete tool calls to preserve history
+					debugLog(
+						`[buildHistoryMessages] Synthesizing error result for incomplete tool call ${call.name}#${call.callId}`,
+					);
+					result = {
+						name: call.name,
+						callId: call.callId,
+						result:
+							'Error: The tool execution was interrupted or failed to return a result. You may need to retry this operation.',
+					};
+				}
+
+				const part = {
+					type: toolType,
+					state: 'output-available',
+					toolCallId: call.callId,
+					input: call.args,
+					output: (() => {
+						const r = result.result;
+						if (typeof r === 'string') return r;
+						try {
+							return JSON.stringify(r);
+						} catch {
+							return String(r);
+						}
+					})(),
+				};
+
+				toolHistory.register(part, {
+					toolName: call.name,
+					callId: call.callId,
+					args: call.args,
+					result: result.result,
+				});
+
+				assistantParts.push(part as never);
+			}
+
+			if (assistantParts.length) {
+				ui.push({ id: m.id, role: 'assistant', parts: assistantParts });
+			}
+		}
+	}
+
+	return await convertToModelMessages(ui);
+}
+
+async function logPendingToolParts(
+	db: Awaited<ReturnType<typeof getDb>>,
+	messageId: string,
+) {
+	try {
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, messageId))
+			.orderBy(asc(messageParts.index));
+
+		const pendingCalls: string[] = [];
+		for (const part of parts) {
+			if (part.type !== 'tool_call') continue;
+			try {
+				const obj = JSON.parse(part.content ?? '{}') as {
+					name?: string;
+					callId?: string;
+				};
+				if (obj.name && obj.callId) {
+					const resultExists = parts.some((candidate) => {
+						if (candidate.type !== 'tool_result') return false;
+						try {
+							const parsed = JSON.parse(candidate.content ?? '{}') as {
+								callId?: string;
+							};
+							return parsed.callId === obj.callId;
+						} catch {
+							return false;
+						}
+					});
+					if (!resultExists) {
+						pendingCalls.push(`${obj.name}#${obj.callId}`);
+					}
+				}
+			} catch {}
+		}
+		if (pendingCalls.length) {
+			debugLog(
+				`[buildHistoryMessages] Pending tool calls for assistant message ${messageId}: ${pendingCalls.join(', ')}`,
+			);
+		}
+	} catch (err) {
+		debugLog(
+			`[buildHistoryMessages] Failed to inspect pending tool calls for ${messageId}: ${
+				err instanceof Error ? err.message : String(err)
+			}`,
+		);
+	}
+}