@agi-cli/server 0.1.161 → 0.1.163

package/package.json

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

package/src/routes/terminals.ts

@@ -200,4 +200,28 @@ export function registerTerminalsRoutes(
 			return c.json({ error: message }, 500);
 		}
 	});
+
+	app.post('/v1/terminals/:id/resize', async (c) => {
+		const id = c.req.param('id');
+		const terminal = terminalManager.get(id);
+
+		if (!terminal) {
+			return c.json({ error: 'Terminal not found' }, 404);
+		}
+
+		try {
+			const body = await c.req.json();
+			const { cols, rows } = body;
+
+			if (!cols || !rows || cols < 1 || rows < 1) {
+				return c.json({ error: 'valid cols and rows are required' }, 400);
+			}
+
+			terminal.resize(cols, rows);
+			return c.json({ success: true });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return c.json({ error: message }, 500);
+		}
+	});
 }

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/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.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));
 	}

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/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);
-}