@ottocode/server 0.1.234 → 0.1.236

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 {}
 }

package/src/runtime/message/service.ts

@@ -9,10 +9,10 @@ import { runSessionLoop } from '../agent/runner.ts';
 import { resolveModel } from '../provider/index.ts';
 import {
 	getFastModelForAuth,
+	logger,
 	type ProviderId,
 	type ReasoningLevel,
 } from '@ottocode/sdk';
-import { debugLog } from '../debug/index.ts';
 import { isCompactCommand, buildCompactionContext } from './compaction.ts';
 import { detectOAuth, adaptSimpleCall } from '../provider/oauth-adapter.ts';
 
@@ -59,13 +59,17 @@ export async function dispatchAssistantMessage(
 		files,
 	} = options;
 
-	debugLog(
-		`[MESSAGE_SERVICE] dispatchAssistantMessage called with userContext: ${userContext ? `${userContext.substring(0, 50)}...` : 'NONE'}`,
-	);
-
 	const sessionId = session.id;
 	const now = Date.now();
 	const userMessageId = crypto.randomUUID();
+	logger.debug('[agent] dispatching assistant message', {
+		sessionId,
+		agent,
+		provider,
+		model,
+		oneShot: Boolean(oneShot),
+		hasUserContext: Boolean(userContext),
+	});
 
 	await db.insert(messages).values({
 		id: userMessageId,
@@ -163,15 +167,10 @@ export async function dispatchAssistantMessage(
 		},
 	});
 
-	debugLog(
-		`[MESSAGE_SERVICE] Enqueuing assistant run with userContext: ${userContext ? `${userContext.substring(0, 50)}...` : 'NONE'}`,
-	);
-
 	const isCompact = isCompactCommand(content);
 	let compactionContext: string | undefined;
 
 	if (isCompact) {
-		debugLog('[MESSAGE_SERVICE] Detected /compact command, building context');
 		const { getModelLimits } = await import('./compaction.ts');
 		const limits = getModelLimits(provider, model);
 		const contextTokenLimit = limits
@@ -182,9 +181,6 @@ export async function dispatchAssistantMessage(
 			sessionId,
 			contextTokenLimit,
 		);
-		debugLog(
-			`[message-service] /compact context length: ${compactionContext.length}, limit: ${contextTokenLimit} tokens`,
-		);
 	}
 
 	const toolApprovalMode = cfg.defaults.toolApproval ?? 'dangerous';
@@ -207,6 +203,14 @@ export async function dispatchAssistantMessage(
 		},
 		runSessionLoop,
 	);
+	logger.debug('[agent] assistant run enqueued', {
+		sessionId,
+		assistantMessageId,
+		agent,
+		provider,
+		model,
+		isCompactCommand: isCompact,
+	});
 
 	void touchSessionLastActive({ db, sessionId });
 
