@ottocode/server 0.1.173

package/src/runtime/stream/error-handler.ts

@@ -0,0 +1,371 @@
+import type { getDb } from '@ottocode/database';
+import { messages, messageParts } from '@ottocode/database/schema';
+import { eq } from 'drizzle-orm';
+import { APICallError } from 'ai';
+import { publish } from '../../events/bus.ts';
+import { toErrorPayload } from '../errors/handling.ts';
+import type { RunOpts } from '../session/queue.ts';
+import type { ToolAdapterContext } from '../../tools/adapter.ts';
+import { pruneSession, performAutoCompaction } from '../message/compaction.ts';
+import { debugLog } from '../debug/index.ts';
+import { enqueueAssistantRun } from '../session/queue.ts';
+import { clearPendingTopup } from '../topup/manager.ts';
+
+export function createErrorHandler(
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+	getStepIndex: () => number,
+	sharedCtx: ToolAdapterContext,
+	retryCallback?: (sessionId: string) => Promise<void>,
+) {
+	return async (err: unknown) => {
+		const errorPayload = toErrorPayload(err);
+		const isApiError = APICallError.isInstance(err);
+		const stepIndex = getStepIndex();
+
+		const errObj = err as Record<string, unknown>;
+		const nestedError = (errObj?.error as Record<string, unknown>)?.error as
+			| Record<string, unknown>
+			| undefined;
+		const causeError = errObj?.cause as Record<string, unknown> | undefined;
+
+		// Check for SETU_FIAT_SELECTED code specifically (not string matching)
+		const errorCode =
+			(errObj?.code as string) ??
+			((errObj?.error as Record<string, unknown>)?.code as string) ??
+			((
+				(errObj?.error as Record<string, unknown>)?.error as Record<
+					string,
+					unknown
+				>
+			)?.code as string) ??
+			((errObj?.data as Record<string, unknown>)?.code as string) ??
+			((errObj?.cause as Record<string, unknown>)?.code as string) ??
+			((
+				(errObj?.cause as Record<string, unknown>)?.error as Record<
+					string,
+					unknown
+				>
+			)?.code as string) ??
+			(nestedError?.code as string) ??
+			(causeError?.code as string) ??
+			'';
+
+		// Also check error message for the exact fiat selection message
+		const errorMessage =
+			(errObj?.message as string) ??
+			((errObj?.error as Record<string, unknown>)?.message as string) ??
+			((
+				(errObj?.error as Record<string, unknown>)?.error as Record<
+					string,
+					unknown
+				>
+			)?.message as string) ??
+			((errObj?.data as Record<string, unknown>)?.message as string) ??
+			((errObj?.cause as Record<string, unknown>)?.message as string) ??
+			((
+				(errObj?.cause as Record<string, unknown>)?.error as Record<
+					string,
+					unknown
+				>
+			)?.message as string) ??
+			(nestedError?.message as string) ??
+			(causeError?.message as string) ??
+			'';
+
+		const isFiatSelected = errorCode === 'SETU_FIAT_SELECTED';
+
+		// Handle fiat payment selected - this is not an error, just a signal to pause
+		if (isFiatSelected) {
+			debugLog('[stream-handlers] Fiat payment selected, pausing request');
+			clearPendingTopup(opts.sessionId);
+
+			// Add a helpful message part telling user to complete payment
+			const partId = crypto.randomUUID();
+			await db.insert(messageParts).values({
+				id: partId,
+				messageId: opts.assistantMessageId,
+				index: await sharedCtx.nextIndex(),
+				stepIndex: getStepIndex(),
+				type: 'error',
+				content: JSON.stringify({
+					message: 'Balance too low — Complete your top-up, then retry.',
+					type: 'balance_low',
+					errorType: 'balance_low',
+					isRetryable: true,
+				}),
+				agent: opts.agent,
+				provider: opts.provider,
+				model: opts.model,
+				startedAt: Date.now(),
+				completedAt: Date.now(),
+			});
+
+			// Mark the message as completed (not error, not pending)
+			await db
+				.update(messages)
+				.set({
+					status: 'complete',
+					completedAt: Date.now(),
+					error: null,
+					errorType: null,
+					errorDetails: null,
+				})
+				.where(eq(messages.id, opts.assistantMessageId));
+
+			// Emit the message part
+			publish({
+				type: 'message.part.delta',
+				sessionId: opts.sessionId,
+				payload: {
+					messageId: opts.assistantMessageId,
+					partId,
+					type: 'error',
+					content: JSON.stringify({
+						message: 'Balance too low — Complete your top-up, then retry.',
+						type: 'balance_low',
+						errorType: 'balance_low',
+						isRetryable: true,
+					}),
+				},
+			});
+
+			// Emit message completed
+			publish({
+				type: 'message.completed',
+				sessionId: opts.sessionId,
+				payload: {
+					id: opts.assistantMessageId,
+					fiatTopupRequired: true,
+				},
+			});
+
+			// Emit a special event so UI knows to show topup modal
+			publish({
+				type: 'setu.fiat.checkout_created',
+				sessionId: opts.sessionId,
+				payload: {
+					messageId: opts.assistantMessageId,
+					needsTopup: true,
+				},
+			});
+
+			return;
+		}
+
+		const errorType =
+			(errObj?.apiErrorType as string) ?? (nestedError?.type as string) ?? '';
+		const fullErrorStrLower = JSON.stringify(err).toLowerCase();
+
+		const isPromptTooLong =
+			fullErrorStrLower.includes('prompt is too long') ||
+			fullErrorStrLower.includes('maximum context length') ||
+			fullErrorStrLower.includes('too many tokens') ||
+			fullErrorStrLower.includes('context_length_exceeded') ||
+			fullErrorStrLower.includes('request too large') ||
+			fullErrorStrLower.includes('exceeds the model') ||
+			fullErrorStrLower.includes('exceeds the limit') ||
+			fullErrorStrLower.includes('prompt token count') ||
+			fullErrorStrLower.includes('context window') ||
+			fullErrorStrLower.includes('input is too long') ||
+			errorCode === 'context_length_exceeded' ||
+			errorType === 'invalid_request_error';
+
+		debugLog(
+			`[stream-handlers] isPromptTooLong: ${isPromptTooLong}, errorCode: ${errorCode}, errorType: ${errorType}`,
+		);
+
+		if (isPromptTooLong && !opts.isCompactCommand) {
+			debugLog(
+				'[stream-handlers] Prompt too long detected, auto-compacting...',
+			);
+
+			const retries = opts.compactionRetries ?? 0;
+			if (retries >= 2) {
+				debugLog(
+					'[stream-handlers] Compaction retry limit reached, surfacing error',
+				);
+			} else {
+				await db
+					.update(messages)
+					.set({ status: 'completed', completedAt: Date.now() })
+					.where(eq(messages.id, opts.assistantMessageId));
+
+				publish({
+					type: 'message.completed',
+					sessionId: opts.sessionId,
+					payload: {
+						id: opts.assistantMessageId,
+						autoCompacted: true,
+					},
+				});
+
+				const compactMessageId = crypto.randomUUID();
+				const compactMessageTime = Date.now();
+				await db.insert(messages).values({
+					id: compactMessageId,
+					sessionId: opts.sessionId,
+					role: 'assistant',
+					status: 'pending',
+					agent: opts.agent,
+					provider: opts.provider,
+					model: opts.model,
+					createdAt: compactMessageTime,
+				});
+
+				publish({
+					type: 'message.created',
+					sessionId: opts.sessionId,
+					payload: { id: compactMessageId, role: 'assistant' },
+				});
+
+				let compactionSucceeded = false;
+				try {
+					const publishWrapper = (event: {
+						type: string;
+						sessionId: string;
+						payload: Record<string, unknown>;
+					}) => {
+						publish(event as Parameters<typeof publish>[0]);
+					};
+					const compactResult = await performAutoCompaction(
+						db,
+						opts.sessionId,
+						compactMessageId,
+						publishWrapper,
+						opts.provider,
+						opts.model,
+					);
+					if (compactResult.success) {
+						debugLog(
+							`[stream-handlers] Auto-compaction succeeded: ${compactResult.summary?.slice(0, 100)}...`,
+						);
+						compactionSucceeded = true;
+					} else {
+						debugLog(
+							`[stream-handlers] Auto-compaction failed: ${compactResult.error}, falling back to prune`,
+						);
+						const pruneResult = await pruneSession(db, opts.sessionId);
+						debugLog(
+							`[stream-handlers] Fallback pruned ${pruneResult.pruned} parts, saved ~${pruneResult.saved} tokens`,
+						);
+						compactionSucceeded = pruneResult.pruned > 0;
+					}
+				} catch (compactErr) {
+					debugLog(
+						`[stream-handlers] Auto-compact error: ${compactErr instanceof Error ? compactErr.message : String(compactErr)}`,
+					);
+				}
+
+				await db
+					.update(messages)
+					.set({
+						status: compactionSucceeded ? 'completed' : 'error',
+						completedAt: Date.now(),
+					})
+					.where(eq(messages.id, compactMessageId));
+
+				publish({
+					type: 'message.completed',
+					sessionId: opts.sessionId,
+					payload: { id: compactMessageId, autoCompacted: true },
+				});
+
+				if (compactionSucceeded && retryCallback) {
+					debugLog('[stream-handlers] Triggering retry after compaction...');
+					const retryMessageId = crypto.randomUUID();
+					await db.insert(messages).values({
+						id: retryMessageId,
+						sessionId: opts.sessionId,
+						role: 'assistant',
+						status: 'pending',
+						agent: opts.agent,
+						provider: opts.provider,
+						model: opts.model,
+						createdAt: Date.now(),
+					});
+
+					publish({
+						type: 'message.created',
+						sessionId: opts.sessionId,
+						payload: { id: retryMessageId, role: 'assistant' },
+					});
+
+					enqueueAssistantRun(
+						{
+							...opts,
+							assistantMessageId: retryMessageId,
+							compactionRetries: retries + 1,
+						},
+						retryCallback,
+					);
+					return;
+				}
+
+				if (compactionSucceeded) {
+					debugLog(
+						'[stream-handlers] No retryCallback provided, cannot auto-retry',
+					);
+					return;
+				}
+			}
+		}
+
+		const errorPartId = crypto.randomUUID();
+		const displayMessage =
+			isPromptTooLong && !opts.isCompactCommand
+				? `${errorPayload.message}. Context auto-compacted - please retry your message.`
+				: errorPayload.message;
+		const errorPartType = isPromptTooLong
+			? 'context_length_exceeded'
+			: errorPayload.type;
+		await db.insert(messageParts).values({
+			id: errorPartId,
+			messageId: opts.assistantMessageId,
+			index: await sharedCtx.nextIndex(),
+			stepIndex,
+			type: 'error',
+			content: JSON.stringify({
+				message: displayMessage,
+				type: errorPartType,
+				errorType: isPromptTooLong ? 'context_length_exceeded' : undefined,
+				details: errorPayload.details,
+				isAborted: false,
+			}),
+			agent: opts.agent,
+			provider: opts.provider,
+			model: opts.model,
+			startedAt: Date.now(),
+			completedAt: Date.now(),
+		});
+
+		await db
+			.update(messages)
+			.set({
+				status: 'error',
+				error: displayMessage,
+				errorType: errorPartType,
+				errorDetails: JSON.stringify({
+					...errorPayload.details,
+					isApiError,
+					autoCompacted: isPromptTooLong && !opts.isCompactCommand,
+				}),
+				isAborted: false,
+			})
+			.where(eq(messages.id, opts.assistantMessageId));
+
+		publish({
+			type: 'error',
+			sessionId: opts.sessionId,
+			payload: {
+				messageId: opts.assistantMessageId,
+				partId: errorPartId,
+				error: displayMessage,
+				errorType: errorPartType,
+				details: errorPayload.details,
+				isAborted: false,
+				autoCompacted: isPromptTooLong && !opts.isCompactCommand,
+			},
+		});
+	};
+}

