@ottocode/server 0.1.234 → 0.1.236

package/src/runtime/agent/runner.ts

@@ -1,12 +1,11 @@
-import { hasToolCall, stepCountIs, streamText } from 'ai';
-import { messages, messageParts, sessions } from '@ottocode/database/schema';
+import { hasToolCall, streamText } from 'ai';
+import { messageParts } from '@ottocode/database/schema';
 import { eq } from 'drizzle-orm';
 import { publish, subscribe } from '../../events/bus.ts';
-import { debugLog, time } from '../debug/index.ts';
+import { time } from '../debug/index.ts';
 import { toErrorPayload } from '../errors/handling.ts';
 import {
 	type RunOpts,
-	enqueueAssistantRun,
 	setRunning,
 	dequeueJob,
 	cleanupSession,
@@ -41,7 +40,6 @@ import {
 	createOauthCodexTextGuardState,
 	consumeOauthCodexTextDelta,
 } from '../stream/text-guard.ts';
-import { decideOauthCodexContinuation } from './oauth-codex-continuation.ts';
 import { createTurnDumpCollector } from '../debug/turn-dump.ts';
 
 export {
@@ -56,17 +54,9 @@ export {
 const DEFAULT_TRACED_TOOL_INPUTS = new Set(['write', 'apply_patch']);
 
 function shouldTraceToolInput(name: string): boolean {
-	const raw = process.env.OTTO_DEBUG_TOOL_INPUT?.trim();
-	if (!raw) return false;
-	const normalized = raw.toLowerCase();
-	if (['1', 'true', 'yes', 'on', 'all'].includes(normalized)) {
-		return DEFAULT_TRACED_TOOL_INPUTS.has(name);
-	}
-	const tokens = raw
-		.split(/[\s,]+/)
-		.map((token) => token.trim().toLowerCase())
-		.filter(Boolean);
-	return tokens.includes('all') || tokens.includes(name.toLowerCase());
+	void DEFAULT_TRACED_TOOL_INPUTS;
+	void name;
+	return false;
 }
 
 function summarizeTraceValue(value: unknown, max = 160): string {
@@ -89,11 +79,7 @@ export async function runSessionLoop(sessionId: string) {
 
 		try {
 			await runAssistant(job);
-		} catch (_err) {
-			debugLog(
-				`[RUNNER] runAssistant threw (swallowed to keep loop alive): ${_err instanceof Error ? _err.message : String(_err)}`,
-			);
-		}
+		} catch {}
 	}
 
 	setRunning(sessionId, false);
@@ -101,12 +87,6 @@ export async function runSessionLoop(sessionId: string) {
 }
 
 async function runAssistant(opts: RunOpts) {
-	const separator = '='.repeat(72);
-	debugLog(separator);
-	debugLog(
-		`[RUNNER] Starting turn for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
-	);
-
 	const setup = await setupRunner(opts);
 	const {
 		cfg,
@@ -203,10 +183,6 @@ async function runAssistant(opts: RunOpts) {
 		}
 	}
 
-	debugLog(
-		`[RUNNER] messagesWithSystemInstructions length: ${messagesWithSystemInstructions.length}`,
-	);
-
 	const dump = createTurnDumpCollector({
 		sessionId: opts.sessionId,
 		messageId: opts.assistantMessageId,
@@ -282,11 +258,7 @@ async function runAssistant(opts: RunOpts) {
 			try {
 				const name = (evt.payload as { name?: string } | undefined)?.name;
 				if (name === 'finish') _finishObserved = true;
-			} catch (err) {
-				debugLog(
-					`[RUNNER] finish observer error: ${err instanceof Error ? err.message : String(err)}`,
-				);
-			}
+			} catch {}
 		}
 	});
 
@@ -364,10 +336,9 @@ async function runAssistant(opts: RunOpts) {
 	const onFinish = createFinishHandler(opts, db, completeAssistantMessage);
 	const isCopilotResponsesApi =
 		opts.provider === 'copilot' && !opts.model.startsWith('gpt-5-mini');
-	const stopWhenCondition =
-		isOpenAIOAuth || isCopilotResponsesApi
-			? stepCountIs(20)
-			: hasToolCall('finish');
+	const stopWhenCondition = isCopilotResponsesApi
+		? undefined
+		: hasToolCall('finish');
 
 	try {
 		const result = streamText({
@@ -401,29 +372,19 @@ async function runAssistant(opts: RunOpts) {
 			if (part.type === 'tool-input-start') {
 				if (shouldTraceToolInput(part.toolName)) {
 					tracedToolInputNamesById.set(part.id, part.toolName);
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-input-start tool=${part.toolName} callId=${part.id}`,
-					);
 				}
 				continue;
 			}
 
 			if (part.type === 'tool-input-delta') {
 				const toolName = tracedToolInputNamesById.get(part.id);
-				if (toolName) {
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-input-delta tool=${toolName} callId=${part.id} delta=${summarizeTraceValue(part.delta)}`,
-					);
-				}
+				if (toolName) void summarizeTraceValue(part.delta);
 				continue;
 			}
 
 			if (part.type === 'tool-input-end') {
 				const toolName = tracedToolInputNamesById.get(part.id);
 				if (toolName) {
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-input-end tool=${toolName} callId=${part.id}`,
-					);
 					tracedToolInputNamesById.delete(part.id);
 				}
 				continue;
@@ -432,18 +393,14 @@ async function runAssistant(opts: RunOpts) {
 			if (part.type === 'tool-call') {
 				if (shouldTraceToolInput(part.toolName)) {
 					tracedToolInputNamesById.delete(part.toolCallId);
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-call tool=${part.toolName} callId=${part.toolCallId} input=${summarizeTraceValue(part.input)}`,
-					);
+					void summarizeTraceValue(part.input);
 				}
 				continue;
 			}
 
 			if (part.type === 'tool-result') {
 				if (shouldTraceToolInput(part.toolName)) {
-					debugLog(
-						`[TOOL_INPUT_TRACE][runner] fullStream tool-result tool=${part.toolName} callId=${part.toolCallId} output=${summarizeTraceValue(part.output)}`,
-					);
+					void summarizeTraceValue(part.output);
 				}
 				continue;
 			}
@@ -550,11 +507,6 @@ async function runAssistant(opts: RunOpts) {
 		}
 
 		const fs = firstToolSeen();
-		if (oauthTextGuard?.dropped) {
-			debugLog(
-				'[RUNNER] Dropped pseudo tool-call text leaked by OpenAI OAuth stream',
-			);
-		}
 		if (!fs && !_finishObserved) {
 			publish({
 				type: 'finish-step',
@@ -581,10 +533,6 @@ async function runAssistant(opts: RunOpts) {
 			streamRawFinishReason = undefined;
 		}
 
-		debugLog(
-			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}, trailingAssistantTextAfterTool=${_trailingAssistantTextAfterTool}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}`,
-		);
-
 		if (dump) {
 			const finalTextSnapshot = latestAssistantText || accumulated;
 			if (finalTextSnapshot.length > 0) {
@@ -601,98 +549,6 @@ async function runAssistant(opts: RunOpts) {
 				aborted: _abortedByUser,
 			});
 		}
-
-		const MAX_CONTINUATIONS = 6;
-		const continuationCount = opts.continuationCount ?? 0;
-		const continuationDecision = decideOauthCodexContinuation({
-			provider: opts.provider,
-			isOpenAIOAuth,
-			finishObserved: _finishObserved,
-			abortedByUser: _abortedByUser,
-			continuationCount,
-			maxContinuations: MAX_CONTINUATIONS,
-			finishReason: streamFinishReason,
-			rawFinishReason: streamRawFinishReason,
-			firstToolSeen: fs,
-			hasTrailingAssistantText: _trailingAssistantTextAfterTool,
-			endedWithToolActivity: _endedWithToolActivity,
-			lastToolName: _lastToolName,
-			droppedPseudoToolText: oauthTextGuard?.dropped ?? false,
-			lastAssistantText: latestAssistantText,
-		});
-
-		if (continuationDecision.shouldContinue) {
-			const sessRows = await db
-				.select()
-				.from(sessions)
-				.where(eq(sessions.id, opts.sessionId))
-				.limit(1);
-			const sessionInputTokens = Number(sessRows[0]?.totalInputTokens ?? 0);
-			const MAX_SESSION_INPUT_TOKENS = 800_000;
-			if (sessionInputTokens > MAX_SESSION_INPUT_TOKENS) {
-				debugLog(
-					`[RUNNER] Token budget exceeded (${sessionInputTokens} > ${MAX_SESSION_INPUT_TOKENS}), stopping continuation.`,
-				);
-			} else {
-				debugLog(
-					`[RUNNER] WARNING: Stream ended without finish. reason=${continuationDecision.reason ?? 'unknown'}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}, firstToolSeen=${fs}. Auto-continuing.`,
-				);
-
-				debugLog(
-					`[RUNNER] Auto-continuing (${continuationCount + 1}/${MAX_CONTINUATIONS})...`,
-				);
-
-				try {
-					await completeAssistantMessage({}, opts, db);
-				} catch (err) {
-					debugLog(
-						`[RUNNER] completeAssistantMessage failed before continuation: ${err instanceof Error ? err.message : String(err)}`,
-					);
-				}
-
-				const continuationMessageId = crypto.randomUUID();
-				await db.insert(messages).values({
-					id: continuationMessageId,
-					sessionId: opts.sessionId,
-					role: 'assistant',
-					status: 'pending',
-					agent: opts.agent,
-					provider: opts.provider,
-					model: opts.model,
-					createdAt: Date.now(),
-				});
-
-				publish({
-					type: 'message.created',
-					sessionId: opts.sessionId,
-					payload: {
-						id: continuationMessageId,
-						role: 'assistant',
-						agent: opts.agent,
-						provider: opts.provider,
-						model: opts.model,
-					},
-				});
-
-				enqueueAssistantRun(
-					{
-						...opts,
-						assistantMessageId: continuationMessageId,
-						continuationCount: continuationCount + 1,
-					},
-					runSessionLoop,
-				);
-				return;
-			}
-		}
-		if (
-			continuationDecision.reason === 'max-continuations-reached' &&
-			!_finishObserved
-		) {
-			debugLog(
-				`[RUNNER] Max continuations (${MAX_CONTINUATIONS}) reached, stopping.`,
-			);
-		}
 	} catch (err) {
 		unsubscribeFinish();
 		dump?.recordError(err);
@@ -715,17 +571,10 @@ async function runAssistant(opts: RunOpts) {
 			errorCode === 'context_length_exceeded' ||
 			apiErrorType === 'invalid_request_error';
 
-		debugLog(
-			`[RUNNER] isPromptTooLong: ${isPromptTooLong}, isCompactCommand: ${opts.isCompactCommand}`,
-		);
-
 		if (isPromptTooLong && !opts.isCompactCommand) {
-			debugLog('[RUNNER] Prompt too long - auto-compacting');
 			try {
 				const pruneResult = await pruneSession(db, opts.sessionId);
-				debugLog(
-					`[RUNNER] Auto-pruned ${pruneResult.pruned} parts, saved ~${pruneResult.saved} tokens`,
-				);
+				void pruneResult;
 
 				publish({
 					type: 'error',
@@ -739,20 +588,10 @@ async function runAssistant(opts: RunOpts) {
 
 				try {
 					await completeAssistantMessage({}, opts, db);
-				} catch (err2) {
-					debugLog(
-						`[RUNNER] completeAssistantMessage failed after prune: ${err2 instanceof Error ? err2.message : String(err2)}`,
-					);
-				}
+				} catch {}
 				return;
-			} catch (pruneErr) {
-				debugLog(
-					`[RUNNER] Auto-prune failed: ${pruneErr instanceof Error ? pruneErr.message : String(pruneErr)}`,
-				);
-			}
+			} catch {}
 		}
-
-		debugLog(`[RUNNER] Error during stream: ${payload.message}`);
 		publish({
 			type: 'error',
 			sessionId: opts.sessionId,
@@ -773,26 +612,13 @@ async function runAssistant(opts: RunOpts) {
 				db,
 			);
 			await completeAssistantMessage({}, opts, db);
-		} catch (err2) {
-			debugLog(
-				`[RUNNER] Failed to complete message after error: ${err2 instanceof Error ? err2.message : String(err2)}`,
-			);
-		}
+		} catch {}
 		throw err;
 	} finally {
 		if (dump) {
 			try {
-				const dumpPath = await dump.flush(cfg.projectRoot);
-				debugLog(`[RUNNER] Debug dump written to ${dumpPath}`);
-			} catch (dumpErr) {
-				debugLog(
-					`[RUNNER] Failed to write debug dump: ${dumpErr instanceof Error ? dumpErr.message : String(dumpErr)}`,
-				);
-			}
+				await dump.flush(cfg.projectRoot);
+			} catch {}
 		}
-		debugLog(
-			`[RUNNER] Turn complete for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
-		);
-		debugLog(separator);
 	}
 }

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