@ottocode/server 0.1.233 → 0.1.235

package/src/runtime/debug/index.ts

@@ -5,70 +5,7 @@
  * centralized debug-state and logger modules.
  */
 
-import { isDebugEnabled as isDebugEnabledNew } from './state.ts';
-import { time as timeNew, debug as debugNew } from '@ottocode/sdk';
-
-const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
-
-const SYNONYMS: Record<string, string> = {
-	debug: 'log',
-	logs: 'log',
-	logging: 'log',
-	trace: 'log',
-	verbose: 'log',
-	log: 'log',
-	time: 'timing',
-	timing: 'timing',
-	timings: 'timing',
-	perf: 'timing',
-};
-
-type DebugConfig = { flags: Set<string> };
-
-let cachedConfig: DebugConfig | null = null;
-
-function isTruthy(raw: string | undefined): boolean {
-	if (!raw) return false;
-	const trimmed = raw.trim().toLowerCase();
-	if (!trimmed) return false;
-	return TRUTHY.has(trimmed) || trimmed === 'all';
-}
-
-function normalizeToken(token: string): string {
-	const trimmed = token.trim().toLowerCase();
-	if (!trimmed) return '';
-	if (TRUTHY.has(trimmed) || trimmed === 'all') return 'all';
-	return SYNONYMS[trimmed] ?? trimmed;
-}
-
-function parseDebugConfig(): DebugConfig {
-	const flags = new Set<string>();
-	const sources = [process.env.OTTO_DEBUG, process.env.DEBUG_OTTO];
-	let sawValue = false;
-	for (const raw of sources) {
-		if (typeof raw !== 'string') continue;
-		const trimmed = raw.trim();
-		if (!trimmed) continue;
-		sawValue = true;
-		const tokens = trimmed.split(/[\s,]+/);
-		let matched = false;
-		for (const token of tokens) {
-			const normalized = normalizeToken(token);
-			if (!normalized) continue;
-			matched = true;
-			flags.add(normalized);
-		}
-		if (!matched && isTruthy(trimmed)) flags.add('all');
-	}
-	if (isTruthy(process.env.OTTO_DEBUG_TIMING)) flags.add('timing');
-	if (!flags.size && sawValue) flags.add('all');
-	return { flags };
-}
-
-function getDebugConfig(): DebugConfig {
-	if (!cachedConfig) cachedConfig = parseDebugConfig();
-	return cachedConfig;
-}
+import { time as timeNew } from '@ottocode/sdk';
 
 /**
  * Check if debug mode is enabled for a specific flag
@@ -77,33 +14,8 @@ function getDebugConfig(): DebugConfig {
  * @deprecated Use isDebugEnabled from debug-state.ts instead
  */
 export function isDebugEnabled(flag?: string): boolean {
-	// Use new centralized debug state for general debug
-	if (!flag || flag === 'log') {
-		return isDebugEnabledNew();
-	}
-
-	// For specific flags like 'timing', check both new state and legacy env vars
-	if (flag === 'timing') {
-		// If new debug state is enabled OR timing flag is set
-		if (isDebugEnabledNew()) return true;
-	}
-
-	// Legacy flag checking
-	const config = getDebugConfig();
-	if (config.flags.has('all')) return true;
-	if (flag) return config.flags.has(flag);
-	return config.flags.has('log');
-}
-
-/**
- * Log debug message
- * Now uses the centralized logger
- *
- * @deprecated Use logger.debug from logger.ts instead
- */
-export function debugLog(...args: unknown[]) {
-	if (!isDebugEnabled('log')) return;
-	debugNew(args.map((arg) => String(arg)).join(' '));
+	void flag;
+	return false;
 }
 
 /**

package/src/runtime/debug/state.ts

@@ -2,12 +2,9 @@
  * Runtime debug state management
  *
  * Centralizes debug flag state that can be set either via:
- * - Environment variables (OTTO_DEBUG, DEBUG_OTTO)
  * - Runtime configuration (CLI --debug flag)
  */
 
