@ottocode/sdk 0.1.173

package/src/providers/src/utils.ts

@@ -0,0 +1,210 @@
+import { catalog } from './catalog-merged.ts';
+import type { ProviderId, ModelInfo } from '../../types/src/index.ts';
+import { filterModelsForAuthType } from './oauth-models.ts';
+
+export const providerIds = Object.keys(catalog) as ProviderId[];
+
+export function isProviderId(value: unknown): value is ProviderId {
+	return typeof value === 'string' && providerIds.includes(value as ProviderId);
+}
+
+export function defaultModelFor(provider: ProviderId): string | undefined {
+	return catalog[provider]?.models?.[0]?.id;
+}
+
+export function listModels(provider: ProviderId): string[] {
+	return (catalog[provider]?.models ?? []).map((m) => m.id);
+}
+
+export function hasModel(
+	provider: ProviderId,
+	model: string | undefined,
+): boolean {
+	if (!model) return false;
+	return listModels(provider).includes(model);
+}
+
+const PREFERRED_FAST_MODELS: Partial<Record<ProviderId, string[]>> = {
+	openai: ['gpt-4.1-mini'],
+	anthropic: ['claude-3-5-haiku-latest'],
+	google: ['gemini-2.0-flash-lite'],
+	openrouter: ['anthropic/claude-3.5-haiku'],
+	opencode: ['claude-3-5-haiku'],
+	setu: ['claude-3-5-haiku-latest'],
+	zai: ['glm-4.5-flash'],
+	copilot: ['gpt-4.1-mini'],
+};
+
+export function getFastModel(provider: ProviderId): string | undefined {
+	const providerModels = catalog[provider]?.models ?? [];
+	if (!providerModels.length) return undefined;
+
+	const preferred = PREFERRED_FAST_MODELS[provider] ?? [];
+	for (const modelId of preferred) {
+		if (providerModels.some((m) => m.id === modelId)) {
+			return modelId;
+		}
+	}
+
+	const sorted = [...providerModels]
+		.filter((m) => m.cost?.input !== undefined && m.toolCall !== false)
+		.sort((a, b) => (a.cost?.input ?? Infinity) - (b.cost?.input ?? Infinity));
+
+	return sorted[0]?.id ?? providerModels[0]?.id;
+}
+
+export function getFastModelForAuth(
+	provider: ProviderId,
+	authType: 'api' | 'oauth' | 'wallet' | undefined,
+): string | undefined {
+	const providerModels = catalog[provider]?.models ?? [];
+	if (!providerModels.length) return undefined;
+
+	const filteredModels = filterModelsForAuthType(
+		provider,
+		providerModels,
+		authType,
+	);
+	if (!filteredModels.length) return getFastModel(provider);
+
+	if (authType !== 'oauth') {
+		const preferred = PREFERRED_FAST_MODELS[provider] ?? [];
+		for (const modelId of preferred) {
+			if (filteredModels.some((m) => m.id === modelId)) {
+				return modelId;
+			}
+		}
+	}
+
+	// For OAuth or when no preferred model found, use cost-based selection
+	const sorted = [...filteredModels]
+		.filter(
+			(m: ModelInfo) => m.cost?.input !== undefined && m.toolCall !== false,
+		)
+		.sort(
+			(a: ModelInfo, b: ModelInfo) =>
+				(a.cost?.input ?? Infinity) - (b.cost?.input ?? Infinity),
+		);
+
+	return sorted[0]?.id ?? filteredModels[0]?.id;
+}
+
+export function getModelNpmBinding(
+	provider: ProviderId,
+	model: string,
+): string | undefined {
+	// 1) Check provider's own catalog entry
+	const entry = catalog[provider];
+	const modelInfo = entry?.models?.find((m) => m.id === model);
+	if (modelInfo?.provider?.npm) return modelInfo.provider.npm;
+	if (entry?.npm) return entry.npm;
+
+	// 2) Search entire catalog for the model
+	for (const key of Object.keys(catalog) as ProviderId[]) {
+		const e = catalog[key];
+		const m = e?.models?.find((x) => x.id === model);
+		if (m?.provider?.npm) return m.provider.npm;
+		if (m && e?.npm) return e.npm;
+	}
+	return undefined;
+}
+
+export function isAnthropicBasedModel(
+	provider: ProviderId,
+	model: string,
+): boolean {
+	if (provider === 'anthropic') return true;
+	const npm = getModelNpmBinding(provider, model);
+	if (npm === '@ai-sdk/anthropic') return true;
+	return false;
+}
+
+export type UnderlyingProviderKey =
+	| 'anthropic'
+	| 'openai'
+	| 'google'
+	| 'moonshot'
+	| 'openai-compatible'
+	| null;
+
+export function getUnderlyingProviderKey(
+	provider: ProviderId,
+	model: string,
+): UnderlyingProviderKey {
+	if (provider === 'anthropic') return 'anthropic';
+	if (provider === 'openai') return 'openai';
+	if (provider === 'google') return 'google';
+	if (provider === 'moonshot') return 'moonshot';
+	if (provider === 'copilot') return 'openai';
+
+	const npm = getModelNpmBinding(provider, model);
+	if (npm === '@ai-sdk/anthropic') return 'anthropic';
+	if (npm === '@ai-sdk/openai') return 'openai';
+	if (npm === '@ai-sdk/google') return 'google';
+	if (npm === '@ai-sdk/openai-compatible') return 'openai-compatible';
+	if (npm === '@openrouter/ai-sdk-provider') return 'openai-compatible';
+	return null;
+}
+
+export function getModelFamily(
+	provider: ProviderId,
+	model: string,
+): UnderlyingProviderKey {
+	// 1) Direct provider mapping
+	if (provider === 'anthropic') return 'anthropic';
+	if (provider === 'openai') return 'openai';
+	if (provider === 'google') return 'google';
+	if (provider === 'moonshot') return 'moonshot';
+	if (provider === 'copilot') return 'openai';
+
+	// 2) For aggregate providers, infer from model ID patterns
+	if (provider === 'openrouter' || provider === 'opencode') {
+		const lowerModel = model.toLowerCase();
+		// Anthropic models
+		if (lowerModel.includes('claude') || lowerModel.startsWith('anthropic/')) {
+			return 'anthropic';
+		}
+		// OpenAI models
+		if (
+			lowerModel.includes('gpt') ||
+			lowerModel.startsWith('openai/') ||
+			lowerModel.includes('codex')
+		) {
+			return 'openai';
+		}
+		// Google models
+		if (lowerModel.includes('gemini') || lowerModel.startsWith('google/')) {
+			return 'google';
+		}
+		// Moonshot models
+		if (lowerModel.includes('kimi') || lowerModel.startsWith('moonshotai/')) {
+			return 'moonshot';
+		}
+	}
+
+	// 2) Check model's family field in catalog
+	const info = getModelInfo(provider, model);
+	if (info?.provider?.family) {
+		return info.provider.family as UnderlyingProviderKey;
+	}
+
+	// 3) Fall back to npm binding (for zai and other providers)
+	return getUnderlyingProviderKey(provider, model);
+}
+
+export function getModelInfo(
+	provider: ProviderId,
+	model: string,
+): ModelInfo | undefined {
+	const entry = catalog[provider];
+	if (!entry) return undefined;
+	return entry.models?.find((m) => m.id === model);
+}
+
+export function modelSupportsReasoning(
+	provider: ProviderId,
+	model: string,
+): boolean {
+	const info = getModelInfo(provider, model);
+	return info?.reasoningText === true;
+}

