@agi-cli/server 0.1.119 → 0.1.121

package/src/runtime/{ask-service.ts → ask/service.ts}

@@ -5,13 +5,13 @@ import {
 	createSession,
 	getLastSession,
 	getSessionById,
-} from './session-manager.ts';
+} from '../session/manager.ts';
 import {
 	selectProviderAndModel,
 	type ProviderSelection,
-} from './provider-selection.ts';
-import { resolveAgentConfig } from './agent-registry.ts';
-import { dispatchAssistantMessage } from './message-service.ts';
+} from '../provider/selection.ts';
+import { resolveAgentConfig } from '../agent/registry.ts';
+import { dispatchAssistantMessage } from '../message/service.ts';
 import {
 	validateProviderModel,
 	isProviderAuthorized,
@@ -21,7 +21,7 @@ import {
 	type ProviderId,
 } from '@agi-cli/sdk';
 import { sessions } from '@agi-cli/database/schema';
-import { time } from './debug.ts';
+import { time } from '../debug/index.ts';
 
 export class AskServiceError extends Error {
 	constructor(

package/src/runtime/{debug.ts → debug/index.ts}

@@ -5,7 +5,7 @@
  * centralized debug-state and logger modules.
  */
 
-import { isDebugEnabled as isDebugEnabledNew } from './debug-state';
+import { isDebugEnabled as isDebugEnabledNew } from './state.ts';
 import { time as timeNew, debug as debugNew } from '@agi-cli/sdk';
 
 const TRUTHY = new Set(['1', 'true', 'yes', 'on']);

package/src/runtime/{api-error.ts → errors/api-error.ts}

@@ -5,8 +5,8 @@
  * across all API endpoints.
  */
 
-import { isDebugEnabled } from './debug-state';
-import { toErrorPayload } from './error-handling';
+import { isDebugEnabled } from '../debug/state.ts';
+import { toErrorPayload } from './handling.ts';
 
 /**
  * Standard API error response format

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

@@ -0,0 +1,137 @@
+import type { getDb } from '@agi-cli/database';
+import { messageParts } from '@agi-cli/database/schema';
+import { eq } from 'drizzle-orm';
+import { streamText } from 'ai';
+import { resolveModel } from '../provider/index.ts';
+import { loadConfig } from '@agi-cli/sdk';
+import { debugLog } from '../debug/index.ts';
+import { getModelLimits } from './compaction-limits.ts';
+import { buildCompactionContext } from './compaction-context.ts';
+import { getCompactionSystemPrompt } from './compaction-detect.ts';
+import { markSessionCompacted } from './compaction-mark.ts';
+
+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 {
+		const limits = getModelLimits(provider, modelId);
+		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' };
+		}
+
+		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,
+		);
+
+		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>`,
+				},
+			],
+			maxOutputTokens: 2000,
+		});
+
+		let summary = '';
+		for await (const chunk of result.textStream) {
+			summary += chunk;
+
+			publishFn({
+				type: 'message.part.delta',
+				sessionId,
+				payload: {
+					messageId: assistantMessageId,
+					partId: compactPartId,
+					stepIndex: 0,
+					type: 'text',
+					delta: chunk,
+				},
+			});
+		}
+
+		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)}...`);
+
+		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/message/compaction-context.ts

@@ -0,0 +1,64 @@
+import type { getDb } from '@agi-cli/database';
+import { messages, messageParts } from '@agi-cli/database/schema';
+import { eq, asc } 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(asc(messages.createdAt));
+
+	const lines: string[] = [];
+	let totalChars = 0;
+	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;
+
+			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));
+					totalChars += text.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;
+				} 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;
+				}
+			} catch {}
+		}
+	}
+
+	return lines.join('\n');
+}

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

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

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

@@ -0,0 +1,58 @@
+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;
+	reasoning?: number;
+}
+
+export interface ModelLimits {
+	context: number;
+	output: number;
+}
+
+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;
+}
+
+export function getModelLimits(
+	_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;
+	}
+
+	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,115 @@
+import type { getDb } from '@agi-cli/database';
+import { messages, messageParts } from '@agi-cli/database/schema';
+import { eq, desc, 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(desc(messages.createdAt));
+
+	let totalTokens = 0;
+	let compactedTokens = 0;
+	const toCompact: Array<{ id: string; content: string }> = [];
+	let turns = 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));
+
+		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 estimate = estimateTokens(contentStr);
+			totalTokens += estimate;
+
+			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] 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: compactedTokens };
+}

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

@@ -0,0 +1,75 @@
+import type { getDb } from '@agi-cli/database';
+import { messages, messageParts } from '@agi-cli/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,23 @@
+export {
+	PRUNE_PROTECT,
+	estimateTokens,
+	type TokenUsage,
+	type ModelLimits,
+	isOverflow,
+	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/{history-builder.ts → message/history-builder.ts}

@@ -2,8 +2,8 @@ import { convertToModelMessages, type ModelMessage, type UIMessage } from 'ai';
 import type { getDb } from '@agi-cli/database';
 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 { debugLog } from '../debug/index.ts';
+import { ToolHistoryTracker } from './tool-history-tracker.ts';
 
 /**
  * Builds the conversation history for a session from the database,

package/src/runtime/{message-service.ts → message/service.ts}

@@ -3,12 +3,12 @@ import { eq } from 'drizzle-orm';
 import type { AGIConfig } from '@agi-cli/sdk';
 import type { DB } from '@agi-cli/database';
 import { messages, messageParts, sessions } from '@agi-cli/database/schema';
-import { publish } from '../events/bus.ts';
-import { enqueueAssistantRun } from './session-queue.ts';
-import { runSessionLoop } from './runner.ts';
-import { resolveModel } from './provider.ts';
-import { getFastModel, type ProviderId } from '@agi-cli/sdk';
-import { debugLog } from './debug.ts';
+import { publish } from '../../events/bus.ts';
+import { enqueueAssistantRun } from '../session/queue.ts';
+import { runSessionLoop } from '../agent/runner.ts';
+import { resolveModel } from '../provider/index.ts';
+import { getFastModelForAuth, type ProviderId } from '@agi-cli/sdk';
+import { debugLog } from '../debug/index.ts';
 import { isCompactCommand, buildCompactionContext } from './compaction.ts';
 
 type SessionRow = typeof sessions.$inferSelect;
@@ -287,20 +287,14 @@ async function generateSessionTitle(args: {
 		debugLog(`[TITLE_GEN] Provider: ${provider}, Model: ${modelName}`);
 
 		const { getAuth } = await import('@agi-cli/sdk');
-		const { getProviderSpoofPrompt } = await import('./prompt.ts');
+		const { getProviderSpoofPrompt } = await import('../prompt/builder.ts');
 		const auth = await getAuth(provider, cfg.projectRoot);
 		const needsSpoof = auth?.type === 'oauth';
 		const spoofPrompt = needsSpoof
 			? getProviderSpoofPrompt(provider)
 			: undefined;
 
-		// Use a smaller, faster model for title generation
-		// Look up the cheapest/fastest model from the catalog for this provider
-		// 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);
+		const titleModel = getFastModelForAuth(provider, auth?.type) ?? modelName;
 		debugLog(`[TITLE_GEN] Using title model: ${titleModel}`);
 		const model = await resolveModel(provider, titleModel, cfg);
 

package/src/runtime/{history → message}/tool-history-tracker.ts

@@ -1,4 +1,4 @@
-import { debugLog } from '../debug.ts';
+import { debugLog } from '../debug/index.ts';
 
 type ToolResultPart = {
 	type: string;

package/src/runtime/{prompt.ts → prompt/builder.ts}

@@ -1,5 +1,5 @@
 import { providerBasePrompt } from '@agi-cli/sdk';
-import { composeEnvironmentAndInstructions } from './environment.ts';
+import { composeEnvironmentAndInstructions } from '../context/environment.ts';
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
 import BASE_PROMPT from '@agi-cli/sdk/prompts/base.txt' with { type: 'text' };
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports