@ottocode/server 0.1.235 → 0.1.236

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.235",
+	"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.235",
-		"@ottocode/database": "0.1.235",
+		"@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(

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';
@@ -133,7 +135,76 @@ 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();
+	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) {
 		const compactPrompt = getCompactionSystemPrompt();

package/src/runtime/message/service.ts

@@ -9,6 +9,7 @@ import { runSessionLoop } from '../agent/runner.ts';
 import { resolveModel } from '../provider/index.ts';
 import {
 	getFastModelForAuth,
+	logger,
 	type ProviderId,
 	type ReasoningLevel,
 } from '@ottocode/sdk';
@@ -61,6 +62,14 @@ export async function dispatchAssistantMessage(
 	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,
@@ -194,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 });
 

package/src/tools/adapter.ts

@@ -2,7 +2,7 @@ import type { Tool } from 'ai';
 import { messageParts, sessions } from '@ottocode/database/schema';
 import { eq } from 'drizzle-orm';
 import { publish } from '../events/bus.ts';
-import type { DiscoveredTool } from '@ottocode/sdk';
+import { logger, type DiscoveredTool } from '@ottocode/sdk';
 import { getCwd, setCwd, joinRelative } from '../runtime/utils/cwd.ts';
 import type {
 	ToolAdapterContext,
@@ -312,6 +312,13 @@ export function adaptTools(
 							messageId: ctx.messageId,
 						},
 					});
+					logger.debug(`[tools] call ${name}`, {
+						sessionId: ctx.sessionId,
+						messageId: ctx.messageId,
+						toolName: name,
+						callId,
+						stepIndex: ctx.stepIndex,
+					});
 					// Persist synchronously to maintain correct ordering
 					try {
 						const index = await ctx.nextIndex();
@@ -689,6 +696,13 @@ export function adaptTools(
 							sessionId: ctx.sessionId,
 							payload: { ...contentObj, stepIndex: stepIndexForEvent },
 						});
+						logger.debug(`[tools] result ${name}`, {
+							sessionId: ctx.sessionId,
+							messageId: ctx.messageId,
+							toolName: name,
+							callId,
+							stepIndex: stepIndexForEvent,
+						});
 						if (name === 'update_todos') {
 							try {
 								const resultValue = (contentObj as { result?: unknown })