package/src/providers/src/validate.ts

@@ -0,0 +1,39 @@
+import { catalog } from './catalog-merged.ts';
+import type { ProviderId } from '../../types/src/index.ts';
+
+export type CapabilityRequest = {
+	wantsToolCalls?: boolean;
+	wantsVision?: boolean; // input image
+};
+
+export function validateProviderModel(
+	provider: string,
+	model: string,
+	cap?: CapabilityRequest,
+) {
+	const p = provider as ProviderId;
+	if (!catalog[p]) {
+		throw new Error(`Provider not supported: ${provider}`);
+	}
+	const entry = catalog[p].models.find((m) => m.id === model);
+	if (!entry) {
+		const list = catalog[p].models
+			.slice(0, 10)
+			.map((m) => m.id)
+			.join(', ');
+		throw new Error(
+			`Model not found for provider ${provider}: ${model}. Example models: ${list}${catalog[p].models.length > 10 ? ', ...' : ''}`,
+		);
+	}
+	if (cap?.wantsToolCalls && !entry.toolCall) {
+		throw new Error(`Model ${model} does not support tool calls.`);
+	}
+	if (cap?.wantsVision) {
+		const inputs = entry.modalities?.input as string[] | undefined;
+		const outputs = entry.modalities?.output as string[] | undefined;
+		const ok =
+			(inputs ?? []).includes('image') || (outputs ?? []).includes('image');
+		if (!ok)
+			throw new Error(`Model ${model} does not support vision input/output.`);
+	}
+}

