@ottocode/server 0.1.260 → 0.1.261

package/src/routes/tunnel.ts

@@ -9,6 +9,7 @@ import {
 	logger,
 } from '@ottocode/sdk';
 import { getServerPort } from '../state.ts';
+import { openApiRoute } from '../openapi/route.ts';
 
 let activeTunnel: OttoTunnel | null = null;
 let tunnelUrl: string | null = null;
@@ -17,143 +18,385 @@ let tunnelError: string | null = null;
 let progressMessage: string | null = null;
 
 export function registerTunnelRoutes(app: Hono) {
-	app.get('/v1/tunnel/status', async (c) => {
-		const binaryInstalled = await isTunnelBinaryInstalled();
-
-		return c.json({
-			status: tunnelStatus,
-			url: tunnelUrl,
-			error: tunnelError,
-			binaryInstalled,
-			isRunning: activeTunnel?.isRunning ?? false,
-		});
-	});
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/tunnel/status',
+			tags: ['tunnel'],
+			operationId: 'getTunnelStatus',
+			summary: 'Get tunnel status',
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									status: {
+										type: 'string',
+										enum: ['idle', 'starting', 'connected', 'error'],
+									},
+									url: {
+										type: 'string',
+										nullable: true,
+									},
+									error: {
+										type: 'string',
+										nullable: true,
+									},
+									binaryInstalled: {
+										type: 'boolean',
+									},
+									isRunning: {
+										type: 'boolean',
+									},
+								},
+								required: ['status', 'binaryInstalled', 'isRunning'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			const binaryInstalled = await isTunnelBinaryInstalled();
 
-	app.post('/v1/tunnel/start', async (c) => {
-		if (activeTunnel?.isRunning) {
 			return c.json({
-				ok: true,
+				status: tunnelStatus,
 				url: tunnelUrl,
-				message: 'Tunnel already running',
+				error: tunnelError,
+				binaryInstalled,
+				isRunning: activeTunnel?.isRunning ?? false,
 			});
-		}
-
-		try {
-			const body = await c.req.json().catch(() => ({}));
-			let port = body.port;
-
-			// Use server's known port if not explicitly provided
-			if (!port) {
-				port = getServerPort() || 9100;
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/tunnel/start',
+			tags: ['tunnel'],
+			operationId: 'startTunnel',
+			summary: 'Start a tunnel',
+			requestBody: {
+				required: false,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								port: {
+									type: 'integer',
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									ok: {
+										type: 'boolean',
+									},
+									url: {
+										type: 'string',
+									},
+									message: {
+										type: 'string',
+									},
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['ok'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			if (activeTunnel?.isRunning) {
+				return c.json({
+					ok: true,
+					url: tunnelUrl,
+					message: 'Tunnel already running',
+				});
 			}
 
-			// Kill any stale tunnel processes first
-			await killStaleTunnels();
+			try {
+				const body = await c.req.json().catch(() => ({}));
+				let port = body.port;
 
-			tunnelStatus = 'starting';
-			tunnelError = null;
-			progressMessage = 'Initializing...';
+				// Use server's known port if not explicitly provided
+				if (!port) {
+					port = getServerPort() || 9100;
+				}
 
-			activeTunnel = new OttoTunnel();
+				// Kill any stale tunnel processes first
+				await killStaleTunnels();
 
-			const url = await activeTunnel.start(port, (msg) => {
-				progressMessage = msg;
-			});
+				tunnelStatus = 'starting';
+				tunnelError = null;
+				progressMessage = 'Initializing...';
 
-			tunnelUrl = url;
-			tunnelStatus = 'connected';
-			progressMessage = null;
+				activeTunnel = new OttoTunnel();
 
-			activeTunnel.on('error', (err) => {
-				logger.error('Tunnel error:', err);
-				tunnelError = err.message;
-				tunnelStatus = 'error';
-			});
+				const url = await activeTunnel.start(port, (msg) => {
+					progressMessage = msg;
+				});
 
-			activeTunnel.on('exit', () => {
-				tunnelStatus = 'idle';
-				tunnelUrl = null;
-				activeTunnel = null;
-			});
+				tunnelUrl = url;
+				tunnelStatus = 'connected';
+				progressMessage = null;
 
-			return c.json({
-				ok: true,
-				url: tunnelUrl,
-				message: 'Tunnel started',
-			});
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			tunnelStatus = 'error';
-			tunnelError = message;
-			progressMessage = null;
-
-			logger.error('Failed to start tunnel:', error);
-			return c.json({ ok: false, error: message }, 500);
-		}
-	});
+				activeTunnel.on('error', (err) => {
+					logger.error('Tunnel error:', err);
+					tunnelError = err.message;
+					tunnelStatus = 'error';
+				});
 
-	app.post('/v1/tunnel/register', async (c) => {
-		try {
-			const body = await c.req.json().catch(() => ({}));
-			const { url } = body;
+				activeTunnel.on('exit', () => {
+					tunnelStatus = 'idle';
+					tunnelUrl = null;
+					activeTunnel = null;
+				});
 
-			if (!url) {
-				return c.json({ ok: false, error: 'URL is required' }, 400);
+				return c.json({
+					ok: true,
+					url: tunnelUrl,
+					message: 'Tunnel started',
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				tunnelStatus = 'error';
+				tunnelError = message;
+				progressMessage = null;
+
+				logger.error('Failed to start tunnel:', error);
+				return c.json({ ok: false, error: message }, 500);
 			}
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/tunnel/register',
+			tags: ['tunnel'],
+			operationId: 'registerTunnel',
+			summary: 'Register an external tunnel URL',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								url: {
+									type: 'string',
+								},
+							},
+							required: ['url'],
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									ok: {
+										type: 'boolean',
+									},
+									url: {
+										type: 'string',
+									},
+									message: {
+										type: 'string',
+									},
+								},
+								required: ['ok'],
+							},
+						},
+					},
+				},
+				'400': {
+					description: 'Bad Request',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const body = await c.req.json().catch(() => ({}));
+				const { url } = body;
+
+				if (!url) {
+					return c.json({ ok: false, error: 'URL is required' }, 400);
+				}
 
-			tunnelUrl = url;
-			tunnelStatus = 'connected';
-			tunnelError = null;
-			progressMessage = null;
+				tunnelUrl = url;
+				tunnelStatus = 'connected';
+				tunnelError = null;
+				progressMessage = null;
 
-			return c.json({
-				ok: true,
-				url: tunnelUrl,
-				message: 'External tunnel registered',
-			});
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			logger.error('Failed to register external tunnel:', error);
-			return c.json({ ok: false, error: message }, 500);
-		}
-	});
+				return c.json({
+					ok: true,
+					url: tunnelUrl,
+					message: 'External tunnel registered',
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				logger.error('Failed to register external tunnel:', error);
+				return c.json({ ok: false, error: message }, 500);
+			}
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/tunnel/stop',
+			tags: ['tunnel'],
+			operationId: 'stopTunnel',
+			summary: 'Stop the tunnel',
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									ok: {
+										type: 'boolean',
+									},
+									message: {
+										type: 'string',
+									},
+								},
+								required: ['ok'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			if (!activeTunnel) {
+				return c.json({ ok: true, message: 'No tunnel running' });
+			}
 
-	app.post('/v1/tunnel/stop', async (c) => {
-		if (!activeTunnel) {
-			return c.json({ ok: true, message: 'No tunnel running' });
-		}
-
-		try {
-			activeTunnel.stop();
-			activeTunnel = null;
-			tunnelUrl = null;
-			tunnelStatus = 'idle';
-			tunnelError = null;
-
-			return c.json({ ok: true, message: 'Tunnel stopped' });
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			return c.json({ ok: false, error: message }, 500);
-		}
-	});
+			try {
+				activeTunnel.stop();
+				activeTunnel = null;
+				tunnelUrl = null;
+				tunnelStatus = 'idle';
+				tunnelError = null;
 
-	app.get('/v1/tunnel/qr', async (c) => {
-		if (!tunnelUrl) {
-			return c.json({ ok: false, error: 'No tunnel URL available' }, 400);
-		}
+				return c.json({ ok: true, message: 'Tunnel stopped' });
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return c.json({ ok: false, error: message }, 500);
+			}
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/tunnel/qr',
+			tags: ['tunnel'],
+			operationId: 'getTunnelQR',
+			summary: 'Get QR code for tunnel URL',
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									ok: {
+										type: 'boolean',
+									},
+									url: {
+										type: 'string',
+									},
+									qrCode: {
+										type: 'string',
+									},
+								},
+								required: ['ok'],
+							},
+						},
+					},
+				},
+				'400': {
+					description: 'Bad Request',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			if (!tunnelUrl) {
+				return c.json({ ok: false, error: 'No tunnel URL available' }, 400);
+			}
 
-		try {
-			const qrCode = await generateQRCode(tunnelUrl);
-			return c.json({
-				ok: true,
-				url: tunnelUrl,
-				qrCode,
-			});
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			return c.json({ ok: false, error: message }, 500);
-		}
-	});
+			try {
+				const qrCode = await generateQRCode(tunnelUrl);
+				return c.json({
+					ok: true,
+					url: tunnelUrl,
+					qrCode,
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return c.json({ ok: false, error: message }, 500);
+			}
+		},
+	);
 
 	const handleTunnelStream = async (c: Context) => {
 		return streamSSE(c as Context, async (stream) => {
@@ -200,8 +443,41 @@ export function registerTunnelRoutes(app: Hono) {
 		});
 	};
 
-	app.get('/v1/tunnel/stream', handleTunnelStream);
-	app.post('/v1/tunnel/stream', handleTunnelStream);
+	const tunnelStreamRoute = {
+		tags: ['tunnel'],
+		summary: 'Subscribe to tunnel status stream',
+		responses: {
+			'200': {
+				description: 'SSE stream of tunnel status updates',
+				content: {
+					'text/event-stream': {
+						schema: { type: 'string' },
+					},
+				},
+			},
+		},
+	};
+
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/tunnel/stream',
+			operationId: 'subscribeTunnelStream',
+			...tunnelStreamRoute,
+		},
+		handleTunnelStream,
+	);
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/tunnel/stream',
+			operationId: 'subscribeTunnelStreamPost',
+			...tunnelStreamRoute,
+		},
+		handleTunnelStream,
+	);
 }
 
 export function stopActiveTunnel() {

package/src/runtime/ask/service.ts

@@ -155,6 +155,7 @@ async function processAskRequest(
 
 		if (request.credentials) {
 			for (const [provider, creds] of Object.entries(request.credentials)) {
+				if (!creds) continue;
 				const envKey =
 					providerEnvVar(provider as ProviderId) ??
 					`${provider.toUpperCase()}_API_KEY`;

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

@@ -1,5 +1,5 @@
 import { catalog, getModelInfo } from '@ottocode/sdk';
-import type { ProviderId } from '@ottocode/sdk';
+import type { BuiltInProviderId, ProviderId } from '@ottocode/sdk';
 
 export const PRUNE_PROTECT = 40_000;
 
@@ -60,9 +60,9 @@ export function getModelLimits(
 	if (info?.limit?.context && info?.limit?.output) {
 		return { context: info.limit.context, output: info.limit.output };
 	}
-	for (const key of Object.keys(catalog) as ProviderId[]) {
+	for (const key of Object.keys(catalog) as BuiltInProviderId[]) {
 		const entry = catalog[key];
-		const m = entry?.models?.find((x) => x.id === model);
+		const m = entry?.models?.find((x: { id: string }) => x.id === model);
 		if (m?.limit?.context && m?.limit?.output) {
 			return { context: m.limit.context, output: m.limit.output };
 		}

package/src/runtime/provider/reasoning.ts

@@ -4,6 +4,7 @@ import {
 	getProviderDefinition,
 	getModelNpmBinding,
 	getUnderlyingProviderKey,
+	isBuiltInProviderId,
 	modelSupportsReasoning,
 	type OttoConfig,
 	type ProviderId,
@@ -118,7 +119,7 @@ function getOpenAICompatibleProviderOptionKeys(
 	cfg?: OttoConfig,
 ): string[] {
 	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
-	const entry = catalog[provider];
+	const entry = isBuiltInProviderId(provider) ? catalog[provider] : undefined;
 	const keys = new Set<string>(['openaiCompatible', toCamelCaseKey(provider)]);
 	const label = definition?.label ?? entry?.label;
 	if (label) {

package/src/runtime/session/db-operations.ts

@@ -1,7 +1,7 @@
 import type { getDb } from '@ottocode/database';
 import { messages, messageParts, sessions } from '@ottocode/database/schema';
 import { eq } from 'drizzle-orm';
-import { catalog, type ProviderId } from '@ottocode/sdk';
+import { catalog, isBuiltInProviderId, type ProviderId } from '@ottocode/sdk';
 import type { RunOpts } from './queue.ts';
 
 export type UsageData = {
@@ -77,10 +77,11 @@ export function resolveUsageProvider(
 	) {
 		return provider;
 	}
-	const entry = catalog[provider];
+	const entry = isBuiltInProviderId(provider) ? catalog[provider] : undefined;
 	const normalizedModel = model.includes('/') ? model.split('/').at(-1) : model;
 	const modelEntry = entry?.models.find(
-		(m) => m.id?.toLowerCase() === normalizedModel?.toLowerCase(),
+		(m: { id?: string }) =>
+			m.id?.toLowerCase() === normalizedModel?.toLowerCase(),
 	);
 	const npm = modelEntry?.provider?.npm ?? '';
 	if (npm.includes('openai')) return 'openai';

package/src/runtime/utils/token.ts

@@ -1,4 +1,4 @@
-import { catalog } from '@ottocode/sdk';
+import { catalog, isBuiltInProviderId } from '@ottocode/sdk';
 import type { ProviderName } from '../provider/index.ts';
 
 /**
@@ -13,11 +13,16 @@ export function getMaxOutputTokens(
 		return undefined;
 	}
 	try {
+		if (!isBuiltInProviderId(provider)) {
+			return undefined;
+		}
 		const providerCatalog = catalog[provider];
 		if (!providerCatalog) {
 			return undefined;
 		}
-		const modelInfo = providerCatalog.models.find((m) => m.id === modelId);
+		const modelInfo = providerCatalog.models.find(
+			(m: { id: string }) => m.id === modelId,
+		);
 		if (!modelInfo) {
 			return undefined;
 		}

package/src/tools/adapter.ts

@@ -530,6 +530,27 @@ export function adaptTools(
 									streamedResult = (chunk as { result: unknown }).result;
 									continue;
 								}
+								if (
+									chunk &&
+									typeof chunk === 'object' &&
+									'terminalId' in chunk &&
+									typeof (chunk as { terminalId?: unknown }).terminalId ===
+										'string'
+								) {
+									publish({
+										type: 'tool.delta',
+										sessionId: ctx.sessionId,
+										payload: {
+											name,
+											channel: 'terminal',
+											delta: (chunk as { terminalId: string }).terminalId,
+											stepIndex: stepIndexForEvent,
+											callId: callIdFromQueue,
+											messageId: ctx.messageId,
+										},
+									});
+									continue;
+								}
 								const delta =
 									typeof chunk === 'string'
 										? chunk