@ottocode/server 0.1.227 → 0.1.230

package/src/runtime/debug/turn-dump.ts

@@ -0,0 +1,330 @@
+import { getLocalDataDir } from '@ottocode/sdk';
+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();
+}
+
+export interface TurnDumpData {
+	sessionId: string;
+	messageId: string;
+	timestamp: string;
+	provider: string;
+	model: string;
+	agent: string;
+	continuationCount?: number;
+	system: {
+		prompt: string;
+		components: string[];
+		length: number;
+	};
+	additionalSystemMessages: Array<{ role: string; content: string }>;
+	history: Array<{
+		role: string;
+		content: unknown;
+		_contentLength?: number;
+	}>;
+	finalMessages: Array<{
+		role: string;
+		content: unknown;
+		_contentLength?: number;
+	}>;
+	tools: {
+		names: string[];
+		count: number;
+	};
+	modelConfig: {
+		maxOutputTokens: number | undefined;
+		effectiveMaxOutputTokens: number | undefined;
+		providerOptions: Record<string, unknown>;
+		isOpenAIOAuth: boolean;
+		needsSpoof: boolean;
+	};
+	stream: {
+		toolCalls: Array<{
+			stepIndex: number;
+			name: string;
+			callId: string;
+			args: unknown;
+			timestamp: string;
+		}>;
+		toolResults: Array<{
+			stepIndex: number;
+			name: string;
+			callId: string;
+			result: unknown;
+			_resultLength?: number;
+			timestamp: string;
+		}>;
+		textDeltas: Array<{
+			stepIndex: number;
+			textSnapshot: string;
+			length: number;
+			timestamp: string;
+		}>;
+		steps: Array<{
+			stepIndex: number;
+			finishReason: string | undefined;
+			usage?: {
+				inputTokens?: number;
+				outputTokens?: number;
+			};
+			timestamp: string;
+		}>;
+		finishReason?: string;
+		rawFinishReason?: string;
+		finishObserved: boolean;
+		aborted: boolean;
+	};
+	error?: {
+		message: string;
+		name?: string;
+		stack?: string;
+	};
+	duration?: number;
+}
+
+export class TurnDumpCollector {
+	private data: TurnDumpData;
+	private startTime: number;
+	private lastTextSnapshot: string = '';
+	private textSnapshotInterval = 2000;
+	private lastTextSnapshotTime = 0;
+
+	constructor(opts: {
+		sessionId: string;
+		messageId: string;
+		provider: string;
+		model: string;
+		agent: string;
+		continuationCount?: number;
+	}) {
+		this.startTime = Date.now();
+		this.data = {
+			sessionId: opts.sessionId,
+			messageId: opts.messageId,
+			timestamp: new Date().toISOString(),
+			provider: opts.provider,
+			model: opts.model,
+			agent: opts.agent,
+			continuationCount: opts.continuationCount,
+			system: { prompt: '', components: [], length: 0 },
+			additionalSystemMessages: [],
+			history: [],
+			finalMessages: [],
+			tools: { names: [], count: 0 },
+			modelConfig: {
+				maxOutputTokens: undefined,
+				effectiveMaxOutputTokens: undefined,
+				providerOptions: {},
+				isOpenAIOAuth: false,
+				needsSpoof: false,
+			},
+			stream: {
+				toolCalls: [],
+				toolResults: [],
+				textDeltas: [],
+				steps: [],
+				finishObserved: false,
+				aborted: false,
+			},
+		};
+	}
+
+	setSystemPrompt(prompt: string, components: string[]) {
+		this.data.system = {
+			prompt,
+			components,
+			length: prompt.length,
+		};
+	}
+
+	setAdditionalSystemMessages(msgs: Array<{ role: string; content: string }>) {
+		this.data.additionalSystemMessages = msgs;
+	}
+
+	setHistory(history: Array<{ role: string; content: unknown }>) {
+		this.data.history = history.map((m) => {
+			const contentStr =
+				typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+			return {
+				role: m.role,
+				content: m.content,
+				_contentLength: contentStr.length,
+			};
+		});
+	}
+
+	setFinalMessages(
+		msgs: Array<{ role: string; content: string | Array<unknown> }>,
+	) {
+		this.data.finalMessages = msgs.map((m) => {
+			const contentStr =
+				typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+			return {
+				role: m.role,
+				content: m.content,
+				_contentLength: contentStr.length,
+			};
+		});
+	}
+
+	setTools(toolset: Record<string, unknown>) {
+		const names = Object.keys(toolset);
+		this.data.tools = { names, count: names.length };
+	}
+
+	setModelConfig(config: {
+		maxOutputTokens: number | undefined;
+		effectiveMaxOutputTokens: number | undefined;
+		providerOptions: Record<string, unknown>;
+		isOpenAIOAuth: boolean;
+		needsSpoof: boolean;
+	}) {
+		this.data.modelConfig = config;
+	}
+
+	recordToolCall(
+		stepIndex: number,
+		name: string,
+		callId: string,
+		args: unknown,
+	) {
+		this.data.stream.toolCalls.push({
+			stepIndex,
+			name,
+			callId,
+			args,
+			timestamp: new Date().toISOString(),
+		});
+	}
+
+	recordToolResult(
+		stepIndex: number,
+		name: string,
+		callId: string,
+		result: unknown,
+	) {
+		const resultStr =
+			typeof result === 'string' ? result : JSON.stringify(result);
+		const truncated =
+			resultStr.length > 50_000
+				? `${resultStr.slice(0, 50_000)}...[TRUNCATED]`
+				: result;
+		this.data.stream.toolResults.push({
+			stepIndex,
+			name,
+			callId,
+			result: truncated,
+			_resultLength: resultStr.length,
+			timestamp: new Date().toISOString(),
+		});
+	}
+
+	recordTextDelta(
+		stepIndex: number,
+		accumulated: string,
+		opts?: { force?: boolean },
+	) {
+		const force = opts?.force === true;
+		const now = Date.now();
+		if (
+			!force &&
+			now - this.lastTextSnapshotTime < this.textSnapshotInterval &&
+			this.lastTextSnapshot.length > 0
+		) {
+			return;
+		}
+		if (force && accumulated.length === 0 && this.lastTextSnapshot.length > 0) {
+			return;
+		}
+		if (force && accumulated === this.lastTextSnapshot) {
+			return;
+		}
+		this.lastTextSnapshotTime = now;
+		this.lastTextSnapshot = accumulated;
+		this.data.stream.textDeltas.push({
+			stepIndex,
+			textSnapshot:
+				accumulated.length > 5000
+					? `${accumulated.slice(0, 5000)}...[TRUNCATED at 5000 chars, total: ${accumulated.length}]`
+					: accumulated,
+			length: accumulated.length,
+			timestamp: new Date().toISOString(),
+		});
+	}
+
+	recordStepFinish(
+		stepIndex: number,
+		finishReason: string | undefined,
+		usage?: { inputTokens?: number; outputTokens?: number },
+	) {
+		this.data.stream.steps.push({
+			stepIndex,
+			finishReason,
+			usage,
+			timestamp: new Date().toISOString(),
+		});
+	}
+
+	recordStreamEnd(opts: {
+		finishReason?: string;
+		rawFinishReason?: string;
+		finishObserved: boolean;
+		aborted: boolean;
+	}) {
+		this.data.stream.finishReason = opts.finishReason;
+		this.data.stream.rawFinishReason = opts.rawFinishReason;
+		this.data.stream.finishObserved = opts.finishObserved;
+		this.data.stream.aborted = opts.aborted;
+	}
+
+	recordError(err: unknown) {
+		this.data.error = {
+			message: err instanceof Error ? err.message : String(err),
+			name: err instanceof Error ? err.name : undefined,
+			stack: err instanceof Error ? err.stack : undefined,
+		};
+	}
+
+	async flush(projectRoot: string) {
+		this.data.duration = Date.now() - this.startTime;
+
+		const dumpDir = join(getLocalDataDir(projectRoot), 'debug-dumps');
+		await mkdir(dumpDir, { recursive: true });
+
+		const ts = new Date()
+			.toISOString()
+			.replace(/[:.]/g, '-')
+			.replace('T', '_')
+			.replace('Z', '');
+		const sessionShort = this.data.sessionId.slice(0, 8);
+		const filename = `turn_${ts}_${sessionShort}.json`;
+		const filepath = join(dumpDir, filename);
+
+		await Bun.write(filepath, JSON.stringify(this.data, null, 2));
+		return filepath;
+	}
+}
+
+export function shouldDumpTurn(): boolean {
+	return isDumpEnabled();
+}
+
+export function createTurnDumpCollector(opts: {
+	sessionId: string;
+	messageId: string;
+	provider: string;
+	model: string;
+	agent: string;
+	continuationCount?: number;
+}): TurnDumpCollector | null {
+	if (!shouldDumpTurn()) return null;
+	return new TurnDumpCollector(opts);
+}