package/src/providers/src/zai-client.ts

@@ -0,0 +1,47 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { catalog } from './catalog-merged.ts';
+
+export type ZaiProviderConfig = {
+	apiKey?: string;
+};
+
+export function createZaiModel(model: string, config?: ZaiProviderConfig) {
+	const entry = catalog.zai;
+	const baseURL = entry?.api || 'https://api.z.ai/api/paas/v4';
+	const apiKey =
+		config?.apiKey ||
+		process.env.ZAI_API_KEY ||
+		process.env.ZHIPU_API_KEY ||
+		'';
+	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+
+	const instance = createOpenAICompatible({
+		name: entry?.label ?? 'Z.AI',
+		baseURL,
+		headers,
+	});
+
+	return instance(model);
+}
+
+export function createZaiCodingModel(
+	model: string,
+	config?: ZaiProviderConfig,
+) {
+	const entry = catalog['zai-coding'];
+	const baseURL = entry?.api || 'https://api.z.ai/api/coding/paas/v4';
+	const apiKey =
+		config?.apiKey ||
+		process.env.ZAI_API_KEY ||
+		process.env.ZHIPU_API_KEY ||
+		'';
+	const headers = apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined;
+
+	const instance = createOpenAICompatible({
+		name: entry?.label ?? 'Z.AI Coding',
+		baseURL,
+		headers,
+	});
+
+	return instance(model);
+}

package/src/skills/index.ts

@@ -0,0 +1,34 @@
+export type {
+	SkillScope,
+	SkillMetadata,
+	SkillDefinition,
+	DiscoveredSkill,
+	SkillLoadResult,
+	SkillErrorResult,
+	SkillResult,
+} from './types.ts';
+
+export {
+	validateMetadata,
+	validateSkillName,
+	SkillValidationError,
+} from './validator.ts';
+
+export { parseSkillFile, extractFrontmatter } from './parser.ts';
+
+export {
+	discoverSkills,
+	loadSkill,
+	getSkillCache,
+	clearSkillCache,
+	findGitRoot,
+	listSkillsInDir,
+} from './loader.ts';
+
+export {
+	initializeSkills,
+	getDiscoveredSkills,
+	isSkillsInitialized,
+	buildSkillTool,
+	rebuildSkillDescription,
+} from './tool.ts';

package/src/skills/loader.ts

