@ottocode/server 0.1.265 → 0.1.266

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

@@ -1,35 +1,32 @@
-import {
-	loadConfig,
-	logger,
-	getConfiguredProviderFamily,
-	getSessionSystemPromptPath,
-	getModelFamily,
-	type OttoConfig,
-} from '@ottocode/sdk';
-import { wrapLanguageModel } from 'ai';
-import { devToolsMiddleware } from '@ai-sdk/devtools';
+import { discoverProjectTools, loadConfig, logger } from '@ottocode/sdk';
 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';
-import { discoverProjectTools } from '@ottocode/sdk';
 import type { Tool } from 'ai';
 import { adaptTools } from '../../tools/adapter.ts';
+import type { ToolAdapterContext } from '../../tools/adapter.ts';
 import { buildDatabaseTools } from '../../tools/database/index.ts';
 import { time } from '../debug/index.ts';
-import { isDebugEnabled, isDevtoolsEnabled } from '../debug/state.ts';
 import { buildHistoryMessages } from '../message/history-builder.ts';
-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';
+import { resolveAgentConfig } from './registry.ts';
+import {
+	appendRunnerPromptMessages,
+	buildRunnerPrompt,
+} from './runner-setup-prompt.ts';
+import {
+	buildAllowedTools,
+	applyModelFamilyEditToolPolicy,
+	mergeProviderOptions,
+} from './runner-setup-tools.ts';
+import {
+	buildRunnerProviderOptions,
+	resolveRunnerModel,
+} from './runner-setup-model.ts';
+import { nowMs, timePromise } from './runner-setup-utils.ts';
+
+export { applyModelFamilyEditToolPolicy, mergeProviderOptions };
 
 type RunnerSetupTimings = {
 	loadConfigAndDbMs: number;
@@ -44,26 +41,6 @@ type RunnerSetupTimings = {
 	totalMs: number;
 };
 
-type TimedResult<T> = {
-	value: T;
-	durationMs: number;
-};
-
-function nowMs(): number {
-	const perf = globalThis.performance;
-	if (perf && typeof perf.now === 'function') return perf.now();
-	return Date.now();
-}
-
-async function timePromise<T>(promise: Promise<T>): Promise<TimedResult<T>> {
-	const startedAt = nowMs();
-	const value = await promise;
-	return {
-		value,
-		durationMs: nowMs() - startedAt,
-	};
-}
-
 export interface SetupResult {
 	cfg: Awaited<ReturnType<typeof loadConfig>>;
 	db: Awaited<ReturnType<typeof getDb>>;
@@ -72,9 +49,7 @@ export interface SetupResult {
 	system: string;
 	systemComponents: string[];
 	additionalSystemMessages: Array<{ role: 'system' | 'user'; content: string }>;
-	model:
-		| Awaited<ReturnType<typeof resolveModel>>
-		| ReturnType<typeof wrapLanguageModel>;
+	model: Awaited<ReturnType<typeof resolveRunnerModel>>['model'];
 	maxOutputTokens: number | undefined;
 	effectiveMaxOutputTokens: number | undefined;
 	toolset: ReturnType<typeof adaptTools>;
@@ -88,78 +63,6 @@ export interface SetupResult {
 	timings: RunnerSetupTimings;
 }
 
-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;
-}
-
-const EDITING_TOOL_NAMES = [
-	'edit',
-	'multiedit',
-	'write',
-	'copy_into',
-	'apply_patch',
-];
-const MODEL_FAMILY_EDIT_TOOL_POLICY_AGENTS = new Set([
-	'build',
-	'general',
-	'init',
-]);
-
-function normalizeToolName(toolName: string): string {
-	return toolName === 'bash' ? 'shell' : toolName;
-}
-
-function normalizeToolNames(toolNames: string[]): string[] {
-	return Array.from(new Set(toolNames.map(normalizeToolName)));
-}
-
-export function applyModelFamilyEditToolPolicy(
-	agent: string,
-	tools: string[],
-	provider: RunOpts['provider'],
-	model: string,
-	cfg?: OttoConfig,
-): string[] {
-	tools = normalizeToolNames(tools);
-	if (!MODEL_FAMILY_EDIT_TOOL_POLICY_AGENTS.has(agent)) return tools;
-
-	const family = cfg
-		? getConfiguredProviderFamily(cfg, provider, model)
-		: getModelFamily(provider, model);
-	const next = tools.filter(
-		(toolName) => !EDITING_TOOL_NAMES.includes(toolName),
-	);
-	const preferredEditingTools =
-		family === 'anthropic' || family === 'openai'
-			? ['write', 'copy_into', 'apply_patch']
-			: ['write', 'edit', 'multiedit', 'copy_into'];
-
-	return Array.from(new Set([...next, ...preferredEditingTools]));
-}
-
 export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const setupStartedAt = nowMs();
 	const cfgTimer = time('runner:loadConfig+db');
@@ -189,8 +92,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		await agentCfgPromise;
 	agentTimer.end({ agent: opts.agent });
 
-	const agentPrompt = agentCfg.prompt || '';
-
 	const historyTimer = time('runner:buildHistory');
 	const { value: history, durationMs: buildHistoryMs } = await historyPromise;
 	historyTimer.end({ messages: history.length });
@@ -207,7 +108,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	if (opts.agent === 'research') {
 		const currentSession = sessionRows[0];
 		const parentSessionId = currentSession?.parentSessionId ?? null;
-
 		const dbTools = buildDatabaseTools(cfg.projectRoot, parentSessionId);
 		for (const dt of dbTools) {
 			discovered.tools.push(dt);
@@ -221,152 +121,30 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const isFirstMessage = !history.some((m) => m.role === 'assistant');
 
 	const systemTimer = time('runner:composeSystemPrompt');
-	const composeSystemPromptStartedAt = nowMs();
-	const { getAuth } = await import('@ottocode/sdk');
-	const auth = await getAuth(opts.provider, cfg.projectRoot);
-	const oauth = detectOAuth(opts.provider, auth);
-
-	const composed = await composeSystemPrompt({
-		provider: opts.provider,
-		model: opts.model,
-		promptFamily: getConfiguredProviderFamily(cfg, opts.provider, opts.model),
-		skillSettings: cfg.skills,
-		projectRoot: cfg.projectRoot,
-		agentPrompt,
-		oneShot: opts.oneShot,
-		guidedMode: cfg.defaults.guidedMode,
-		spoofPrompt: undefined,
-		includeProjectTree: false,
-		userContext: opts.userContext,
+	const prompt = await buildRunnerPrompt({
+		opts,
+		cfg,
+		agentPrompt: agentCfg.prompt || '',
 		contextSummary,
-		isOpenAIOAuth: oauth.isOpenAIOAuth,
+		historyLength: history.length,
+		isFirstMessage,
 	});
-
-	const rawMaxOutputTokens = getMaxOutputTokens(opts.provider, opts.model);
-	const adapted = adaptRunnerCall(oauth, composed, {
-		provider: opts.provider,
-		rawMaxOutputTokens,
+	systemTimer.end();
+	appendRunnerPromptMessages({
+		opts,
+		additionalSystemMessages: prompt.additionalSystemMessages,
 	});
 
-	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';
-	const composeSystemPromptMs = nowMs() - composeSystemPromptStartedAt;
-	systemTimer.end();
-	logger.debug('[prompt] system prompt assembled', {
-		sessionId: opts.sessionId,
-		messageId: opts.assistantMessageId,
-		agent: opts.agent,
+	const gated = buildAllowedTools({
+		agentName: agentCfg.name,
+		agentTools: agentCfg.tools || [],
 		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 && isDebugEnabled()) {
-		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();
-		additionalSystemMessages.push({
-			role: 'system',
-			content: compactPrompt,
-		});
-		additionalSystemMessages.push({
-			role: 'user',
-			content: `Please summarize this conversation:\n\n<conversation-to-summarize>\n${opts.compactionContext}\n</conversation-to-summarize>`,
-		});
-	}
-
-	if (opts.additionalPromptMessages?.length) {
-		additionalSystemMessages.push(...opts.additionalPromptMessages);
-	}
-	const allowedToolNames = applyModelFamilyEditToolPolicy(
-		agentCfg.name,
-		agentCfg.tools || [],
-		opts.provider,
-		opts.model,
-	);
-	const allowedNames = new Set([
-		...normalizeToolNames(allowedToolNames),
-		'finish',
-	]);
-	const gated = allTools.filter(
-		(tool) => allowedNames.has(tool.name) || tool.name === 'load_mcp_tools',
-	);
-
-	const resolveModelStartedAt = nowMs();
-	const model = await resolveModel(opts.provider, opts.model, cfg, {
-		sessionId: opts.sessionId,
-		messageId: opts.assistantMessageId,
-		reasoningText: opts.reasoningText,
+		cfg,
+		allTools,
 	});
-	const resolveModelMs = nowMs() - resolveModelStartedAt;
-	const wrappedModel = isDevtoolsEnabled()
-		? wrapLanguageModel({
-				// biome-ignore lint/suspicious/noExplicitAny: OpenRouter provider uses v2 spec
-				model: model as any,
-				middleware: devToolsMiddleware(),
-			})
-		: model;
 
-	const maxOutputTokens = adapted.maxOutputTokens;
+	const { model, resolveModelMs } = await resolveRunnerModel({ opts, cfg });
 
 	const setupToolContextStartedAt = nowMs();
 	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
@@ -376,38 +154,26 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const setupToolContextMs = nowMs() - setupToolContextStartedAt;
 
 	const buildToolsetStartedAt = nowMs();
+	const { getAuth } = await import('@ottocode/sdk');
 	const providerAuth = await getAuth(opts.provider, opts.projectRoot);
 	const authType = providerAuth?.type;
 	const toolset = adaptTools(gated, sharedCtx, opts.provider, authType);
 	const buildToolsetMs = nowMs() - buildToolsetStartedAt;
 
-	const providerOptions = { ...adapted.providerOptions };
-	let effectiveMaxOutputTokens = maxOutputTokens;
-
-	if (opts.provider === 'copilot') {
-		providerOptions.openai = {
-			...((providerOptions.openai as Record<string, unknown>) || {}),
-			store: false,
-		};
-	}
-
-	const reasoningConfig = buildReasoningConfig({
-		cfg,
-		provider: opts.provider,
-		model: opts.model,
-		reasoningText: opts.reasoningText,
-		reasoningLevel: opts.reasoningLevel,
-		maxOutputTokens,
-	});
-	mergeProviderOptions(providerOptions, reasoningConfig.providerOptions);
-	effectiveMaxOutputTokens = reasoningConfig.effectiveMaxOutputTokens;
+	const { providerOptions, effectiveMaxOutputTokens } =
+		buildRunnerProviderOptions({
+			cfg,
+			opts,
+			adaptedProviderOptions: prompt.providerOptions,
+			maxOutputTokens: prompt.maxOutputTokens,
+		});
 
 	const timings: RunnerSetupTimings = {
 		loadConfigAndDbMs,
 		resolveAgentConfigMs,
 		buildHistoryMs,
 		loadSessionMs,
-		composeSystemPromptMs,
+		composeSystemPromptMs: prompt.composeSystemPromptMs,
 		discoverToolsMs,
 		resolveModelMs,
 		setupToolContextMs,
@@ -422,8 +188,8 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		provider: opts.provider,
 		model: opts.model,
 		historyMessages: history.length,
-		systemPromptChars: effectiveSystemPrompt.length,
-		additionalPromptMessages: additionalSystemMessages.length,
+		systemPromptChars: prompt.effectiveSystemPrompt.length,
+		additionalPromptMessages: prompt.additionalSystemMessages.length,
 		allowedToolCount: gated.length,
 		timings,
 	});
@@ -433,19 +199,19 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		db,
 		agentCfg,
 		history,
-		system,
-		systemComponents,
-		additionalSystemMessages,
-		model: wrappedModel,
-		maxOutputTokens,
+		system: prompt.system,
+		systemComponents: prompt.systemComponents,
+		additionalSystemMessages: prompt.additionalSystemMessages,
+		model,
+		maxOutputTokens: prompt.maxOutputTokens,
 		effectiveMaxOutputTokens,
 		toolset,
 		sharedCtx,
 		firstToolTimer,
 		firstToolSeen,
 		providerOptions,
-		needsSpoof: oauth.needsSpoof,
-		isOpenAIOAuth: oauth.isOpenAIOAuth,
+		needsSpoof: prompt.needsSpoof,
+		isOpenAIOAuth: prompt.isOpenAIOAuth,
 		mcpToolsRecord,
 		timings,
 	};

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

@@ -0,0 +1,112 @@
+import { logger } from '@ottocode/sdk';
+import { time } from '../debug/index.ts';
+import type { RunOpts } from '../session/queue.ts';
+import type { RunnerMessage } from './runner-reminders.ts';
+import type { SetupResult } from './runner-setup.ts';
+
+export function nowMs(): number {
+	const perf = globalThis.performance;
+	if (perf && typeof perf.now === 'function') return perf.now();
+	return Date.now();
+}
+
+export function approximateMessageChars(messages: RunnerMessage[]): 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;
+}
+
+export 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),
+	};
+}
+
+export function createFirstOutputLatencyLogger(args: {
+	opts: RunOpts;
+	runStartedAt: number;
+	queueWaitMs: number;
+	timings: SetupResult['timings'];
+}) {
+	const streamStartTimer = time('runner:first-delta');
+	let firstDeltaSeen = false;
+	return (kind: 'text' | 'reasoning') => {
+		if (firstDeltaSeen) return;
+		firstDeltaSeen = true;
+		const firstOutputMs = nowMs() - args.runStartedAt;
+		streamStartTimer.end({
+			kind,
+			queueWaitMs: args.queueWaitMs,
+			setupMs: args.timings.totalMs,
+		});
+		logger.info('[latency] first output', {
+			sessionId: args.opts.sessionId,
+			messageId: args.opts.assistantMessageId,
+			agent: args.opts.agent,
+			provider: args.opts.provider,
+			model: args.opts.model,
+			kind,
+			queueWaitMs: args.queueWaitMs,
+			firstOutputMs,
+			setupMs: args.timings.totalMs,
+			totalSinceEnqueueMs: args.queueWaitMs + firstOutputMs,
+			timings: args.timings,
+		});
+	};
+}
+
+export function logStreamRequestReady(args: {
+	opts: RunOpts;
+	setup: SetupResult;
+	queueWaitMs: number;
+	messages: RunnerMessage[];
+	toolset: Record<string, unknown>;
+	hasPrepareStep: boolean;
+}): void {
+	const { opts, setup, queueWaitMs, messages, toolset, hasPrepareStep } = args;
+	const toolShape = summarizeToolShape(toolset);
+	logger.info('[latency] stream request ready', {
+		sessionId: opts.sessionId,
+		messageId: opts.assistantMessageId,
+		agent: opts.agent,
+		provider: opts.provider,
+		model: opts.model,
+		queueWaitMs,
+		setupMs: setup.timings.totalMs,
+		messageCount: messages.length,
+		toolCount: Object.keys(toolset).length,
+		toolNames: toolShape.toolNames,
+		toolSchemaCharsApprox: toolShape.toolSchemaCharsApprox,
+		largestTools: toolShape.largestTools,
+		hasPrepareStep,
+		providerOptionsKeys: Object.keys(setup.providerOptions),
+		systemPromptChars: setup.system.length,
+		messageCharsApprox: approximateMessageChars(messages),
+		additionalSystemMessages: setup.additionalSystemMessages.length,
+		historyMessages: setup.history.length,
+	});
+}

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

@@ -0,0 +1,108 @@
+import { messageParts } from '@ottocode/database/schema';
+import { eq } from 'drizzle-orm';
+import { logger } from '@ottocode/sdk';
+import { publish } from '../../events/bus.ts';
+import type { getDb } from '@ottocode/database';
+import type { RunOpts } from '../session/queue.ts';
+import type { ToolAdapterContext } from '../../tools/adapter.ts';
+import type { createTurnDumpCollector } from '../debug/turn-dump.ts';
+import type { RunnerToolObserverState } from './runner-tool-observer.ts';
+import { nowMs } from './runner-telemetry.ts';
+
+type TurnDumpCollector = NonNullable<
+	ReturnType<typeof createTurnDumpCollector>
+>;
+
+export type RunnerTextState = {
+	currentPartId: string | null;
+	accumulated: string;
+	latestAssistantText: string;
+	lastTextDeltaStepIndex: number | null;
+	firstPublishedDeltaSeen: boolean;
+};
+
+export async function handleRunnerTextDelta(args: {
+	delta: string;
+	state: RunnerTextState;
+	toolObserver: RunnerToolObserverState;
+	opts: RunOpts;
+	db: Awaited<ReturnType<typeof getDb>>;
+	sharedCtx: ToolAdapterContext;
+	stepIndex: number;
+	dump: TurnDumpCollector | null;
+	firstToolSeen: () => boolean;
+	logFirstOutputLatency: (kind: 'text' | 'reasoning') => void;
+	runStartedAt: number;
+	queueWaitMs: number;
+	setupMs: number;
+}): Promise<boolean> {
+	const { delta, state, opts, db, sharedCtx, stepIndex, dump } = args;
+	state.accumulated += delta;
+	if (state.accumulated.trim()) {
+		state.latestAssistantText = state.accumulated;
+	}
+	if (state.accumulated.length > 0) {
+		state.lastTextDeltaStepIndex = stepIndex;
+	}
+	dump?.recordTextDelta(stepIndex, state.accumulated);
+	if (
+		(delta.trim().length > 0 && args.toolObserver.toolActivityObserved) ||
+		(delta.trim().length > 0 && args.firstToolSeen())
+	) {
+		args.toolObserver.trailingAssistantTextAfterTool = true;
+		args.toolObserver.endedWithToolActivity = false;
+	}
+
+	if (!state.currentPartId && !state.accumulated.trim()) {
+		return false;
+	}
+
+	args.logFirstOutputLatency('text');
+
+	if (!state.currentPartId) {
+		state.currentPartId = crypto.randomUUID();
+		sharedCtx.assistantPartId = state.currentPartId;
+		await db.insert(messageParts).values({
+			id: state.currentPartId,
+			messageId: opts.assistantMessageId,
+			index: await sharedCtx.nextIndex(),
+			stepIndex: null,
+			type: 'text',
+			content: JSON.stringify({ text: state.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: state.currentPartId,
+			stepIndex,
+			delta,
+		},
+	});
+	if (!state.firstPublishedDeltaSeen) {
+		state.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() - args.runStartedAt,
+			queueWaitMs: args.queueWaitMs,
+			setupMs: args.setupMs,
+			deltaPreview: delta.length > 80 ? `${delta.slice(0, 80)}…` : delta,
+		});
+	}
+	await db
+		.update(messageParts)
+		.set({ content: JSON.stringify({ text: state.accumulated }) })
+		.where(eq(messageParts.id, state.currentPartId));
+	return true;
+}