@@ -249,9 +253,7 @@ function scheduleSessionTitle(args: {
 		titlePending.delete(sessionId);
 		try {
 			await generateSessionTitle({ cfg, db, sessionId, content });
-		} catch (err) {
-			debugLog('[TITLE_GEN] Title generation error:');
-			debugLog(err);
+		} catch {
 		} finally {
 			titleInFlight.delete(sessionId);
 			titleActiveCount--;
@@ -288,34 +290,24 @@ async function generateSessionTitle(args: {
 			.where(eq(sessions.id, sessionId));
 
 		if (!existingSession.length) {
-			debugLog('[TITLE_GEN] Session not found, aborting');
 			return;
 		}
 
 		const sess = existingSession[0];
 		if (sess.title && sess.title !== 'New Session') {
-			debugLog('[TITLE_GEN] Session already has a title, skipping');
 			return;
 		}
 
 		const provider = (sess.provider ?? cfg.defaults.provider) as ProviderId;
 		const modelName = sess.model ?? cfg.defaults.model;
 
-		debugLog('[TITLE_GEN] Generating title for session');
-		debugLog(`[TITLE_GEN] Provider: ${provider}, Model: ${modelName}`);
-
 		const { getAuth } = await import('@ottocode/sdk');
 		const auth = await getAuth(provider, cfg.projectRoot);
 		const oauth = detectOAuth(provider, auth);
 
 		const titleModel = getFastModelForAuth(provider, auth?.type) ?? modelName;
-		debugLog(`[TITLE_GEN] Using title model: ${titleModel}`);
 		const model = await resolveModel(provider, titleModel, cfg);
 
-		debugLog(
-			`[TITLE_GEN] oauth: needsSpoof=${oauth.needsSpoof}, isOpenAIOAuth=${oauth.isOpenAIOAuth}`,
-		);
-
 		const promptText = String(content ?? '').slice(0, 2000);
 
 		const titleInstructions = `Generate a brief title (6-8 words) summarizing what the user wants to do.
@@ -330,10 +322,6 @@ Output ONLY the title, nothing else.`;
 			userContent: promptText,
 		});
 
-		debugLog(
-			`[TITLE_GEN] mode=${adapted.forceStream ? 'openai-oauth' : oauth.needsSpoof ? 'spoof' : 'api-key'}`,
-		);
-
 		let modelTitle = '';
 		try {
 			if (adapted.forceStream || oauth.needsSpoof) {
@@ -348,7 +336,6 @@ Output ONLY the title, nothing else.`;
 				}
 				modelTitle = modelTitle.trim();
 			} else {
-				debugLog('[TITLE_GEN] Using generateText...');
 				const out = await generateText({
 					model,
 					system: adapted.system,
@@ -356,24 +343,15 @@ Output ONLY the title, nothing else.`;
 				});
 				modelTitle = (out?.text || '').trim();
 			}
-
-			debugLog('[TITLE_GEN] Raw response from model:');
-			debugLog(`[TITLE_GEN] "${modelTitle}"`);
-		} catch (err) {
-			debugLog('[TITLE_GEN] Error generating title:');
-			debugLog(err);
-		}
+		} catch {}
 
 		if (!modelTitle) {
-			debugLog('[TITLE_GEN] No title returned, aborting');
 			return;
 		}
 
 		const sanitized = sanitizeTitle(modelTitle);
-		debugLog(`[TITLE_GEN] After sanitization: "${sanitized}"`);
 
 		if (!sanitized || sanitized === 'New Session') {
-			debugLog('[TITLE_GEN] Sanitized title is empty or default, aborting');
 			return;
 		}
 
