@ottocode/server 0.1.237 → 0.1.242

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.237",
+	"version": "0.1.242",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -49,8 +49,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.237",
-		"@ottocode/database": "0.1.237",
+		"@ottocode/sdk": "0.1.242",
+		"@ottocode/database": "0.1.242",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.3.6"

package/src/index.ts

@@ -25,10 +25,14 @@ import { registerProviderUsageRoutes } from './routes/provider-usage.ts';
 import { registerDoctorRoutes } from './routes/doctor.ts';
 import { registerSkillsRoutes } from './routes/skills.ts';
 import type { AgentConfigEntry } from './runtime/agent/registry.ts';
+import { installAiSdkWarningHandler } from './runtime/ai-sdk-warnings.ts';
 
 const globalTerminalManager = new TerminalManager();
 setTerminalManager(globalTerminalManager);
 
+// Suppress noisy AI SDK provider warnings unless debug mode is enabled.
+installAiSdkWarningHandler();
+
 function initApp() {
 	const app = new Hono();
 
@@ -190,8 +194,9 @@ export type EmbeddedAppConfig = {
 		provider?: ProviderId;
 		model?: string;
 		agent?: string;
-		toolApproval?: 'auto' | 'dangerous' | 'all';
+		toolApproval?: 'auto' | 'dangerous' | 'all' | 'yolo';
 		fullWidthContent?: boolean;
+		autoCompactThresholdTokens?: number | null;
 	};
 	/** Additional CORS origins for proxies/Tailscale (e.g., ['https://myapp.ts.net', 'https://example.com']) */
 	corsOrigins?: string[];
@@ -305,3 +310,6 @@ export { logger } from '@ottocode/sdk';
 
 // Export server state management
 export { setServerPort, getServerPort, getServerInfo } from './state.ts';
+
+// Export WebSocket handler for Bun.serve()
+export { websocket as bunWebSocket } from './ws.ts';

package/src/openapi/paths/config.ts

@@ -179,6 +179,10 @@ export const configPaths = {
 								provider: { type: 'string' },
 								model: { type: 'string' },
 								fullWidthContent: { type: 'boolean' },
+								autoCompactThresholdTokens: {
+									type: 'integer',
+									nullable: true,
+								},
 								reasoningText: { type: 'boolean' },
 								reasoningLevel: {
 									type: 'string',
@@ -210,6 +214,10 @@ export const configPaths = {
 											provider: { type: 'string' },
 											model: { type: 'string' },
 											fullWidthContent: { type: 'boolean' },
+											autoCompactThresholdTokens: {
+												type: 'integer',
+												nullable: true,
+											},
 											reasoningText: { type: 'boolean' },
 											reasoningLevel: {
 												type: 'string',

package/src/openapi/schemas.ts

@@ -197,6 +197,7 @@ export const schemas = {
 					provider: { $ref: '#/components/schemas/Provider' },
 					model: { type: 'string' },
 					fullWidthContent: { type: 'boolean' },
+					autoCompactThresholdTokens: { type: 'integer', nullable: true },
 					reasoningText: { type: 'boolean' },
 					reasoningLevel: {
 						type: 'string',

package/src/presets.ts

@@ -7,6 +7,9 @@ import AGENT_PLAN from '@ottocode/sdk/prompts/agents/plan.txt' with {
 import AGENT_GENERAL from '@ottocode/sdk/prompts/agents/general.txt' with {
 	type: 'text',
 };
+import AGENT_INIT from '@ottocode/sdk/prompts/agents/init.txt' with {
+	type: 'text',
+};
 import AGENT_RESEARCH from '@ottocode/sdk/prompts/agents/research.txt' with {
 	type: 'text',
 };
@@ -36,6 +39,10 @@ export const BUILTIN_AGENTS = {
 		prompt: AGENT_GENERAL,
 		tools: defaultToolsForAgent('general'),
 	},
+	init: {
+		prompt: AGENT_INIT,
+		tools: defaultToolsForAgent('init'),
+	},
 	research: {
 		prompt: AGENT_RESEARCH,
 		tools: defaultToolsForAgent('research'),

package/src/routes/config/agents.ts

@@ -17,7 +17,7 @@ export function registerAgentsRoute(app: Hono) {
 			if (embeddedConfig) {
 				const agents = embeddedConfig.agents
 					? Object.keys(embeddedConfig.agents)
-					: ['general', 'build', 'plan'];
+					: ['general', 'build', 'plan', 'init'];
 				return c.json({
 					agents,
 					default: getDefault(

package/src/routes/config/defaults.ts

@@ -16,12 +16,13 @@ export function registerDefaultsRoute(app: Hono) {
 				agent?: string;
 				provider?: string;
 				model?: string;
-				toolApproval?: 'auto' | 'dangerous' | 'all';
+				toolApproval?: 'auto' | 'dangerous' | 'all' | 'yolo';
 				guidedMode?: boolean;
 				reasoningText?: boolean;
 				reasoningLevel?: ReasoningLevel;
 				theme?: string;
 				fullWidthContent?: boolean;
+				autoCompactThresholdTokens?: number | null;
 				scope?: 'global' | 'local';
 			}>();
 
@@ -30,12 +31,13 @@ export function registerDefaultsRoute(app: Hono) {
 				agent: string;
 				provider: ProviderId;
 				model: string;
-				toolApproval: 'auto' | 'dangerous' | 'all';
+				toolApproval: 'auto' | 'dangerous' | 'all' | 'yolo';
 				guidedMode: boolean;
 				reasoningText: boolean;
 				reasoningLevel: ReasoningLevel;
 				theme: string;
 				fullWidthContent: boolean;
+				autoCompactThresholdTokens: number | null;
 			}> = {};
 
 			if (body.agent) updates.agent = body.agent;
@@ -49,6 +51,14 @@ export function registerDefaultsRoute(app: Hono) {
 			if (body.theme) updates.theme = body.theme;
 			if (body.fullWidthContent !== undefined)
 				updates.fullWidthContent = body.fullWidthContent;
+			if (body.autoCompactThresholdTokens !== undefined) {
+				const threshold = body.autoCompactThresholdTokens;
+				if (threshold === null) {
+					updates.autoCompactThresholdTokens = null;
+				} else if (Number.isFinite(threshold) && threshold > 0) {
+					updates.autoCompactThresholdTokens = Math.floor(threshold);
+				}
+			}
 
 			await setConfig(scope, updates, projectRoot);
 

package/src/routes/config/main.ts

@@ -58,7 +58,7 @@ export function registerMainConfigRoute(app: Hono) {
 					undefined,
 					embeddedConfig?.defaults?.toolApproval,
 					cfg.defaults.toolApproval,
-				) as 'auto' | 'dangerous' | 'all',
+				) as 'auto' | 'dangerous' | 'all' | 'yolo',
 				guidedMode: cfg.defaults.guidedMode ?? false,
 				reasoningText: cfg.defaults.reasoningText ?? true,
 				reasoningLevel: cfg.defaults.reasoningLevel ?? 'high',
@@ -69,6 +69,12 @@ export function registerMainConfigRoute(app: Hono) {
 						embeddedConfig?.defaults?.fullWidthContent,
 						cfg.defaults.fullWidthContent,
 					) ?? false,
+				autoCompactThresholdTokens:
+					getDefault(
+						undefined,
+						embeddedConfig?.defaults?.autoCompactThresholdTokens,
+						cfg.defaults.autoCompactThresholdTokens,
+					) ?? null,
 			};
 
 			return c.json({

package/src/routes/config/utils.ts

@@ -72,7 +72,7 @@ export async function getAuthTypeForProvider(
 export async function discoverAllAgents(
 	projectRoot: string,
 ): Promise<string[]> {
-	const builtInAgents = ['general', 'build', 'plan'];
+	const builtInAgents = ['general', 'build', 'plan', 'init'];
 	const agentSet = new Set<string>(builtInAgents);
 
 	try {

package/src/routes/terminals.ts

@@ -3,6 +3,7 @@ import type { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import type { TerminalManager } from '@ottocode/sdk';
 import { logger } from '@ottocode/sdk';
+import { upgradeWebSocket } from '../ws.ts';
 
 export function registerTerminalsRoutes(
 	app: Hono,
@@ -67,6 +68,99 @@ export function registerTerminalsRoutes(
 		return c.json({ terminal: terminal.toJSON() });
 	});
 
+	app.get(
+		'/v1/terminals/:id/ws',
+		upgradeWebSocket((c) => {
+			const id = c.req.param('id');
+
+			let onData: ((data: string) => void) | null = null;
+			let onExit: ((exitCode: number) => void) | null = null;
+
+			return {
+				onOpen(_event, ws) {
+					const terminal = terminalManager.get(id);
+					if (!terminal) {
+						ws.close(4004, 'Terminal not found');
+						return;
+					}
+
+					const history = terminal.read();
+					for (const chunk of history) {
+						ws.send(chunk);
+					}
+
+					onData = (data: string) => {
+						try {
+							ws.send(data);
+						} catch {
+							// ws may be closed
+						}
+					};
+
+					onExit = (exitCode: number) => {
+						try {
+							ws.send(JSON.stringify({ type: 'exit', exitCode }));
+							ws.close(1000, 'Process exited');
+						} catch {
+							// ws may already be closed
+						}
+					};
+
+					terminal.onData(onData);
+					terminal.onExit(onExit);
+
+					if (terminal.status === 'exited') {
+						onExit(terminal.exitCode ?? 0);
+					}
+				},
+				onMessage(event, _ws) {
+					const terminal = terminalManager.get(id);
+					if (!terminal) return;
+
+					const raw = event.data;
+					const message =
+						typeof raw === 'string'
+							? raw
+							: raw instanceof ArrayBuffer
+								? new TextDecoder().decode(raw)
+								: String(raw);
+
+					if (message.startsWith('{')) {
+						try {
+							const msg = JSON.parse(message);
+							if (msg.type === 'resize' && msg.cols > 0 && msg.rows > 0) {
+								terminal.resize(msg.cols, msg.rows);
+								return;
+							}
+						} catch {
+							// not JSON, treat as input
+						}
+					}
+
+					terminal.write(message);
+				},
+				onClose() {
+					const terminal = terminalManager.get(id);
+					if (terminal) {
+						if (onData) terminal.removeDataListener(onData);
+						if (onExit) terminal.removeExitListener(onExit);
+					}
+					onData = null;
+					onExit = null;
+				},
+				onError() {
+					const terminal = terminalManager.get(id);
+					if (terminal) {
+						if (onData) terminal.removeDataListener(onData);
+						if (onExit) terminal.removeExitListener(onExit);
+					}
+					onData = null;
+					onExit = null;
+				},
+			};
+		}),
+	);
+
 	const handleTerminalOutput = async (c: Context) => {
 		const id = c.req.param('id');
 		const terminal = terminalManager.get(id);

package/src/runtime/agent/registry.ts

@@ -14,6 +14,10 @@ import AGENT_PLAN from '@ottocode/sdk/prompts/agents/plan.txt' with {
 import AGENT_GENERAL from '@ottocode/sdk/prompts/agents/general.txt' with {
 	type: 'text',
 };
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import AGENT_INIT from '@ottocode/sdk/prompts/agents/init.txt' with {
+	type: 'text',
+};
 import AGENT_RESEARCH from '@ottocode/sdk/prompts/agents/research.txt' with {
 	type: 'text',
 };
@@ -144,6 +148,22 @@ const defaultToolExtras: Record<string, string[]> = {
 		'websearch',
 		'update_todos',
 	],
+	init: [
+		'read',
+		'edit',
+		'multiedit',
+		'write',
+		'ls',
+		'tree',
+		'bash',
+		'update_todos',
+		'glob',
+		'ripgrep',
+		'git_status',
+		'terminal',
+		'apply_patch',
+		'websearch',
+	],
 	git: ['git_status', 'git_diff', 'git_commit', 'read', 'ls'],
 	commit: ['git_status', 'git_diff', 'git_commit', 'read', 'ls'],
 	research: [
@@ -308,6 +328,7 @@ export async function resolveAgentConfig(
 			if (n === 'build') return AGENT_BUILD;
 			if (n === 'plan') return AGENT_PLAN;
 			if (n === 'general') return AGENT_GENERAL;
+			if (n === 'init') return AGENT_INIT;
 			if (n === 'research') return AGENT_RESEARCH;
 			return undefined;
 		};

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

@@ -9,6 +9,10 @@ export type ReasoningState = {
 	partId: string;
 	text: string;
 	providerMetadata?: unknown;
+	persisted: boolean;
+	opts: RunOpts;
+	sharedCtx: ToolAdapterContext;
+	getStepIndex: () => number;
 };
 
 export function serializeReasoningContent(state: ReasoningState): string {
@@ -23,7 +27,7 @@ export async function handleReasoningStart(
 	reasoningId: string,
 	providerMetadata: unknown,
 	opts: RunOpts,
-	db: Awaited<ReturnType<typeof getDb>>,
+	_db: Awaited<ReturnType<typeof getDb>>,
 	sharedCtx: ToolAdapterContext,
 	getStepIndex: () => number,
 	reasoningStates: Map<string, ReasoningState>,
@@ -33,21 +37,33 @@ export async function handleReasoningStart(
 		partId: reasoningPartId,
 		text: '',
 		providerMetadata,
+		persisted: false,
+		opts,
+		sharedCtx,
+		getStepIndex,
 	};
 	reasoningStates.set(reasoningId, state);
+}
+
+async function persistReasoningPart(
+	state: ReasoningState,
+	db: Awaited<ReturnType<typeof getDb>>,
+): Promise<void> {
+	if (state.persisted) return;
 	try {
 		await db.insert(messageParts).values({
-			id: reasoningPartId,
-			messageId: opts.assistantMessageId,
-			index: await sharedCtx.nextIndex(),
-			stepIndex: getStepIndex(),
+			id: state.partId,
+			messageId: state.opts.assistantMessageId,
+			index: await state.sharedCtx.nextIndex(),
+			stepIndex: state.getStepIndex(),
 			type: 'reasoning',
 			content: serializeReasoningContent(state),
-			agent: opts.agent,
-			provider: opts.provider,
-			model: opts.model,
+			agent: state.opts.agent,
+			provider: state.opts.provider,
+			model: state.opts.model,
 			startedAt: Date.now(),
 		});
+		state.persisted = true;
 	} catch {}
 }
 
@@ -66,6 +82,14 @@ export async function handleReasoningDelta(
 	if (providerMetadata != null) {
 		state.providerMetadata = providerMetadata;
 	}
+
+	// Skip empty-text updates (e.g. Anthropic signature_delta from adaptive
+	// thinking emits reasoning-delta with `text: ""`). Publishing/persisting
+	// these would create an empty reasoning placeholder shown as `{"text":""}`.
+	if (!text) return;
+
+	await persistReasoningPart(state, db);
+
 	publish({
 		type: 'reasoning.delta',
 		sessionId: opts.sessionId,
@@ -92,9 +116,11 @@ export async function handleReasoningEnd(
 	const state = reasoningStates.get(reasoningId);
 	if (!state) return;
 	if (!state.text || state.text.trim() === '') {
-		try {
-			await db.delete(messageParts).where(eq(messageParts.id, state.partId));
-		} catch {}
+		if (state.persisted) {
+			try {
+				await db.delete(messageParts).where(eq(messageParts.id, state.partId));
+			} catch {}
+		}
 		reasoningStates.delete(reasoningId);
 		return;
 	}

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

@@ -1,4 +1,9 @@
-import { loadConfig, logger, getSessionSystemPromptPath } from '@ottocode/sdk';
+import {
+	loadConfig,
+	logger,
+	getSessionSystemPromptPath,
+	getModelFamily,
+} from '@ottocode/sdk';
 import { wrapLanguageModel } from 'ai';
 import { devToolsMiddleware } from '@ai-sdk/devtools';
 import { getDb } from '@ottocode/database';
@@ -74,6 +79,33 @@ export function mergeProviderOptions(
 	return base;
 }
 
+const EDITING_TOOL_NAMES = ['edit', 'multiedit', 'write', 'apply_patch'];
+const MODEL_FAMILY_EDIT_TOOL_POLICY_AGENTS = new Set([
+	'build',
+	'general',
+	'init',
+]);
+
+export function applyModelFamilyEditToolPolicy(
+	agent: string,
+	tools: string[],
+	provider: RunOpts['provider'],
+	model: string,
+): string[] {
+	if (!MODEL_FAMILY_EDIT_TOOL_POLICY_AGENTS.has(agent)) return tools;
+
+	const family = getModelFamily(provider, model);
+	const next = tools.filter(
+		(toolName) => !EDITING_TOOL_NAMES.includes(toolName),
+	);
+	const preferredEditingTools =
+		family === 'anthropic' || family === 'openai'
+			? ['write', 'apply_patch']
+			: ['write', 'edit', 'multiedit'];
+
+	return Array.from(new Set([...next, ...preferredEditingTools]));
+}
+
 export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const cfgTimer = time('runner:loadConfig+db');
 	const cfg = await loadConfig(opts.projectRoot);
@@ -88,7 +120,7 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 
 	const historyTimer = time('runner:buildHistory');
 	let history: Awaited<ReturnType<typeof buildHistoryMessages>>;
-	if (opts.isCompactCommand && opts.compactionContext) {
+	if (opts.omitHistory || (opts.isCompactCommand && opts.compactionContext)) {
 		history = [];
 	} else {
 		history = await buildHistoryMessages(
@@ -218,6 +250,10 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		});
 	}
 
+	if (opts.additionalPromptMessages?.length) {
+		additionalSystemMessages.push(...opts.additionalPromptMessages);
+	}
+
 	const toolsTimer = time('runner:discoverTools');
 	const discovered = await discoverProjectTools(cfg.projectRoot);
 	const allTools = discovered.tools;
@@ -236,7 +272,13 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	toolsTimer.end({
 		count: allTools.length + Object.keys(mcpToolsRecord).length,
 	});
-	const allowedNames = new Set([...(agentCfg.tools || []), 'finish']);
+	const allowedToolNames = applyModelFamilyEditToolPolicy(
+		agentCfg.name,
+		agentCfg.tools || [],
+		opts.provider,
+		opts.model,
+	);
+	const allowedNames = new Set([...allowedToolNames, 'finish']);
 	const gated = allTools.filter(
 		(tool) => allowedNames.has(tool.name) || tool.name === 'load_mcp_tools',
 	);

package/src/runtime/agent/runner.ts

@@ -1,5 +1,6 @@
 import { hasToolCall, streamText } from 'ai';
-import { messageParts } from '@ottocode/database/schema';
+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';
@@ -22,7 +23,11 @@ import {
 	createAbortHandler,
 	createFinishHandler,
 } from '../stream/handlers.ts';
-import { pruneSession } from '../message/compaction.ts';
+import {
+	pruneSession,
+	getModelLimits,
+	shouldAutoCompactBeforeOverflow,
+} from '../message/compaction.ts';
 import { triggerDeferredTitleGeneration } from '../message/service.ts';
 import { setupRunner } from './runner-setup.ts';
 import {
@@ -75,6 +80,28 @@ function summarizeTraceValue(value: unknown, max = 160): string {
 	return fallback.length > max ? `${fallback.slice(0, max)}…` : fallback;
 }
 
+async function shouldPreemptivelyAutoCompact(
+	db: Awaited<ReturnType<typeof getDb>>,
+	opts: RunOpts,
+	threshold: number | null | undefined,
+): Promise<boolean> {
+	const limits = getModelLimits(opts.provider, opts.model);
+	const sessionRows = await db
+		.select({ currentContextTokens: sessions.currentContextTokens })
+		.from(sessions)
+		.where(eq(sessions.id, opts.sessionId))
+		.limit(1);
+
+	return shouldAutoCompactBeforeOverflow({
+		autoCompactThresholdTokens: threshold,
+		modelContextWindow: limits?.context ?? null,
+		currentContextTokens: sessionRows[0]?.currentContextTokens ?? 0,
+		estimatedInputTokens: opts.estimatedInputTokens ?? 0,
+		isCompactCommand: opts.isCompactCommand,
+		compactionRetries: opts.compactionRetries,
+	});
+}
+
 export async function runSessionLoop(sessionId: string) {
 	setRunning(sessionId, true);
 
@@ -332,6 +359,22 @@ async function runAssistant(opts: RunOpts) {
 		runSessionLoop,
 	);
 
+	if (
+		await shouldPreemptivelyAutoCompact(
+			db,
+			opts,
+			cfg.defaults.autoCompactThresholdTokens,
+		)
+	) {
+		const autoCompactError = Object.assign(
+			new Error('Configured auto-compaction threshold reached'),
+			{ code: 'context_length_exceeded' },
+		);
+		await onError(autoCompactError);
+		unsubscribeFinish();
+		return;
+	}
+
 	const baseOnAbort = createAbortHandler(opts, db, getStepIndex, sharedCtx);
 	const onAbort = async (event: Parameters<typeof baseOnAbort>[0]) => {
 		_abortedByUser = true;

package/src/runtime/ai-sdk-warnings.ts

@@ -0,0 +1,70 @@
+/**
+ * AI SDK warning handler.
+ *
+ * The AI SDK logs provider warnings (e.g. unsupported features like
+ * `maxOutputTokens` caps) to the console via `globalThis.AI_SDK_LOG_WARNINGS`.
+ * These warnings are noisy during normal operation. We suppress them by
+ * default and only surface them when debug mode is enabled.
+ *
+ * See: https://ai-sdk.dev (AI_SDK_LOG_WARNINGS global)
+ */
+
+import { isDebugEnabled } from './debug/state.ts';
+
+type AiSdkWarning =
+	| { type: 'unsupported'; feature: string; details?: string }
+	| { type: 'compatibility'; feature: string; details?: string }
+	| { type: 'other'; message: string };
+
+type LogWarningsOptions = {
+	warnings: AiSdkWarning[];
+	provider: string;
+	model: string;
+};
+
+function formatWarning(
+	warning: AiSdkWarning,
+	provider: string,
+	model: string,
+): string {
+	const prefix = `AI SDK Warning (${provider} / ${model}):`;
+	switch (warning.type) {
+		case 'unsupported': {
+			let message = `${prefix} The feature "${warning.feature}" is not supported.`;
+			if (warning.details) message += ` ${warning.details}`;
+			return message;
+		}
+		case 'compatibility': {
+			let message = `${prefix} The feature "${warning.feature}" is used in a compatibility mode.`;
+			if (warning.details) message += ` ${warning.details}`;
+			return message;
+		}
+		case 'other':
+			return `${prefix} ${warning.message}`;
+		default:
+			return `${prefix} ${JSON.stringify(warning)}`;
+	}
+}
+
+let installed = false;
+
+/**
+ * Install a custom AI SDK warning handler that suppresses warnings unless
+ * debug mode is enabled. Safe to call multiple times (installs once).
+ */
+export function installAiSdkWarningHandler(): void {
+	if (installed) return;
+	installed = true;
+
+	(
+		globalThis as unknown as {
+			AI_SDK_LOG_WARNINGS?: ((options: LogWarningsOptions) => void) | false;
+		}
+	).AI_SDK_LOG_WARNINGS = (options: LogWarningsOptions) => {
+		if (!isDebugEnabled()) return;
+		if (!options.warnings?.length) return;
+		for (const warning of options.warnings) {
+			console.warn(formatWarning(warning, options.provider, options.model));
+		}
+	};
+}