@ottocode/server 0.1.265 → 0.1.266

package/src/runtime/agent/runner-tool-observer.ts

@@ -0,0 +1,86 @@
+import { subscribe } from '../../events/bus.ts';
+import type { OttoEvent } from '../../events/types.ts';
+import type { createTurnDumpCollector } from '../debug/turn-dump.ts';
+
+export type RunnerToolObserverState = {
+	finishObserved: boolean;
+	toolActivityObserved: boolean;
+	trailingAssistantTextAfterTool: boolean;
+	endedWithToolActivity: boolean;
+	lastToolName?: string;
+};
+
+type TurnDumpCollector = NonNullable<
+	ReturnType<typeof createTurnDumpCollector>
+>;
+
+export function observeRunnerToolEvents(args: {
+	sessionId: string;
+	dump: TurnDumpCollector | null;
+	getStepIndex: () => number;
+	onToolCall?: () => void;
+}): { state: RunnerToolObserverState; unsubscribe: () => void } {
+	const state: RunnerToolObserverState = {
+		finishObserved: false,
+		toolActivityObserved: false,
+		trailingAssistantTextAfterTool: false,
+		endedWithToolActivity: false,
+		lastToolName: undefined,
+	};
+
+	const unsubscribe = subscribe(args.sessionId, (evt: OttoEvent) => {
+		if (evt.type === 'tool.call' || evt.type === 'tool.result') {
+			state.toolActivityObserved = true;
+			state.trailingAssistantTextAfterTool = false;
+			state.endedWithToolActivity = true;
+			try {
+				state.lastToolName = (
+					evt.payload as { name?: string } | undefined
+				)?.name;
+			} catch {
+				state.lastToolName = undefined;
+			}
+		}
+		if (evt.type === 'tool.call') {
+			args.onToolCall?.();
+			if (args.dump) {
+				try {
+					const p = evt.payload as {
+						name?: string;
+						callId?: string;
+						args?: unknown;
+					};
+					args.dump.recordToolCall(
+						args.getStepIndex(),
+						p.name ?? '',
+						p.callId ?? '',
+						p.args,
+					);
+				} catch {}
+			}
+		}
+		if (evt.type === 'tool.result') {
+			if (args.dump) {
+				try {
+					const p = evt.payload as {
+						name?: string;
+						callId?: string;
+						result?: unknown;
+					};
+					args.dump.recordToolResult(
+						args.getStepIndex(),
+						p.name ?? '',
+						p.callId ?? '',
+						p.result,
+					);
+				} catch {}
+			}
+			try {
+				const name = (evt.payload as { name?: string } | undefined)?.name;
+				if (name === 'finish') state.finishObserved = true;
+			} catch {}
+		}
+	});
+
+	return { state, unsubscribe };
+}

package/src/runtime/agent/runner.ts

@@ -1,11 +1,6 @@
 import { hasToolCall, streamText } from 'ai';
 import { logger } from '@ottocode/sdk';