@@ -382,17 +360,12 @@ Output ONLY the title, nothing else.`;
 			.set({ title: sanitized, lastActiveAt: Date.now() })
 			.where(eq(sessions.id, sessionId));
 
-		debugLog(`[TITLE_GEN] Setting final title: "${sanitized}"`);
-
 		publish({
 			type: 'session.updated',
 			sessionId,
 			payload: { id: sessionId, title: sanitized },
 		});
-	} catch (err) {
-		debugLog('[TITLE_GEN] Error in generateSessionTitle:');
-		debugLog(err);
-	}
+	} catch {}
 }
 
 function sanitizeTitle(raw: string): string {
@@ -424,9 +397,7 @@ async function touchSessionLastActive(args: {
 			.set({ lastActiveAt: Date.now() })
 			.where(eq(sessions.id, sessionId))
 			.run();
-	} catch (err) {
-		debugLog('[touchSessionLastActive] Error:', err);
-	}
+	} catch {}
 }
 
 export async function triggerDeferredTitleGeneration(args: {
@@ -445,9 +416,6 @@ export async function triggerDeferredTitleGeneration(args: {
 			.limit(1);
 
 		if (!userMessages.length || userMessages[0].role !== 'user') {
-			debugLog(
-				'[TITLE_GEN] No user message found for deferred title generation',
-			);
 			return;
 		}
 
@@ -459,9 +427,6 @@ export async function triggerDeferredTitleGeneration(args: {
 			.limit(1);
 
 		if (!parts.length) {
-			debugLog(
-				'[TITLE_GEN] No message parts found for deferred title generation',
-			);
 			return;
 		}
 
@@ -470,19 +435,12 @@ export async function triggerDeferredTitleGeneration(args: {
 			const parsed = JSON.parse(parts[0].content ?? '{}');
 			content = String(parsed.text ?? '');
 		} catch {
-			debugLog('[TITLE_GEN] Failed to parse message part content');
 			return;
 		}
 
 		if (!content) {
-			debugLog('[TITLE_GEN] Empty content for deferred title generation');
 			return;
 		}
-
-		debugLog('[TITLE_GEN] Triggering deferred title generation');
 		enqueueSessionTitle({ cfg, db, sessionId, content });
-	} catch (err) {
-		debugLog('[TITLE_GEN] Error in triggerDeferredTitleGeneration:');
-		debugLog(err);
-	}
+	} catch {}
 }

package/src/runtime/message/tool-history-tracker.ts

@@ -1,5 +1,3 @@
-import { debugLog } from '../debug/index.ts';
-
 type ToolResultPart = {
 	type: string;
 	state?: string;
@@ -61,7 +59,6 @@ export class ToolHistoryTracker {
 			.callProviderMetadata;
 		delete (entry.part as { providerMetadata?: unknown }).providerMetadata;
 		entry.summarized = true;
-		debugLog(`[history] summarized tool output -> ${entry.summary}`);
 	}
 }
 

package/src/runtime/prompt/builder.ts

@@ -1,5 +1,4 @@
 import { providerBasePrompt } from '@ottocode/sdk';
-import { debugLog } from '../debug/index.ts';
 import { composeEnvironmentAndInstructions } from '../context/environment.ts';
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
 import BASE_PROMPT from '@ottocode/sdk/prompts/base.txt' with { type: 'text' };
@@ -163,7 +162,6 @@ export async function composeSystemPrompt(options: {
 
 	const composed = parts.filter(Boolean).join('\n\n').trim();
 	if (composed) {
-		debugLog(`[system] pieces: ${dedupeComponents(components).join(', ')}`);
 		return {
 			prompt: composed,
 			components: dedupeComponents(components),

package/src/runtime/provider/oauth-adapter.ts

@@ -88,11 +88,11 @@ export function detectOAuth(
 const CODEX_INSTRUCTIONS =
 	'You are a coding agent. Follow all developer messages. Use tools to complete tasks.';
 
-export function buildCodexProviderOptions() {
+export function buildCodexProviderOptions(instructions?: string) {
 	return {
 		openai: {
 			store: false as const,
-			instructions: CODEX_INSTRUCTIONS,
+			instructions: instructions?.trim() || CODEX_INSTRUCTIONS,
 			parallelToolCalls: false,
 		},
 	};
@@ -145,7 +145,7 @@ export function adaptSimpleCall(
 					content: input.userContent,
 				},
 			],
-			providerOptions: buildCodexProviderOptions(),
+			providerOptions: buildCodexProviderOptions(input.instructions),
 			forceStream: true,
 		};
 	}
@@ -229,9 +229,9 @@ export function adaptRunnerCall(
 		return {
 			system: '',
 			systemComponents: composed.components,
-			additionalSystemMessages: [{ role: 'system', content: composed.prompt }],
+			additionalSystemMessages: [],
 			maxOutputTokens: undefined,
-			providerOptions: buildCodexProviderOptions(),
+			providerOptions: buildCodexProviderOptions(composed.prompt),
 		};
 	}
 

package/src/runtime/stream/error-handler.ts

@@ -7,7 +7,6 @@ import { toErrorPayload } from '../errors/handling.ts';
 import type { RunOpts } from '../session/queue.ts';
 import type { ToolAdapterContext } from '../../tools/adapter.ts';
 import { pruneSession, performAutoCompaction } from '../message/compaction.ts';
-import { debugLog } from '../debug/index.ts';
 import { enqueueAssistantRun } from '../session/queue.ts';
 import { clearPendingTopup } from '../topup/manager.ts';
 
@@ -77,7 +76,6 @@ export function createErrorHandler(
 
 		// Handle fiat payment selected - this is not an error, just a signal to pause
 		if (isFiatSelected) {
-			debugLog('[stream-handlers] Fiat payment selected, pausing request');
 			clearPendingTopup(opts.sessionId);
 
 			// Add a helpful message part telling user to complete payment
@@ -171,20 +169,9 @@ export function createErrorHandler(
 			errorCode === 'context_length_exceeded' ||
 			errorType === 'invalid_request_error';
 
-		debugLog(
-			`[stream-handlers] isPromptTooLong: ${isPromptTooLong}, errorCode: ${errorCode}, errorType: ${errorType}`,
-		);
-
 		if (isPromptTooLong && !opts.isCompactCommand) {
-			debugLog(
-				'[stream-handlers] Prompt too long detected, auto-compacting...',
-			);
-
 			const retries = opts.compactionRetries ?? 0;
 			if (retries >= 2) {
-				debugLog(
-					'[stream-handlers] Compaction retry limit reached, surfacing error',
-				);
 			} else {
 				await db
 					.update(messages)
@@ -243,25 +230,12 @@ export function createErrorHandler(
 						opts.model,
 					);
 					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] Auto-compact error: ${compactErr instanceof Error ? compactErr.message : String(compactErr)}`,
