@ottocode/server 0.1.245 → 0.1.247

package/src/routes/skills.ts

@@ -1,6 +1,7 @@
 import type { Hono } from 'hono';
 import {
 	discoverSkills,
+	filterDiscoveredSkills,
 	loadSkill,
 	loadSkillFile,
 	discoverSkillFiles,
@@ -8,32 +9,56 @@ import {
 	validateSkillName,
 	parseSkillFile,
 	logger,
+	loadConfig,
+	writeSkillSettings,
 } from '@ottocode/sdk';
 import { serializeError } from '../runtime/errors/api-error.ts';
 
+function dedupeSkillsByName<T extends { name: string }>(skills: T[]): T[] {
+	const seen = new Set<string>();
+	return skills.filter((skill) => {
+		const key = skill.name.trim();
+		if (!key || seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+
+function sortSkillsByName<T extends { name: string }>(skills: T[]): T[] {
+	return [...skills].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function mapSkillsWithEnabled(
+	discovered: Array<{
+		name: string;
+		description: string;
+		scope: string;
+		path: string;
+	}>,
+	cfg: Awaited<ReturnType<typeof loadConfig>>,
+) {
+	return discovered.map((skill) => ({
+		name: skill.name,
+		description: skill.description,
+		scope: skill.scope,
+		path: skill.path,
+		enabled: cfg.skills?.items?.[skill.name]?.enabled !== false,
+	}));
+}
+
 export function registerSkillsRoutes(app: Hono) {
 	app.get('/v1/skills', async (c) => {
 		try {
 			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
 			const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
-			const skills = await discoverSkills(projectRoot, repoRoot);
-			// Dedupe by name (same skill may exist in multiple source dirs like
-			// ~/.claude/skills and ~/.codex/skills). `discoverSkills` already
-			// dedupes via its internal Map, but be defensive here for UI consistency.
-			const seen = new Set<string>();
-			const unique = skills.filter((s) => {
-				const key = s.name.trim();
-				if (!key || seen.has(key)) return false;
-				seen.add(key);
-				return true;
-			});
+			const discovered = sortSkillsByName(
+				await discoverSkills(projectRoot, repoRoot),
+			);
+			const filtered = filterDiscoveredSkills(discovered, cfg.skills);
+			const unique = sortSkillsByName(dedupeSkillsByName(filtered));
 			return c.json({
-				skills: unique.map((s) => ({
-					name: s.name,
-					description: s.description,
-					scope: s.scope,
-					path: s.path,
-				})),
+				skills: mapSkillsWithEnabled(unique, cfg),
 			});
 		} catch (error) {
 			logger.error('Failed to list skills', error);
@@ -42,6 +67,68 @@ export function registerSkillsRoutes(app: Hono) {
 		}
 	});
 
+	app.get('/v1/config/skills', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+			const discovered = sortSkillsByName(
+				dedupeSkillsByName(await discoverSkills(projectRoot, repoRoot)),
+			);
+			const filtered = sortSkillsByName(
+				filterDiscoveredSkills(discovered, cfg.skills),
+			);
+			return c.json({
+				enabled: cfg.skills?.enabled !== false,
+				totalCount: discovered.length,
+				enabledCount: filtered.length,
+				items: mapSkillsWithEnabled(discovered, cfg),
+			});
+		} catch (error) {
+			logger.error('Failed to get skills config', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, (errorResponse.error.status || 500) as 500);
+		}
+	});
+
+	app.put('/v1/config/skills', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const body = await c.req.json<{
+				enabled?: boolean;
+				items?: Record<string, { enabled?: boolean }>;
+				scope?: 'global' | 'local';
+			}>();
+			await writeSkillSettings(
+				body.scope || 'local',
+				{
+					...(body.enabled !== undefined ? { enabled: body.enabled } : {}),
+					...(body.items ? { items: body.items } : {}),
+				},
+				projectRoot,
+			);
+			const cfg = await loadConfig(projectRoot);
+			const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+			const discovered = sortSkillsByName(
+				dedupeSkillsByName(await discoverSkills(projectRoot, repoRoot)),
+			);
+			const filtered = sortSkillsByName(
+				filterDiscoveredSkills(discovered, cfg.skills),
+			);
+			return c.json({
+				success: true,
+				enabled: cfg.skills?.enabled !== false,
+				totalCount: discovered.length,
+				enabledCount: filtered.length,
+				items: mapSkillsWithEnabled(discovered, cfg),
+			});
+		} catch (error) {
+			logger.error('Failed to update skills config', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, (errorResponse.error.status || 500) as 500);
+		}
+	});
+
 	app.get('/v1/skills/:name', async (c) => {
 		try {
 			const name = c.req.param('name');
@@ -72,52 +159,46 @@ export function registerSkillsRoutes(app: Hono) {
 		}
 	});
 
-	app.post('/v1/skills/validate', async (c) => {
-		app.get('/v1/skills/:name/files', async (c) => {
-			try {
-				const name = c.req.param('name');
-				const projectRoot = c.req.query('project') || process.cwd();
-				const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
-				await discoverSkills(projectRoot, repoRoot);
-
-				const files = await discoverSkillFiles(name);
-				return c.json({ files });
-			} catch (error) {
-				logger.error('Failed to list skill files', error);
-				const errorResponse = serializeError(error);
-				return c.json(
-					errorResponse,
-					(errorResponse.error.status || 500) as 500,
-				);
-			}
-		});
-
-		app.get('/v1/skills/:name/files/*', async (c) => {
-			try {
-				const name = c.req.param('name');
-				const filePath = c.req.path.replace(`/v1/skills/${name}/files/`, '');
-				const projectRoot = c.req.query('project') || process.cwd();
-				const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
-				await discoverSkills(projectRoot, repoRoot);
-
-				const result = await loadSkillFile(name, filePath);
-				if (!result) {
-					return c.json(
-						{ error: `File '${filePath}' not found in skill '${name}'` },
-						404,
-					);
-				}
-				return c.json({ content: result.content, path: result.resolvedPath });
-			} catch (error) {
-				logger.error('Failed to load skill file', error);
-				const errorResponse = serializeError(error);
+	app.get('/v1/skills/:name/files', async (c) => {
+		try {
+			const name = c.req.param('name');
+			const projectRoot = c.req.query('project') || process.cwd();
+			const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+			await discoverSkills(projectRoot, repoRoot);
+
+			const files = await discoverSkillFiles(name);
+			return c.json({ files });
+		} catch (error) {
+			logger.error('Failed to list skill files', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, (errorResponse.error.status || 500) as 500);
+		}
+	});
+
+	app.get('/v1/skills/:name/files/*', async (c) => {
+		try {
+			const name = c.req.param('name');
+			const filePath = c.req.path.replace(`/v1/skills/${name}/files/`, '');
+			const projectRoot = c.req.query('project') || process.cwd();
+			const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+			await discoverSkills(projectRoot, repoRoot);
+
+			const result = await loadSkillFile(name, filePath);
+			if (!result) {
 				return c.json(
-					errorResponse,
-					(errorResponse.error.status || 500) as 500,
+					{ error: `File '${filePath}' not found in skill '${name}'` },
+					404,
 				);
 			}
-		});
+			return c.json({ content: result.content, path: result.resolvedPath });
+		} catch (error) {
+			logger.error('Failed to load skill file', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, (errorResponse.error.status || 500) as 500);
+		}
+	});
 
+	app.post('/v1/skills/validate', async (c) => {
 		try {
 			const body = await c.req.json<{ content: string; path?: string }>();
 			if (!body.content) {

package/src/runtime/agent/registry.ts

@@ -115,17 +115,18 @@ function mergeAgentEntries(
 	return merged;
 }
 
-const baseToolSet = ['progress_update', 'finish', 'skill'] as const;
+const baseToolSet = ['progress_update', 'finish'] as const;
 
 const defaultToolExtras: Record<string, string[]> = {
 	build: [
+		'skill',
 		'read',
 		'edit',
 		'multiedit',
 		'write',
 		'ls',
 		'tree',
-		'bash',
+		'shell',
 		'update_todos',
 		'glob',
 		'ripgrep',
@@ -134,28 +135,30 @@ const defaultToolExtras: Record<string, string[]> = {
 		'apply_patch',
 		'websearch',
 	],
-	plan: ['read', 'ls', 'tree', 'ripgrep', 'update_todos', 'websearch'],
+	plan: ['skill', 'read', 'ls', 'tree', 'ripgrep', 'update_todos', 'websearch'],
 	general: [
+		'skill',
 		'read',
 		'edit',
 		'multiedit',
 		'write',
 		'ls',
 		'tree',
-		'bash',
+		'shell',
 		'ripgrep',
 		'glob',
 		'websearch',
 		'update_todos',
 	],
 	init: [
+		'skill',
 		'read',
 		'edit',
 		'multiedit',
 		'write',
 		'ls',
 		'tree',
-		'bash',
+		'shell',
 		'update_todos',
 		'glob',
 		'ripgrep',

package/src/runtime/agent/runner-setup.ts

@@ -1,8 +1,10 @@
 import {
 	loadConfig,
 	logger,
+	getConfiguredProviderFamily,
 	getSessionSystemPromptPath,
 	getModelFamily,
+	type OttoConfig,
 } from '@ottocode/sdk';
 import { wrapLanguageModel } from 'ai';
 import { devToolsMiddleware } from '@ai-sdk/devtools';
@@ -19,7 +21,7 @@ import type { Tool } from 'ai';
 import { adaptTools } from '../../tools/adapter.ts';
 import { buildDatabaseTools } from '../../tools/database/index.ts';
 import { time } from '../debug/index.ts';
-import { isDevtoolsEnabled } from '../debug/state.ts';
+import { isDebugEnabled, isDevtoolsEnabled } from '../debug/state.ts';
 import { buildHistoryMessages } from '../message/history-builder.ts';
 import { getMaxOutputTokens } from '../utils/token.ts';
 import { setupToolContext } from '../tools/setup.ts';
@@ -29,6 +31,39 @@ import { buildReasoningConfig } from '../provider/reasoning.ts';
 import type { RunOpts } from '../session/queue.ts';
 import type { ToolAdapterContext } from '../../tools/adapter.ts';
 
+type RunnerSetupTimings = {
+	loadConfigAndDbMs: number;
+	resolveAgentConfigMs: number;
+	buildHistoryMs: number;
+	loadSessionMs: number;
+	composeSystemPromptMs: number;
+	discoverToolsMs: number;
+	resolveModelMs: number;
+	setupToolContextMs: number;
+	buildToolsetMs: number;
+	totalMs: number;
+};
+
+type TimedResult<T> = {
+	value: T;
+	durationMs: number;
+};
+
+function nowMs(): number {
+	const perf = globalThis.performance;
+	if (perf && typeof perf.now === 'function') return perf.now();
+	return Date.now();
+}
+
+async function timePromise<T>(promise: Promise<T>): Promise<TimedResult<T>> {
+	const startedAt = nowMs();
+	const value = await promise;
+	return {
+		value,
+		durationMs: nowMs() - startedAt,
+	};
+}
+
 export interface SetupResult {
 	cfg: Awaited<ReturnType<typeof loadConfig>>;
 	db: Awaited<ReturnType<typeof getDb>>;
@@ -50,6 +85,7 @@ export interface SetupResult {
 	needsSpoof: boolean;
 	isOpenAIOAuth: boolean;
 	mcpToolsRecord: Record<string, Tool>;
+	timings: RunnerSetupTimings;
 }
 
 export function mergeProviderOptions(
@@ -86,15 +122,27 @@ const MODEL_FAMILY_EDIT_TOOL_POLICY_AGENTS = new Set([
 	'init',
 ]);
 
+function normalizeToolName(toolName: string): string {
+	return toolName === 'bash' ? 'shell' : toolName;
+}
+
+function normalizeToolNames(toolNames: string[]): string[] {
+	return Array.from(new Set(toolNames.map(normalizeToolName)));
+}
+
 export function applyModelFamilyEditToolPolicy(
 	agent: string,
 	tools: string[],
 	provider: RunOpts['provider'],
 	model: string,
+	cfg?: OttoConfig,
 ): string[] {
+	tools = normalizeToolNames(tools);
 	if (!MODEL_FAMILY_EDIT_TOOL_POLICY_AGENTS.has(agent)) return tools;
 
-	const family = getModelFamily(provider, model);
+	const family = cfg
+		? getConfiguredProviderFamily(cfg, provider, model)
+		: getModelFamily(provider, model);
 	const next = tools.filter(
 		(toolName) => !EDITING_TOOL_NAMES.includes(toolName),
 	);
@@ -107,40 +155,67 @@ export function applyModelFamilyEditToolPolicy(
 }
 
 export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
+	const setupStartedAt = nowMs();
 	const cfgTimer = time('runner:loadConfig+db');
+	const loadConfigAndDbStartedAt = nowMs();
 	const cfg = await loadConfig(opts.projectRoot);
 	const db = await getDb(cfg.projectRoot);
+	const loadConfigAndDbMs = nowMs() - loadConfigAndDbStartedAt;
 	cfgTimer.end();
 
 	const agentTimer = time('runner:resolveAgentConfig');
-	const agentCfg = await resolveAgentConfig(cfg.projectRoot, opts.agent);
+	const agentCfgPromise = timePromise(
+		resolveAgentConfig(cfg.projectRoot, opts.agent),
+	);
+	const historyPromise =
+		opts.omitHistory || (opts.isCompactCommand && opts.compactionContext)
+			? Promise.resolve({ value: [], durationMs: 0 })
+			: timePromise(
+					buildHistoryMessages(db, opts.sessionId, opts.assistantMessageId),
+				);
+	const sessionRowsPromise = timePromise(
+		db.select().from(sessions).where(eq(sessions.id, opts.sessionId)).limit(1),
+	);
+	const discoveredToolsPromise = timePromise(
+		discoverProjectTools(cfg.projectRoot, undefined, cfg.skills),
+	);
+	const { value: agentCfg, durationMs: resolveAgentConfigMs } =
+		await agentCfgPromise;
 	agentTimer.end({ agent: opts.agent });
 
 	const agentPrompt = agentCfg.prompt || '';
 
 	const historyTimer = time('runner:buildHistory');
-	let history: Awaited<ReturnType<typeof buildHistoryMessages>>;
-	if (opts.omitHistory || (opts.isCompactCommand && opts.compactionContext)) {
-		history = [];
-	} else {
-		history = await buildHistoryMessages(
-			db,
-			opts.sessionId,
-			opts.assistantMessageId,
-		);
-	}
+	const { value: history, durationMs: buildHistoryMs } = await historyPromise;
 	historyTimer.end({ messages: history.length });
 
-	const sessionRows = await db
-		.select()
-		.from(sessions)
-		.where(eq(sessions.id, opts.sessionId))
-		.limit(1);
+	const { value: sessionRows, durationMs: loadSessionMs } =
+		await sessionRowsPromise;
 	const contextSummary = sessionRows[0]?.contextSummary ?? undefined;
+	const toolsTimer = time('runner:discoverTools');
+	const { value: discovered, durationMs: discoverToolsMs } =
+		await discoveredToolsPromise;
+	const allTools = discovered.tools;
+	const { mcpToolsRecord } = discovered;
+
+	if (opts.agent === 'research') {
+		const currentSession = sessionRows[0];
+		const parentSessionId = currentSession?.parentSessionId ?? null;
+
+		const dbTools = buildDatabaseTools(cfg.projectRoot, parentSessionId);
+		for (const dt of dbTools) {
+			discovered.tools.push(dt);
+		}
+	}
+
+	toolsTimer.end({
+		count: allTools.length + Object.keys(mcpToolsRecord).length,
+	});
 
 	const isFirstMessage = !history.some((m) => m.role === 'assistant');
 
 	const systemTimer = time('runner:composeSystemPrompt');
+	const composeSystemPromptStartedAt = nowMs();
 	const { getAuth } = await import('@ottocode/sdk');
 	const auth = await getAuth(opts.provider, cfg.projectRoot);
 	const oauth = detectOAuth(opts.provider, auth);
@@ -148,6 +223,8 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const composed = await composeSystemPrompt({
 		provider: opts.provider,
 		model: opts.model,
+		promptFamily: getConfiguredProviderFamily(cfg, opts.provider, opts.model),
+		skillSettings: cfg.skills,
 		projectRoot: cfg.projectRoot,
 		agentPrompt,
 		oneShot: opts.oneShot,
@@ -180,6 +257,7 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		: oauth.needsSpoof
 			? 'spoof'
 			: 'standard';
+	const composeSystemPromptMs = nowMs() - composeSystemPromptStartedAt;
 	systemTimer.end();
 	logger.debug('[prompt] system prompt assembled', {
 		sessionId: opts.sessionId,
@@ -216,7 +294,7 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 			(message) => message.role,
 		),
 	});
-	if (effectiveSystemPrompt) {
+	if (effectiveSystemPrompt && isDebugEnabled()) {
 		const systemPromptPath = getSessionSystemPromptPath(opts.sessionId);
 		try {
 			await mkdir(dirname(systemPromptPath), { recursive: true });
@@ -253,40 +331,27 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	if (opts.additionalPromptMessages?.length) {
 		additionalSystemMessages.push(...opts.additionalPromptMessages);
 	}
-
-	const toolsTimer = time('runner:discoverTools');
-	const discovered = await discoverProjectTools(cfg.projectRoot);
-	const allTools = discovered.tools;
-	const { mcpToolsRecord } = discovered;
-
-	if (opts.agent === 'research') {
-		const currentSession = sessionRows[0];
-		const parentSessionId = currentSession?.parentSessionId ?? null;
-
-		const dbTools = buildDatabaseTools(cfg.projectRoot, parentSessionId);
-		for (const dt of dbTools) {
-			discovered.tools.push(dt);
-		}
-	}
-
-	toolsTimer.end({
-		count: allTools.length + Object.keys(mcpToolsRecord).length,
-	});
 	const allowedToolNames = applyModelFamilyEditToolPolicy(
 		agentCfg.name,
 		agentCfg.tools || [],
 		opts.provider,
 		opts.model,
 	);
-	const allowedNames = new Set([...allowedToolNames, 'finish']);
+	const allowedNames = new Set([
+		...normalizeToolNames(allowedToolNames),
+		'finish',
+	]);
 	const gated = allTools.filter(
 		(tool) => allowedNames.has(tool.name) || tool.name === 'load_mcp_tools',
 	);
 
+	const resolveModelStartedAt = nowMs();
 	const model = await resolveModel(opts.provider, opts.model, cfg, {
 		sessionId: opts.sessionId,
 		messageId: opts.assistantMessageId,
+		reasoningText: opts.reasoningText,
 	});
+	const resolveModelMs = nowMs() - resolveModelStartedAt;
 	const wrappedModel = isDevtoolsEnabled()
 		? wrapLanguageModel({
 				// biome-ignore lint/suspicious/noExplicitAny: OpenRouter provider uses v2 spec
@@ -297,14 +362,18 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 
 	const maxOutputTokens = adapted.maxOutputTokens;
 
+	const setupToolContextStartedAt = nowMs();
 	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
 		opts,
 		db,
 	);
+	const setupToolContextMs = nowMs() - setupToolContextStartedAt;
 
+	const buildToolsetStartedAt = nowMs();
 	const providerAuth = await getAuth(opts.provider, opts.projectRoot);
 	const authType = providerAuth?.type;
 	const toolset = adaptTools(gated, sharedCtx, opts.provider, authType);
+	const buildToolsetMs = nowMs() - buildToolsetStartedAt;
 
 	const providerOptions = { ...adapted.providerOptions };
 	let effectiveMaxOutputTokens = maxOutputTokens;
@@ -317,6 +386,7 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	}
 
 	const reasoningConfig = buildReasoningConfig({
+		cfg,
 		provider: opts.provider,
 		model: opts.model,
 		reasoningText: opts.reasoningText,
@@ -326,6 +396,32 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	mergeProviderOptions(providerOptions, reasoningConfig.providerOptions);
 	effectiveMaxOutputTokens = reasoningConfig.effectiveMaxOutputTokens;
 
+	const timings: RunnerSetupTimings = {
+		loadConfigAndDbMs,
+		resolveAgentConfigMs,
+		buildHistoryMs,
+		loadSessionMs,
+		composeSystemPromptMs,
+		discoverToolsMs,
+		resolveModelMs,
+		setupToolContextMs,
+		buildToolsetMs,
+		totalMs: nowMs() - setupStartedAt,
+	};
+
+	logger.info('[latency] runner setup', {
+		sessionId: opts.sessionId,
+		messageId: opts.assistantMessageId,
+		agent: opts.agent,
+		provider: opts.provider,
+		model: opts.model,
+		historyMessages: history.length,
+		systemPromptChars: effectiveSystemPrompt.length,
+		additionalPromptMessages: additionalSystemMessages.length,
+		allowedToolCount: gated.length,
+		timings,
+	});
+
 	return {
 		cfg,
 		db,
@@ -345,5 +441,6 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		needsSpoof: oauth.needsSpoof,
 		isOpenAIOAuth: oauth.isOpenAIOAuth,
 		mcpToolsRecord,
+		timings,
 	};
 }