@ottocode/server 0.1.228 → 0.1.231

package/src/runtime/provider/reasoning.ts

@@ -0,0 +1,291 @@
+import {
+	catalog,
+	getModelNpmBinding,
+	getUnderlyingProviderKey,
+	modelSupportsReasoning,
+	type ProviderId,
+	type ReasoningLevel,
+} from '@ottocode/sdk';
+
+const THINKING_BUDGET = 16000;
+
+export type ReasoningConfigResult = {
+	providerOptions: Record<string, unknown>;
+	effectiveMaxOutputTokens: number | undefined;
+	enabled: boolean;
+};
+
+function normalizeReasoningLevel(
+	level: ReasoningLevel | undefined,
+): Exclude<ReasoningLevel, 'xhigh'> {
+	if (!level) return 'high';
+	if (level === 'xhigh') return 'high';
+	return level;
+}
+
+function toAnthropicEffort(
+	level: ReasoningLevel | undefined,
+): 'low' | 'medium' | 'high' | 'max' {
+	switch (level) {
+		case 'minimal':
+		case 'low':
+			return 'low';
+		case 'medium':
+			return 'medium';
+		case 'max':
+		case 'xhigh':
+			return 'max';
+		case 'high':
+		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';
+		case 'high':
+		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';
+		case 'max':
+		case 'xhigh':
+		case 'high':
+		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);
+		case 'high':
+		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): string[] {
+	const entry = catalog[provider];
+	const keys = new Set<string>(['openaiCompatible', toCamelCaseKey(provider)]);
+	if (entry?.label) {
+		keys.add(toCamelCaseKey(entry.label));
+	}
+	return Array.from(keys).filter(Boolean);
+}
+
+function buildSharedProviderOptions(
+	provider: ProviderId,
+	options: Record<string, unknown>,
+): Record<string, unknown> {
+	const keys = getOpenAICompatibleProviderOptionKeys(provider);
+	return Object.fromEntries(keys.map((key) => [key, options]));
+}
+
+function usesAdaptiveAnthropicThinking(model: string): boolean {
+	const lower = model.toLowerCase();
+	return (
+		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,
+):
+	| 'anthropic'
+	| 'openai'
+	| 'google'
+	| 'openai-compatible'
+	| 'openrouter'
+	| null {
+	if (provider === 'openrouter') return 'openrouter';
+	if (
+		provider === 'moonshot' ||
+		provider === 'zai' ||
+		provider === 'zai-coding'
+	) {
+		return 'openai-compatible';
+	}
+	if (provider === 'minimax') return 'anthropic';
+
+	const npmBinding = getModelNpmBinding(provider, model);
+	if (npmBinding === '@ai-sdk/anthropic') return 'anthropic';
+	if (npmBinding === '@ai-sdk/openai') return 'openai';
+	if (npmBinding === '@ai-sdk/google') return 'google';
+	if (npmBinding === '@ai-sdk/openai-compatible') return 'openai-compatible';
+	if (npmBinding === '@openrouter/ai-sdk-provider') return 'openrouter';
+
+	const underlyingProvider = getUnderlyingProviderKey(provider, model);
+	if (underlyingProvider === 'anthropic') return 'anthropic';
+	if (underlyingProvider === 'openai') return 'openai';
+	if (underlyingProvider === 'google') return 'google';
+	if (underlyingProvider === 'openai-compatible') return 'openai-compatible';
+	return null;
+}
+
+export function buildReasoningConfig(args: {
+	provider: ProviderId;
+	model: string;
+	reasoningText?: boolean;
+	reasoningLevel?: ReasoningLevel;
+	maxOutputTokens: number | undefined;
+}): ReasoningConfigResult {
+	const { provider, model, reasoningText, reasoningLevel, maxOutputTokens } =
+		args;
+	if (!reasoningText || !modelSupportsReasoning(provider, model)) {
+		return {
+			providerOptions: {},
+			effectiveMaxOutputTokens: maxOutputTokens,
+			enabled: false,
+		};
+	}
+
+	const reasoningTarget = getReasoningProviderTarget(provider, model);
+	if (reasoningTarget === 'anthropic') {
+		if (usesAdaptiveAnthropicThinking(model)) {
+			return {
+				providerOptions: {
+					anthropic: {
+						thinking: { type: 'adaptive' },
+						effort: toAnthropicEffort(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') {
+		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 === 'openrouter') {
+		return {
+			providerOptions: {
+				openrouter: {
+					reasoning: { effort: normalizeReasoningLevel(reasoningLevel) },
+				},
+			},
+			effectiveMaxOutputTokens: maxOutputTokens,
+			enabled: true,
+		};
+	}
+
+	if (reasoningTarget === 'openai-compatible') {
+		return {
+			providerOptions: buildSharedProviderOptions(provider, {
+				reasoningEffort: normalizeReasoningLevel(reasoningLevel),
+			}),
+			effectiveMaxOutputTokens: maxOutputTokens,
+			enabled: true,
+		};
+	}
+
+	return {
+		providerOptions: {},
+		effectiveMaxOutputTokens: maxOutputTokens,
+		enabled: false,
+	};
+}

package/src/runtime/session/queue.ts

@@ -1,6 +1,7 @@
 import type { ProviderName } from '../provider/index.ts';
 import { publish } from '../../events/bus.ts';
 import type { ToolApprovalMode } from '../tools/approval.ts';
+import type { ReasoningLevel } from '@ottocode/sdk';
 
 export type RunOpts = {
 	sessionId: string;
@@ -12,6 +13,7 @@ export type RunOpts = {
 	oneShot?: boolean;
 	userContext?: string;
 	reasoningText?: boolean;
+	reasoningLevel?: ReasoningLevel;
 	abortSignal?: AbortSignal;
 	isCompactCommand?: boolean;
 	compactionContext?: string;

package/src/runtime/tools/guards.ts

@@ -1,9 +1,19 @@
+import { resolve as resolvePath } from 'node:path';
+
 export type GuardAction =
 	| { type: 'block'; reason: string }
 	| { type: 'approve'; reason: string }
 	| { type: 'allow' };
 
-export function guardToolCall(toolName: string, args: unknown): GuardAction {
+export type GuardContext = {
+	projectRoot?: string;
+};
+
+export function guardToolCall(
+	toolName: string,
+	args: unknown,
+	context: GuardContext = {},
+): GuardAction {
 	const a = (args ?? {}) as Record<string, unknown>;
 
 	switch (toolName) {
@@ -12,7 +22,7 @@ export function guardToolCall(toolName: string, args: unknown): GuardAction {
 		case 'terminal':
 			return guardTerminal(a);
 		case 'read':
-			return guardReadPath(String(a.path ?? ''));
+			return guardReadPath(String(a.path ?? ''), context.projectRoot);
 		case 'write':
 		case 'edit':
 		case 'multiedit':
@@ -118,7 +128,42 @@ const SENSITIVE_READ_PATHS: Array<{ pattern: RegExp; reason: string }> = [
 	{ pattern: /^~?\/?\.docker\/config\.json$/, reason: 'Docker credentials' },
 ];
 
-function guardReadPath(path: string): GuardAction {
+function normalizeForComparison(value: string): string {
+	const withForwardSlashes = value.replace(/\\/g, '/');
+	return process.platform === 'win32'
+		? withForwardSlashes.toLowerCase()
+		: withForwardSlashes;
+}
+
+function expandTilde(path: string): string {
+	const home = process.env.HOME || process.env.USERPROFILE || '';
+	if (!home) return path;
+	if (path === '~') return home;
+	if (path.startsWith('~/')) return `${home}/${path.slice(2)}`;
+	return path;
+}
+
+function isAbsoluteLike(path: string): boolean {
+	return (
+		path.startsWith('/') || path.startsWith('~') || /^[A-Za-z]:[\\/]/.test(path)
+	);
+}
+
+function isPathInProject(path: string, projectRoot?: string): boolean {
+	if (!projectRoot || !isAbsoluteLike(path)) return false;
+	const root = resolvePath(projectRoot);
+	const target = resolvePath(expandTilde(path));
+	const rootNorm = (() => {
+		const normalized = normalizeForComparison(root);
+		if (normalized === '/') return '/';
+		return normalized.replace(/[\\/]+$/, '');
+	})();
+	const targetNorm = normalizeForComparison(target);
+	const rootWithSlash = rootNorm === '/' ? '/' : `${rootNorm}/`;
+	return targetNorm === rootNorm || targetNorm.startsWith(rootWithSlash);
+}
+
+function guardReadPath(path: string, projectRoot?: string): GuardAction {
 	if (!path) return { type: 'allow' };
 	const p = path.trim();
 
@@ -128,7 +173,10 @@ function guardReadPath(path: string): GuardAction {
 	for (const { pattern, reason } of SENSITIVE_READ_PATHS) {
 		if (pattern.test(p)) return { type: 'approve', reason };
 	}
-	if (p.startsWith('/') || p.startsWith('~')) {
+	if (isPathInProject(p, projectRoot)) {
+		return { type: 'allow' };
+	}
+	if (isAbsoluteLike(p)) {
 		return { type: 'approve', reason: 'Reading path outside project root' };
 	}
 	return { type: 'allow' };

package/src/tools/adapter.ts

@@ -18,6 +18,7 @@ import {
 	requestApproval,
 } from '../runtime/tools/approval.ts';
 import { guardToolCall } from '../runtime/tools/guards.ts';
+import { debugLog } from '../runtime/debug/index.ts';
 
 export type { ToolAdapterContext } from '../runtime/tools/context.ts';
 
@@ -55,6 +56,37 @@ function getPendingQueue(
 	return queue;
 }
 
+function extractToolCallId(options: unknown): string | undefined {
+	return (options as { toolCallId?: string } | undefined)?.toolCallId;
+}
+
+const DEFAULT_TRACED_TOOL_INPUTS = new Set(['write', 'apply_patch']);
+
+function shouldTraceToolInput(name: string): boolean {
+	const raw = process.env.OTTO_DEBUG_TOOL_INPUT?.trim();
+	if (!raw) return false;
+	const normalized = raw.toLowerCase();
+	if (['1', 'true', 'yes', 'on', 'all'].includes(normalized)) {
+		return DEFAULT_TRACED_TOOL_INPUTS.has(name);
+	}
+	const tokens = raw
+		.split(/[\s,]+/)
+		.map((token) => token.trim().toLowerCase())
+		.filter(Boolean);
+	return tokens.includes('all') || tokens.includes(name.toLowerCase());
+}
+
+function summarizeTraceValue(value: unknown, max = 160): string {
+	try {
+		const json = JSON.stringify(value);
+		if (typeof json === 'string') {
+			return json.length > max ? `${json.slice(0, max)}…` : json;
+		}
+	} catch {}
+	const fallback = String(value);
+	return fallback.length > max ? `${fallback.slice(0, max)}…` : fallback;
+}
+
 function unwrapDoubleWrappedArgs(
 	input: unknown,
 	expectedName: string,
@@ -199,12 +231,18 @@ export function adaptTools(
 			...base,
 			...(providerOptions ? { providerOptions } : {}),
 			async onInputStart(options: unknown) {
+				const sdkCallId = extractToolCallId(options);
 				const queue = getPendingQueue(pendingCalls, name);
 				queue.push({
-					callId: crypto.randomUUID(),
+					callId: sdkCallId || crypto.randomUUID(),
 					startTs: Date.now(),
 					stepIndex: ctx.stepIndex,
 				});
+				if (shouldTraceToolInput(name)) {
+					debugLog(
+						`[TOOL_INPUT_TRACE][adapter] onInputStart tool=${name} callId=${sdkCallId ?? queue[queue.length - 1]?.callId ?? 'unknown'} step=${ctx.stepIndex}`,
+					);
+				}
 				if (typeof base.onInputStart === 'function')
 					// biome-ignore lint/suspicious/noExplicitAny: AI SDK types are complex
 					await base.onInputStart(options as any);
@@ -212,8 +250,14 @@ export function adaptTools(
 			async onInputDelta(options: unknown) {
 				const delta = (options as { inputTextDelta?: string } | undefined)
 					?.inputTextDelta;
+				const sdkCallId = extractToolCallId(options);
 				const queue = pendingCalls.get(name);
 				const meta = queue?.length ? queue[queue.length - 1] : undefined;
+				if (shouldTraceToolInput(name)) {
+					debugLog(
+						`[TOOL_INPUT_TRACE][adapter] onInputDelta tool=${name} callId=${sdkCallId ?? meta?.callId ?? 'unknown'} step=${meta?.stepIndex ?? ctx.stepIndex} delta=${summarizeTraceValue(delta ?? '')}`,
+					);
+				}
 				// Stream tool argument deltas as events if needed
 				publish({
 					type: 'tool.delta',
@@ -233,21 +277,30 @@ export function adaptTools(
 			},
 			async onInputAvailable(options: unknown) {
 				const args = (options as { input?: unknown } | undefined)?.input;
+				const sdkCallId = extractToolCallId(options);
 				const queue = getPendingQueue(pendingCalls, name);
 				let meta = queue.length ? queue[queue.length - 1] : undefined;
 				if (!meta) {
 					meta = {
-						callId: crypto.randomUUID(),
+						callId: sdkCallId || crypto.randomUUID(),
 						startTs: Date.now(),
 						stepIndex: ctx.stepIndex,
 					};
 					queue.push(meta);
 				}
+				if (sdkCallId && meta.callId !== sdkCallId) {
+					meta.callId = sdkCallId;
+				}
 				meta.stepIndex = ctx.stepIndex;
 				meta.args = args;
 				const callId = meta.callId;
 				const callPartId = crypto.randomUUID();
 				const startTs = meta.startTs;
+				if (shouldTraceToolInput(name)) {
+					debugLog(
+						`[TOOL_INPUT_TRACE][adapter] onInputAvailable tool=${name} callId=${callId} step=${ctx.stepIndex} input=${summarizeTraceValue(args)}`,
+					);
+				}
 
 				if (
 					!firstToolCallReported &&
@@ -340,7 +393,9 @@ export function adaptTools(
 						args,
 					);
 				}
-				const guard = guardToolCall(name, args);
+				const guard = guardToolCall(name, args, {
+					projectRoot: ctx.projectRoot,
+				});
 				if (guard.type === 'block') {
 					meta.blocked = true;
 					meta.blockReason = guard.reason;
@@ -360,10 +415,11 @@ export function adaptTools(
 			},
 			async execute(input: ToolExecuteInput, options: ToolExecuteOptions) {
 				input = unwrapDoubleWrappedArgs(input, name);
+				const sdkCallId = extractToolCallId(options);
 				const queue = pendingCalls.get(name);
 				const meta = queue?.shift();
 				if (queue && queue.length === 0) pendingCalls.delete(name);
-				const callIdFromQueue = meta?.callId;
+				const callIdFromQueue = sdkCallId || meta?.callId;
 				const startTsFromQueue = meta?.startTs;
 				const stepIndexForEvent = meta?.stepIndex ?? ctx.stepIndex;
 
@@ -462,23 +518,46 @@ export function adaptTools(
 						// If tool returns an async iterable, stream deltas while accumulating
 						if (res && typeof res === 'object' && Symbol.asyncIterator in res) {
 							const chunks: unknown[] = [];
+							let streamedResult: unknown = null;
 							for await (const chunk of res as AsyncIterable<unknown>) {
 								chunks.push(chunk);
+								if (chunk && typeof chunk === 'object' && 'result' in chunk) {
+									streamedResult = (chunk as { result: unknown }).result;
+									continue;
+								}
+								const delta =
+									typeof chunk === 'string'
+										? chunk
+										: chunk &&
+												typeof chunk === 'object' &&
+												'delta' in chunk &&
+												typeof (chunk as { delta?: unknown }).delta === 'string'
+											? ((chunk as { delta: string }).delta ?? '')
+											: null;
+								if (!delta) continue;
+								const channel =
+									chunk &&
+									typeof chunk === 'object' &&
+									'channel' in chunk &&
+									typeof (chunk as { channel?: unknown }).channel === 'string'
+										? ((chunk as { channel: string }).channel ?? 'output')
+										: 'output';
 								publish({
 									type: 'tool.delta',
 									sessionId: ctx.sessionId,
 									payload: {
 										name,
-										channel: 'output',
-										delta: chunk,
+										channel,
+										delta,
 										stepIndex: stepIndexForEvent,
 										callId: callIdFromQueue,
 										messageId: ctx.messageId,
 									},
 								});
 							}
-							// Prefer the last chunk as the result if present, otherwise the entire array
-							result = chunks.length > 0 ? chunks[chunks.length - 1] : null;
+							result =
+								streamedResult ??
+								(chunks.length > 0 ? chunks[chunks.length - 1] : null);
 						} else {
 							// Await promise or passthrough value
 							result = await Promise.resolve(res as ToolExecuteReturn);