@ottocode/server 0.1.228 → 0.1.230

package/package.json

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

package/src/openapi/paths/ask.ts

@@ -35,6 +35,17 @@ export const askPaths = {
 									description:
 										'Optional model override for the selected provider.',
 								},
+								reasoningText: {
+									type: 'boolean',
+									description:
+										'Enable extended thinking / reasoning for models that support it.',
+								},
+								reasoningLevel: {
+									type: 'string',
+									enum: ['minimal', 'low', 'medium', 'high', 'max', 'xhigh'],
+									description:
+										'Optional reasoning intensity override for supported providers/models.',
+								},
 								sessionId: {
 									type: 'string',
 									description: 'Send the prompt to a specific session.',

package/src/openapi/paths/config.ts

@@ -179,6 +179,10 @@ export const configPaths = {
 								provider: { type: 'string' },
 								model: { type: 'string' },
 								reasoningText: { type: 'boolean' },
+								reasoningLevel: {
+									type: 'string',
+									enum: ['minimal', 'low', 'medium', 'high', 'max', 'xhigh'],
+								},
 								scope: {
 									type: 'string',
 									enum: ['global', 'local'],
@@ -205,6 +209,17 @@ export const configPaths = {
 											provider: { type: 'string' },
 											model: { type: 'string' },
 											reasoningText: { type: 'boolean' },
+											reasoningLevel: {
+												type: 'string',
+												enum: [
+													'minimal',
+													'low',
+													'medium',
+													'high',
+													'max',
+													'xhigh',
+												],
+											},
 										},
 										required: ['agent', 'provider', 'model'],
 									},

package/src/openapi/paths/messages.ts

@@ -72,6 +72,12 @@ export const messagesPaths = {
 									description:
 										'Enable extended thinking / reasoning for models that support it.',
 								},
+								reasoningLevel: {
+									type: 'string',
+									enum: ['minimal', 'low', 'medium', 'high', 'max', 'xhigh'],
+									description:
+										'Reasoning intensity level for providers/models that support it.',
+								},
 							},
 						},
 					},

package/src/openapi/schemas.ts

@@ -73,6 +73,7 @@ export const schemas = {
 				additionalProperties: { type: 'integer' },
 				nullable: true,
 			},
+			isRunning: { type: 'boolean' },
 		},
 		required: ['id', 'agent', 'provider', 'model', 'projectPath', 'createdAt'],
 	},
@@ -196,6 +197,10 @@ export const schemas = {
 					provider: { $ref: '#/components/schemas/Provider' },
 					model: { type: 'string' },
 					reasoningText: { type: 'boolean' },
+					reasoningLevel: {
+						type: 'string',
+						enum: ['minimal', 'low', 'medium', 'high', 'max', 'xhigh'],
+					},
 				},
 				required: ['agent', 'provider', 'model'],
 			},

package/src/routes/ask.ts