-import type { getDb } from '@ottocode/database';
-import { messageParts, sessions } from '@ottocode/database/schema';
-import { eq } from 'drizzle-orm';
-import { publish, subscribe } from '../../events/bus.ts';
-import { time } from '../debug/index.ts';
-import { toErrorPayload } from '../errors/handling.ts';
+import { publish } from '../../events/bus.ts';
 import {
 	type RunOpts,
 	setRunning,
@@ -24,10 +19,6 @@ import {
 	createAbortHandler,
 	createFinishHandler,
 } from '../stream/handlers.ts';
-import {
-	pruneSession,
-	shouldAutoCompactBeforeOverflow,
-} from '../message/compaction.ts';
 import { triggerDeferredTitleGeneration } from '../message/service.ts';
 import { setupRunner } from './runner-setup.ts';
 import {
@@ -46,6 +37,21 @@ import {
 	consumeOauthCodexTextDelta,
 } from '../stream/text-guard.ts';
 import { createTurnDumpCollector } from '../debug/turn-dump.ts';
+import {
+	appendRunnerReminderMessages,
+	type RunnerMessage,
+} from './runner-reminders.ts';
+import {
+	createFirstOutputLatencyLogger,
+	logStreamRequestReady,
+	nowMs,
+} from './runner-telemetry.ts';
+import { handleRunnerTextDelta, type RunnerTextState } from './runner-text.ts';
+import { observeRunnerToolEvents } from './runner-tool-observer.ts';
+import {
+	handleRunnerError,
+	shouldPreemptivelyAutoCompact,
+} from './runner-errors.ts';
 
 export {
 	enqueueAssistantRun,
@@ -56,95 +62,6 @@ export {
 	getRunnerState,
 } from '../session/queue.ts';
 
-const DEFAULT_TRACED_TOOL_INPUTS = new Set([
-	'write',
-	'edit',
-	'multiedit',
-	'copy_into',
-	'apply_patch',
-]);
-
-function shouldTraceToolInput(name: string): boolean {
-	void DEFAULT_TRACED_TOOL_INPUTS;
-	void name;
-	return false;
-}
-
-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;
-}
-
-function nowMs(): number {
-	const perf = globalThis.performance;
-	if (perf && typeof perf.now === 'function') return perf.now();
-	return Date.now();
-}
-
-function approximateMessageChars(
-	messages: Array<{ role: string; content: string | Array<unknown> }>,
-): number {
-	let total = 0;
-	for (const message of messages) {
-		total += message.role.length;
-		if (typeof message.content === 'string') {
-			total += message.content.length;
-			continue;
-		}
-		try {
-			total += JSON.stringify(message.content).length;
-		} catch {}
-	}
-	return total;
-}
-
-function summarizeToolShape(tools: Record<string, unknown>) {
-	const names = Object.keys(tools);
-	const entries = names.map((name) => {
-		const toolValue = tools[name];
-		let approxChars = 0;
-		try {
-			approxChars = JSON.stringify(toolValue).length;
-		} catch {}
-		return { name, approxChars };
-	});
-	entries.sort((a, b) => b.approxChars - a.approxChars);
-	return {
-		toolNames: names,
-		toolSchemaCharsApprox: entries.reduce(
-			(total, entry) => total + entry.approxChars,
-			0,
-		),
-		largestTools: entries.slice(0, 8),
-	};
-}
-
-async function shouldPreemptivelyAutoCompact(
-	db: Awaited<ReturnType<typeof getDb>>,
-	opts: RunOpts,
-	threshold: number | null | undefined,
-): Promise<boolean> {
-	const sessionRows = await db
-		.select({ currentContextTokens: sessions.currentContextTokens })
-		.from(sessions)
-		.where(eq(sessions.id, opts.sessionId))
-		.limit(1);
-
-	return shouldAutoCompactBeforeOverflow({
-		autoCompactThresholdTokens: threshold,
-		currentContextTokens: sessionRows[0]?.currentContextTokens ?? 0,
-		estimatedInputTokens: opts.estimatedInputTokens ?? 0,
-		isCompactCommand: opts.isCompactCommand,
-		compactionRetries: opts.compactionRetries,
-	});
-}
-
 export async function runSessionLoop(sessionId: string) {
 	setRunning(sessionId, true);
 
@@ -225,41 +142,16 @@ async function runAssistant(opts: RunOpts) {
 
 	const isFirstMessage = !history.some((m) => m.role === 'assistant');
 
-	const messagesWithSystemInstructions: Array<{
-		role: string;
-		content: string | Array<unknown>;
-	}> = [...additionalSystemMessages, ...history];
-
-	if (!isFirstMessage) {
-		if (isOpenAIOAuth) {
-			messagesWithSystemInstructions.push({
-				role: 'system',
-				content:
-					'[system-reminder] Continuing an existing session. Execute directly, use tools as needed, and call `finish` at the end. For simple questions, your answer IS the response — do not add a "Summary:" recap.',
-			});
-		} else {
-			messagesWithSystemInstructions.push({
-				role: 'user',
-				content:
-					'<system-reminder>Continuing an existing session. Answer or complete the work directly, then call `finish`. For simple questions, your answer IS the response — do NOT add a labeled "Summary:" line or recap trivial replies.</system-reminder>',
-			});
-		}
-	}
-	if ((opts.continuationCount ?? 0) > 0) {
-		if (isOpenAIOAuth) {
-			messagesWithSystemInstructions.push({
-				role: 'system',
-				content:
-					'[system-reminder] Your previous response stopped mid-task. Resume from where you left off and complete the actual work — not a plan-only update.',
-			});
-		} else {
-			messagesWithSystemInstructions.push({
-				role: 'user',
-				content:
-					'<system-reminder>Your previous response stopped before calling `finish`. Resume from where you left off, do the actual work (no plan-only updates), then stream a summary and call `finish`.</system-reminder>',
-			});
-		}
-	}
+	const messagesWithSystemInstructions: RunnerMessage[] = [
+		...additionalSystemMessages,
+		...history,
+	];
+	appendRunnerReminderMessages({
+		messages: messagesWithSystemInstructions,
+		isFirstMessage,
+		isOpenAIOAuth,
+		continuationCount: opts.continuationCount,
+	});
 
 	const dump = createTurnDumpCollector({
 		sessionId: opts.sessionId,
@@ -286,98 +178,34 @@ async function runAssistant(opts: RunOpts) {
 		});
 	}
 
-	let _finishObserved = false;
-	let _toolActivityObserved = false;
-	let _trailingAssistantTextAfterTool = false;
-	let _endedWithToolActivity = false;
-	let _lastToolName: string | undefined;
 	let _abortedByUser = false;
 	let titleGenerationTriggered = false;
-	const unsubscribeFinish = subscribe(opts.sessionId, (evt) => {
-		if (evt.type === 'tool.call' || evt.type === 'tool.result') {
-			_toolActivityObserved = true;
-			_trailingAssistantTextAfterTool = false;
-			_endedWithToolActivity = true;
-			try {
-				_lastToolName = (evt.payload as { name?: string } | undefined)?.name;
-			} catch {
-				_lastToolName = undefined;
-			}
-		}
-		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') {
-			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 {}
-		}
+	const logFirstOutputLatency = createFirstOutputLatencyLogger({
+		opts,
+		runStartedAt,
+		queueWaitMs,
+		timings,
 	});
 
-	const streamStartTimer = time('runner:first-delta');
-	let firstDeltaSeen = false;
-	const logFirstOutputLatency = (kind: 'text' | 'reasoning') => {
-		if (firstDeltaSeen) return;
-		firstDeltaSeen = true;
-		const firstOutputMs = nowMs() - runStartedAt;
-		streamStartTimer.end({ kind, queueWaitMs, setupMs: timings.totalMs });
-		logger.info('[latency] first output', {
-			sessionId: opts.sessionId,
-			messageId: opts.assistantMessageId,
-			agent: opts.agent,
-			provider: opts.provider,
-			model: opts.model,
-			kind,
-			queueWaitMs,
-			firstOutputMs,
-			setupMs: timings.totalMs,
-			totalSinceEnqueueMs: queueWaitMs + firstOutputMs,
-			timings,
-		});
+	const textState: RunnerTextState = {
+		currentPartId: null,
+		accumulated: '',
+		latestAssistantText: '',
+		lastTextDeltaStepIndex: null,
+		firstPublishedDeltaSeen: false,
 	};
-
-	let currentPartId: string | null = null;
-	let accumulated = '';
-	let latestAssistantText = '';
-	let lastTextDeltaStepIndex: number | null = null;
 	let stepIndex = 0;
 	const oauthTextGuard = isOpenAIOAuth
 		? createOauthCodexTextGuardState()
 		: null;
 
-	const getCurrentPartId = () => currentPartId;
+	const getCurrentPartId = () => textState.currentPartId;
 	const getStepIndex = () => stepIndex;
 	const updateCurrentPartId = (id: string | null) => {
-		currentPartId = id;
+		textState.currentPartId = id;
 	};
 	const updateAccumulated = (text: string) => {
-		accumulated = text;
+		textState.accumulated = text;
 	};
 	const incrementStepIndex = () => {
 		stepIndex += 1;
@@ -399,6 +227,13 @@ async function runAssistant(opts: RunOpts) {
 			sessionId: opts.sessionId,
 		});
 	};
+	const toolObserver = observeRunnerToolEvents({
+		sessionId: opts.sessionId,
+		dump,
+		getStepIndex,
+		onToolCall: triggerTitleGenerationWhenReady,
+	});
+	const unsubscribeFinish = toolObserver.unsubscribe;
 
 	const reasoningStates = new Map<string, ReasoningState>();
 
@@ -452,26 +287,13 @@ async function runAssistant(opts: RunOpts) {
 	const stopWhenCondition = isCopilotResponsesApi
 		? undefined
 		: hasToolCall('finish');
-	const toolShape = summarizeToolShape(toolset as Record<string, unknown>);
-	logger.info('[latency] stream request ready', {
-		sessionId: opts.sessionId,
-		messageId: opts.assistantMessageId,
-		agent: opts.agent,
-		provider: opts.provider,
-		model: opts.model,
+	logStreamRequestReady({
+		opts,
+		setup,
 		queueWaitMs,
-		setupMs: timings.totalMs,
-		messageCount: messagesWithSystemInstructions.length,
-		toolCount: Object.keys(toolset).length,
-		toolNames: toolShape.toolNames,
-		toolSchemaCharsApprox: toolShape.toolSchemaCharsApprox,
-		largestTools: toolShape.largestTools,
+		messages: messagesWithSystemInstructions,
+		toolset: toolset as Record<string, unknown>,
 		hasPrepareStep: Boolean(prepareStep),
-		providerOptionsKeys: Object.keys(providerOptions),
-		systemPromptChars: system.length,
-		messageCharsApprox: approximateMessageChars(messagesWithSystemInstructions),
-		additionalSystemMessages: additionalSystemMessages.length,
-		historyMessages: history.length,
 	});
 
 	try {
@@ -516,9 +338,7 @@ async function runAssistant(opts: RunOpts) {
 			model: opts.model,
 			invokeMs: nowMs() - streamInvocationStartedAt,
 		});
-		const tracedToolInputNamesById = new Map<string, string>();
 		let firstFullStreamPartSeen = false;
-		let firstPublishedDeltaSeen = false;
 
 		for await (const part of result.fullStream) {
 			if (!part) continue;
@@ -538,38 +358,22 @@ async function runAssistant(opts: RunOpts) {
 			}
 
 			if (part.type === 'tool-input-start') {
-				if (shouldTraceToolInput(part.toolName)) {
-					tracedToolInputNamesById.set(part.id, part.toolName);
-				}
 				continue;
 			}
 
 			if (part.type === 'tool-input-delta') {
-				const toolName = tracedToolInputNamesById.get(part.id);
-				if (toolName) void summarizeTraceValue(part.delta);
 				continue;
 			}
 
 			if (part.type === 'tool-input-end') {
-				const toolName = tracedToolInputNamesById.get(part.id);
-				if (toolName) {
-					tracedToolInputNamesById.delete(part.id);
-				}
 				continue;
 			}
 
 			if (part.type === 'tool-call') {
-				if (shouldTraceToolInput(part.toolName)) {
-					tracedToolInputNamesById.delete(part.toolCallId);
-					void summarizeTraceValue(part.input);
-				}
 				continue;
 			}
 
 			if (part.type === 'tool-result') {
-				if (shouldTraceToolInput(part.toolName)) {
-					void summarizeTraceValue(part.output);
-				}
 				continue;
 			}
 
@@ -582,73 +386,21 @@ async function runAssistant(opts: RunOpts) {
 					: rawDelta;
 				if (!delta) continue;
 
-				accumulated += delta;
-				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())
-				) {
-					_trailingAssistantTextAfterTool = true;
-					_endedWithToolActivity = false;
-				}
-
-				if (!currentPartId && !accumulated.trim()) {
-					continue;
-				}
-
-				logFirstOutputLatency('text');
-
-				if (!currentPartId) {
-					currentPartId = crypto.randomUUID();
-					sharedCtx.assistantPartId = currentPartId;
-					await db.insert(messageParts).values({
-						id: currentPartId,
-						messageId: opts.assistantMessageId,
-						index: await sharedCtx.nextIndex(),
-						stepIndex: null,
-						type: 'text',
-						content: JSON.stringify({ text: accumulated }),
-						agent: opts.agent,
-						provider: opts.provider,
-						model: opts.model,
-						startedAt: Date.now(),
-					});
-				}
-
-				publish({
-					type: 'message.part.delta',
-					sessionId: opts.sessionId,
-					payload: {
-						messageId: opts.assistantMessageId,
-						partId: currentPartId,
-						stepIndex,
-						delta,
-					},
+				await handleRunnerTextDelta({
+					delta,
+					state: textState,
+					toolObserver: toolObserver.state,
+					opts,
+					db,
+					sharedCtx,
+					stepIndex,
+					dump,
+					firstToolSeen,
+					logFirstOutputLatency,
+					runStartedAt,
+					queueWaitMs,
+					setupMs: timings.totalMs,
 				});
-				if (!firstPublishedDeltaSeen) {
-					firstPublishedDeltaSeen = true;
-					logger.info('[latency] first published delta', {
-						sessionId: opts.sessionId,
-						messageId: opts.assistantMessageId,
-						agent: opts.agent,
-						provider: opts.provider,
-						model: opts.model,
-						sinceRunStartMs: nowMs() - runStartedAt,
-						queueWaitMs,
-						setupMs: timings.totalMs,
-						deltaPreview: delta.length > 80 ? `${delta.slice(0, 80)}…` : delta,
-					});
-				}
-				await db
-					.update(messageParts)
-					.set({ content: JSON.stringify({ text: accumulated }) })
-					.where(eq(messageParts.id, currentPartId));
 				continue;
 			}
 
@@ -690,7 +442,7 @@ async function runAssistant(opts: RunOpts) {
 		}
 
 		const fs = firstToolSeen();
-		if (!fs && !_finishObserved) {
+		if (!fs && !toolObserver.state.finishObserved) {
 			publish({
 				type: 'finish-step',
 				sessionId: opts.sessionId,
@@ -717,10 +469,11 @@ async function runAssistant(opts: RunOpts) {
 		}
 
 		if (dump) {
-			const finalTextSnapshot = latestAssistantText || accumulated;
+			const finalTextSnapshot =
+				textState.latestAssistantText || textState.accumulated;
 			if (finalTextSnapshot.length > 0) {
 				dump.recordTextDelta(
-					lastTextDeltaStepIndex ?? stepIndex,
+					textState.lastTextDeltaStepIndex ?? stepIndex,
 					finalTextSnapshot,
 					{ force: true },
 				);
@@ -728,74 +481,22 @@ async function runAssistant(opts: RunOpts) {
 			dump.recordStreamEnd({
 				finishReason: streamFinishReason,
 				rawFinishReason: streamRawFinishReason,
-				finishObserved: _finishObserved,
+				finishObserved: toolObserver.state.finishObserved,
 				aborted: _abortedByUser,
 			});
 		}
 	} catch (err) {
 		unsubscribeFinish();
 		dump?.recordError(err);
-		const payload = toErrorPayload(err);
-
-		const errorMessage = err instanceof Error ? err.message : String(err);
-		const errorCode = (err as { code?: string })?.code ?? '';
-		const responseBody = (err as { responseBody?: string })?.responseBody ?? '';
-		const apiErrorType = (err as { apiErrorType?: string })?.apiErrorType ?? '';
-		const combinedError = `${errorMessage} ${responseBody}`.toLowerCase();
-
-		const isPromptTooLong =
-			combinedError.includes('prompt is too long') ||
-			combinedError.includes('maximum context length') ||
-			combinedError.includes('too many tokens') ||
-			combinedError.includes('context_length_exceeded') ||
-			combinedError.includes('request too large') ||
-			combinedError.includes('exceeds the model') ||
-			combinedError.includes('input is too long') ||
-			errorCode === 'context_length_exceeded' ||
-			apiErrorType === 'invalid_request_error';
-
-		if (isPromptTooLong && !opts.isCompactCommand) {
-			try {
-				const pruneResult = await pruneSession(db, opts.sessionId);
-				void pruneResult;
-
-				publish({
-					type: 'error',
-					sessionId: opts.sessionId,
-					payload: {
-						...payload,
-						message: `Context too large. Auto-compacted old tool results. Please retry your message.`,
-						name: 'ContextOverflow',
-					},
-				});
-
-				try {
-					await completeAssistantMessage({}, opts, db);
-				} catch {}
-				return;
-			} catch {}
-		}
-		publish({
-			type: 'error',
-			sessionId: opts.sessionId,
-			payload,
+		const outcome = await handleRunnerError({
+			err,
+			opts,
+			db,
+			completeAssistantMessage,
+			updateSessionTokensIncremental,
+			updateMessageTokensIncremental,
 		});
-
-		try {
-			await updateSessionTokensIncremental(
-				{ inputTokens: 0, outputTokens: 0 },
-				undefined,
-				opts,
-				db,
-			);
-			await updateMessageTokensIncremental(
-				{ inputTokens: 0, outputTokens: 0 },
-				undefined,
-				opts,
-				db,
-			);
-			await completeAssistantMessage({}, opts, db);
-		} catch {}
+		if (outcome === 'handled') return;
 		throw err;
 	} finally {
 		if (dump) {