package/src/runtime/stream/finish-handler.ts

@@ -0,0 +1,101 @@
+import type { getDb } from '@ottocode/database';
+import { messages, messageParts } from '@ottocode/database/schema';
+import { eq } from 'drizzle-orm';
+import { publish } from '../../events/bus.ts';
+import { estimateModelCostUsd } from '@ottocode/sdk';
+import type { RunOpts } from '../session/queue.ts';
+import { markSessionCompacted } from '../message/compaction.ts';
+import { debugLog } from '../debug/index.ts';
+import type { FinishEvent } from './types.ts';
+import {
+	normalizeUsage,
+	resolveUsageProvider,
+} from '../session/db-operations.ts';
+
+export function createFinishHandler(
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+	completeAssistantMessageFn: (
+		fin: FinishEvent,
+		opts: RunOpts,
+		db: Awaited<ReturnType<typeof getDb>>,
+	) => Promise<void>,
+) {
+	return async (fin: FinishEvent) => {
+		try {
+			await completeAssistantMessageFn(fin, opts, db);
+		} catch {}
+
+		if (opts.isCompactCommand && fin.finishReason !== 'error') {
+			const assistantParts = await db
+				.select()
+				.from(messageParts)
+				.where(eq(messageParts.messageId, opts.assistantMessageId));
+			const hasTextContent = assistantParts.some(
+				(p) => p.type === 'text' && p.content && p.content !== '{"text":""}',
+			);
+
+			if (!hasTextContent) {
+				debugLog(
+					'[stream-handlers] /compact finished but no summary generated, skipping compaction marking',
+				);
+			} else {
+				try {
+					debugLog(
+						`[stream-handlers] /compact complete, marking session compacted`,
+					);
+					const result = await markSessionCompacted(
+						db,
+						opts.sessionId,
+						opts.assistantMessageId,
+					);
+					debugLog(
+						`[stream-handlers] Compacted ${result.compacted} parts, saved ~${result.saved} tokens`,
+					);
+				} catch (err) {
+					debugLog(
+						`[stream-handlers] Compaction failed: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
+			}
+		}
+
+		const sessRows = await db
+			.select()
+			.from(messages)
+			.where(eq(messages.id, opts.assistantMessageId));
+
+		const usage = sessRows[0]
+			? {
+					inputTokens: Number(sessRows[0].inputTokens ?? 0),
+					outputTokens: Number(sessRows[0].outputTokens ?? 0),
+					totalTokens: Number(sessRows[0].totalTokens ?? 0),
+					cachedInputTokens: Number(sessRows[0].cachedInputTokens ?? 0),
+					cacheCreationInputTokens: Number(
+						sessRows[0].cacheCreationInputTokens ?? 0,
+					),
+				}
+			: fin.usage
+				? normalizeUsage(
+						fin.usage,
+						undefined,
+						resolveUsageProvider(opts.provider, opts.model),
+					)
+				: undefined;
+
+		const costUsd = usage
+			? estimateModelCostUsd(opts.provider, opts.model, usage)
+			: undefined;
+
+		publish({
+			type: 'message.completed',
+			sessionId: opts.sessionId,
+			payload: {
+				id: opts.assistantMessageId,
+				usage,
+				costUsd,
+				finishReason: fin.finishReason,
+			},
+		});
+	};
+}

package/src/runtime/stream/handlers.ts

@@ -0,0 +1,5 @@
+export { createStepFinishHandler } from './step-finish.ts';
+export { createErrorHandler } from './error-handler.ts';
+export { createAbortHandler } from './abort-handler.ts';
+export { createFinishHandler } from './finish-handler.ts';
+export type { StepFinishEvent, FinishEvent, AbortEvent } from './types.ts';

package/src/runtime/stream/step-finish.ts

@@ -0,0 +1,93 @@
+import type { getDb } from '@ottocode/database';
+import { messageParts } from '@ottocode/database/schema';
+import { eq } from 'drizzle-orm';
+import { publish } from '../../events/bus.ts';
+import type { RunOpts } from '../session/queue.ts';
+import type { ToolAdapterContext } from '../../tools/adapter.ts';
+import type { UsageData, ProviderMetadata } from '../session/db-operations.ts';
+import type { StepFinishEvent } from './types.ts';
+
+export function createStepFinishHandler(
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+	getStepIndex: () => number,
+	incrementStepIndex: () => number,
+	getCurrentPartId: () => string | null,
+	updateCurrentPartId: (id: string | null) => void,
+	updateAccumulated: (text: string) => void,
+	sharedCtx: ToolAdapterContext,
+	updateSessionTokensIncrementalFn: (
+		usage: UsageData,
+		providerOptions: ProviderMetadata | undefined,
+		opts: RunOpts,
+		db: Awaited<ReturnType<typeof getDb>>,
+	) => Promise<void>,
+	updateMessageTokensIncrementalFn: (
+		usage: UsageData,
+		providerOptions: ProviderMetadata | undefined,
+		opts: RunOpts,
+		db: Awaited<ReturnType<typeof getDb>>,
+	) => Promise<void>,
+) {
+	return async (step: StepFinishEvent) => {
+		const finishedAt = Date.now();
+		const currentPartId = getCurrentPartId();
+		const stepIndex = getStepIndex();
+
+		try {
+			if (currentPartId) {
+				await db
+					.update(messageParts)
+					.set({ completedAt: finishedAt })
+					.where(eq(messageParts.id, currentPartId));
+			}
+		} catch {}
+
+		if (step.usage) {
+			try {
+				await updateSessionTokensIncrementalFn(
+					step.usage,
+					step.providerMetadata,
+					opts,
+					db,
+				);
+			} catch {}
+
+			try {
+				await updateMessageTokensIncrementalFn(
+					step.usage,
+					step.providerMetadata,
+					opts,
+					db,
+				);
+			} catch {}
+		}
+
+		try {
+			publish({
+				type: 'finish-step',
+				sessionId: opts.sessionId,
+				payload: {
+					stepIndex,
+					usage: step.usage,
+					finishReason: step.finishReason,
+					response: step.response,
+				},
+			});
+			if (step.usage) {
+				publish({
+					type: 'usage',
+					sessionId: opts.sessionId,
+					payload: { stepIndex, ...step.usage },
+				});
+			}
+		} catch {}
+
+		try {
+			const newStepIndex = incrementStepIndex();
+			sharedCtx.stepIndex = newStepIndex;
+			updateCurrentPartId(null);
+			updateAccumulated('');
+		} catch {}
+	};
+}

package/src/runtime/stream/types.ts

@@ -0,0 +1,25 @@
+import type { UsageData, ProviderMetadata } from '../session/db-operations.ts';
+
+export type StepFinishEvent = {
+	usage?: UsageData;
+	finishReason?: string;
+	response?: unknown;
+	providerMetadata?: ProviderMetadata;
+};
+
+export type FinishEvent = {
+	usage?: Pick<
+		UsageData,
+		| 'inputTokens'
+		| 'outputTokens'
+		| 'totalTokens'
+		| 'cachedInputTokens'
+		| 'cacheCreationInputTokens'
+		| 'reasoningTokens'
+	>;
+	finishReason?: string;
+};
+
+export type AbortEvent = {
+	steps: unknown[];
+};