@ottocode/server 0.1.234 → 0.1.236

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.234",
+	"version": "0.1.236",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -49,8 +49,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.234",
-		"@ottocode/database": "0.1.234",
+		"@ottocode/sdk": "0.1.236",
+		"@ottocode/database": "0.1.236",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.3.6"

package/src/openapi/paths/config.ts

@@ -234,6 +234,100 @@ export const configPaths = {
 			},
 		},
 	},
+	'/v1/config/debug': {
+		get: {
+			tags: ['config'],
+			operationId: 'getDebugConfig',
+			summary: 'Get debug configuration',
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									enabled: { type: 'boolean' },
+									scopes: {
+										type: 'array',
+										items: { type: 'string' },
+									},
+									logPath: { type: 'string' },
+									sessionsDir: { type: 'string' },
+									debugDir: { type: 'string' },
+								},
+								required: [
+									'enabled',
+									'scopes',
+									'logPath',
+									'sessionsDir',
+									'debugDir',
+								],
+							},
+						},
+					},
+				},
+			},
+		},
+		patch: {
+			tags: ['config'],
+			operationId: 'updateDebugConfig',
+			summary: 'Update debug configuration',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								enabled: { type: 'boolean' },
+								scopes: {
+									type: 'array',
+									items: { type: 'string' },
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: { type: 'boolean' },
+									debug: {
+										type: 'object',
+										properties: {
+											enabled: { type: 'boolean' },
+											scopes: {
+												type: 'array',
+												items: { type: 'string' },
+											},
+											logPath: { type: 'string' },
+											sessionsDir: { type: 'string' },
+											debugDir: { type: 'string' },
+										},
+										required: [
+											'enabled',
+											'scopes',
+											'logPath',
+											'sessionsDir',
+											'debugDir',
+										],
+									},
+								},
+								required: ['success', 'debug'],
+							},
+						},
+					},
+				},
+			},
+		},
+	},
 	'/v1/config/models': {
 		get: {
 			tags: ['config'],

package/src/routes/config/debug.ts

@@ -0,0 +1,39 @@
+import type { Hono } from 'hono';
+import { logger, readDebugConfig, writeDebugConfig } from '@ottocode/sdk';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+
+export function registerDebugConfigRoute(app: Hono) {
+	app.get('/v1/config/debug', async (c) => {
+		try {
+			const debug = await readDebugConfig();
+			return c.json(debug);
+		} catch (error) {
+			logger.error('Failed to load debug config', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.patch('/v1/config/debug', async (c) => {
+		try {
+			const body = await c.req.json<{
+				enabled?: boolean;
+				scopes?: string[];
+			}>();
+
+			await writeDebugConfig({
+				enabled: body.enabled,
+				scopes: Array.isArray(body.scopes)
+					? body.scopes.map((scope) => scope.trim()).filter(Boolean)
+					: body.scopes,
+			});
+
+			const debug = await readDebugConfig();
+			return c.json({ success: true, debug });
+		} catch (error) {
+			logger.error('Failed to update debug config', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/index.ts

@@ -5,6 +5,7 @@ import { registerAgentsRoute } from './agents.ts';
 import { registerProvidersRoute } from './providers.ts';
 import { registerModelsRoutes } from './models.ts';
 import { registerDefaultsRoute } from './defaults.ts';
+import { registerDebugConfigRoute } from './debug.ts';
 
 export function registerConfigRoutes(app: Hono) {
 	registerCwdRoute(app);
@@ -13,4 +14,5 @@ export function registerConfigRoutes(app: Hono) {
 	registerProvidersRoute(app);
 	registerModelsRoutes(app);
 	registerDefaultsRoute(app);
+	registerDebugConfigRoute(app);
 }

package/src/routes/config/utils.ts

@@ -9,7 +9,6 @@ import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import type { EmbeddedAppConfig } from '../../index.ts';
 import type { OttoConfig } from '@ottocode/sdk';
-import { logger } from '@ottocode/sdk';
 import { loadAgentsConfig } from '../../runtime/agent/registry.ts';
 
 export async function isProviderAuthorizedHybrid(
@@ -83,11 +82,7 @@ export async function discoverAllAgents(
 				agentSet.add(agentName);
 			}
 		}
-	} catch (err) {
-		logger.debug('Failed to load agents.json', {
-			error: err instanceof Error ? err.message : String(err),
-		});
-	}
+	} catch {}
 
 	try {
 		const localAgentsPath = join(projectRoot, '.otto', 'agents');
@@ -100,11 +95,7 @@ export async function discoverAllAgents(
 				}
 			}
 		}
-	} catch (err) {
-		logger.debug('Failed to read local agents directory', {
-			error: err instanceof Error ? err.message : String(err),
-		});
-	}
+	} catch {}
 
 	try {
 		const globalAgentsPath = getGlobalAgentsDir();
@@ -117,11 +108,7 @@ export async function discoverAllAgents(
 				}
 			}
 		}
-	} catch (err) {
-		logger.debug('Failed to read global agents directory', {
-			error: err instanceof Error ? err.message : String(err),
-		});
-	}
+	} catch {}
 
 	return Array.from(agentSet).sort();
 }

package/src/routes/git/commit.ts

@@ -10,7 +10,6 @@ import { sessions } from '@ottocode/database/schema';
 import { gitCommitSchema, gitGenerateCommitMessageSchema } from './schemas.ts';
 import { validateAndGetGitRoot, parseGitStatus } from './utils.ts';
 import { resolveModel } from '../../runtime/provider/index.ts';
-import { debugLog } from '../../runtime/debug/index.ts';
 import {
 	detectOAuth,
 	adaptSimpleCall,
@@ -168,7 +167,6 @@ Commit message:`;
 			});
 
 			if (adapted.forceStream) {
-				debugLog('[COMMIT] Using streamText for OpenAI OAuth');
 				const result = streamText({
 					model,
 					system: adapted.system,
@@ -180,7 +178,6 @@ Commit message:`;
 					text += chunk;
 				}
 				const message = text.trim();
-				debugLog(`[COMMIT] OAuth result: "${message.slice(0, 80)}..."`);
 				return c.json({ status: 'ok', data: { message } });
 			}
 

package/src/routes/terminals.ts

@@ -18,9 +18,7 @@ export function registerTerminalsRoutes(
 
 	app.post('/v1/terminals', async (c) => {
 		try {
-			logger.debug('POST /v1/terminals called');
 			const body = await c.req.json();
-			logger.debug('Creating terminal request received', body);
 			const { command, args, purpose, cwd, title } = body;
 
 			if (!command || !purpose) {
@@ -36,13 +34,6 @@ export function registerTerminalsRoutes(
 			}
 			const resolvedCwd = cwd || process.cwd();
 
-			logger.debug('Creating terminal', {
-				command: resolvedCommand,
-				args,
-				purpose,
-				cwd: resolvedCwd,
-			});
-
 			const terminal = terminalManager.create({
 				command: resolvedCommand,
 				args: args || [],
@@ -52,8 +43,6 @@ export function registerTerminalsRoutes(
 				title,
 			});
 
-			logger.debug('Terminal created successfully', { id: terminal.id });
-
 			return c.json({
 				terminalId: terminal.id,
 				pid: terminal.pid,
@@ -80,25 +69,18 @@ export function registerTerminalsRoutes(
 
 	const handleTerminalOutput = async (c: Context) => {
 		const id = c.req.param('id');
-		logger.debug('SSE client connecting to terminal', { id });
 		const terminal = terminalManager.get(id);
 
 		if (!terminal) {
-			logger.debug('SSE terminal not found', { id });
 			return c.json({ error: 'Terminal not found' }, 404);
 		}
 
 		const activeTerminal = terminal;
 
 		return streamSSE(c, async (stream) => {
-			logger.debug('SSE stream started for terminal', { id });
 			const skipHistory = c.req.query('skipHistory') === 'true';
 			if (!skipHistory) {
 				const history = activeTerminal.read();
-				logger.debug('SSE sending terminal history', {
-					id,
-					lines: history.length,
-				});
 				for (const line of history) {
 					await stream.write(
 						`data: ${JSON.stringify({ type: 'data', line })}\n\n`,
@@ -155,9 +137,6 @@ export function registerTerminalsRoutes(
 			}
 
 			function onAbort() {
-				logger.debug('SSE client disconnected from terminal', {
-					id: activeTerminal.id,
-				});
 				stream.close();
 				finish();
 			}

package/src/routes/tunnel.ts

@@ -47,8 +47,6 @@ export function registerTunnelRoutes(app: Hono) {
 				port = getServerPort() || 9100;
 			}
 
-			logger.debug('Starting tunnel on port:', port);
-
 			// Kill any stale tunnel processes first
 			await killStaleTunnels();
 
@@ -60,7 +58,6 @@ export function registerTunnelRoutes(app: Hono) {
 
 			const url = await activeTunnel.start(port, (msg) => {
 				progressMessage = msg;
-				logger.debug('Tunnel progress', { message: msg });
 			});
 
 			tunnelUrl = url;
@@ -109,8 +106,6 @@ export function registerTunnelRoutes(app: Hono) {
 			tunnelError = null;
 			progressMessage = null;
 
-			logger.debug('External tunnel registered:', url);
-
 			return c.json({
 				ok: true,
 				url: tunnelUrl,

package/src/runtime/agent/mcp-prepare-step.ts

@@ -1,5 +1,4 @@
 import type { Tool } from 'ai';
-import { debugLog } from '../debug/index.ts';
 
 export interface MCPPrepareStepState {
 	mcpToolsRecord: Record<string, Tool>;
@@ -57,12 +56,7 @@ export function buildPrepareStep(state: MCPPrepareStepState) {
 		}
 
 		const activeTools = [...state.baseToolNames, ...state.loadedMCPTools];
-
-		if (state.loadedMCPTools.size > 0) {
-			debugLog(
-				`[MCP prepareStep] step=${stepNumber}, active MCP tools: ${[...state.loadedMCPTools].join(', ')}`,
-			);
-		}
+		void stepNumber;
 
 		return { activeTools };
 	};

package/src/runtime/agent/registry.ts

@@ -1,5 +1,4 @@
 import { getGlobalAgentsJsonPath, getGlobalAgentsDir } from '@ottocode/sdk';
-import { debugLog } from '../debug/index.ts';
 import type { ProviderName } from '@ottocode/sdk';
 import { catalog } from '@ottocode/sdk';
 // Embed default agent prompts; only user overrides read from disk.
@@ -334,13 +333,7 @@ export async function resolveAgentConfig(
 	const deduped = Array.from(new Set([...tools, ...baseToolSet]));
 	const provider = normalizeProvider(entry?.provider);
 	const model = normalizeModel(entry?.model);
-	debugLog(`[agent] ${name} prompt source: ${promptSource}`);
-	debugLog(
-		`[agent] ${name} prompt summary: ${JSON.stringify({
-			length: prompt.length,
-			lines: prompt.split('\n').length,
-		})}`,
-	);
+	void promptSource;
 	return {
 		name,
 		prompt,

package/src/runtime/agent/runner-setup.ts

@@ -1,9 +1,11 @@
-import { loadConfig } from '@ottocode/sdk';
+import { loadConfig, logger, getSessionSystemPromptPath } from '@ottocode/sdk';
 import { wrapLanguageModel } from 'ai';
 import { devToolsMiddleware } from '@ai-sdk/devtools';
 import { getDb } from '@ottocode/database';
 import { sessions } from '@ottocode/database/schema';
 import { eq } from 'drizzle-orm';
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
 import { resolveModel } from '../provider/index.ts';
 import { resolveAgentConfig } from './registry.ts';
 import { composeSystemPrompt } from '../prompt/builder.ts';
@@ -11,7 +13,7 @@ import { discoverProjectTools } from '@ottocode/sdk';
 import type { Tool } from 'ai';
 import { adaptTools } from '../../tools/adapter.ts';
 import { buildDatabaseTools } from '../../tools/database/index.ts';
-import { debugLog, time } from '../debug/index.ts';
+import { time } from '../debug/index.ts';
 import { isDevtoolsEnabled } from '../debug/state.ts';
 import { buildHistoryMessages } from '../message/history-builder.ts';
 import { getMaxOutputTokens } from '../utils/token.ts';
@@ -87,7 +89,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const historyTimer = time('runner:buildHistory');
 	let history: Awaited<ReturnType<typeof buildHistoryMessages>>;
 	if (opts.isCompactCommand && opts.compactionContext) {
-		debugLog('[RUNNER] Using minimal history for /compact command');
 		history = [];
 	} else {
 		history = await buildHistoryMessages(
@@ -104,34 +105,14 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		.where(eq(sessions.id, opts.sessionId))
 		.limit(1);
 	const contextSummary = sessionRows[0]?.contextSummary ?? undefined;
-	if (contextSummary) {
-		debugLog(
-			`[RUNNER] Using context summary from compaction (${contextSummary.length} chars)`,
-		);
-	}
 
 	const isFirstMessage = !history.some((m) => m.role === 'assistant');
 
-	debugLog(`[RUNNER] isFirstMessage: ${isFirstMessage}`);
-	debugLog(`[RUNNER] userContext provided: ${opts.userContext ? 'YES' : 'NO'}`);
-	if (opts.userContext) {
-		debugLog(
-			`[RUNNER] userContext value: ${opts.userContext.substring(0, 100)}${opts.userContext.length > 100 ? '...' : ''}`,
-		);
-	}
-
 	const systemTimer = time('runner:composeSystemPrompt');
 	const { getAuth } = await import('@ottocode/sdk');
 	const auth = await getAuth(opts.provider, cfg.projectRoot);
 	const oauth = detectOAuth(opts.provider, auth);
 
-	debugLog(
-		`[RUNNER] needsSpoof (OAuth): ${oauth.needsSpoof}, isOpenAIOAuth: ${oauth.isOpenAIOAuth}`,
-	);
-	debugLog(
-		`[RUNNER] spoofPrompt: ${oauth.spoofPrompt ? `present (${opts.provider})` : 'none'}`,
-	);
-
 	const composed = await composeSystemPrompt({
 		provider: opts.provider,
 		model: opts.model,
@@ -154,16 +135,78 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 
 	const { system } = adapted;
 	const { systemComponents, additionalSystemMessages } = adapted;
+	const openAIProviderOptions = adapted.providerOptions.openai as
+		| Record<string, unknown>
+		| undefined;
+	const openAIInstructions =
+		typeof openAIProviderOptions?.instructions === 'string'
+			? openAIProviderOptions.instructions
+			: '';
+	const effectiveSystemPrompt = system || openAIInstructions || composed.prompt;
+	const promptMode = oauth.isOpenAIOAuth
+		? 'openai-oauth'
+		: oauth.needsSpoof
+			? 'spoof'
+			: 'standard';
 	systemTimer.end();
-	debugLog(
-		`[system] summary: ${JSON.stringify({
-			components: systemComponents,
-			length: system.length,
-		})}`,
-	);
+	logger.debug('[prompt] system prompt assembled', {
+		sessionId: opts.sessionId,
+		messageId: opts.assistantMessageId,
+		agent: opts.agent,
+		provider: opts.provider,
+		model: opts.model,
+		promptMode,
+		components: systemComponents,
+		systemLength: effectiveSystemPrompt.length,
+		historyMessages: history.length,
+		additionalSystemMessages: additionalSystemMessages.length,
+		isFirstMessage,
+		isOpenAIOAuth: oauth.isOpenAIOAuth,
+		needsSpoof: oauth.needsSpoof,
+	});
+	logger.debug('[prompt] detailed prompt context', {
+		sessionId: opts.sessionId,
+		messageId: opts.assistantMessageId,
+		debugDetail: true,
+		agentPromptLength: agentPrompt.length,
+		contextSummaryLength: contextSummary?.length ?? 0,
+		userContextLength: opts.userContext?.length ?? 0,
+		oneShot: Boolean(opts.oneShot),
+		guidedMode: Boolean(cfg.defaults.guidedMode),
+		isOpenAIOAuth: oauth.isOpenAIOAuth,
+		needsSpoof: oauth.needsSpoof,
+		promptMode,
+		rawSystemLength: system.length,
+		openAIInstructionsLength: openAIInstructions.length,
+		effectiveSystemPromptLength: effectiveSystemPrompt.length,
+		systemComponents,
+		additionalSystemMessageRoles: additionalSystemMessages.map(
+			(message) => message.role,
+		),
+	});
+	if (effectiveSystemPrompt) {
+		const systemPromptPath = getSessionSystemPromptPath(opts.sessionId);
+		try {
+			await mkdir(dirname(systemPromptPath), { recursive: true });
+			await Bun.write(systemPromptPath, effectiveSystemPrompt);
+			logger.debug('[prompt] wrote system prompt file', {
+				sessionId: opts.sessionId,
+				messageId: opts.assistantMessageId,
+				path: systemPromptPath,
+				debugDetail: true,
+				promptMode,
+				effectiveSystemPromptLength: effectiveSystemPrompt.length,
+			});
+		} catch (error) {
+			logger.warn('[prompt] failed to write system prompt file', {
+				sessionId: opts.sessionId,
+				messageId: opts.assistantMessageId,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
 
 	if (opts.isCompactCommand && opts.compactionContext) {
-		debugLog('[RUNNER] Injecting compaction context for /compact command');
 		const compactPrompt = getCompactionSystemPrompt();
 		additionalSystemMessages.push({
 			role: 'system',
@@ -188,9 +231,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		for (const dt of dbTools) {
 			discovered.tools.push(dt);
 		}
-		debugLog(
-			`[tools] Added ${dbTools.length} database tools for research agent (parent: ${parentSessionId ?? 'none'})`,
-		);
 	}
 
 	toolsTimer.end({
@@ -200,12 +240,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const gated = allTools.filter(
 		(tool) => allowedNames.has(tool.name) || tool.name === 'load_mcp_tools',
 	);
-	debugLog(
-		`[tools] ${gated.length} gated tools, ${Object.keys(mcpToolsRecord).length} lazy MCP tools`,
-	);
-
-	debugLog(`[RUNNER] About to create model with provider: ${opts.provider}`);
-	debugLog(`[RUNNER] About to create model ID: ${opts.model}`);
 
 	const model = await resolveModel(opts.provider, opts.model, cfg, {
 		sessionId: opts.sessionId,
@@ -218,12 +252,8 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 				middleware: devToolsMiddleware(),
 			})
 		: model;
-	debugLog(
-		`[RUNNER] Model created: ${JSON.stringify({ id: model.modelId, provider: model.provider })}`,
-	);
 
 	const maxOutputTokens = adapted.maxOutputTokens;
-	debugLog(`[RUNNER] maxOutputTokens for ${opts.model}: ${maxOutputTokens}`);
 
 	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
 		opts,
@@ -253,12 +283,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	});
 	mergeProviderOptions(providerOptions, reasoningConfig.providerOptions);
 	effectiveMaxOutputTokens = reasoningConfig.effectiveMaxOutputTokens;
-	debugLog(
-		`[RUNNER] reasoning enabled for ${opts.provider}/${opts.model}: ${reasoningConfig.enabled}, level: ${opts.reasoningLevel ?? 'default'}`,
-	);
-	debugLog(
-		`[RUNNER] final providerOptions: ${JSON.stringify(providerOptions)}`,
-	);
 
 	return {
 		cfg,