@ottocode/server 0.1.265 → 0.1.266

package/src/runtime/provider/reasoning.ts

@@ -1,17 +1,21 @@
 import {
-	catalog,
 	getConfiguredProviderFamily,
 	getProviderDefinition,
 	getModelNpmBinding,
 	getUnderlyingProviderKey,
-	isBuiltInProviderId,
 	modelSupportsReasoning,
 	type OttoConfig,
 	type ProviderId,
 	type ReasoningLevel,
 } from '@ottocode/sdk';
-
-const THINKING_BUDGET = 16000;
+import {
+	buildAnthropicReasoningOptions,
+	buildGoogleReasoningOptions,
+	buildOllamaReasoningOptions,
+	buildOpenAICompatibleReasoningOptions,
+	buildOpenAIReasoningOptions,
+	buildOpenRouterReasoningOptions,
+} from './reasoning-builders.ts';
 
 export type ReasoningConfigResult = {
 	providerOptions: Record<string, unknown>;
@@ -19,152 +23,19 @@ export type ReasoningConfigResult = {
 	enabled: boolean;
 };
 
-function normalizeReasoningLevel(
-	level: ReasoningLevel | undefined,
-): Exclude<ReasoningLevel, 'xhigh'> {
-	if (!level) return 'high';
-	if (level === 'xhigh') return 'high';
-	return level;
-}
-
-function toAnthropicEffort(
-	model: string,
-	level: ReasoningLevel | undefined,
-): 'low' | 'medium' | 'high' | 'xhigh' | 'max' {
-	switch (level) {
-		case 'minimal':
-		case 'low':
-			return 'low';
-		case 'medium':
-			return 'medium';
-		case 'max':
-			return 'max';
-		case 'xhigh':
-			return isClaudeOpus47(model) ? 'xhigh' : 'max';
-		default:
-			return 'high';
-	}
-}
-
-function toOpenAIEffort(
-	level: ReasoningLevel | undefined,
-): 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' {
-	switch (level) {
-		case 'minimal':
-			return 'minimal';
-		case 'low':
-			return 'low';
-		case 'medium':
-			return 'medium';
-		case 'max':
-		case 'xhigh':
-			return 'xhigh';
-		default:
-			return 'high';
-	}
-}
-
-function toGoogleThinkingLevel(
-	level: ReasoningLevel | undefined,
-): 'minimal' | 'low' | 'medium' | 'high' {
-	switch (level) {
-		case 'minimal':
-			return 'minimal';
-		case 'low':
-			return 'low';
-		case 'medium':
-			return 'medium';
-		default:
-			return 'high';
-	}
-}
-
-function toThinkingBudget(
-	level: ReasoningLevel | undefined,
-	maxOutputTokens: number | undefined,
-): number {
-	const cap = maxOutputTokens
-		? Math.max(maxOutputTokens, THINKING_BUDGET)
-		: THINKING_BUDGET;
-	switch (level) {
-		case 'minimal':
-			return Math.min(2048, cap);
-		case 'low':
-			return Math.min(4096, cap);
-		case 'medium':
-			return Math.min(8192, cap);
-		case 'max':
-		case 'xhigh':
-			return Math.min(24000, cap);
-		default:
-			return Math.min(16000, cap);
-	}
-}
-
-function toCamelCaseKey(value: string): string {
-	return value
-		.replace(/[^a-zA-Z0-9]+/g, ' ')
-		.trim()
-		.split(/\s+/)
-		.map((segment, index) => {
-			const lower = segment.toLowerCase();
-			if (index === 0) return lower;
-			return lower.charAt(0).toUpperCase() + lower.slice(1);
-		})
-		.join('');
-}
-
-function getOpenAICompatibleProviderOptionKeys(
-	provider: ProviderId,
-	cfg?: OttoConfig,
-): string[] {
-	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
-	const entry = isBuiltInProviderId(provider) ? catalog[provider] : undefined;
-	const keys = new Set<string>(['openaiCompatible', toCamelCaseKey(provider)]);
-	const label = definition?.label ?? entry?.label;
-	if (label) {
-		keys.add(toCamelCaseKey(label));
-	}
-	return Array.from(keys).filter(Boolean);
-}
-
-function buildSharedProviderOptions(
-	provider: ProviderId,
-	options: Record<string, unknown>,
-	cfg?: OttoConfig,
-): Record<string, unknown> {
-	const keys = getOpenAICompatibleProviderOptionKeys(provider, cfg);
-	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 (
-		isClaudeOpus47(model) ||
-		lower.includes('claude-opus-4-6') ||
-		lower.includes('claude-opus-4.6') ||
-		lower.includes('claude-sonnet-4-6') ||
-		lower.includes('claude-sonnet-4.6')
-	);
-}
-
-function getReasoningProviderTarget(
-	provider: ProviderId,
-	model: string,
-	cfg?: OttoConfig,
-):
+type ReasoningProviderTarget =
 	| 'anthropic'
 	| 'openai'
 	| 'google'
 	| 'ollama'
 	| 'openai-compatible'
