@ottocode/server 0.1.228 → 0.1.231

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;