package/src/runtime/message/history-builder.ts

@@ -1,4 +1,10 @@
-import { convertToModelMessages, type ModelMessage, type UIMessage } from 'ai';
+import {
+	convertToModelMessages,
+	type FilePart,
+	type ModelMessage,
+	type TextPart,
+	type UIMessage,
+} from 'ai';
 import type { getDb } from '@ottocode/database';
 import { messages, messageParts } from '@ottocode/database/schema';
 import { eq, asc } from 'drizzle-orm';
@@ -20,7 +26,7 @@ export async function buildHistoryMessages(
 		.where(eq(messages.sessionId, sessionId))
 		.orderBy(asc(messages.createdAt));
 
-	const ui: UIMessage[] = [];
+	const history: ModelMessage[] = [];
 	const toolHistory = new ToolHistoryTracker();
 
 	for (const m of rows) {
@@ -49,13 +55,13 @@ export async function buildHistoryMessages(
 		}
 
 		if (m.role === 'user') {
-			const uparts: UIMessage['parts'] = [];
+			const userParts: Array<TextPart | FilePart> = [];
 			for (const p of parts) {
 				if (p.type === 'text') {
 					try {
 						const obj = JSON.parse(p.content ?? '{}');
 						const t = String(obj.text ?? '');
-						if (t) uparts.push({ type: 'text', text: t });
+						if (t) userParts.push({ type: 'text', text: t });
 					} catch {}
 				} else if (p.type === 'image') {
 					try {
@@ -64,11 +70,11 @@ export async function buildHistoryMessages(
 							mediaType?: string;
 						};
 						if (obj.data && obj.mediaType) {
-							uparts.push({
+							userParts.push({
 								type: 'file',
+								data: obj.data,
 								mediaType: obj.mediaType,
-								url: `data:${obj.mediaType};base64,${obj.data}`,
-							} as never);
+							});
 						}
 					} catch {}
 				} else if (p.type === 'file') {
@@ -81,41 +87,72 @@ export async function buildHistoryMessages(
 							textContent?: string;
 						};
 						if (obj.type === 'text' && obj.textContent) {
-							uparts.push({
+							userParts.push({
 								type: 'text',
 								text: `<file name="${obj.name || 'file'}">\n${obj.textContent}\n</file>`,
 							});
 						} else if (obj.type === 'pdf' && obj.data && obj.mediaType) {
-							uparts.push({
+							userParts.push({
 								type: 'file',
+								data: obj.data,
+								filename: obj.name,
 								mediaType: obj.mediaType,
-								url: `data:${obj.mediaType};base64,${obj.data}`,
-							} as never);
+							});
 						} else if (obj.type === 'image' && obj.data && obj.mediaType) {
-							uparts.push({
+							userParts.push({
 								type: 'file',
+								data: obj.data,
+								filename: obj.name,
 								mediaType: obj.mediaType,
-								url: `data:${obj.mediaType};base64,${obj.data}`,
-							} as never);
+							});
 						}
 					} catch {}
 				}
 			}
-			if (uparts.length) {
-				ui.push({ id: m.id, role: 'user', parts: uparts });
+			if (userParts.length) {
+				history.push({ role: 'user', content: userParts });
 			}
 			continue;
 		}
 
 		if (m.role === 'assistant') {
 			const assistantParts: UIMessage['parts'] = [];
-			const toolCalls: Array<{ name: string; callId: string; args: unknown }> =
-				[];
-			const toolResults: Array<{
-				name: string;
-				callId: string;
-				result: unknown;
-			}> = [];
+			const flushAssistantParts = async () => {
+				if (!assistantParts.length) return;
+				history.push(
+					...(await convertToModelMessages([
+						{ role: 'assistant', parts: assistantParts },
+					])),
+				);
+				assistantParts.length = 0;
+			};
+			const toolResultsById = new Map<
+				string,
+				{
+					name: string;
+					callId: string;
+					result: unknown;
+				}
+			>();
+
+			for (const p of parts) {
+				if (p.type !== 'tool_result' || p.compactedAt) continue;
+
+				try {
+					const obj = JSON.parse(p.content ?? '{}') as {
+						name?: string;
+						callId?: string;
+						result?: unknown;
+					};
+					if (obj.callId) {
+						toolResultsById.set(obj.callId, {
+							name: obj.name ?? 'tool',
+							callId: obj.callId,
+							result: obj.result,
+						});
+					}
+				} catch {}
+			}
 
 			for (const p of parts) {
 				if (p.type === 'reasoning') continue;
@@ -135,89 +172,60 @@ export async function buildHistoryMessages(
 							callId?: string;
 							args?: unknown;
 						};
-						if (obj.callId && obj.name) {
-							toolCalls.push({
+						if (!obj.callId || !obj.name) continue;
+						if (obj.name === 'finish') continue;
+
+						const toolType = `tool-${obj.name}` as `tool-${string}`;
+						let result = toolResultsById.get(obj.callId);
+
+						if (!result) {
+							debugLog(
+								`[buildHistoryMessages] Synthesizing error result for incomplete tool call ${obj.name}#${obj.callId}`,
+							);
+							result = {
 								name: obj.name,
 								callId: obj.callId,
-								args: obj.args,
-							});
+								result:
+									'Error: The tool execution was interrupted or failed to return a result. You may need to retry this operation.',
+							};
 						}
-					} catch {}
-				} else if (p.type === 'tool_result') {
-					if (p.compactedAt) continue;
 
-					try {
-						const obj = JSON.parse(p.content ?? '{}') as {
-							name?: string;
-							callId?: string;
-							result?: unknown;
+						const part = {
+							type: toolType,
+							state: 'output-available',
+							toolCallId: obj.callId,
+							input: obj.args,
+							output: (() => {
+								const r = result.result;
+								if (typeof r === 'string') return r;
+								try {
+									return JSON.stringify(r);
+								} catch {
+									return String(r);
+								}
+							})(),
 						};
-						if (obj.callId) {
-							toolResults.push({
-								name: obj.name ?? 'tool',
-								callId: obj.callId,
-								result: obj.result,
-							});
-						}
-					} catch {}
-				}
-			}
-
-			const toolResultsById = new Map(
-				toolResults.map((result) => [result.callId, result]),
-			);
-
-			for (const call of toolCalls) {
-				if (call.name === 'finish') continue;
 
-				const toolType = `tool-${call.name}` as `tool-${string}`;
-				let result = toolResultsById.get(call.callId);
+						toolHistory.register(part, {
+							toolName: obj.name,
+							callId: obj.callId,
+							args: obj.args,
+							result: result.result,
+						});
 
-				if (!result) {
-					debugLog(
-						`[buildHistoryMessages] Synthesizing error result for incomplete tool call ${call.name}#${call.callId}`,
-					);
-					result = {
-						name: call.name,
-						callId: call.callId,
-						result:
-							'Error: The tool execution was interrupted or failed to return a result. You may need to retry this operation.',
-					};
+						assistantParts.push(part as never);
+						await flushAssistantParts();
+					} catch {}
 				}
-
-				const part = {
-					type: toolType,
-					state: 'output-available',
-					toolCallId: call.callId,
-					input: call.args,
-					output: (() => {
-						const r = result.result;
-						if (typeof r === 'string') return r;
-						try {
-							return JSON.stringify(r);
-						} catch {
-							return String(r);
-						}
-					})(),
-				};
-
-				toolHistory.register(part, {
-					toolName: call.name,
-					callId: call.callId,
-					args: call.args,
-					result: result.result,
-				});
-
-				assistantParts.push(part as never);
 			}
 
 			if (assistantParts.length) {
-				ui.push({ id: m.id, role: 'assistant', parts: assistantParts });
+				await flushAssistantParts();
 			}
 		}
 	}
 
-	return await convertToModelMessages(ui);
+	return history;
 }
 
 async function _logPendingToolParts(

package/src/runtime/message/service.ts

@@ -7,7 +7,11 @@ import { publish } from '../../events/bus.ts';
 import { enqueueAssistantRun } from '../session/queue.ts';
 import { runSessionLoop } from '../agent/runner.ts';
 import { resolveModel } from '../provider/index.ts';
-import { getFastModelForAuth, type ProviderId } from '@ottocode/sdk';
+import {
+	getFastModelForAuth,
+	type ProviderId,
+	type ReasoningLevel,
+} from '@ottocode/sdk';
 import { debugLog } from '../debug/index.ts';
 import { isCompactCommand, buildCompactionContext } from './compaction.ts';
 import { detectOAuth, adaptSimpleCall } from '../provider/oauth-adapter.ts';
@@ -25,6 +29,7 @@ type DispatchOptions = {
 	oneShot?: boolean;
 	userContext?: string;
 	reasoningText?: boolean;
+	reasoningLevel?: ReasoningLevel;
 	images?: Array<{ data: string; mediaType: string }>;
 	files?: Array<{
 		type: 'image' | 'pdf' | 'text';
@@ -49,6 +54,7 @@ export async function dispatchAssistantMessage(
 		oneShot,
 		userContext,
 		reasoningText,
+		reasoningLevel,
 		images,
 		files,
 	} = options;
@@ -187,6 +193,7 @@ export async function dispatchAssistantMessage(
 			oneShot: Boolean(oneShot),
 			userContext,
 			reasoningText,
+			reasoningLevel,
 			isCompactCommand: isCompact,
 			compactionContext,
 			toolApprovalMode,

package/src/runtime/prompt/builder.ts

@@ -71,21 +71,23 @@ export async function composeSystemPrompt(options: {
 			options.projectRoot,
 		);
 		const baseInstructions = (BASE_PROMPT || '').trim();
+		const agentInstructions = options.agentPrompt.trim();
+		const providerInstructions = providerResult.prompt.trim();
 
 		parts.push(
-			providerResult.prompt.trim(),
 			baseInstructions.trim(),
-			options.agentPrompt.trim(),
+			agentInstructions,
+			providerInstructions,
 		);
-		if (providerResult.prompt.trim()) {
-			components.push(`provider:${providerResult.resolvedType}`);
-		}
 		if (baseInstructions.trim()) {
 			components.push('base');
 		}
-		if (options.agentPrompt.trim()) {
+		if (agentInstructions) {
 			components.push('agent');
 		}
+		if (providerInstructions) {
+			components.push(`provider:${providerResult.resolvedType}`);
+		}
 	}
 
 	if (options.oneShot) {