@@ -79,6 +79,14 @@ export function registerAskRoutes(app: Hono) {
 			agent: typeof body.agent === 'string' ? body.agent : undefined,
 			provider: typeof body.provider === 'string' ? body.provider : undefined,
 			model: typeof body.model === 'string' ? body.model : undefined,
+			reasoningText:
+				typeof body.reasoningText === 'boolean'
+					? body.reasoningText
+					: undefined,
+			reasoningLevel:
+				typeof body.reasoningLevel === 'string'
+					? (body.reasoningLevel as AskServerRequest['reasoningLevel'])
+					: undefined,
 			sessionId:
 				typeof body.sessionId === 'string' ? body.sessionId : undefined,
 			last: Boolean(body.last),

package/src/routes/config/defaults.ts

@@ -1,5 +1,10 @@
 import type { Hono } from 'hono';
-import { setConfig, loadConfig, type ProviderId } from '@ottocode/sdk';
+import {
+	setConfig,
+	loadConfig,
+	type ProviderId,
+	type ReasoningLevel,
+} from '@ottocode/sdk';
 import { logger } from '@ottocode/sdk';
 import { serializeError } from '../../runtime/errors/api-error.ts';
 
@@ -14,6 +19,7 @@ export function registerDefaultsRoute(app: Hono) {
 				toolApproval?: 'auto' | 'dangerous' | 'all';
 				guidedMode?: boolean;
 				reasoningText?: boolean;
+				reasoningLevel?: ReasoningLevel;
 				theme?: string;
 				scope?: 'global' | 'local';
 			}>();
@@ -26,6 +32,7 @@ export function registerDefaultsRoute(app: Hono) {
 				toolApproval: 'auto' | 'dangerous' | 'all';
 				guidedMode: boolean;
 				reasoningText: boolean;
+				reasoningLevel: ReasoningLevel;
 				theme: string;
 			}> = {};
 
@@ -36,6 +43,7 @@ export function registerDefaultsRoute(app: Hono) {
 			if (body.guidedMode !== undefined) updates.guidedMode = body.guidedMode;
 			if (body.reasoningText !== undefined)
 				updates.reasoningText = body.reasoningText;
+			if (body.reasoningLevel) updates.reasoningLevel = body.reasoningLevel;
 			if (body.theme) updates.theme = body.theme;
 
 			await setConfig(scope, updates, projectRoot);

package/src/routes/config/main.ts

@@ -61,6 +61,7 @@ export function registerMainConfigRoute(app: Hono) {
 				) as 'auto' | 'dangerous' | 'all',
 				guidedMode: cfg.defaults.guidedMode ?? false,
 				reasoningText: cfg.defaults.reasoningText ?? true,
+				reasoningLevel: cfg.defaults.reasoningLevel ?? 'high',
 				theme: cfg.defaults.theme,
 			};
 

package/src/routes/session-messages.ts

@@ -1,5 +1,5 @@
 import type { Hono } from 'hono';
-import { loadConfig } from '@ottocode/sdk';
+import { loadConfig, type ReasoningLevel } from '@ottocode/sdk';
 import { getDb } from '@ottocode/database';
 import { messages, messageParts, sessions } from '@ottocode/database/schema';
 import { eq, inArray } from 'drizzle-orm';
@@ -124,6 +124,10 @@ export function registerSessionMessagesRoutes(app: Hono) {
 
 			const reasoning =
 				body?.reasoningText ?? cfg.defaults.reasoningText ?? false;
+			const reasoningLevel =
+				(body?.reasoningLevel as ReasoningLevel | undefined) ??
+				cfg.defaults.reasoningLevel ??
+				'high';
 
 			// Validate model capabilities if tools are allowed for this agent
 			const wantsToolCalls = true; // agent toolset may be non-empty
@@ -158,6 +162,7 @@ export function registerSessionMessagesRoutes(app: Hono) {
 				oneShot: Boolean(body?.oneShot),
 				userContext,
 				reasoningText: reasoning,
+				reasoningLevel,
 				images,
 				files,
 			});

package/src/routes/sessions.ts

@@ -15,6 +15,7 @@ import { resolveAgentConfig } from '../runtime/agent/registry.ts';
 import { createSession as createSessionRow } from '../runtime/session/manager.ts';
 import { serializeError } from '../runtime/errors/api-error.ts';
 import { logger } from '@ottocode/sdk';
+import { getRunnerState } from '../runtime/session/queue.ts';
 
 export function registerSessionsRoutes(app: Hono) {
 	// List sessions
@@ -53,7 +54,9 @@ export function registerSessionsRoutes(app: Hono) {
 				} catch {}
 			}
 			const { toolCountsJson: _toolCountsJson, ...rest } = r;
-			return counts ? { ...rest, toolCounts: counts } : rest;
+			const isRunning = getRunnerState(r.id)?.running ?? false;
+			const base = counts ? { ...rest, toolCounts: counts } : rest;
+			return { ...base, isRunning };
 		});
 		return c.json({
 			items: normalized,

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

@@ -1,4 +1,4 @@
-import { loadConfig, getUnderlyingProviderKey } from '@ottocode/sdk';
+import { loadConfig } from '@ottocode/sdk';
 import { wrapLanguageModel } from 'ai';
 import { devToolsMiddleware } from '@ai-sdk/devtools';
 import { getDb } from '@ottocode/database';
@@ -18,6 +18,7 @@ import { getMaxOutputTokens } from '../utils/token.ts';
 import { setupToolContext } from '../tools/setup.ts';
 import { getCompactionSystemPrompt } from '../message/compaction.ts';
 import { detectOAuth, adaptRunnerCall } from '../provider/oauth-adapter.ts';
+import { buildReasoningConfig } from '../provider/reasoning.ts';
 import type { RunOpts } from '../session/queue.ts';
 import type { ToolAdapterContext } from '../../tools/adapter.ts';
 
@@ -44,7 +45,32 @@ export interface SetupResult {
 	mcpToolsRecord: Record<string, Tool>;
 }
 
-const THINKING_BUDGET = 16000;
+export function mergeProviderOptions(
+	base: Record<string, unknown>,
+	incoming: Record<string, unknown>,
+): Record<string, unknown> {
+	for (const [key, value] of Object.entries(incoming)) {
+		const existing = base[key];
+		if (
+			existing &&
+			typeof existing === 'object' &&
+			!Array.isArray(existing) &&
+			value &&
+			typeof value === 'object' &&
+			!Array.isArray(value)
+		) {
+			base[key] = {
+				...(existing as Record<string, unknown>),
+				...(value as Record<string, unknown>),
+			};
+			continue;
+		}
+
+		base[key] = value;
+	}
+
+	return base;
+}
 
 export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const cfgTimer = time('runner:loadConfig+db');
@@ -218,38 +244,21 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		};
 	}
 