-	| 'openrouter'
-	| null {
+	| 'openrouter';
+
+function getReasoningProviderTarget(
+	provider: ProviderId,
+	model: string,
+	cfg?: OttoConfig,
+): ReasoningProviderTarget | null {
 	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
 	if (definition?.source === 'custom') {
 		if (definition.compatibility === 'anthropic') return 'anthropic';
@@ -210,6 +81,45 @@ function getReasoningProviderTarget(
 	return null;
 }
 
+function isReasoningSupported(args: {
+	cfg?: OttoConfig;
+	provider: ProviderId;
+	model: string;
+}): boolean {
+	const { cfg, provider, model } = args;
+	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
+	if (definition?.compatibility === 'ollama') return true;
+	if (definition?.source === 'custom') return true;
+	if (provider === 'ottorouter') return true;
+	return modelSupportsReasoning(provider, model);
+}
+
+function buildTargetReasoningConfig(
+	target: ReasoningProviderTarget,
+	args: {
+		cfg?: OttoConfig;
+		provider: ProviderId;
+		model: string;
+		reasoningLevel?: ReasoningLevel;
+		maxOutputTokens: number | undefined;
+	},
+): ReasoningConfigResult {
+	switch (target) {
+		case 'anthropic':
+			return buildAnthropicReasoningOptions(args);
+		case 'openai':
+			return buildOpenAIReasoningOptions(args);
+		case 'google':
+			return buildGoogleReasoningOptions(args);
+		case 'ollama':
+			return buildOllamaReasoningOptions(args);
+		case 'openrouter':
+			return buildOpenRouterReasoningOptions(args);
+		case 'openai-compatible':
+			return buildOpenAICompatibleReasoningOptions(args);
+	}
+}
+
 export function buildReasoningConfig(args: {
 	cfg?: OttoConfig;
 	provider: ProviderId;
@@ -226,16 +136,8 @@ export function buildReasoningConfig(args: {
 		reasoningLevel,
 		maxOutputTokens,
 	} = args;
-	const definition = cfg ? getProviderDefinition(cfg, provider) : undefined;
-	const supportsReasoning =
-		definition?.compatibility === 'ollama'
-			? true
-			: definition?.source === 'custom'
-				? true
-				: provider === 'ottorouter'
-					? true
-					: modelSupportsReasoning(provider, model);
-	if (!reasoningText || !supportsReasoning) {
+
+	if (!reasoningText || !isReasoningSupported({ cfg, provider, model })) {
 		return {
 			providerOptions: {},
 			effectiveMaxOutputTokens: maxOutputTokens,
@@ -244,118 +146,19 @@ 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,
-						effort: toAnthropicEffort(model, reasoningLevel),
-					},
-				},
-				effectiveMaxOutputTokens: maxOutputTokens,
-				enabled: true,
-			};
-		}
-
-		const thinkingBudget = toThinkingBudget(reasoningLevel, maxOutputTokens);
-
-		return {
-			providerOptions: {
-				anthropic: {
-					thinking: { type: 'enabled', budgetTokens: thinkingBudget },
-				},
-			},
-			effectiveMaxOutputTokens:
-				maxOutputTokens && maxOutputTokens > thinkingBudget
-					? maxOutputTokens - thinkingBudget
-					: maxOutputTokens,
-			enabled: true,
-		};
-	}
-
-	if (reasoningTarget === 'openai') {
+	if (!reasoningTarget) {
 		return {
-			providerOptions: {
-				openai: {
-					reasoningEffort: toOpenAIEffort(reasoningLevel),
-					reasoningSummary: 'auto',
-				},
-			},
-			effectiveMaxOutputTokens: maxOutputTokens,
-			enabled: true,
-		};
-	}
-
-	if (reasoningTarget === 'google') {
-		const isGemini3 = model.includes('gemini-3');
-		return {
-			providerOptions: {
-				google: {
-					thinkingConfig: isGemini3
-						? {
-								thinkingLevel: toGoogleThinkingLevel(reasoningLevel),
-								includeThoughts: true,
-							}
-						: {
-								thinkingBudget: toThinkingBudget(
-									reasoningLevel,
-									maxOutputTokens,
-								),
-								includeThoughts: true,
-							},
-				},
-			},
-			effectiveMaxOutputTokens: maxOutputTokens,
-			enabled: true,
-		};
-	}
-
-	if (reasoningTarget === 'ollama') {
-		return {
-			providerOptions: {
-				ollama: {
-					think: true,
-				},
-			},
-			effectiveMaxOutputTokens: maxOutputTokens,
-			enabled: true,
-		};
-	}
-
-	if (reasoningTarget === 'openrouter') {
-		return {
-			providerOptions: {
-				openrouter: {
-					reasoning: { effort: normalizeReasoningLevel(reasoningLevel) },
-				},
-			},
-			effectiveMaxOutputTokens: maxOutputTokens,
-			enabled: true,
-		};
-	}
-
-	if (reasoningTarget === 'openai-compatible') {
-		return {
-			providerOptions: buildSharedProviderOptions(
-				provider,
-				{
-					reasoningEffort: normalizeReasoningLevel(reasoningLevel),
-				},
-				cfg,
-			),
+			providerOptions: {},
 			effectiveMaxOutputTokens: maxOutputTokens,
-			enabled: true,
+			enabled: false,
 		};
 	}
 
-	return {
-		providerOptions: {},
-		effectiveMaxOutputTokens: maxOutputTokens,
-		enabled: false,
-	};
+	return buildTargetReasoningConfig(reasoningTarget, {
+		cfg,
+		provider,
+		model,
+		reasoningLevel,
+		maxOutputTokens,
+	});
 }

package/src/tools/adapter/events.ts

@@ -0,0 +1,116 @@
+import { logger } from '@ottocode/sdk';
+import { publish } from '../../events/bus.ts';
+import type { ToolAdapterContext } from '../../runtime/tools/context.ts';
+
+export type ToolResultContent = {
+	name: string;
+	result: unknown;
+	callId?: string;
+	artifact?: unknown;
+	args?: unknown;
+};
+
+export function publishToolCall(
+	ctx: ToolAdapterContext,
+	args: {
+		name: string;
+		input: unknown;
+		callId: string;
+		stepIndex?: number;
+	},
+): void {
+	publish({
+		type: 'tool.call',
+		sessionId: ctx.sessionId,
+		payload: {
+			name: args.name,
+			args: args.input,
+			callId: args.callId,
+			stepIndex: args.stepIndex,
+			messageId: ctx.messageId,
+		},
+	});
+}
+
+export function logToolCall(
+	ctx: ToolAdapterContext,
+	args: { name: string; callId?: string; stepIndex?: number },
+): void {
+	logger.debug(`[tools] call ${args.name}`, {
+		sessionId: ctx.sessionId,
+		messageId: ctx.messageId,
+		toolName: args.name,
+		callId: args.callId,
+		stepIndex: args.stepIndex,
+	});
+}
+
+export function publishToolDelta(
+	ctx: ToolAdapterContext,
+	args: {
+		name: string;
+		channel: string;
+		delta: unknown;
+		stepIndex?: number;
+		callId?: string;
+	},
+): void {
+	publish({
+		type: 'tool.delta',
+		sessionId: ctx.sessionId,
+		payload: {
+			name: args.name,
+			channel: args.channel,
+			delta: args.delta,
+			stepIndex: args.stepIndex,
+			callId: args.callId,
+			messageId: ctx.messageId,
+		},
+	});
+}
+
+export function publishToolResult(
+	ctx: ToolAdapterContext,
+	content: ToolResultContent,
+	stepIndex?: number,
+): void {
+	publish({
+		type: 'tool.result',
+		sessionId: ctx.sessionId,
+		payload: { ...content, stepIndex },
+	});
+}
+
+export function logToolResult(
+	ctx: ToolAdapterContext,
+	args: { name: string; callId?: string; stepIndex?: number },
+): void {
+	logger.debug(`[tools] result ${args.name}`, {
+		sessionId: ctx.sessionId,
+		messageId: ctx.messageId,
+		toolName: args.name,
+		callId: args.callId,
+		stepIndex: args.stepIndex,
+	});
+}
+
+export function publishPlanUpdated(
+	ctx: ToolAdapterContext,
+	result: unknown,
+): void {
+	try {
+		const resultValue = result as
+			| { items?: unknown; note?: unknown }
+			| undefined;
+		if (resultValue && Array.isArray(resultValue.items)) {
+			publish({
+				type: 'plan.updated',
+				sessionId: ctx.sessionId,
+				payload: {
+					items: resultValue.items,
+					note: resultValue.note,
+				},
+			});
+		}
+	} catch {}
+}

package/src/tools/adapter/execution.ts

@@ -0,0 +1,160 @@
+import type { Tool } from 'ai';
+import type { ToolAdapterContext } from '../../runtime/tools/context.ts';
+import { getCwd, joinRelative, setCwd } from '../../runtime/utils/cwd.ts';
+import { publishToolDelta } from './events.ts';
+
+type ToolExecuteSignature = Tool['execute'] extends (
+	input: infer Input,
+	options: infer Options,
+) => infer Result
+	? { input: Input; options: Options; result: Result }
+	: { input: unknown; options: unknown; result: unknown };
+
+type ToolExecuteInput = ToolExecuteSignature['input'];
+type ToolExecuteOptions = ToolExecuteSignature['options'] extends never
+	? undefined
+	: ToolExecuteSignature['options'];
+type ToolExecuteReturn = ToolExecuteSignature['result'];
+
+export function executeBaseTool(
+	ctx: ToolAdapterContext,
+	args: {
+		base: Tool;
+		name: string;
+		input: ToolExecuteInput;
+		options: ToolExecuteOptions;
+	},
+): ToolExecuteReturn | { cwd: string } | null | undefined {
+	const cwd = getCwd(ctx.sessionId);
+	const { base, name, input, options } = args;
+
+	if (name === 'pwd') {
+		return { cwd };
+	}
+
+	if (name === 'cd') {
+		const next = joinRelative(
+			cwd,
+			String((input as Record<string, unknown>)?.path ?? '.'),
+		);
+		setCwd(ctx.sessionId, next);
+		return { cwd: next };
+	}
+
+	if (
+		['read', 'write', 'ls', 'tree'].includes(name) &&
+		typeof (input as Record<string, unknown>)?.path === 'string'
+	) {
+		const rel = joinRelative(
+			cwd,
+			String((input as Record<string, unknown>).path),
+		);
+		const nextInput = {
+			...(input as Record<string, unknown>),
+			path: rel,
+		} as ToolExecuteInput;
+		// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+		return base.execute?.(nextInput, options as any);
+	}
+
+	if (name === 'shell' || name === 'bash') {
+		const needsCwd =
+			!input || typeof (input as Record<string, unknown>).cwd !== 'string';
+		const nextInput = needsCwd
+			? ({
+					...(input as Record<string, unknown>),
+					cwd,
+				} as ToolExecuteInput)
+			: input;
+		// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+		return base.execute?.(nextInput, options as any);
+	}
+
+	// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
+	return base.execute?.(input, options as any);
+}
+
+function getStringDelta(chunk: unknown): string | null {
+	if (typeof chunk === 'string') return chunk;
+	if (
+		chunk &&
+		typeof chunk === 'object' &&
+		'delta' in chunk &&
+		typeof (chunk as { delta?: unknown }).delta === 'string'
+	) {
+		return (chunk as { delta: string }).delta ?? '';
+	}
+	return null;
+}
+
+function getStringChannel(chunk: unknown): string {
+	if (
+		chunk &&
+		typeof chunk === 'object' &&
+		'channel' in chunk &&
+		typeof (chunk as { channel?: unknown }).channel === 'string'
+	) {
+		return (chunk as { channel: string }).channel ?? 'output';
+	}
+	return 'output';
+}
+
+function getTerminalId(chunk: unknown): string | null {
+	if (
+		chunk &&
+		typeof chunk === 'object' &&
+		'terminalId' in chunk &&
+		typeof (chunk as { terminalId?: unknown }).terminalId === 'string'
+	) {
+		return (chunk as { terminalId: string }).terminalId;
+	}
+	return null;
+}
+
+export async function consumeToolStream(
+	ctx: ToolAdapterContext,
+	args: {
+		stream: AsyncIterable<unknown>;
+		name: string;
+		stepIndex?: number;
+		callId?: string;
+	},
+): Promise<unknown> {
+	const chunks: unknown[] = [];
+	let streamedResult: unknown = null;
+
+	for await (const chunk of args.stream) {
+		chunks.push(chunk);
+		if (chunk && typeof chunk === 'object' && 'result' in chunk) {
+			streamedResult = (chunk as { result: unknown }).result;
+			continue;
+		}
+
+		const terminalId = getTerminalId(chunk);
+		if (terminalId) {
+			publishToolDelta(ctx, {
+				name: args.name,
+				channel: 'terminal',
+				delta: terminalId,
+				stepIndex: args.stepIndex,
+				callId: args.callId,
+			});
+			continue;
+		}
+
+		const delta = getStringDelta(chunk);
+		if (!delta) continue;
+
+		publishToolDelta(ctx, {
+			name: args.name,
+			channel: getStringChannel(chunk),
+			delta,
+			stepIndex: args.stepIndex,
+			callId: args.callId,
+		});
+	}
+
+	return (
+		streamedResult ?? (chunks.length > 0 ? chunks[chunks.length - 1] : null)
+	);
+}

package/src/tools/adapter/pending.ts

@@ -0,0 +1,37 @@
+export type PendingCallMeta = {
+	callId: string;
+	startTs: number;
+	stepIndex?: number;
+	args?: unknown;
+	approvalPromise?: Promise<boolean>;
+	blocked?: boolean;
+	blockReason?: string;
+};
+
+export function getPendingQueue(
+	map: Map<string, PendingCallMeta[]>,
+	name: string,
+): PendingCallMeta[] {
+	let queue = map.get(name);
+	if (!queue) {
+		queue = [];
+		map.set(name, queue);
+	}
+	return queue;
+}
+
+export function shiftPendingCall(
+	map: Map<string, PendingCallMeta[]>,
+	name: string,
+): PendingCallMeta | undefined {
+	const queue = map.get(name);
+	const meta = queue?.shift();
+	if (queue && queue.length === 0) {
+		map.delete(name);
+	}
+	return meta;
+}
+
+export function extractToolCallId(options: unknown): string | undefined {
+	return (options as { toolCallId?: string } | undefined)?.toolCallId;
+}