@ottocode/server 0.1.259 → 0.1.261

package/src/runtime/provider/reasoning.ts

@@ -4,6 +4,7 @@ import {
 	getProviderDefinition,
 	getModelNpmBinding,
 	getUnderlyingProviderKey,
+	isBuiltInProviderId,
 	modelSupportsReasoning,
 	type OttoConfig,
 	type ProviderId,
@@ -27,8 +28,9 @@ function normalizeReasoningLevel(
 }
 
 function toAnthropicEffort(
+	model: string,
 	level: ReasoningLevel | undefined,
-): 'low' | 'medium' | 'high' | 'max' {
+): 'low' | 'medium' | 'high' | 'xhigh' | 'max' {
 	switch (level) {
 		case 'minimal':
 		case 'low':
@@ -36,8 +38,9 @@ function toAnthropicEffort(
 		case 'medium':
 			return 'medium';
 		case 'max':
-		case 'xhigh':
 			return 'max';
+		case 'xhigh':
+			return isClaudeOpus47(model) ? 'xhigh' : 'max';
 		default:
 			return 'high';
 	}
@@ -116,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) {
@@ -134,11 +137,15 @@ function buildSharedProviderOptions(
 	return Object.fromEntries(keys.map((key) => [key, options]));
 }
 
+function isClaudeOpus47(model: string): boolean {
+	const lower = model.toLowerCase();
+	return lower.includes('claude-opus-4-7') || lower.includes('claude-opus-4.7');
+}
+
 function usesAdaptiveAnthropicThinking(model: string): boolean {
 	const lower = model.toLowerCase();
 	return (
-		lower.includes('claude-opus-4-7') ||
-		lower.includes('claude-opus-4.7') ||
+		isClaudeOpus47(model) ||
 		lower.includes('claude-opus-4-6') ||
 		lower.includes('claude-opus-4.6') ||
 		lower.includes('claude-sonnet-4-6') ||
@@ -238,11 +245,15 @@ export function buildReasoningConfig(args: {
 	const reasoningTarget = getReasoningProviderTarget(provider, model, cfg);
 	if (reasoningTarget === 'anthropic') {
 		if (usesAdaptiveAnthropicThinking(model)) {
+			const thinking = isClaudeOpus47(model)
+				? { type: 'adaptive', display: 'summarized' }
+				: { type: 'adaptive' };
+
 			return {
 				providerOptions: {
 					anthropic: {
-						thinking: { type: 'adaptive' },
-						effort: toAnthropicEffort(reasoningLevel),
+						thinking,
+						effort: toAnthropicEffort(model, reasoningLevel),
 					},
 				},
 				effectiveMaxOutputTokens: maxOutputTokens,

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

package/src/openapi/paths/ask.ts

@@ -1,81 +0,0 @@
-import { errorResponse, projectQueryParam } from '../helpers';
-
-export const askPaths = {
-	'/v1/ask': {
-		post: {
-			tags: ['ask'],
-			operationId: 'ask',
-			summary: 'Send a prompt using the ask service',
-			description:
-				'Streamlined endpoint used by the CLI to send prompts and receive assistant responses. Creates sessions as needed and reuses the last session when requested.',
-			parameters: [projectQueryParam()],
-			requestBody: {
-				required: true,
-				content: {
-					'application/json': {
-						schema: {
-							type: 'object',
-							required: ['prompt'],
-							properties: {
-								prompt: {
-									type: 'string',
-									description: 'User prompt to send to the assistant.',
-								},
-								agent: {
-									type: 'string',
-									description: 'Optional agent name to use for this request.',
-								},
-								provider: {
-									$ref: '#/components/schemas/Provider',
-									description:
-										'Optional provider override. When omitted the agent and config defaults apply.',
-								},
-								model: {
-									type: 'string',
-									description:
-										'Optional model override for the selected provider.',
-								},
-								reasoningText: {
-									type: 'boolean',
-									description:
-										'Enable extended thinking / reasoning for models that support it.',
-								},
-								reasoningLevel: {
-									type: 'string',
-									enum: ['minimal', 'low', 'medium', 'high', 'max', 'xhigh'],
-									description:
-										'Optional reasoning intensity override for supported providers/models.',
-								},
-								sessionId: {
-									type: 'string',
-									description: 'Send the prompt to a specific session.',
-								},
-								last: {
-									type: 'boolean',
-									description:
-										'If true, reuse the most recent session for the project.',
-								},
-								jsonMode: {
-									type: 'boolean',
-									description:
-										'Request structured JSON output when supported by the agent.',
-								},
-							},
-						},
-					},
-				},
-			},
-			responses: {
-				202: {
-					description: 'Accepted',
-					content: {
-						'application/json': {
-							schema: { $ref: '#/components/schemas/AskResponse' },
-						},
-					},
-				},
-				400: errorResponse(),
-			},
-		},
-	},
-} as const;