-	if (opts.reasoningText) {
-		const underlyingProvider = getUnderlyingProviderKey(
-			opts.provider,
-			opts.model,
-		);
-
-		if (underlyingProvider === 'anthropic') {
-			providerOptions.anthropic = {
-				thinking: { type: 'enabled', budgetTokens: THINKING_BUDGET },
-			};
-			if (maxOutputTokens && maxOutputTokens > THINKING_BUDGET) {
-				effectiveMaxOutputTokens = maxOutputTokens - THINKING_BUDGET;
-			}
-		} else if (underlyingProvider === 'openai') {
-			providerOptions.openai = {
-				...((providerOptions.openai as Record<string, unknown>) || {}),
-				reasoningEffort: 'high',
-				reasoningSummary: 'auto',
-			};
-		} else if (underlyingProvider === 'google') {
-			const isGemini3 = opts.model.includes('gemini-3');
-			providerOptions.google = {
-				thinkingConfig: isGemini3
-					? { thinkingLevel: 'high', includeThoughts: true }
-					: { thinkingBudget: THINKING_BUDGET },
-			};
-		} else if (underlyingProvider === 'openai-compatible') {
-			providerOptions.openaiCompatible = {
-				reasoningEffort: 'high',
-			};
-		}
-	}
+	const reasoningConfig = buildReasoningConfig({
+		provider: opts.provider,
+		model: opts.model,
+		reasoningText: opts.reasoningText,
+		reasoningLevel: opts.reasoningLevel,
+		maxOutputTokens,
+	});
+	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,

package/src/runtime/agent/runner.ts

@@ -42,6 +42,7 @@ import {
 	consumeOauthCodexTextDelta,
 } from '../stream/text-guard.ts';
 import { decideOauthCodexContinuation } from './oauth-codex-continuation.ts';
