@ottocode/sdk 0.1.244 → 0.1.246

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.244",
+	"version": "0.1.246",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",
@@ -97,9 +97,10 @@
 		"@modelcontextprotocol/sdk": "^1.12",
 		"@openauthjs/openauth": "^0.4.3",
 		"@openrouter/ai-sdk-provider": "^1.2.0",
-		"@ottocode/ai-sdk": "0.2.0",
+		"@ottorouter/ai-sdk": "0.2.1",
 		"@solana/web3.js": "^1.98.0",
 		"ai": "^6.0.0",
+		"ai-sdk-ollama": "^3.8.3",
 		"bs58": "^6.0.0",
 		"bun-pty": "^0.3.2",
 		"diff": "^8.0.2",

package/src/auth/src/index.ts

@@ -86,8 +86,8 @@ export {
 	generateWallet,
 	importWallet,
 	isValidPrivateKey,
-	getSetuWallet,
-	ensureSetuWallet,
+	getOttoRouterWallet,
+	ensureOttoRouterWallet,
 	type WalletInfo,
 } from './wallet.ts';
 

package/src/auth/src/wallet.ts

@@ -34,25 +34,25 @@ export function isValidPrivateKey(privateKey: string): boolean {
 	}
 }
 
-export async function getSetuWallet(
+export async function getOttoRouterWallet(
 	projectRoot?: string,
 ): Promise<WalletInfo | null> {
-	const auth = await getAuth('setu', projectRoot);
+	const auth = await getAuth('ottorouter', projectRoot);
 	if (auth?.type === 'wallet' && auth.secret) {
 		return importWallet(auth.secret);
 	}
 	return null;
 }
 
-export async function ensureSetuWallet(
+export async function ensureOttoRouterWallet(
 	projectRoot?: string,
 ): Promise<WalletInfo> {
-	const existing = await getSetuWallet(projectRoot);
+	const existing = await getOttoRouterWallet(projectRoot);
 	if (existing) return existing;
 
 	const wallet = generateWallet();
 	await setAuth(
-		'setu',
+		'ottorouter',
 		{ type: 'wallet', secret: wallet.privateKey },
 		projectRoot,
 		'global',

package/src/config/src/index.ts

@@ -13,10 +13,11 @@ const DEFAULT_PROVIDER_SETTINGS: OttoConfig['providers'] = {
 	openai: { enabled: false },
 	anthropic: { enabled: false },
 	google: { enabled: false },
+	'ollama-cloud': { enabled: false, baseURL: 'https://ollama.com' },
 	openrouter: { enabled: false },
 	opencode: { enabled: false },
 	copilot: { enabled: false },
-	setu: { enabled: true },
+	ottorouter: { enabled: true },
 	zai: { enabled: false },
 	'zai-coding': { enabled: false },
 	moonshot: { enabled: false },
@@ -29,7 +30,7 @@ const DEFAULTS: {
 } = {
 	defaults: {
 		agent: 'build',
-		provider: 'setu',
+		provider: 'ottorouter',
 		model: 'kimi-k2.5',
 		toolApproval: 'auto',
 		guidedMode: false,
@@ -64,6 +65,7 @@ export async function loadConfig(
 		projectRoot,
 		defaults: merged.defaults as OttoConfig['defaults'],
 		providers: merged.providers as OttoConfig['providers'],
+		skills: merged.skills as OttoConfig['skills'],
 		paths: {
 			dataDir,
 			dbPath,
@@ -129,6 +131,9 @@ export {
 	isAuthorized,
 	ensureEnv,
 	writeDefaults,
+	writeProviderSettings,
+	removeProviderSettings,
+	writeSkillSettings,
 	writeAuth,
 	removeAuth,
 } from './manager.ts';

package/src/config/src/manager.ts

@@ -6,6 +6,10 @@ import {
 	type ProviderId,
 	type AuthInfo,
 } from '../../auth/src/index.ts';
+import type {
+	ProviderSettingsEntry,
+	SkillSettings,
+} from '../../types/src/index.ts';
 import {
 	getGlobalConfigDir,
 	getGlobalConfigPath,
@@ -83,30 +87,8 @@ export async function writeDefaults(
 	}>,
 	projectRoot?: string,
 ) {
-	const root = projectRoot ? String(projectRoot) : process.cwd();
-
-	if (scope === 'local') {
-		const localDir = getLocalDataDir(root);
-		const localPath = joinPath(localDir, 'config.json');
-		const existing = await readJsonFile(localPath);
-		const prevDefaults =
-			existing && typeof existing.defaults === 'object'
-				? (existing.defaults as Record<string, unknown>)
-				: {};
-		const next = {
-			...existing,
-			defaults: { ...prevDefaults, ...updates },
-		};
-		try {
-			const { promises: fs } = await import('node:fs');
-			await fs.mkdir(localDir, { recursive: true }).catch(() => {});
-		} catch {}
-		await Bun.write(localPath, JSON.stringify(next, null, 2));
-		return;
-	}
-
-	const globalPath = getGlobalConfigPath();
-	const existing = await readJsonFile(globalPath);
+	const filePath = getConfigFilePath(scope, projectRoot);
+	const existing = await readJsonFile(filePath);
 	const prevDefaults =
 		existing && typeof existing.defaults === 'object'
 			? (existing.defaults as Record<string, unknown>)
@@ -115,12 +97,82 @@ export async function writeDefaults(
 		...existing,
 		defaults: { ...prevDefaults, ...updates },
 	};
-	const base = getGlobalConfigDir();
-	try {
-		const { promises: fs } = await import('node:fs');
-		await fs.mkdir(base, { recursive: true }).catch(() => {});
-	} catch {}
-	await Bun.write(globalPath, JSON.stringify(next, null, 2));
+	await writeConfigFile(filePath, next);
+}
+
+/**
+ * Persist provider settings for a built-in or custom provider entry.
+ */
+export async function writeProviderSettings(
+	scope: Scope,
+	provider: string,
+	updates: ProviderSettingsEntry,
+	projectRoot?: string,
+) {
+	const filePath = getConfigFilePath(scope, projectRoot);
+	const existing = await readJsonFile(filePath);
+	const prevProviders =
+		existing && typeof existing.providers === 'object'
+			? (existing.providers as Record<string, unknown>)
+			: {};
+	const previousEntry =
+		prevProviders[provider] && typeof prevProviders[provider] === 'object'
+			? (prevProviders[provider] as Record<string, unknown>)
+			: {};
+	const next = {
+		...existing,
+		providers: {
+			...prevProviders,
+			[provider]: { ...previousEntry, ...updates },
+		},
+	};
+	await writeConfigFile(filePath, next);
+}
+
+/**
+ * Remove a provider override or custom provider entry from config.
+ */
+export async function removeProviderSettings(
+	scope: Scope,
+	provider: string,
+	projectRoot?: string,
+) {
+	const filePath = getConfigFilePath(scope, projectRoot);
+	const existing = await readJsonFile(filePath);
+	if (!existing || typeof existing.providers !== 'object') return;
+	const providers = { ...(existing.providers as Record<string, unknown>) };
+	delete providers[provider];
+	const next = { ...existing, providers };
+	await writeConfigFile(filePath, next);
+}
+
+export async function writeSkillSettings(
+	scope: Scope,
+	updates: SkillSettings,
+	projectRoot?: string,
+) {
+	const filePath = getConfigFilePath(scope, projectRoot);
+	const existing = await readJsonFile(filePath);
+	const prevSkills =
+		existing && typeof existing.skills === 'object'
+			? (existing.skills as Record<string, unknown>)
+			: {};
+	const prevItems =
+		prevSkills.items && typeof prevSkills.items === 'object'
+			? (prevSkills.items as Record<string, unknown>)
+			: {};
+	const next = {
+		...existing,
+		skills: {
+			...prevSkills,
+			...updates,
+			items: {
+				...prevItems,
+				...(updates.items ?? {}),
+			},
+		},
+	};
+	await writeConfigFile(filePath, next);
 }
 
 export async function readDebugConfig(
@@ -183,6 +235,30 @@ async function readJsonFile(
 	}
 }
 
+function getConfigFilePath(scope: Scope, projectRoot?: string): string {
+	const root = projectRoot ? String(projectRoot) : process.cwd();
+	if (scope === 'local') {
+		const localDir = getLocalDataDir(root);
+		return joinPath(localDir, 'config.json');
+	}
+	return getGlobalConfigPath();
+}
+
+async function writeConfigFile(
+	filePath: string,
+	value: Record<string, unknown>,
+) {
+	const base =
+		filePath === getGlobalConfigPath()
+			? getGlobalConfigDir()
+			: filePath.slice(0, Math.max(0, filePath.lastIndexOf('/')));
+	try {
+		const { promises: fs } = await import('node:fs');
+		await fs.mkdir(base, { recursive: true }).catch(() => {});
+	} catch {}
+	await Bun.write(filePath, JSON.stringify(value, null, 2));
+}
+
 export async function writeAuth(
 	provider: ProviderId,
 	info: AuthInfo,

package/src/core/src/index.ts

@@ -105,7 +105,12 @@ export {
 // Logging & Debug
 // =======================
 export { logger, debug, info, warn, error, time } from './utils/logger.ts';
-export { isDebugEnabled, isTraceEnabled } from './utils/debug.ts';
+export {
+	isDebugEnabled,
+	isTraceEnabled,
+	setDebugEnabled,
+	setTraceEnabled,
+} from './utils/debug.ts';
 
 // =======================
 // MCP (Model Context Protocol)

package/src/core/src/providers/resolver.ts

@@ -1,12 +1,14 @@
 import { openai, createOpenAI } from '@ai-sdk/openai';
 import { anthropic, createAnthropic } from '@ai-sdk/anthropic';
 import { google, createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createOllama } from 'ai-sdk-ollama';
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import {
 	catalog,
-	createSetuModel,
+	createOttoRouterModel,
 	createOpenAIOAuthModel,
+	normalizeOllamaBaseURL,
 } from '../../../providers/src/index.ts';
 import { createCopilotModel } from '../../../providers/src/copilot-client.ts';
 import type { OAuth } from '../../../types/src/index.ts';
@@ -32,13 +34,15 @@ export type ProviderName =
 	| 'openai'
 	| 'anthropic'
 	| 'google'
+	| 'ollama-cloud'
 	| 'openrouter'
 	| 'opencode'
 	| 'copilot'
-	| 'setu'
+	| 'ottorouter'
 	| 'zai'
 	| 'zai-coding'
-	| 'moonshot';
+	| 'moonshot'
+	| 'minimax';
 
 export type ModelConfig = {
 	apiKey?: string;
@@ -96,6 +100,20 @@ export async function resolveModel(
 		return google(model);
 	}
 
+	if (provider === 'ollama-cloud') {
+		const entry = catalog[provider];
+		const apiKey = config.apiKey || process.env.OLLAMA_API_KEY || '';
+		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+		const baseURL = normalizeOllamaBaseURL(
+			config.baseURL || entry?.api || 'https://ollama.com',
+		);
+		const instance = createOllama({
+			baseURL,
+			headers,
+		});
+		return instance(model);
+	}
+
 	if (provider === 'openrouter') {
 		const apiKey = config.apiKey || process.env.OPENROUTER_API_KEY || '';
 		const openrouter = createOpenRouter({ apiKey });
@@ -163,16 +181,17 @@ export async function resolveModel(
 		);
 	}
 
-	if (provider === 'setu') {
-		const privateKey = config.apiKey || process.env.SETU_PRIVATE_KEY || '';
+	if (provider === 'ottorouter') {
+		const privateKey =
+			config.apiKey || process.env.OTTOROUTER_PRIVATE_KEY || '';
 		if (!privateKey) {
 			throw new Error(
-				'Setu provider requires SETU_PRIVATE_KEY (base58 Solana secret).',
+				'OttoRouter provider requires OTTOROUTER_PRIVATE_KEY (base58 Solana secret).',
 			);
 		}
-		const baseURL = config.baseURL || process.env.SETU_BASE_URL;
-		const rpcURL = process.env.SETU_SOLANA_RPC_URL;
-		return createSetuModel(
+		const baseURL = config.baseURL || process.env.OTTOROUTER_BASE_URL;
+		const rpcURL = process.env.OTTOROUTER_SOLANA_RPC_URL;
+		return createOttoRouterModel(
 			model,
 			{ privateKey },
 			{
@@ -232,6 +251,15 @@ export async function resolveModel(
 		return instance(model);
 	}
 
+	if (provider === 'minimax') {
+		const entry = catalog[provider];
+		const apiKey = config.apiKey || process.env.MINIMAX_API_KEY || '';
+		const baseURL =
+			config.baseURL || entry?.api || 'https://api.minimax.io/anthropic/v1';
+		const instance = createAnthropic({ apiKey, baseURL });
+		return instance(model);
+	}
+
 	throw new Error(`Unsupported provider: ${provider}`);
 }
 

package/src/core/src/tools/builtin/bash.ts

@@ -60,9 +60,9 @@ export function buildBashTool(projectRoot: string): {
 	name: string;
 	tool: Tool;
 } {
-	// biome-ignore lint/suspicious/noExplicitAny: AI SDK tool typings do not model async-iterable execute results yet.
 	const bash = tool({
 		description: DESCRIPTION,
+
 		inputSchema: z
 			.object({
 				cmd: z.string().describe('Shell command to run (bash -c <cmd>)'),
@@ -261,6 +261,6 @@ export function buildBashTool(projectRoot: string): {
 
 			return stream();
 		},
-	} as any);
+	}) as unknown as Tool;
 	return { name: 'bash', tool: bash };
 }

package/src/core/src/tools/builtin/bash.txt

@@ -9,4 +9,4 @@
 - Chain commands with `&&` to fail-fast.
 - For long outputs, redirect to a file and `read` it back.
 - Batch independent checks (e.g. `git status && git diff`) in parallel tool calls rather than sequential bash chains when you need results separately.
-- Never use `bash` with `sed`/`awk` for programmatic file editing — use `edit`, `multiedit`, or `apply_patch` instead.
+- Never use `bash` with `sed`/`awk` for programmatic file editing — use the dedicated file-editing tools instead.

package/src/core/src/tools/builtin/fs/edit-shared.ts

@@ -34,7 +34,7 @@ export function applyStringEdit(
 ): { content: string; occurrences: number } {
 	if (oldString.length === 0) {
 		throw new Error(
-			'oldString must not be empty. Use write to create files or apply_patch for structural insertions.',
+			'oldString must not be empty. Use write to create files or a structural editing tool for larger insertions.',
 		);
 	}
 	if (oldString === newString) {

package/src/core/src/tools/builtin/fs/edit.txt

@@ -1,9 +1,9 @@
 Replace an exact text block in an existing file.
 
-Use this for targeted edits instead of apply_patch whenever possible.
+Use this for targeted edits instead of structural patch-style editing whenever possible.
 
 Rules:
 - You must read the file first in the current session before editing it.
 - `oldString` must match the file exactly, including whitespace.
 - If `oldString` appears multiple times, provide more context or set `replaceAll: true`.
-- Use `write` for new files and `apply_patch` for structural multi-file diffs.
+- Use `write` for new files and a structural editing tool for multi-file diffs when that capability exists.

package/src/core/src/tools/builtin/fs/write.txt

@@ -6,6 +6,6 @@
 Usage tips:
 - Use for creating NEW files
 - Use when replacing >70% of a file's content (almost complete rewrite)
-- NEVER use for partial/targeted edits - use edit/multiedit first, or apply_patch for structural changes
+- NEVER use for partial/targeted edits - use the dedicated exact-editing tools first, or a structural editing tool for larger changes when available
 - Using write for partial edits wastes output tokens and risks hallucinating unchanged parts
 - Prefer idempotent writes by providing the full intended content when you do use write

package/src/core/src/tools/loader.ts

@@ -12,7 +12,11 @@ import { updateTodosTool } from './builtin/todos.ts';
 import { buildWebSearchTool } from './builtin/websearch.ts';
 import { buildTerminalTool } from './builtin/terminal.ts';
 import type { TerminalManager } from '../terminals/index.ts';
-import { initializeSkills, buildSkillTool } from '../../../skills/index.ts';
+import {
+	initializeSkills,
+	buildSkillTool,
+	setSkillSettings,
+} from '../../../skills/index.ts';
 import { getMCPManager } from '../mcp/index.ts';
 import {
 	getMCPToolBriefs,
@@ -104,6 +108,7 @@ type FsHelpers = {
 const pluginPatterns = ['tools/*/tool.js', 'tools/*/tool.mjs'];
 
 let globalTerminalManager: TerminalManager | null = null;
+const staticToolDiscoveryCache = new Map<string, Promise<DiscoveredTool[]>>();
 
 export function setTerminalManager(manager: TerminalManager): void {
 	globalTerminalManager = manager;
@@ -113,42 +118,141 @@ export function getTerminalManager(): TerminalManager | null {
 	return globalTerminalManager;
 }
 
+function getStaticToolDiscoveryCacheKey(
+	projectRoot: string,
+	globalConfigDir?: string,
+): string {
+	return `${projectRoot}::${globalConfigDir ?? ''}`;
+}
+
+async function discoverStaticProjectTools(
+	projectRoot: string,
+	globalConfigDir?: string,
+	skillSettings?: {
+		enabled?: boolean;
+		items?: Record<string, { enabled?: boolean }>;
+	},
+): Promise<DiscoveredTool[]> {
+	setSkillSettings(skillSettings);
+	const cacheKey = getStaticToolDiscoveryCacheKey(projectRoot, globalConfigDir);
+	const cached = staticToolDiscoveryCache.get(cacheKey);
+	if (cached) return cached;
+
+	const discoveryPromise = (async () => {
+		const tools = new Map<string, Tool>();
+		for (const { name, tool } of buildFsTools(projectRoot))
+			tools.set(name, tool);
+		for (const { name, tool } of buildGitTools(projectRoot))
+			tools.set(name, tool);
+		// Built-ins
+		tools.set('finish', finishTool);
+		tools.set('progress_update', progressUpdateTool);
+		const bash = buildBashTool(projectRoot);
+		tools.set(bash.name, bash.tool);
+		// Search
+		const rg = buildRipgrepTool(projectRoot);
+		tools.set(rg.name, rg.tool);
+		const glob = buildGlobTool(projectRoot);
+		tools.set(glob.name, glob.tool);
+		// Patch/apply
+		const ap = buildApplyPatchTool(projectRoot);
+		tools.set(ap.name, ap.tool);
+		// Todo tracking
+		tools.set('update_todos', updateTodosTool);
+		// Web search
+		const ws = buildWebSearchTool();
+		tools.set(ws.name, ws.tool);
+		// Skills
+		await initializeSkills(projectRoot);
+		const skillTool = buildSkillTool();
+		tools.set(skillTool.name, skillTool.tool);
+
+		async function loadFromBase(base: string | null | undefined) {
+			if (!base) return;
+			try {
+				await fs.readdir(base);
+			} catch {
+				return;
+			}
+			for (const pattern of pluginPatterns) {
+				const files = await fg(pattern, { cwd: base, absolute: false });
+				for (const rel of files) {
+					const match = rel.match(/^tools\/([^/]+)\/tool\.(m?js)$/);
+					if (!match || !match[1]) continue;
+					const folder = match[1];
+					const absPath = join(base, rel).replace(/\\/g, '/');
+					try {
+						const plugin = await loadPlugin(absPath, folder, projectRoot);
+						if (plugin) tools.set(plugin.name, plugin.tool);
+					} catch {}
+				}
+			}
+			// Fallback: manual directory scan
+			try {
+				const toolsDir = join(base, 'tools');
+				const entries = await fs.readdir(toolsDir).catch(() => [] as string[]);
+				for (const folder of entries) {
+					const js = join(toolsDir, folder, 'tool.js');
+					const mjs = join(toolsDir, folder, 'tool.mjs');
+					const candidate = await fs
+						.stat(js)
+						.then(() => js)
+						.catch(
+							async () =>
+								await fs
+									.stat(mjs)
+									.then(() => mjs)
+									.catch(() => null),
+						);
+					if (!candidate) continue;
+					try {
+						const plugin = await loadPlugin(
+							candidate.replace(/\\/g, '/'),
+							folder,
+							projectRoot,
+						);
+						if (plugin) tools.set(plugin.name, plugin.tool);
+					} catch {}
+				}
+			} catch {}
+		}
+
+		await loadFromBase(globalConfigDir);
+		await loadFromBase(join(projectRoot, '.otto'));
+		return Array.from(tools.entries()).map(([name, tool]) => ({ name, tool }));
+	})();
+
+	staticToolDiscoveryCache.set(cacheKey, discoveryPromise);
+	try {
+		return await discoveryPromise;
+	} catch (error) {
+		staticToolDiscoveryCache.delete(cacheKey);
+		throw error;
+	}
+}
+
 export async function discoverProjectTools(
 	projectRoot: string,
 	globalConfigDir?: string,
+	skillSettings?: {
+		enabled?: boolean;
+		items?: Record<string, { enabled?: boolean }>;
+	},
 ): Promise<DiscoverResult> {
-	const tools = new Map<string, Tool>();
-	for (const { name, tool } of buildFsTools(projectRoot)) tools.set(name, tool);
-	for (const { name, tool } of buildGitTools(projectRoot))
-		tools.set(name, tool);
-	// Built-ins
-	tools.set('finish', finishTool);
-	tools.set('progress_update', progressUpdateTool);
-	const bash = buildBashTool(projectRoot);
-	tools.set(bash.name, bash.tool);
-	// Search
-	const rg = buildRipgrepTool(projectRoot);
-	tools.set(rg.name, rg.tool);
-	const glob = buildGlobTool(projectRoot);
-	tools.set(glob.name, glob.tool);
-	// Patch/apply
-	const ap = buildApplyPatchTool(projectRoot);
-	tools.set(ap.name, ap.tool);
-	// Todo tracking
-	tools.set('update_todos', updateTodosTool);
-	// Web search
-	const ws = buildWebSearchTool();
-	tools.set(ws.name, ws.tool);
-	// Terminal (if manager is available)
+	setSkillSettings(skillSettings);
+	const staticTools = await discoverStaticProjectTools(
+		projectRoot,
+		globalConfigDir,
+		skillSettings,
+	);
+	const tools = new Map<string, Tool>(
+		staticTools.map(({ name, tool }) => [name, tool]),
+	);
+
 	if (globalTerminalManager) {
 		const term = buildTerminalTool(projectRoot, globalTerminalManager);
 		tools.set(term.name, term.tool);
 	}
-	// Skills
-	// Always reinitialize to ensure skills are discovered for the current project
-	await initializeSkills(projectRoot);
-	const skillTool = buildSkillTool();
-	tools.set(skillTool.name, skillTool.tool);
 
 	const mcpManager = getMCPManager();
 	let mcpToolsRecord: Record<string, Tool> = {};
@@ -162,58 +266,6 @@ export async function discoverProjectTools(
 		}
 	}
 
-	async function loadFromBase(base: string | null | undefined) {
-		if (!base) return;
-		try {
-			await fs.readdir(base);
-		} catch {
-			return;
-		}
-		for (const pattern of pluginPatterns) {
-			const files = await fg(pattern, { cwd: base, absolute: false });
-			for (const rel of files) {
-				const match = rel.match(/^tools\/([^/]+)\/tool\.(m?js)$/);
-				if (!match || !match[1]) continue;
-				const folder = match[1];
-				const absPath = join(base, rel).replace(/\\/g, '/');
-				try {
-					const plugin = await loadPlugin(absPath, folder, projectRoot);
-					if (plugin) tools.set(plugin.name, plugin.tool);
-				} catch {}
-			}
-		}
-		// Fallback: manual directory scan
-		try {
-			const toolsDir = join(base, 'tools');
-			const entries = await fs.readdir(toolsDir).catch(() => [] as string[]);
-			for (const folder of entries) {
-				const js = join(toolsDir, folder, 'tool.js');
-				const mjs = join(toolsDir, folder, 'tool.mjs');
-				const candidate = await fs
-					.stat(js)
-					.then(() => js)
-					.catch(
-						async () =>
-							await fs
-								.stat(mjs)
-								.then(() => mjs)
-								.catch(() => null),
-					);
-				if (!candidate) continue;
-				try {
-					const plugin = await loadPlugin(
-						candidate.replace(/\\/g, '/'),
-						folder,
-						projectRoot,
-					);
-					if (plugin) tools.set(plugin.name, plugin.tool);
-				} catch {}
-			}
-		} catch {}
-	}
-
-	await loadFromBase(globalConfigDir);
-	await loadFromBase(join(projectRoot, '.otto'));
 	return {
 		tools: Array.from(tools.entries()).map(([name, tool]) => ({ name, tool })),
 		mcpToolsRecord,