-const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
-
 type DebugState = {
 	enabled: boolean;
 	traceEnabled: boolean;
@@ -23,66 +20,16 @@ const state: DebugState = {
 	runtimeTraceOverride: null,
 };
 
-type GlobalDebugFlags = {
-	__OTTO_DEBUG_ENABLED__?: boolean;
-	__OTTO_TRACE_ENABLED__?: boolean;
-};
-
-const globalFlags = globalThis as GlobalDebugFlags;
-
-function syncGlobalFlags() {
-	globalFlags.__OTTO_DEBUG_ENABLED__ = state.enabled;
-	globalFlags.__OTTO_TRACE_ENABLED__ = state.traceEnabled;
-}
-
-/**
- * Check if environment variables indicate debug mode
- */
-function checkEnvDebug(): boolean {
-	const sources = [process.env.OTTO_DEBUG, process.env.DEBUG_OTTO];
-	for (const value of sources) {
-		if (!value) continue;
-		const trimmed = value.trim().toLowerCase();
-		if (TRUTHY.has(trimmed) || trimmed === 'all') {
-			return true;
-		}
-	}
-	return false;
-}
-
-/**
- * Check if environment variables indicate trace mode
- */
-function checkEnvTrace(): boolean {
-	const sources = [process.env.OTTO_TRACE, process.env.TRACE_OTTO];
-	for (const value of sources) {
-		if (!value) continue;
-		const trimmed = value.trim().toLowerCase();
-		if (TRUTHY.has(trimmed)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-function checkEnvDevtools(): boolean {
-	const raw = process.env.OTTO_DEVTOOLS;
-	if (!raw) return false;
-	const trimmed = raw.trim().toLowerCase();
-	return TRUTHY.has(trimmed);
-}
-
 /**
  * Initialize debug state from environment
  */
 function initialize() {
 	if (state.runtimeOverride === null) {
-		state.enabled = checkEnvDebug();
+		state.enabled = false;
 	}
 	if (state.runtimeTraceOverride === null) {
-		state.traceEnabled = checkEnvTrace();
+		state.traceEnabled = false;
 	}
-	syncGlobalFlags();
 }
 
 /**
@@ -104,7 +51,7 @@ export function isTraceEnabled(): boolean {
 }
 
 export function isDevtoolsEnabled(): boolean {
-	return checkEnvDevtools();
+	return false;
 }
 
 /**
@@ -116,7 +63,6 @@ export function isDevtoolsEnabled(): boolean {
 export function setDebugEnabled(enabled: boolean): void {
 	state.enabled = enabled;
 	state.runtimeOverride = enabled;
-	syncGlobalFlags();
 }
 
 /**
@@ -128,7 +74,6 @@ export function setDebugEnabled(enabled: boolean): void {
 export function setTraceEnabled(enabled: boolean): void {
 	state.traceEnabled = enabled;
 	state.runtimeTraceOverride = enabled;
-	syncGlobalFlags();
 }
 
 /**
@@ -137,9 +82,8 @@ export function setTraceEnabled(enabled: boolean): void {
 export function resetDebugState(): void {
 	state.runtimeOverride = null;
 	state.runtimeTraceOverride = null;
-	state.enabled = checkEnvDebug();
-	state.traceEnabled = checkEnvTrace();
-	syncGlobalFlags();
+	state.enabled = false;
+	state.traceEnabled = false;
 }
 
 /**

package/src/runtime/debug/turn-dump.ts

@@ -3,11 +3,7 @@ import { join } from 'node:path';
 import { mkdir } from 'node:fs/promises';
 import { isDebugEnabled } from './state.ts';
 
-const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
-
 function isDumpEnabled(): boolean {
-	const explicit = process.env.OTTO_DEBUG_DUMP;
-	if (explicit) return TRUTHY.has(explicit.trim().toLowerCase());
 	return isDebugEnabled();
 }
 

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

@@ -5,7 +5,6 @@ import { streamText } from 'ai';
 import { resolveModel } from '../provider/index.ts';
 import { getAuth } from '@ottocode/sdk';
 import { loadConfig } from '@ottocode/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';
@@ -29,16 +28,11 @@ export async function performAutoCompaction(
 	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,
@@ -46,14 +40,10 @@ export async function performAutoCompaction(
 			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 auth = await getAuth(
 			provider as Parameters<typeof getAuth>[0],
@@ -61,10 +51,6 @@ export async function performAutoCompaction(
 		);
 		const oauth = detectOAuth(provider, auth);
 
-		debugLog(
-			`[compaction] OAuth: needsSpoof=${oauth.needsSpoof}, isOpenAIOAuth=${oauth.isOpenAIOAuth}`,
-		);
-
 		const model = await resolveModel(
 			provider as Parameters<typeof resolveModel>[0],
 			modelId,
@@ -130,25 +116,19 @@ export async function performAutoCompaction(
 			.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`,
-		);
+		void compactResult;
 
 		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-mark.ts

@@ -1,18 +1,28 @@
 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'];
 
+type PartInfo = {
+	id: string;
+	tokens: number;
+	toolCallId: string | null;
+	type: 'tool_call' | 'tool_result';
+	index: number;
+};
+
+type CompactUnit = {
+	partIds: string[];
+	tokens: number;
+};
+
 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)
@@ -20,7 +30,6 @@ export async function markSessionCompacted(
 		.limit(1);
 
 	if (!compactMsg.length) {
-		debugLog('[compaction] Compact message not found');
 		return { compacted: 0, saved: 0 };
 	}
 
@@ -37,8 +46,7 @@ export async function markSessionCompacted(
 		)
 		.orderBy(asc(messages.createdAt));
 
-	type PartInfo = { id: string; tokens: number };
-	const allToolParts: PartInfo[] = [];
+	const allCompactUnits: CompactUnit[] = [];
 	let totalToolTokens = 0;
 
 	for (const msg of oldMessages) {
@@ -48,6 +56,8 @@ export async function markSessionCompacted(
 			.where(eq(messageParts.messageId, msg.id))
 			.orderBy(asc(messageParts.index));
 
+		const eligibleParts: PartInfo[] = [];
+
 		for (const part of parts) {
 			if (part.type !== 'tool_call' && part.type !== 'tool_result') continue;
 			if (part.toolName && PROTECTED_TOOLS.includes(part.toolName)) continue;
@@ -69,43 +79,81 @@ export async function markSessionCompacted(
 
 			const tokens = estimateTokens(contentStr);
 			totalToolTokens += tokens;
-			allToolParts.push({ id: part.id, tokens });
+			eligibleParts.push({
+				id: part.id,
+				tokens,
+				toolCallId: part.toolCallId,
+				type: part.type,
+				index: part.index,
+			});
+		}
+
+		const pairedCallIds = new Set<string>();
+		const callsById = new Map<string, PartInfo[]>();
+		const resultsById = new Map<string, PartInfo[]>();
+
+		for (const part of eligibleParts) {
+			if (!part.toolCallId) continue;
+			const bucket = part.type === 'tool_call' ? callsById : resultsById;
+			const items = bucket.get(part.toolCallId) ?? [];
+			items.push(part);
+			bucket.set(part.toolCallId, items);
+		}
+
+		for (const [toolCallId, callParts] of callsById) {
+			const resultParts = resultsById.get(toolCallId);
+			if (!resultParts?.length) continue;
+
+			const pairParts = [...callParts, ...resultParts].sort(
+				(a, b) => a.index - b.index,
+			);
+			pairedCallIds.add(toolCallId);
+			allCompactUnits.push({
+				partIds: pairParts.map((part) => part.id),
+				tokens: pairParts.reduce((sum, part) => sum + part.tokens, 0),
+			});
+		}
+
+		for (const part of eligibleParts) {
+			if (part.toolCallId && pairedCallIds.has(part.toolCallId)) continue;
+			allCompactUnits.push({
+				partIds: [part.id],
+				tokens: part.tokens,
+			});
 		}
 	}
 
 	const tokensToFree = Math.max(0, totalToolTokens - PRUNE_PROTECT);
 
-	const toCompact: PartInfo[] = [];
+	const toCompact: CompactUnit[] = [];
 	let freedTokens = 0;
 
-	for (const part of allToolParts) {
+	for (const unit of allCompactUnits) {
 		if (freedTokens >= tokensToFree) break;
-		freedTokens += part.tokens;
-		toCompact.push(part);
+		freedTokens += unit.tokens;
+		toCompact.push(unit);
 	}
 
-	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)}`,
-				);
+		for (const unit of toCompact) {
+			for (const partId of unit.partIds) {
+				try {
+					await db
+						.update(messageParts)
+						.set({ compactedAt })
+						.where(eq(messageParts.id, partId));
+				} catch {}
 			}
 		}
 
-		debugLog(`[compaction] Marked ${toCompact.length} parts as compacted`);
+		const compactedParts = toCompact.reduce(
+			(sum, unit) => sum + unit.partIds.length,
+			0,
+		);
+		return { compacted: compactedParts, saved: freedTokens };
 	}
 
-	return { compacted: toCompact.length, saved: freedTokens };
+	return { compacted: 0, saved: freedTokens };
 }

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

@@ -1,7 +1,6 @@
 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'];
@@ -10,8 +9,6 @@ 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)

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

@@ -8,7 +8,6 @@ import {
 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';
 
 /**
@@ -43,15 +42,8 @@ export async function buildHistoryMessages(
 			m.status !== 'error'
 		) {
 			if (parts.length === 0) {
-				debugLog(
-					`[buildHistoryMessages] Skipping empty assistant message ${m.id} with status ${m.status}`,
-				);
 				continue;
 			}
-
-			debugLog(
-				`[buildHistoryMessages] Including non-complete assistant message ${m.id} (status: ${m.status}) with ${parts.length} parts to preserve context`,
-			);
 		}
 
 		if (m.role === 'user') {
@@ -179,9 +171,6 @@ export async function buildHistoryMessages(
 						let result = toolResultsById.get(obj.callId);
 
 						if (!result) {
-							debugLog(
-								`[buildHistoryMessages] Synthesizing error result for incomplete tool call ${obj.name}#${obj.callId}`,
-							);
 							result = {
 								name: obj.name,
 								callId: obj.callId,
@@ -265,16 +254,6 @@ async function _logPendingToolParts(
 				}
 			} 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)
-			}`,
-		);
-	}
+		void pendingCalls;
+	} catch {}
 }