+import { createTurnDumpCollector } from '../debug/turn-dump.ts';
 
 export {
 	enqueueAssistantRun,
@@ -52,6 +53,33 @@ export {
 	getRunnerState,
 } from '../session/queue.ts';
 
+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());
+}
+
+function summarizeTraceValue(value: unknown, max = 160): string {
+	try {
+		const json = JSON.stringify(value);
+		if (typeof json === 'string') {
+			return json.length > max ? `${json.slice(0, max)}…` : json;
+		}
+	} catch {}
+	const fallback = String(value);
+	return fallback.length > max ? `${fallback.slice(0, max)}…` : fallback;
+}
+
 export async function runSessionLoop(sessionId: string) {
 	setRunning(sessionId, true);
 
@@ -179,6 +207,31 @@ async function runAssistant(opts: RunOpts) {
 		`[RUNNER] messagesWithSystemInstructions length: ${messagesWithSystemInstructions.length}`,
 	);
 
+	const dump = createTurnDumpCollector({
+		sessionId: opts.sessionId,
+		messageId: opts.assistantMessageId,
+		provider: opts.provider,
+		model: opts.model,
+		agent: opts.agent,
+		continuationCount: opts.continuationCount,
+	});
+	if (dump) {
+		dump.setSystemPrompt(system, setup.systemComponents);
+		dump.setAdditionalSystemMessages(
+			additionalSystemMessages as Array<{ role: string; content: string }>,
+		);
+		dump.setHistory(history as Array<{ role: string; content: unknown }>);
+		dump.setFinalMessages(messagesWithSystemInstructions);
+		dump.setTools(toolset);
+		dump.setModelConfig({
+			maxOutputTokens: setup.maxOutputTokens,
+			effectiveMaxOutputTokens,
+			providerOptions,
+			isOpenAIOAuth,
+			needsSpoof: setup.needsSpoof,
+		});
+	}
+
 	let _finishObserved = false;
 	let _toolActivityObserved = false;
 	let _trailingAssistantTextAfterTool = false;
@@ -199,15 +252,41 @@ async function runAssistant(opts: RunOpts) {
 		}
 		if (evt.type === 'tool.call') {
 			triggerTitleGenerationWhenReady();
+			if (dump) {
+				try {
+					const p = evt.payload as {
+						name?: string;
+						callId?: string;
+						args?: unknown;
+					};
+					dump.recordToolCall(stepIndex, p.name ?? '', p.callId ?? '', p.args);
+				} catch {}
+			}
 		}
-		if (evt.type !== 'tool.result') return;
-		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)}`,
-			);
+		if (evt.type === 'tool.result') {
+			if (dump) {
+				try {
+					const p = evt.payload as {
+						name?: string;
+						callId?: string;
+						result?: unknown;
+					};
+					dump.recordToolResult(
+						stepIndex,
+						p.name ?? '',
+						p.callId ?? '',
+						p.result,
+					);
+				} catch {}
+			}
+			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)}`,
+				);
+			}
 		}
 	});
 
@@ -217,6 +296,7 @@ async function runAssistant(opts: RunOpts) {
 	let currentPartId: string | null = null;
 	let accumulated = '';
 	let latestAssistantText = '';
+	let lastTextDeltaStepIndex: number | null = null;
 	let stepIndex = 0;
 	const oauthTextGuard = isOpenAIOAuth
 		? createOauthCodexTextGuardState()
@@ -313,10 +393,61 @@ async function runAssistant(opts: RunOpts) {
 			onFinish: onFinish as any,
 			// biome-ignore lint/suspicious/noExplicitAny: AI SDK streamText options type
 		} as any);
+		const tracedToolInputNamesById = new Map<string, string>();
 
 		for await (const part of result.fullStream) {
 			if (!part) continue;
 
+			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)}`,
+					);
+				}
+				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;
+			}
+
+			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)}`,
+					);
+				}
+				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)}`,
+					);
+				}
+				continue;
+			}
+
 			if (part.type === 'text-delta') {
 				const rawDelta = part.text;
 				if (!rawDelta) continue;
@@ -330,6 +461,10 @@ async function runAssistant(opts: RunOpts) {
 				if (accumulated.trim()) {
 					latestAssistantText = accumulated;
 				}
+				if (accumulated.length > 0) {
+					lastTextDeltaStepIndex = stepIndex;
+				}
+				dump?.recordTextDelta(stepIndex, accumulated);
 				if (
 					(delta.trim().length > 0 && _toolActivityObserved) ||
 					(delta.trim().length > 0 && firstToolSeen())
@@ -450,6 +585,23 @@ async function runAssistant(opts: RunOpts) {
 			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}, trailingAssistantTextAfterTool=${_trailingAssistantTextAfterTool}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}`,
 		);
 