-					);
-				}
+				} catch {}
 
 				await db
 					.update(messages)
@@ -278,7 +252,6 @@ export function createErrorHandler(
 				});
 
 				if (compactionSucceeded && retryCallback) {
-					debugLog('[stream-handlers] Triggering retry after compaction...');
 					const retryMessageId = crypto.randomUUID();
 					await db.insert(messages).values({
 						id: retryMessageId,
@@ -315,9 +288,6 @@ export function createErrorHandler(
 				}
 
 				if (compactionSucceeded) {
-					debugLog(
-						'[stream-handlers] No retryCallback provided, cannot auto-retry',
-					);
 					return;
 				}
 			}

package/src/runtime/stream/finish-handler.ts

@@ -5,7 +5,6 @@ import { publish } from '../../events/bus.ts';
 import { estimateModelCostUsd } from '@ottocode/sdk';
 import type { RunOpts } from '../session/queue.ts';
 import { markSessionCompacted } from '../message/compaction.ts';
-import { debugLog } from '../debug/index.ts';
 import type { FinishEvent } from './types.ts';
 import {
 	normalizeUsage,
@@ -24,11 +23,7 @@ export function createFinishHandler(
 	return async (fin: FinishEvent) => {
 		try {
 			await completeAssistantMessageFn(fin, opts, db);
-		} catch (err) {
-			debugLog(
-				`[finish-handler] completeAssistantMessage failed: ${err instanceof Error ? err.message : String(err)}`,
-			);
-		}
+		} catch {}
 
 		if (opts.isCompactCommand && fin.finishReason !== 'error') {
 			const assistantParts = await db
@@ -40,27 +35,15 @@ export function createFinishHandler(
 			);
 
 			if (!hasTextContent) {
-				debugLog(
-					'[stream-handlers] /compact finished but no summary generated, skipping compaction marking',
-				);
 			} else {
 				try {
-					debugLog(
-						`[stream-handlers] /compact complete, marking session compacted`,
-					);
 					const result = await markSessionCompacted(
 						db,
 						opts.sessionId,
 						opts.assistantMessageId,
 					);
-					debugLog(
-						`[stream-handlers] Compacted ${result.compacted} parts, saved ~${result.saved} tokens`,
-					);
-				} catch (err) {
-					debugLog(
-						`[stream-handlers] Compaction failed: ${err instanceof Error ? err.message : String(err)}`,
-					);
-				}
+					void result;
+				} catch {}
 			}
 		}