@ottocode/server 0.1.173

package/src/runtime/debug/state.ts

@@ -0,0 +1,140 @@
+/**
+ * Runtime debug state management
+ *
+ * Centralizes debug flag state that can be set either via:
+ * - Environment variables (OTTO_DEBUG, DEBUG_OTTO)
+ * - Runtime configuration (CLI --debug flag)
+ */
+
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+
+type DebugState = {
+	enabled: boolean;
+	traceEnabled: boolean;
+	runtimeOverride: boolean | null;
+	runtimeTraceOverride: boolean | null;
+};
+
+// Global state
+const state: DebugState = {
+	enabled: false,
+	traceEnabled: false,
+	runtimeOverride: null,
+	runtimeTraceOverride: null,
+};
+
+type GlobalDebugFlags = {
+	__OTTO_DEBUG_ENABLED__?: boolean;
+	__OTTO_TRACE_ENABLED__?: boolean;
+};
+
+const globalFlags = globalThis as GlobalDebugFlags;
+
+function syncGlobalFlags() {
+	globalFlags.__OTTO_DEBUG_ENABLED__ = state.enabled;
+	globalFlags.__OTTO_TRACE_ENABLED__ = state.traceEnabled;
+}
+
+/**
+ * Check if environment variables indicate debug mode
+ */
+function checkEnvDebug(): boolean {
+	const sources = [process.env.OTTO_DEBUG, process.env.DEBUG_OTTO];
+	for (const value of sources) {
+		if (!value) continue;
+		const trimmed = value.trim().toLowerCase();
+		if (TRUTHY.has(trimmed) || trimmed === 'all') {
+			return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * Check if environment variables indicate trace mode
+ */
+function checkEnvTrace(): boolean {
+	const sources = [process.env.OTTO_TRACE, process.env.TRACE_OTTO];
+	for (const value of sources) {
+		if (!value) continue;
+		const trimmed = value.trim().toLowerCase();
+		if (TRUTHY.has(trimmed)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * Initialize debug state from environment
+ */
+function initialize() {
+	if (state.runtimeOverride === null) {
+		state.enabled = checkEnvDebug();
+	}
+	if (state.runtimeTraceOverride === null) {
+		state.traceEnabled = checkEnvTrace();
+	}
+	syncGlobalFlags();
+}
+
+/**
+ * Check if debug mode is enabled
+ * Considers both runtime override and environment variables
+ */
+export function isDebugEnabled(): boolean {
+	initialize();
+	return state.enabled;
+}
+
+/**
+ * Check if trace mode is enabled (shows stack traces)
+ * Trace mode requires debug mode to be enabled
+ */
+export function isTraceEnabled(): boolean {
+	initialize();
+	return state.enabled && state.traceEnabled;
+}
+
+/**
+ * Enable or disable debug mode at runtime
+ * Overrides environment variable settings
+ *
+ * @param enabled - true to enable debug mode, false to disable
+ */
+export function setDebugEnabled(enabled: boolean): void {
+	state.enabled = enabled;
+	state.runtimeOverride = enabled;
+	syncGlobalFlags();
+}
+
+/**
+ * Enable or disable trace mode at runtime
+ * Trace mode shows full stack traces in error logs
+ *
+ * @param enabled - true to enable trace mode, false to disable
+ */
+export function setTraceEnabled(enabled: boolean): void {
+	state.traceEnabled = enabled;
+	state.runtimeTraceOverride = enabled;
+	syncGlobalFlags();
+}
+
+/**
+ * Reset debug state to environment defaults
+ */
+export function resetDebugState(): void {
+	state.runtimeOverride = null;
+	state.runtimeTraceOverride = null;
+	state.enabled = checkEnvDebug();
+	state.traceEnabled = checkEnvTrace();
+	syncGlobalFlags();
+}
+
+/**
+ * Get current debug state (for testing/diagnostics)
+ */
+export function getDebugState(): Readonly<DebugState> {
+	initialize();
+	return { ...state };
+}

package/src/runtime/errors/api-error.ts

@@ -0,0 +1,192 @@
+/**
+ * Unified API error handling
+ *
+ * Provides consistent error serialization and response formatting
+ * across all API endpoints.
+ */
+
+import { isDebugEnabled } from '../debug/state.ts';
+import { toErrorPayload } from './handling.ts';
+
+/**
+ * Standard API error response format
+ */
+export type APIErrorResponse = {
+	error: {
+		message: string;
+		type: string;
+		code?: string;
+		status?: number;
+		details?: Record<string, unknown>;
+		stack?: string;
+	};
+};
+
+/**
+ * Custom API Error class
+ */
+export class APIError extends Error {
+	public readonly code?: string;
+	public readonly status: number;
+	public readonly type: string;
+	public readonly details?: Record<string, unknown>;
+
+	constructor(
+		message: string,
+		options?: {
+			code?: string;
+			status?: number;
+			type?: string;
+			details?: Record<string, unknown>;
+			cause?: unknown;
+		},
+	) {
+		super(message);
+		this.name = 'APIError';
+		this.code = options?.code;
+		this.status = options?.status ?? 500;
+		this.type = options?.type ?? 'api_error';
+		this.details = options?.details;
+
+		if (options?.cause) {
+			this.cause = options.cause;
+		}
+
+		// Maintain proper stack trace
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, APIError);
+		}
+	}
+}
+
+/**
+ * Serialize any error into a consistent API error response
+ *
+ * @param err - The error to serialize
+ * @returns A properly formatted API error response
+ */
+export function serializeError(err: unknown): APIErrorResponse {
+	// Use existing error payload logic
+	const payload = toErrorPayload(err);
+
+	// Determine HTTP status code
+	// Default to 400 for generic errors (client errors)
+	// Only use 500 if explicitly set or for APIError instances without a status
+	let status = 400;
+
+	// Handle APIError instances first
+	if (err instanceof APIError) {
+		status = err.status;
+	} else if (err && typeof err === 'object') {
+		const errObj = err as Record<string, unknown>;
+		if (typeof errObj.status === 'number') {
+			status = errObj.status;
+		} else if (typeof errObj.statusCode === 'number') {
+			status = errObj.statusCode;
+		} else if (
+			errObj.details &&
+			typeof errObj.details === 'object' &&
+			typeof (errObj.details as Record<string, unknown>).statusCode === 'number'
+		) {
+			status = (errObj.details as Record<string, unknown>).statusCode as number;
+		}
+	}
+
+	// Extract code if available
+	let code: string | undefined;
+	if (err && typeof err === 'object') {
+		const errObj = err as Record<string, unknown>;
+		if (typeof errObj.code === 'string') {
+			code = errObj.code;
+		}
+	}
+
+	if (err instanceof APIError && err.code) {
+		code = err.code;
+	}
+
+	// Build response
+	const response: APIErrorResponse = {
+		error: {
+			message: payload.message || 'An error occurred',
+			type: payload.type || 'unknown',
+			status,
+			...(code ? { code } : {}),
+			...(payload.details ? { details: payload.details } : {}),
+		},
+	};
+
+	// Include stack trace in debug mode
+	if (isDebugEnabled() && err instanceof Error && err.stack) {
+		response.error.stack = err.stack;
+	}
+
+	return response;
+}
+
+/**
+ * Create an error response with proper HTTP status code
+ *
+ * @param err - The error to convert
+ * @returns Tuple of [APIErrorResponse, HTTP status code]
+ */
+export function createErrorResponse(err: unknown): [APIErrorResponse, number] {
+	const response = serializeError(err);
+	return [response, response.error.status ?? 500];
+}
+
+/**
+ * Normalize error to ensure it's an Error instance
+ *
+ * @param err - The error to normalize
+ * @returns An Error instance
+ */
+export function normalizeError(err: unknown): Error {
+	if (err instanceof Error) {
+		return err;
+	}
+
+	if (typeof err === 'string') {
+		return new Error(err);
+	}
+
+	if (err && typeof err === 'object') {
+		const errObj = err as Record<string, unknown>;
+		if (typeof errObj.message === 'string') {
+			return new Error(errObj.message);
+		}
+	}
+
+	return new Error('An unknown error occurred');
+}
+
+/**
+ * Extract error message from any error type
+ *
+ * @param err - The error to extract message from
+ * @returns The error message string
+ */
+export function getErrorMessage(err: unknown): string {
+	if (typeof err === 'string') {
+		return err;
+	}
+
+	if (err instanceof Error) {
+		return err.message;
+	}
+
+	if (err && typeof err === 'object') {
+		const errObj = err as Record<string, unknown>;
+		if (typeof errObj.message === 'string') {
+			return errObj.message;
+		}
+		if (typeof errObj.error === 'string') {
+			return errObj.error;
+		}
+	}
+
+	return 'An unknown error occurred';
+}
+
+// Legacy compatibility - AskServiceError alias
+export { APIError as AskServiceError };

package/src/runtime/errors/handling.ts

@@ -0,0 +1,199 @@
+import { APICallError } from 'ai';
+
+export type ErrorPayload = {
+	message: string;
+	type: string;
+	details?: Record<string, unknown>;
+};
+
+export function toErrorPayload(err: unknown): ErrorPayload {
+	let actualError = err;
+	if (
+		err &&
+		typeof err === 'object' &&
+		'error' in err &&
+		Object.keys(err).length === 1
+	) {
+		actualError = (err as { error: unknown }).error;
+	}
+
+	const asObj =
+		actualError && typeof actualError === 'object'
+			? (actualError as Record<string, unknown>)
+			: undefined;
+	let message = '';
+	let errorType = 'unknown';
+	const details: Record<string, unknown> = {};
+
+	if (APICallError.isInstance(actualError)) {
+		errorType = 'api_error';
+		message = actualError.message || 'API call failed';
+
+		details.name = actualError.name;
+		details.statusCode = actualError.statusCode;
+		details.url = actualError.url;
+		details.isRetryable = actualError.isRetryable;
+
+		if (actualError.responseBody) {
+			details.responseBody = actualError.responseBody;
+			try {
+				const parsed = JSON.parse(actualError.responseBody);
+				if (parsed.error) {
+					if (typeof parsed.error === 'string') {
+						message = parsed.error;
+					} else if (parsed.error.message) {
+						message = parsed.error.message;
+					}
+				}
+				if (parsed.error?.type) {
+					details.apiErrorType = parsed.error.type;
+				}
+				if (parsed.error?.code) {
+					details.apiErrorCode = parsed.error.code;
+				}
+			} catch {}
+		}
+
+		if (actualError.requestBodyValues) {
+			details.requestBodyValues = actualError.requestBodyValues;
+		}
+
+		if (actualError.responseHeaders) {
+			details.responseHeaders = actualError.responseHeaders;
+		}
+
+		if (actualError.cause) {
+			const cause = actualError.cause as Record<string, unknown> | undefined;
+			details.cause = {
+				message: typeof cause?.message === 'string' ? cause.message : undefined,
+				code: cause?.code,
+				status: cause?.status ?? cause?.statusCode,
+			};
+		}
+
+		return { message, type: errorType, details };
+	}
+
+	if (
+		asObj &&
+		'type' in asObj &&
+		asObj.type === 'error' &&
+		'error' in asObj &&
+		typeof asObj.error === 'object' &&
+		asObj.error
+	) {
+		const errorObj = asObj.error as Record<string, unknown>;
+
+		if (typeof errorObj.message === 'string') {
+			message = errorObj.message;
+		}
+		if (typeof errorObj.type === 'string') {
+			errorType = errorObj.type;
+			details.errorType = errorObj.type;
+		}
+		if (typeof errorObj.code === 'string') {
+			details.code = errorObj.code;
+		}
+		if ('param' in errorObj) {
+			details.param = errorObj.param;
+		}
+
+		return { message, type: errorType, details };
+	}
+
+	if (asObj) {
+		if ('name' in asObj && typeof asObj.name === 'string') {
+			errorType = asObj.name;
+			details.name = asObj.name;
+		}
+
+		if ('type' in asObj && typeof asObj.type === 'string') {
+			errorType = asObj.type;
+			details.type = asObj.type;
+		}
+
+		if ('code' in asObj && asObj.code != null) {
+			details.code = asObj.code;
+		}
+
+		if ('status' in asObj && asObj.status != null) {
+			details.status = asObj.status;
+		}
+
+		if ('statusCode' in asObj && asObj.statusCode != null) {
+			details.statusCode = asObj.statusCode;
+		}
+	}
+
+	if (asObj && typeof asObj.message === 'string' && asObj.message) {
+		message = asObj.message;
+	} else if (typeof actualError === 'string') {
+		message = actualError;
+	} else if (asObj && typeof asObj.error === 'string' && asObj.error) {
+		message = asObj.error;
+	} else if (
+		asObj &&
+		typeof asObj.responseBody === 'string' &&
+		asObj.responseBody
+	) {
+		details.responseBody = asObj.responseBody;
+		try {
+			const parsed = JSON.parse(asObj.responseBody);
+			if (parsed.error) {
+				if (typeof parsed.error === 'string') {
+					message = parsed.error;
+				} else if (typeof parsed.error.message === 'string') {
+					message = parsed.error.message;
+				} else {
+					message = asObj.responseBody;
+				}
+			} else {
+				message = asObj.responseBody;
+			}
+		} catch {
+			message = asObj.responseBody;
+		}
+	} else if (asObj?.statusCode && asObj.url) {
+		message = `HTTP ${String(asObj.statusCode)} error at ${String(asObj.url)}`;
+		details.url = asObj.url;
+	} else if (asObj?.name) {
+		message = String(asObj.name);
+	} else {
+		message = 'An error occurred';
+	}
+
+	if (asObj) {
+		if ('url' in asObj) details.url = asObj.url;
+		if ('isRetryable' in asObj) details.isRetryable = asObj.isRetryable;
+		if ('data' in asObj) details.data = asObj.data;
+
+		if (asObj.cause) {
+			const c = asObj.cause as Record<string, unknown> | undefined;
+			details.cause = {
+				message: typeof c?.message === 'string' ? c.message : undefined,
+				code: c?.code,
+				status: c?.status ?? c?.statusCode,
+			};
+		}
+
+		if (
+			(asObj as { response?: { status?: unknown; statusText?: unknown } })
+				?.response?.status
+		) {
+			details.response = {
+				status: (
+					asObj as { response?: { status?: unknown; statusText?: unknown } }
+				).response?.status,
+				statusText: (
+					asObj as { response?: { status?: unknown; statusText?: unknown } }
+				).response?.statusText,
+			};
+		}
+	}
+
+	return {
+		message,
+		type: errorType,
+		details: Object.keys(details).length ? details : undefined,
+	};
+}

package/src/runtime/message/compaction-auto.ts

@@ -0,0 +1,154 @@
+import type { getDb } from '@ottocode/database';
+import { messageParts } from '@ottocode/database/schema';
+import { eq } from 'drizzle-orm';
+import { streamText } from 'ai';
+import { resolveModel } from '../provider/index.ts';
+import { getAuth } from '@ottocode/sdk';
+import { loadConfig } from '@ottocode/sdk';
+import { debugLog } from '../debug/index.ts';
+import { getModelLimits } from './compaction-limits.ts';
+import { buildCompactionContext } from './compaction-context.ts';
+import { getCompactionSystemPrompt } from './compaction-detect.ts';
+import { markSessionCompacted } from './compaction-mark.ts';
+import { detectOAuth, adaptSimpleCall } from '../provider/oauth-adapter.ts';
+
+export async function performAutoCompaction(
+	db: Awaited<ReturnType<typeof getDb>>,
+	sessionId: string,
+	assistantMessageId: string,
+	publishFn: (event: {
+		type: string;
+		sessionId: string;
+		payload: Record<string, unknown>;
+	}) => void,
+	provider: string,
+	modelId: string,
+): Promise<{
+	success: boolean;
+	summary?: string;
+	error?: string;
+	compactMessageId?: string;
+}> {
+	debugLog(`[compaction] Starting auto-compaction for session ${sessionId}`);
+
+	try {
+		const limits = getModelLimits(provider, modelId);
+		const contextTokenLimit = limits
+			? Math.max(Math.floor(limits.context * 0.5), 15000)
+			: 15000;
+		debugLog(
+			`[compaction] Model ${modelId} context limit: ${limits?.context ?? 'unknown'}, using ${contextTokenLimit} tokens for compaction`,
+		);
+
+		const context = await buildCompactionContext(
+			db,
+			sessionId,
+			contextTokenLimit,
+		);
+		if (!context || context.length < 100) {
+			debugLog('[compaction] Not enough context to compact');
+			return { success: false, error: 'Not enough context to compact' };
+		}
+
+		const cfg = await loadConfig();
+		debugLog(
+			`[compaction] Using session model ${provider}/${modelId} for auto-compaction`,
+		);
+
+		const auth = await getAuth(
+			provider as Parameters<typeof getAuth>[0],
+			cfg.projectRoot,
+		);
+		const oauth = detectOAuth(provider, auth);
+
+		debugLog(
+			`[compaction] OAuth: needsSpoof=${oauth.needsSpoof}, isOpenAIOAuth=${oauth.isOpenAIOAuth}`,
+		);
+
+		const model = await resolveModel(
+			provider as Parameters<typeof resolveModel>[0],
+			modelId,
+			cfg,
+		);
+
+		const compactionPrompt = getCompactionSystemPrompt();
+		const userContent = `IMPORTANT: Generate a comprehensive summary. This will replace the detailed conversation history.\n\nPlease summarize this conversation:\n\n<conversation-to-summarize>\n${context}\n</conversation-to-summarize>`;
+
+		const adapted = adaptSimpleCall(oauth, {
+			instructions: compactionPrompt,
+			userContent,
+			maxOutputTokens: 2000,
+		});
+
+		const compactPartId = crypto.randomUUID();
+		const now = Date.now();
+
+		await db.insert(messageParts).values({
+			id: compactPartId,
+			messageId: assistantMessageId,
+			index: 0,
+			stepIndex: 0,
+			type: 'text',
+			content: JSON.stringify({ text: '' }),
+			agent: 'system',
+			provider: provider,
+			model: modelId,
+			startedAt: now,
+		});
+
+		const result = streamText({
+			model,
+			system: adapted.system,
+			messages: adapted.messages,
+			maxOutputTokens: adapted.maxOutputTokens,
+			providerOptions: adapted.providerOptions,
+		});
+
+		let summary = '';
+		for await (const chunk of result.textStream) {
+			summary += chunk;
+
+			publishFn({
+				type: 'message.part.delta',
+				sessionId,
+				payload: {
+					messageId: assistantMessageId,
+					partId: compactPartId,
+					stepIndex: 0,
+					type: 'text',
+					delta: chunk,
+				},
+			});
+		}
+
+		await db
+			.update(messageParts)
+			.set({
+				content: JSON.stringify({ text: summary }),
+				completedAt: Date.now(),
+			})
+			.where(eq(messageParts.id, compactPartId));
+
+		if (!summary || summary.length < 50) {
+			debugLog('[compaction] Failed to generate summary');
+			return { success: false, error: 'Failed to generate summary' };
+		}
+
+		debugLog(`[compaction] Generated summary: ${summary.slice(0, 100)}...`);
+
+		const compactResult = await markSessionCompacted(
+			db,
+			sessionId,
+			assistantMessageId,
+		);
+		debugLog(
+			`[compaction] Marked ${compactResult.compacted} parts as compacted, saved ~${compactResult.saved} tokens`,
+		);
+
+		return { success: true, summary, compactMessageId: assistantMessageId };
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : String(err);
+		debugLog(`[compaction] Auto-compaction failed: ${errorMsg}`);
+		return { success: false, error: errorMsg };
+	}
+}