@ottocode/server 0.1.259 → 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/agent/runner-reasoning.ts

@@ -27,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>,
@@ -43,6 +43,22 @@ export async function handleReasoningStart(
 		getStepIndex,
 	};
 	reasoningStates.set(reasoningId, state);
+
+	if (hasAnthropicRedactedReasoning(providerMetadata)) {
+		const delta = '[Reasoning redacted by Anthropic]\n';
+		state.text = delta;
+		await persistReasoningPart(state, db);
+		publish({
+			type: 'reasoning.delta',
+			sessionId: opts.sessionId,
+			payload: {
+				messageId: opts.assistantMessageId,
+				partId: state.partId,
+				stepIndex: getStepIndex(),
+				delta,
+			},
+		});
+	}
 }
 
 async function persistReasoningPart(
@@ -73,11 +89,23 @@ export async function handleReasoningDelta(
 	providerMetadata: unknown,
 	opts: RunOpts,
 	db: Awaited<ReturnType<typeof getDb>>,
+	sharedCtx: ToolAdapterContext,
 	getStepIndex: () => number,
 	reasoningStates: Map<string, ReasoningState>,
 ): Promise<void> {
-	const state = reasoningStates.get(reasoningId);
-	if (!state) return;
+	let state = reasoningStates.get(reasoningId);
+	if (!state) {
+		state = {
+			partId: crypto.randomUUID(),
+			text: '',
+			providerMetadata,
+			persisted: false,
+			opts,
+			sharedCtx,
+			getStepIndex,
+		};
+		reasoningStates.set(reasoningId, state);
+	}
 	state.text += text;
 	if (providerMetadata != null) {
 		state.providerMetadata = providerMetadata;
@@ -108,6 +136,13 @@ export async function handleReasoningDelta(
 	} catch {}
 }
 
+function hasAnthropicRedactedReasoning(providerMetadata: unknown): boolean {
+	if (!providerMetadata || typeof providerMetadata !== 'object') return false;
+	const anthropic = (providerMetadata as Record<string, unknown>).anthropic;
+	if (!anthropic || typeof anthropic !== 'object') return false;
+	return 'redactedData' in anthropic;
+}
+
 export async function handleReasoningEnd(
 	reasoningId: string,
 	db: Awaited<ReturnType<typeof getDb>>,

package/src/runtime/agent/runner.ts

@@ -680,6 +680,7 @@ async function runAssistant(opts: RunOpts) {
 					part.providerMetadata,
 					opts,
 					db,
+					sharedCtx,
 					getStepIndex,
 					reasoningStates,
 				);

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 };
 		}