@ottocode/sdk 0.1.265 → 0.1.267

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.265",
+	"version": "0.1.267",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",
@@ -102,7 +102,7 @@
 		"@modelcontextprotocol/sdk": "^1.12",
 		"@openauthjs/openauth": "^0.4.3",
 		"@openrouter/ai-sdk-provider": "^1.2.0",
-		"@ottorouter/ai-sdk": "0.2.1",
+		"@ottorouter/ai-sdk": "0.2.2",
 		"@solana/web3.js": "^1.98.0",
 		"ai": "^6.0.170",
 		"ai-sdk-ollama": "^3.8.3",

package/src/config/src/index.ts

@@ -1,5 +1,6 @@
 import {
 	getGlobalConfigPath,
+	getGlobalSkillsConfigPath,
 	getLocalDataDir,
 	ensureDir,
 	fileExists,
@@ -54,13 +55,16 @@ export async function loadConfig(
 	const dbPath = joinPath(dataDir, 'otto.sqlite');
 	const projectConfigPath = joinPath(dataDir, 'config.json');
 	const globalConfigPath = getGlobalConfigPath();
+	const globalSkillsConfigPath = getGlobalSkillsConfigPath();
 
 	const projectCfg = await readJsonOptional(projectConfigPath);
 	const globalCfg = await readJsonOptional(globalConfigPath);
+	const globalSkillsCfg = await readJsonOptional(globalSkillsConfigPath);
 
 	const merged = deepMerge(
 		DEFAULTS,
 		globalCfg,
+		globalSkillsCfg ? { skills: globalSkillsCfg } : undefined,
 		omitGlobalOnlySettings(projectCfg),
 	);
 

package/src/config/src/manager.ts

@@ -13,6 +13,7 @@ import type {
 import {
 	getGlobalConfigDir,
 	getGlobalConfigPath,
+	getGlobalSkillsConfigPath,
 	getGlobalDebugDir,
 	getGlobalDebugLogPath,
 	getGlobalDebugSessionsDir,
@@ -151,25 +152,18 @@ export async function writeSkillSettings(
 	updates: SkillSettings,
 	_projectRoot?: string,
 ) {
-	const filePath = getConfigFilePath('global');
+	const filePath = getGlobalSkillsConfigPath();
 	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>)
+		existing?.items && typeof existing.items === 'object'
+			? (existing.items as Record<string, unknown>)
 			: {};
 	const next = {
 		...existing,
-		skills: {
-			...prevSkills,
-			...updates,
-			items: {
-				...prevItems,
-				...(updates.items ?? {}),
-			},
+		...updates,
+		items: {
+			...prevItems,
+			...(updates.items ?? {}),
 		},
 	};
 	await writeConfigFile(filePath, next);

package/src/config/src/paths.ts

@@ -31,6 +31,10 @@ export function getGlobalConfigPath(): string {
 	return joinPath(getGlobalConfigDir(), 'config.json');
 }
 
+export function getGlobalSkillsConfigPath(): string {
+	return joinPath(getGlobalConfigDir(), 'skills.json');
+}
+
 export function getGlobalAuthPath(): string {
 	return joinPath(getGlobalConfigDir(), 'auth.json');
 }

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

@@ -4,33 +4,22 @@ 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 { createXai } from '@ai-sdk/xai';
 import {
 	catalog,
+	createMinimaxModel,
+	createMoonshotModel,
 	createOttoRouterModel,
 	createOpenAIOAuthModel,
+	createXaiModel,
+	createZaiCodingModel,
+	createZaiModel,
 	normalizeOllamaBaseURL,
+	resolveOpenAIResponsesModel,
+	shouldUseOpenAIResponsesApi,
 } from '../../../providers/src/index.ts';
 import { createCopilotModel } from '../../../providers/src/copilot-client.ts';
 import type { OAuth } from '../../../types/src/index.ts';
 
-function needsResponsesApi(model: string): boolean {
-	const m = model.toLowerCase();
-	if (m.includes('gpt-5')) return true;
-	if (m.startsWith('o1')) return true;
-	if (m.startsWith('o3')) return true;
-	if (m.startsWith('o4')) return true;
-	if (m.includes('codex-mini')) return true;
-	return false;
-}
-
-function resolveOpenAIModel(
-	instance: ReturnType<typeof createOpenAI>,
-	model: string,
-) {
-	return needsResponsesApi(model) ? instance.responses(model) : instance(model);
-}
-
 export type ProviderName =
 	| 'openai'
 	| 'anthropic'
@@ -71,13 +60,15 @@ export async function resolveModel(
 				apiKey: config.apiKey || 'oauth-token',
 				fetch: config.customFetch,
 			});
-			return resolveOpenAIModel(instance, model);
+			return resolveOpenAIResponsesModel(instance, model);
 		}
 		if (config.apiKey) {
 			const instance = createOpenAI({ apiKey: config.apiKey });
-			return resolveOpenAIModel(instance, model);
+			return resolveOpenAIResponsesModel(instance, model);
 		}
-		return needsResponsesApi(model) ? openai.responses(model) : openai(model);
+		return shouldUseOpenAIResponsesApi(model)
+			? openai.responses(model)
+			: openai(model);
 	}
 
 	if (provider === 'anthropic') {
@@ -204,70 +195,38 @@ export async function resolveModel(
 	}
 
 	if (provider === 'xai') {
-		const entry = catalog[provider];
-		const apiKey = config.apiKey || process.env.XAI_API_KEY || '';
-		const baseURL = config.baseURL || entry?.api;
-		const instance = createXai({ apiKey, baseURL });
-		return instance(model);
+		return createXaiModel(model, {
+			apiKey: config.apiKey,
+			baseURL: config.baseURL,
+		});
 	}
 
 	if (provider === 'zai') {
-		const entry = catalog[provider];
-		const apiKey =
-			config.apiKey ||
-			process.env.ZAI_API_KEY ||
-			process.env.ZHIPU_API_KEY ||
-			'';
-		const baseURL =
-			config.baseURL || entry?.api || 'https://api.z.ai/api/paas/v4';
-		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
-		const instance = createOpenAICompatible({
-			name: entry?.label ?? 'Z.AI',
-			baseURL,
-			headers,
+		return createZaiModel(model, {
+			apiKey: config.apiKey,
+			baseURL: config.baseURL,
 		});
-		return instance(model);
 	}
 
 	if (provider === 'zai-coding') {
-		const entry = catalog[provider];
-		const apiKey =
-			config.apiKey ||
-			process.env.ZAI_CODING_API_KEY ||
-			process.env.ZHIPU_API_KEY ||
-			'';
-		const baseURL =
-			config.baseURL || entry?.api || 'https://api.z.ai/api/coding/paas/v4';
-		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
-		const instance = createOpenAICompatible({
-			name: entry?.label ?? 'Z.AI Coding',
-			baseURL,
-			headers,
+		return createZaiCodingModel(model, {
+			apiKey: config.apiKey,
+			baseURL: config.baseURL,
 		});
-		return instance(model);
 	}
 
 	if (provider === 'moonshot') {
-		const entry = catalog[provider];
-		const apiKey = config.apiKey || process.env.MOONSHOT_API_KEY || '';
-		const baseURL =
-			config.baseURL || entry?.api || 'https://api.moonshot.ai/v1';
-		const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
-		const instance = createOpenAICompatible({
-			name: entry?.label ?? 'Moonshot AI',
-			baseURL,
-			headers,
+		return createMoonshotModel(model, {
+			apiKey: config.apiKey,
+			baseURL: config.baseURL,
 		});
-		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);
+		return createMinimaxModel(model, {
+			apiKey: config.apiKey,
+			baseURL: config.baseURL,
+		});
 	}
 
 	throw new Error(`Unsupported provider: ${provider}`);

package/src/core/src/tools/bin-manager/cache.ts

@@ -0,0 +1,13 @@
+const resolvedPaths = new Map<string, string>();
+
+export function getCachedBinary(name: string): string | undefined {
+	return resolvedPaths.get(name);
+}
+
+export function setCachedBinary(name: string, path: string): void {
+	resolvedPaths.set(name, path);
+}
+
+export function clearCachedBinaries(): void {
+	resolvedPaths.clear();
+}

package/src/core/src/tools/bin-manager/filesystem.ts

@@ -0,0 +1,32 @@
+import { promises as fs } from 'node:fs';
+
+export async function ensureDir(dir: string): Promise<void> {
+	await fs.mkdir(dir, { recursive: true });
+}
+
+export async function fileExists(p: string): Promise<boolean> {
+	try {
+		await fs.access(p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function isExecutable(p: string): Promise<boolean> {
+	try {
+		await fs.access(p, 0o1);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function makeExecutable(p: string): Promise<void> {
+	if (process.platform === 'win32') return;
+	try {
+		await fs.chmod(p, 0o755);
+	} catch {}
+}
+
+export { fs };

package/src/core/src/tools/bin-manager/paths.ts

@@ -0,0 +1,36 @@
+import { join } from 'node:path';
+
+const OTTO_BIN_DIR_NAME = 'bin';
+
+let cachedBinDir: string | null = null;
+
+function getConfigHome(): string {
+	const cfgHome = process.env.XDG_CONFIG_HOME;
+	if (cfgHome?.trim()) return cfgHome.replace(/\\/g, '/');
+	const home = process.env.HOME || process.env.USERPROFILE || '';
+	return join(home, '.config');
+}
+
+export function getAgiBinDir(): string {
+	if (cachedBinDir) return cachedBinDir;
+	cachedBinDir = join(getConfigHome(), 'otto', OTTO_BIN_DIR_NAME);
+	return cachedBinDir;
+}
+
+export function getPlatformKey(): string {
+	const platform = process.platform;
+	const arch = process.arch;
+	const os =
+		platform === 'darwin'
+			? 'darwin'
+			: platform === 'win32'
+				? 'windows'
+				: 'linux';
+	const cpu = arch === 'arm64' ? 'arm64' : 'x64';
+	return `${os}-${cpu}`;
+}
+
+export function getBinaryFileName(name: string): string {
+	if (process.platform === 'win32') return `${name}.exe`;
+	return name;
+}

package/src/core/src/tools/bin-manager/vendor.ts

@@ -0,0 +1,80 @@
+import { join } from 'node:path';
+import {
+	ensureDir,
+	fileExists,
+	fs,
+	isExecutable,
+	makeExecutable,
+} from './filesystem.ts';
+import { getAgiBinDir, getBinaryFileName, getPlatformKey } from './paths.ts';
+
+function getVendorSearchPaths(binaryName: string): string[] {
+	const platformKey = getPlatformKey();
+	const paths: string[] = [];
+
+	const tauriResource = process.env.TAURI_RESOURCE_DIR;
+	if (tauriResource) {
+		paths.push(join(tauriResource, 'vendor', 'bin', platformKey, binaryName));
+		paths.push(join(tauriResource, 'vendor', 'bin', binaryName));
+	}
+
+	try {
+		const exePath = process.execPath;
+		if (exePath) {
+			const exeDir = join(exePath, '..');
+			paths.push(join(exeDir, 'vendor', 'bin', platformKey, binaryName));
+			paths.push(
+				join(
+					exeDir,
+					'..',
+					'Resources',
+					'vendor',
+					'bin',
+					platformKey,
+					binaryName,
+				),
+			);
+		}
+	} catch {}
+
+	if (process.env.CARGO_MANIFEST_DIR) {
+		paths.push(
+			join(
+				process.env.CARGO_MANIFEST_DIR,
+				'resources',
+				'vendor',
+				'bin',
+				platformKey,
+				binaryName,
+			),
+		);
+	}
+
+	const cwd = process.cwd();
+	paths.push(join(cwd, 'vendor', 'bin', platformKey, binaryName));
+
+	return paths;
+}
+
+export async function extractFromVendor(name: string): Promise<string | null> {
+	const binaryName = getBinaryFileName(name);
+	const binDir = getAgiBinDir();
+	const targetPath = join(binDir, binaryName);
+
+	if ((await fileExists(targetPath)) && (await isExecutable(targetPath))) {
+		return targetPath;
+	}
+
+	const searchPaths = getVendorSearchPaths(binaryName);
+
+	for (const src of searchPaths) {
+		if (await fileExists(src)) {
+			await ensureDir(binDir);
+			await fs.copyFile(src, targetPath);
+			await makeExecutable(targetPath);
+			return targetPath;
+		}
+	}
+
+	return null;
+}

package/src/core/src/tools/bin-manager.ts

@@ -1,73 +1,18 @@
 import { join } from 'node:path';
-import { promises as fs } from 'node:fs';
 import { spawn, execSync } from 'node:child_process';
 import { homedir } from 'node:os';
+import {
+	clearCachedBinaries,
+	getCachedBinary,
+	setCachedBinary,
+} from './bin-manager/cache.ts';
+import { fileExists, isExecutable } from './bin-manager/filesystem.ts';
+import { getAgiBinDir, getBinaryFileName } from './bin-manager/paths.ts';
+import { extractFromVendor } from './bin-manager/vendor.ts';
 
-const OTTO_BIN_DIR_NAME = 'bin';
-
-let cachedBinDir: string | null = null;
-const resolvedPaths = new Map<string, string>();
 let cachedLoginPath: string | null = null;
 
-function getConfigHome(): string {
-	const cfgHome = process.env.XDG_CONFIG_HOME;
-	if (cfgHome?.trim()) return cfgHome.replace(/\\/g, '/');
-	const home = process.env.HOME || process.env.USERPROFILE || '';
-	return join(home, '.config');
-}
-
-export function getAgiBinDir(): string {
-	if (cachedBinDir) return cachedBinDir;
-	cachedBinDir = join(getConfigHome(), 'otto', OTTO_BIN_DIR_NAME);
-	return cachedBinDir;
-}
-
-function getPlatformKey(): string {
-	const platform = process.platform;
-	const arch = process.arch;
-	const os =
-		platform === 'darwin'
-			? 'darwin'
-			: platform === 'win32'
-				? 'windows'
-				: 'linux';
-	const cpu = arch === 'arm64' ? 'arm64' : 'x64';
-	return `${os}-${cpu}`;
-}
-
-function getBinaryFileName(name: string): string {
-	if (process.platform === 'win32') return `${name}.exe`;
-	return name;
-}
-
-async function ensureDir(dir: string): Promise<void> {
-	await fs.mkdir(dir, { recursive: true });
-}
-
-async function fileExists(p: string): Promise<boolean> {
-	try {
-		await fs.access(p);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-async function isExecutable(p: string): Promise<boolean> {
-	try {
-		await fs.access(p, 0o1);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-async function makeExecutable(p: string): Promise<void> {
-	if (process.platform === 'win32') return;
-	try {
-		await fs.chmod(p, 0o755);
-	} catch {}
-}
+export { getAgiBinDir } from './bin-manager/paths.ts';
 
 async function whichBinary(name: string): Promise<string | null> {
 	const cmd = process.platform === 'win32' ? 'where' : 'which';
@@ -85,79 +30,8 @@ async function whichBinary(name: string): Promise<string | null> {
 	});
 }
 
-function getVendorSearchPaths(binaryName: string): string[] {
-	const platformKey = getPlatformKey();
-	const paths: string[] = [];
-
-	const tauriResource = process.env.TAURI_RESOURCE_DIR;
-	if (tauriResource) {
-		paths.push(join(tauriResource, 'vendor', 'bin', platformKey, binaryName));
-		paths.push(join(tauriResource, 'vendor', 'bin', binaryName));
-	}
-
-	try {
-		const exePath = process.execPath;
-		if (exePath) {
-			const exeDir = join(exePath, '..');
-			paths.push(join(exeDir, 'vendor', 'bin', platformKey, binaryName));
-			paths.push(
-				join(
-					exeDir,
-					'..',
-					'Resources',
-					'vendor',
-					'bin',
-					platformKey,
-					binaryName,
-				),
-			);
-		}
-	} catch {}
-
-	if (process.env.CARGO_MANIFEST_DIR) {
-		paths.push(
-			join(
-				process.env.CARGO_MANIFEST_DIR,
-				'resources',
-				'vendor',
-				'bin',
-				platformKey,
-				binaryName,
-			),
-		);
-	}
-
-	const cwd = process.cwd();
-	paths.push(join(cwd, 'vendor', 'bin', platformKey, binaryName));
-
-	return paths;
-}
-
-async function extractFromVendor(name: string): Promise<string | null> {
-	const binaryName = getBinaryFileName(name);
-	const binDir = getAgiBinDir();
-	const targetPath = join(binDir, binaryName);
-
-	if ((await fileExists(targetPath)) && (await isExecutable(targetPath))) {
-		return targetPath;
-	}
-
-	const searchPaths = getVendorSearchPaths(binaryName);
-
-	for (const src of searchPaths) {
-		if (await fileExists(src)) {
-			await ensureDir(binDir);
-			await fs.copyFile(src, targetPath);
-			await makeExecutable(targetPath);
-			return targetPath;
-		}
-	}
-
-	return null;
-}
-
 export async function resolveBinary(name: string): Promise<string> {
-	const cached = resolvedPaths.get(name);
+	const cached = getCachedBinary(name);
 	if (cached) return cached;
 
 	const binaryName = getBinaryFileName(name);
@@ -167,19 +41,19 @@ export async function resolveBinary(name: string): Promise<string> {
 		(await fileExists(installedPath)) &&
 		(await isExecutable(installedPath))
 	) {
-		resolvedPaths.set(name, installedPath);
+		setCachedBinary(name, installedPath);
 		return installedPath;
 	}
 
 	const vendorPath = await extractFromVendor(name);
 	if (vendorPath) {
-		resolvedPaths.set(name, vendorPath);
+		setCachedBinary(name, vendorPath);
 		return vendorPath;
 	}
 
 	const systemPath = await whichBinary(binaryName);
 	if (systemPath) {
-		resolvedPaths.set(name, systemPath);
+		setCachedBinary(name, systemPath);
 		return systemPath;
 	}
 
@@ -187,7 +61,7 @@ export async function resolveBinary(name: string): Promise<string> {
 }
 
 export function clearBinaryCache(): void {
-	resolvedPaths.clear();
+	clearCachedBinaries();
 }
 
 function getLoginShellPath(): string | null {