@@ -0,0 +1,152 @@
+import { join, dirname } from 'node:path';
+import { promises as fs } from 'node:fs';
+import fg from 'fast-glob';
+import { parseSkillFile } from './parser.ts';
+import type { SkillDefinition, DiscoveredSkill, SkillScope } from './types.ts';
+import { getGlobalConfigDir, getHomeDir } from '../config/src/paths.ts';
+
+const skillCache = new Map<string, SkillDefinition>();
+
+const SKILL_DIRS = [
+	'.otto/skills',
+	'.claude/skills',
+	'.opencode/skills',
+	'.codex/skills',
+];
+
+export async function discoverSkills(
+	cwd: string,
+	repoRoot?: string,
+): Promise<DiscoveredSkill[]> {
+	const skills = new Map<string, SkillDefinition>();
+	const home = getHomeDir();
+
+	const globalDirs = [
+		join(getGlobalConfigDir(), 'skills'),
+		join(home, '.claude/skills'),
+		join(home, '.config/opencode/skills'),
+		join(home, '.codex/skills'),
+	];
+	for (const dir of globalDirs) {
+		await loadSkillsFromDir(dir, 'user', skills);
+	}
+
+	if (repoRoot && repoRoot !== cwd) {
+		for (const skillDir of SKILL_DIRS) {
+			await loadSkillsFromDir(join(repoRoot, skillDir), 'repo', skills);
+		}
+	}
+
+	let current = cwd;
+	const visited = new Set<string>();
+	while (current && !visited.has(current)) {
+		visited.add(current);
+		const scope: SkillScope =
+			current === cwd ? 'cwd' : current === repoRoot ? 'repo' : 'parent';
+		for (const skillDir of SKILL_DIRS) {
+			await loadSkillsFromDir(join(current, skillDir), scope, skills);
+		}
+		const parent = dirname(current);
+		if (parent === current) break;
+		if (repoRoot && !current.startsWith(repoRoot)) break;
+		current = parent;
+	}
+
+	skillCache.clear();
+	for (const [name, def] of skills) {
+		skillCache.set(name, def);
+	}
+
+	return Array.from(skills.values()).map((s) => ({
+		name: s.metadata.name,
+		description: s.metadata.description,
+		path: s.path,
+		scope: s.scope,
+	}));
+}
+
+export async function loadSkill(name: string): Promise<SkillDefinition | null> {
+	return skillCache.get(name) ?? null;
+}
+
+export function getSkillCache(): Map<string, SkillDefinition> {
+	return skillCache;
+}
+
+export function clearSkillCache(): void {
+	skillCache.clear();
+}
+
+async function loadSkillsFromDir(
+	dir: string,
+	scope: SkillScope,
+	skills: Map<string, SkillDefinition>,
+): Promise<void> {
+	try {
+		await fs.access(dir);
+	} catch {
+		return;
+	}
+
+	const pattern = '*/SKILL.md';
+	let files: string[];
+	try {
+		files = await fg(pattern, { cwd: dir, absolute: true });
+	} catch {
+		return;
+	}
+
+	for (const filePath of files) {
+		try {
+			const content = await fs.readFile(filePath, 'utf-8');
+			const skill = parseSkillFile(content, filePath, scope);
+
+			const dirName = dirname(filePath).split('/').pop();
+			if (dirName !== skill.metadata.name) {
+				if (process.env.OTTO_DEBUG === '1') {
+					console.warn(
+						`Skill name '${skill.metadata.name}' doesn't match directory '${dirName}' in ${filePath}`,
+					);
+				}
+			}
+
+			skills.set(skill.metadata.name, skill);
+		} catch (err) {
+			if (process.env.OTTO_DEBUG === '1') {
+				console.error(`Failed to load skill from ${filePath}:`, err);
+			}
+		}
+	}
+}
+
+export async function findGitRoot(startDir: string): Promise<string | null> {
+	let current = startDir;
+	const visited = new Set<string>();
+
+	while (current && !visited.has(current)) {
+		visited.add(current);
+		try {
+			await fs.access(join(current, '.git'));
+			return current;
+		} catch {
+			const parent = dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+	}
+
+	return null;
+}
+
+export async function listSkillsInDir(dir: string): Promise<string[]> {
+	try {
+		await fs.access(dir);
+	} catch {
+		return [];
+	}
+
+	const pattern = '*/SKILL.md';
+	const files = await fg(pattern, { cwd: dir, absolute: false });
+
+	return files.map((f) => dirname(f));
+}

package/src/skills/parser.ts

@@ -0,0 +1,108 @@
+import type { SkillDefinition, SkillMetadata, SkillScope } from './types.ts';
+import { validateMetadata } from './validator.ts';
+
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+
+export function parseSkillFile(
+	content: string,
+	path: string,
+	scope: SkillScope,
+): SkillDefinition {
+	const match = content.match(FRONTMATTER_REGEX);
+	if (!match) {
+		throw new Error(`Invalid SKILL.md format: missing frontmatter in ${path}`);
+	}
+
+	const [, yamlStr, body] = match;
+	if (!yamlStr) {
+		throw new Error(`Empty frontmatter in ${path}`);
+	}
+
+	const metadata = parseYamlFrontmatter(yamlStr, path);
+	validateMetadata(metadata, path);
+
+	return {
+		metadata: metadata as SkillMetadata,
+		content: body?.trim() ?? '',
+		path,
+		scope,
+	};
+}
+
+function parseYamlFrontmatter(
+	yaml: string,
+	_path: string,
+): Record<string, unknown> {
+	const result: Record<string, unknown> = {};
+	const lines = yaml.split('\n');
+	let currentKey: string | null = null;
+	let currentIndent = 0;
+	let nestedObject: Record<string, string> | null = null;
+
+	for (const line of lines) {
+		if (!line.trim()) continue;
+
+		const indent = line.search(/\S/);
+		const trimmed = line.trim();
+
+		if (indent === 0 || (indent <= currentIndent && nestedObject)) {
+			if (nestedObject && currentKey) {
+				result[currentKey] = nestedObject;
+				nestedObject = null;
+				currentKey = null;
+			}
+		}
+
+		const colonIdx = trimmed.indexOf(':');
+		if (colonIdx === -1) continue;
+
+		const key = trimmed.slice(0, colonIdx).trim();
+		const value = trimmed.slice(colonIdx + 1).trim();
+
+		if (indent > 0 && nestedObject) {
+			nestedObject[key] = parseYamlValue(value);
+			continue;
+		}
+
+		if (!value) {
+			currentKey = normalizeKey(key);
+			currentIndent = indent;
+			nestedObject = {};
+			continue;
+		}
+
+		result[normalizeKey(key)] = parseYamlValue(value);
+	}
+
+	if (nestedObject && currentKey) {
+		result[currentKey] = nestedObject;
+	}
+
+	return result;
+}
+
+function normalizeKey(key: string): string {
+	if (key === 'allowed-tools') return 'allowedTools';
+	return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+function parseYamlValue(value: string): string {
+	if (
+		(value.startsWith('"') && value.endsWith('"')) ||
+		(value.startsWith("'") && value.endsWith("'"))
+	) {
+		return value.slice(1, -1);
+	}
+	return value;
+}
+
+export function extractFrontmatter(
+	content: string,
+): { frontmatter: string; body: string } | null {
+	const match = content.match(FRONTMATTER_REGEX);
+	if (!match) return null;
+	return {
+		frontmatter: match[1] ?? '',
+		body: match[2] ?? '',
+	};
+}

package/src/skills/tool.ts

@@ -0,0 +1,87 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+import { loadSkill, discoverSkills, findGitRoot } from './loader.ts';
+import type { DiscoveredSkill, SkillResult } from './types.ts';
+
+let cachedSkillList: DiscoveredSkill[] = [];
+let initializedForPath: string | null = null;
+
+export async function initializeSkills(
+	cwd: string,
+	repoRoot?: string,
+): Promise<DiscoveredSkill[]> {
+	const root = repoRoot ?? (await findGitRoot(cwd)) ?? cwd;
+	cachedSkillList = await discoverSkills(cwd, root);
+	initializedForPath = cwd;
+	return cachedSkillList;
+}
+
+export function getDiscoveredSkills(): DiscoveredSkill[] {
+	return cachedSkillList;
+}
+
+export function isSkillsInitialized(forPath?: string): boolean {
+	if (!initializedForPath) return false;
+	if (forPath && forPath !== initializedForPath) return false;
+	return true;
+}
+
+export function buildSkillTool(): { name: string; tool: Tool } {
+	const skillTool = tool({
+		description: buildSkillDescription(),
+		inputSchema: z.object({
+			name: z.string().describe('Name of the skill to load'),
+		}),
+		async execute({ name }: { name: string }): Promise<SkillResult> {
+			const skill = await loadSkill(name);
+			if (!skill) {
+				return { ok: false, error: `Skill '${name}' not found` };
+			}
+			return {
+				ok: true,
+				name: skill.metadata.name,
+				description: skill.metadata.description,
+				content: skill.content,
+				path: skill.path,
+				scope: skill.scope,
+				allowedTools: skill.metadata.allowedTools,
+			};
+		},
+	});
+
+	return { name: 'skill', tool: skillTool };
+}
+
+function buildSkillDescription(): string {
+	if (cachedSkillList.length === 0) {
+		return 'Load a skill by name. No skills are currently available.';
+	}
+
+	const skillsXml = cachedSkillList
+		.map(
+			(s) =>
+				`<skill><name>${escapeXml(s.name)}</name><description>${escapeXml(s.description)}</description></skill>`,
+		)
+		.join('\n');
+
+	return `Load a skill by name to get detailed instructions.
+
+<available_skills>
+${skillsXml}
+</available_skills>
+
+Call this tool with the skill name when you need the full instructions.`;
+}
+
+function escapeXml(str: string): string {
+	return str
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;')
+		.replace(/'/g, '&apos;');
+}
+
+export function rebuildSkillDescription(): string {
+	return buildSkillDescription();
+}