+		if (dump) {
+			const finalTextSnapshot = latestAssistantText || accumulated;
+			if (finalTextSnapshot.length > 0) {
+				dump.recordTextDelta(
+					lastTextDeltaStepIndex ?? stepIndex,
+					finalTextSnapshot,
+					{ force: true },
+				);
+			}
+			dump.recordStreamEnd({
+				finishReason: streamFinishReason,
+				rawFinishReason: streamRawFinishReason,
+				finishObserved: _finishObserved,
+				aborted: _abortedByUser,
+			});
+		}
+
 		const MAX_CONTINUATIONS = 6;
 		const continuationCount = opts.continuationCount ?? 0;
 		const continuationDecision = decideOauthCodexContinuation({
@@ -543,6 +695,7 @@ async function runAssistant(opts: RunOpts) {
 		}
 	} catch (err) {
 		unsubscribeFinish();
+		dump?.recordError(err);
 		const payload = toErrorPayload(err);
 
 		const errorMessage = err instanceof Error ? err.message : String(err);
@@ -627,6 +780,16 @@ async function runAssistant(opts: RunOpts) {
 		}
 		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)}`,
+				);
+			}
+		}
 		debugLog(
 			`[RUNNER] Turn complete for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
 		);

package/src/runtime/ask/service.ts

@@ -19,6 +19,7 @@ import {
 	isProviderId,
 	providerEnvVar,
 	type ProviderId,
+	type ReasoningLevel,
 } from '@ottocode/sdk';
 import { sessions } from '@ottocode/database/schema';
 import { time } from '../debug/index.ts';
@@ -48,6 +49,8 @@ export type InjectableConfig = {
 	model?: string;
 	apiKey?: string;
 	agent?: string;
+	reasoningText?: boolean;
+	reasoningLevel?: ReasoningLevel;
 };
 
 export type InjectableCredentials = Partial<
@@ -60,6 +63,8 @@ export type AskServerRequest = {
 	agent?: string;
 	provider?: string;
 	model?: string;
+	reasoningText?: boolean;
+	reasoningLevel?: ReasoningLevel;
 	sessionId?: string;
 	last?: boolean;
 	jsonMode?: boolean;
@@ -120,6 +125,10 @@ async function processAskRequest(
 				provider: injectedProvider,
 				model: injectedModel,
 				agent: injectedAgent,
+				reasoningText:
+					request.config?.reasoningText ?? request.reasoningText ?? true,
+				reasoningLevel:
+					request.config?.reasoningLevel ?? request.reasoningLevel ?? 'high',
 			},
 			providers: {
 				openai: { enabled: true },
@@ -299,6 +308,11 @@ async function processAskRequest(
 		await ensureProviderEnv(cfg, providerForMessage);
 	}
 
+	const reasoningText =
+		request.reasoningText ?? cfg.defaults.reasoningText ?? false;
+	const reasoningLevel =
+		request.reasoningLevel ?? cfg.defaults.reasoningLevel ?? 'high';
+
 	const assistantMessage = await dispatchAssistantMessage({
 		cfg,
 		db,
@@ -308,6 +322,8 @@ async function processAskRequest(
 		model: modelForMessage,
 		content: request.prompt,
 		oneShot: !request.sessionId && !request.last,
+		reasoningText,
+		reasoningLevel,
 	});
 
 	const headerAgent = session.agent ?? agentName;