@ottocode/sdk 0.1.252 → 0.1.254

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.252",
+	"version": "0.1.254",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/config/src/index.ts

@@ -57,7 +57,11 @@ export async function loadConfig(
 	const projectCfg = await readJsonOptional(projectConfigPath);
 	const globalCfg = await readJsonOptional(globalConfigPath);
 
-	const merged = deepMerge(DEFAULTS, globalCfg, projectCfg);
+	const merged = deepMerge(
+		DEFAULTS,
+		globalCfg,
+		omitGlobalOnlySettings(projectCfg),
+	);
 
 	await ensureDir(dataDir);
 
@@ -81,6 +85,14 @@ export async function loadConfig(
 
 type JsonObject = Record<string, unknown>;
 
+function omitGlobalOnlySettings(
+	config: JsonObject | undefined,
+): JsonObject | undefined {
+	if (!config) return undefined;
+	const { providers: _providers, skills: _skills, ...rest } = config;
+	return rest;
+}
+
 async function readJsonOptional(file: string): Promise<JsonObject | undefined> {
 	const f = Bun.file(file);
 	if (!(await f.exists())) return undefined;

package/src/config/src/manager.ts

@@ -104,12 +104,12 @@ export async function writeDefaults(
  * Persist provider settings for a built-in or custom provider entry.
  */
 export async function writeProviderSettings(
-	scope: Scope,
+	_scope: Scope,
 	provider: string,
 	updates: ProviderSettingsEntry,
-	projectRoot?: string,
+	_projectRoot?: string,
 ) {
-	const filePath = getConfigFilePath(scope, projectRoot);
+	const filePath = getConfigFilePath('global');
 	const existing = await readJsonFile(filePath);
 	const prevProviders =
 		existing && typeof existing.providers === 'object'
@@ -133,11 +133,11 @@ export async function writeProviderSettings(
  * Remove a provider override or custom provider entry from config.
  */
 export async function removeProviderSettings(
-	scope: Scope,
+	_scope: Scope,
 	provider: string,
-	projectRoot?: string,
+	_projectRoot?: string,
 ) {
-	const filePath = getConfigFilePath(scope, projectRoot);
+	const filePath = getConfigFilePath('global');
 	const existing = await readJsonFile(filePath);
 	if (!existing || typeof existing.providers !== 'object') return;
 	const providers = { ...(existing.providers as Record<string, unknown>) };
@@ -147,11 +147,11 @@ export async function removeProviderSettings(
 }
 
 export async function writeSkillSettings(
-	scope: Scope,
+	_scope: Scope,
 	updates: SkillSettings,
-	projectRoot?: string,
+	_projectRoot?: string,
 ) {
-	const filePath = getConfigFilePath(scope, projectRoot);
+	const filePath = getConfigFilePath('global');
 	const existing = await readJsonFile(filePath);
 	const prevSkills =
 		existing && typeof existing.skills === 'object'

package/src/core/src/tools/builtin/fs/copy-into.ts

@@ -0,0 +1,270 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+import DESCRIPTION from './copy-into.txt' with { type: 'text' };
+import { buildWriteArtifact, isAbsoluteLike, resolveSafePath } from './util.ts';
+import {
+	convertToLineEnding,
+	detectLineEnding,
+	normalizeLineEndings,
+} from './edit-shared.ts';
+import { assertFreshRead, rememberFileWrite } from './read-tracker.ts';
+import { createToolError, type ToolResponse } from '../../error.ts';
+
+const copyIntoSchema = z.object({
+	sourcePath: z
+		.string()
+		.describe('Relative source file path within the project.'),
+	startLine: z
+		.number()
+		.int()
+		.min(1)
+		.describe('First source line to copy, 1-indexed and inclusive.'),
+	endLine: z
+		.number()
+		.int()
+		.min(1)
+		.describe('Last source line to copy, 1-indexed and inclusive.'),
+	targetPath: z
+		.string()
+		.describe('Relative target file path within the project.'),
+	insertAtLine: z
+		.number()
+		.int()
+		.min(1)
+		.optional()
+		.describe(
+			'Line to insert before, 1-indexed. Use totalLines + 1 to append.',
+		),
+	mode: z
+		.enum(['insert_before', 'insert_after', 'replace_range'])
+		.optional()
+		.default('insert_before')
+		.describe('How to apply copied content to the target file.'),
+	targetStartLine: z
+		.number()
+		.int()
+		.min(1)
+		.optional()
+		.describe('First target line to replace when mode is replace_range.'),
+	targetEndLine: z
+		.number()
+		.int()
+		.min(1)
+		.optional()
+		.describe('Last target line to replace when mode is replace_range.'),
+});
+
+type CopyIntoInput = z.infer<typeof copyIntoSchema>;
+
+function splitLinesForEdit(content: string): {
+	lines: string[];
+	trailingNewline: boolean;
+} {
+	const normalized = normalizeLineEndings(content);
+	const trailingNewline = normalized.endsWith('\n');
+	const lines = normalized.split('\n');
+	if (trailingNewline) lines.pop();
+	return { lines, trailingNewline };
+}
+
+function joinLinesForEdit(lines: string[], trailingNewline: boolean): string {
+	const joined = lines.join('\n');
+	return trailingNewline ? `${joined}\n` : joined;
+}
+
+function validateRelativePath(path: string, label: string): string | undefined {
+	if (!path || path.trim().length === 0) {
+		return `Missing required parameter: ${label}`;
+	}
+	if (isAbsoluteLike(path)) {
+		return `Refusing to access outside project root: ${path}. Use a relative path within the project.`;
+	}
+	return undefined;
+}
+
+function getLineRange(
+	lines: string[],
+	startLine: number,
+	endLine: number,
+): string[] {
+	if (startLine > endLine) {
+		throw new Error('startLine must be less than or equal to endLine.');
+	}
+	if (endLine > lines.length) {
+		throw new Error(
+			`Source range ${startLine}-${endLine} exceeds source file length (${lines.length} lines).`,
+		);
+	}
+	return lines.slice(startLine - 1, endLine);
+}
+
+function applyCopiedLines(
+	input: CopyIntoInput,
+	targetLines: string[],
+	copied: string[],
+): string[] {
+	const mode = input.mode ?? 'insert_before';
+	if (mode === 'replace_range') {
+		if (
+			input.targetStartLine === undefined ||
+			input.targetEndLine === undefined
+		) {
+			throw new Error(
+				'targetStartLine and targetEndLine are required when mode is replace_range.',
+			);
+		}
+		if (input.targetStartLine > input.targetEndLine) {
+			throw new Error(
+				'targetStartLine must be less than or equal to targetEndLine.',
+			);
+		}
+		if (input.targetEndLine > targetLines.length) {
+			throw new Error(
+				`Target range ${input.targetStartLine}-${input.targetEndLine} exceeds target file length (${targetLines.length} lines).`,
+			);
+		}
+		return [
+			...targetLines.slice(0, input.targetStartLine - 1),
+			...copied,
+			...targetLines.slice(input.targetEndLine),
+		];
+	}
+
+	if (input.insertAtLine === undefined) {
+		throw new Error(
+			'insertAtLine is required for insert_before and insert_after modes.',
+		);
+	}
+	if (input.insertAtLine > targetLines.length + 1) {
+		throw new Error(
+			`insertAtLine ${input.insertAtLine} exceeds append position (${targetLines.length + 1}).`,
+		);
+	}
+
+	const insertIndex =
+		mode === 'insert_after' ? input.insertAtLine : input.insertAtLine - 1;
+	if (insertIndex > targetLines.length) {
+		throw new Error(
+			`insertAtLine ${input.insertAtLine} with insert_after exceeds target file length (${targetLines.length} lines).`,
+		);
+	}
+
+	return [
+		...targetLines.slice(0, insertIndex),
+		...copied,
+		...targetLines.slice(insertIndex),
+	];
+}
+
+export function buildCopyIntoTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	const copyInto = tool({
+		description: DESCRIPTION,
+		inputSchema: copyIntoSchema,
+		async execute(input: CopyIntoInput): Promise<
+			ToolResponse<{
+				sourcePath: string;
+				targetPath: string;
+				linesCopied: number;
+				bytes: number;
+				artifact: unknown;
+			}>
+		> {
+			const sourcePathError = validateRelativePath(
+				input.sourcePath,
+				'sourcePath',
+			);
+			if (sourcePathError) {
+				return createToolError(sourcePathError, 'validation', {
+					parameter: 'sourcePath',
+					value: input.sourcePath,
+					suggestion: 'Use a relative path within the project',
+				});
+			}
+			const targetPathError = validateRelativePath(
+				input.targetPath,
+				'targetPath',
+			);
+			if (targetPathError) {
+				return createToolError(targetPathError, 'validation', {
+					parameter: 'targetPath',
+					value: input.targetPath,
+					suggestion: 'Use a relative path within the project',
+				});
+			}
+
+			const sourceAbs = resolveSafePath(projectRoot, input.sourcePath);
+			const targetAbs = resolveSafePath(projectRoot, input.targetPath);
+
+			try {
+				await assertFreshRead(projectRoot, targetAbs, input.targetPath);
+				const [sourceContent, targetContent] = await Promise.all([
+					readFile(sourceAbs, 'utf-8'),
+					readFile(targetAbs, 'utf-8'),
+				]);
+				const source = splitLinesForEdit(sourceContent);
+				const copiedLines = getLineRange(
+					source.lines,
+					input.startLine,
+					input.endLine,
+				);
+				const target = splitLinesForEdit(targetContent);
+				const nextLines = applyCopiedLines(input, target.lines, copiedLines);
+				const nextNormalized = joinLinesForEdit(
+					nextLines,
+					target.trailingNewline,
+				);
+				const nextContent = convertToLineEnding(
+					nextNormalized,
+					detectLineEnding(targetContent),
+				);
+
+				if (nextContent === targetContent) {
+					return createToolError('No changes applied.', 'validation', {
+						suggestion:
+							'Choose a source range or target location that changes the file',
+					});
+				}
+
+				await writeFile(targetAbs, nextContent, 'utf-8');
+				await rememberFileWrite(projectRoot, targetAbs);
+				const artifact = await buildWriteArtifact(
+					input.targetPath,
+					true,
+					targetContent,
+					nextContent,
+				);
+				return {
+					ok: true,
+					sourcePath: input.sourcePath,
+					targetPath: input.targetPath,
+					linesCopied: copiedLines.length,
+					bytes: nextContent.length,
+					artifact,
+				};
+			} catch (error: unknown) {
+				const isEnoent =
+					error &&
+					typeof error === 'object' &&
+					'code' in error &&
+					error.code === 'ENOENT';
+				return createToolError(
+					isEnoent
+						? 'Source or target file not found.'
+						: `Failed to copy into file: ${error instanceof Error ? error.message : String(error)}`,
+					isEnoent ? 'not_found' : 'execution',
+					{
+						suggestion: isEnoent
+							? 'Use read, ls, or tree to confirm both file paths first'
+							: undefined,
+					},
+				);
+			}
+		},
+	});
+
+	return { name: 'copy_into', tool: copyInto };
+}

package/src/core/src/tools/builtin/fs/copy-into.txt

@@ -0,0 +1,11 @@
+Copy a line range from one project file into another project file without reprinting the copied content.
+
+Use this when duplicating large existing content such as SVGs, licenses, generated blocks, examples, or repeated config snippets.
+
+Rules:
+- Source and target paths must be relative paths within the project.
+- You must read the target file first in the current session before modifying it.
+- Line numbers are 1-indexed and inclusive.
+- `insertAtLine` inserts before that line. Use `insertAtLine: totalLines + 1` to append.
+- Use `mode: "replace_range"` with `targetStartLine` and `targetEndLine` to replace target lines.
+- This tool does not use the system clipboard.

package/src/core/src/tools/builtin/fs/index.ts

@@ -3,6 +3,7 @@ import { buildEditTool } from './edit.ts';
 import { buildReadTool } from './read.ts';
 import { buildMultiEditTool } from './multiedit.ts';
 import { buildWriteTool } from './write.ts';
+import { buildCopyIntoTool } from './copy-into.ts';
 import { buildLsTool } from './ls.ts';
 import { buildTreeTool } from './tree.ts';
 import { buildPwdTool } from './pwd.ts';
@@ -16,6 +17,7 @@ export function buildFsTools(
 	out.push(buildEditTool(projectRoot));
 	out.push(buildMultiEditTool(projectRoot));
 	out.push(buildWriteTool(projectRoot));
+	out.push(buildCopyIntoTool(projectRoot));
 	out.push(buildLsTool(projectRoot));
 	out.push(buildTreeTool(projectRoot));
 	out.push(buildPwdTool());

package/src/providers/src/model-catalog-cache.ts

@@ -16,8 +16,10 @@ export type CachedModelCatalog = {
 export const DEFAULT_REMOTE_MODEL_CATALOG_URL =
 	'https://ottocode.io/catalog/models.json';
 
+const MODEL_CATALOG_CACHE_FILENAME = 'catalog-models.json';
+
 export function getModelCatalogCachePath(): string {
-	return joinPath(getGlobalConfigDir(), 'models-catalog.json');
+	return joinPath(getGlobalConfigDir(), MODEL_CATALOG_CACHE_FILENAME);
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -30,10 +32,10 @@ async function loadFsPromises(): Promise<typeof import('node:fs/promises')> {
 
 function readFileSyncCompat(path: string): string | null {
 	try {
-		const req = Function(
-			'return typeof require === "function" ? require : null',
-		)() as ((specifier: string) => typeof import('node:fs')) | null;
-		return req?.('node:fs').readFileSync(path, 'utf8') ?? null;
+		const fs = globalThis.process?.getBuiltinModule?.('node:fs') as
+			| { readFileSync: (filePath: string, encoding: 'utf8') => string }
+			| undefined;
+		return fs?.readFileSync(path, 'utf8') ?? null;
 	} catch {
 		return null;
 	}
@@ -70,21 +72,27 @@ export function normalizeModelCatalogPayload(
 	return providers;
 }
 
+function normalizeCachedModelCatalogPayload(
+	payload: unknown,
+): CachedModelCatalog {
+	const updatedAt =
+		isRecord(payload) && typeof payload.updatedAt === 'string'
+			? payload.updatedAt
+			: new Date(0).toISOString();
+	return {
+		version: 1,
+		updatedAt,
+		providers: normalizeModelCatalogPayload(payload),
+	};
+}
+
 export async function readCachedModelCatalog(): Promise<CachedModelCatalog | null> {
 	try {
 		const { readFile } = await loadFsPromises();
 		const payload = JSON.parse(
 			await readFile(getModelCatalogCachePath(), 'utf8'),
 		);
-		const providers = normalizeModelCatalogPayload(payload);
-		return {
-			version: 1,
-			updatedAt:
-				isRecord(payload) && typeof payload.updatedAt === 'string'
-					? payload.updatedAt
-					: new Date(0).toISOString(),
-			providers,
-		};
+		return normalizeCachedModelCatalogPayload(payload);
 	} catch {
 		return null;
 	}
@@ -95,15 +103,7 @@ export function readCachedModelCatalogSync(): CachedModelCatalog | null {
 		const text = readFileSyncCompat(getModelCatalogCachePath());
 		if (!text) return null;
 		const payload = JSON.parse(text);
-		const providers = normalizeModelCatalogPayload(payload);
-		return {
-			version: 1,
-			updatedAt:
-				isRecord(payload) && typeof payload.updatedAt === 'string'
-					? payload.updatedAt
-					: new Date(0).toISOString(),
-			providers,
-		};
+		return normalizeCachedModelCatalogPayload(payload);
 	} catch {
 		return null;
 	}

package/src/providers/src/registry.ts

@@ -56,25 +56,7 @@ const BUILTIN_FAMILY: Record<BuiltInProviderId, ProviderPromptFamily> = {
 	minimax: 'minimax',
 };
 
-function normalizeCustomModels(
-	models: Array<string | ModelInfo> | undefined,
-): ModelInfo[] {
-	return (models ?? [])
-		.map((model) => {
-			if (typeof model === 'string') {
-				const id = String(model).trim();
-				return id ? ({ id, label: id } satisfies ModelInfo) : null;
-			}
-			const id = String(model.id ?? '').trim();
-			if (!id) return null;
-			return {
-				...model,
-				id,
-				label: model.label?.trim() || id,
-			} satisfies ModelInfo;
-		})
-		.filter((model): model is ModelInfo => Boolean(model));
-}
+const USE_BUILTIN_MODEL_CATALOG = process.env.CI === 'true';
 
 function normalizeOptionalText(value: string | undefined): string | undefined {
 	if (!value) return undefined;
@@ -97,13 +79,6 @@ function resolveCustomFamily(
 	return settings.family ?? 'default';
 }
 
-function resolveCustomProviderLabel(
-	id: string,
-	settings: ProviderSettingsEntry,
-): string {
-	return settings.label ?? id;
-}
-
 export function isBuiltInProviderId(
 	value: unknown,
 ): value is BuiltInProviderId {
@@ -129,9 +104,8 @@ export function getProviderDefinition(
 		const entry = catalog[provider];
 		if (!entry) return undefined;
 		const cachedEntry = getCachedProviderCatalogEntry(provider);
-		const models = cachedEntry?.models.length
-			? cachedEntry.models
-			: entry.models;
+		const models =
+			cachedEntry?.models ?? (USE_BUILTIN_MODEL_CATALOG ? entry.models : []);
 		return {
 			id: provider,
 			label: settings?.label ?? cachedEntry?.label ?? entry.label ?? provider,
@@ -148,10 +122,11 @@ export function getProviderDefinition(
 	}
 
 	if (!settings?.custom) return undefined;
-	const models = normalizeCustomModels(settings.models);
+	const cachedEntry = getCachedProviderCatalogEntry(provider);
+	const models = cachedEntry?.models ?? [];
 	return {
 		id: provider,
-		label: resolveCustomProviderLabel(provider, settings),
+		label: settings.label ?? cachedEntry?.label ?? provider,
 		source: 'custom',
 		compatibility: resolveCustomCompatibility(settings),
 		family: resolveCustomFamily(settings),

package/src/providers/src/validate.ts

@@ -3,7 +3,6 @@ import { getCachedProviderCatalogEntry } from './model-catalog-cache.ts';
 import type { OttoConfig, ProviderId } from '../../types/src/index.ts';
 import {
 	getProviderDefinition,
-	getConfiguredProviderModels,
 	hasConfiguredModel,
 	providerAllowsAnyModel,
 } from './registry.ts';
@@ -19,51 +18,76 @@ export function validateProviderModel(
 	cfgOrCap?: OttoConfig | CapabilityRequest,
 	cap?: CapabilityRequest,
 ) {
+	const providerId = provider.trim() as ProviderId;
+	const modelId = model.trim();
 	const cfg = isOttoConfigLike(cfgOrCap) ? cfgOrCap : undefined;
 	const effectiveCap = isOttoConfigLike(cfgOrCap) ? cap : cfgOrCap;
 
 	if (cfg) {
-		const definition = getProviderDefinition(cfg, provider);
+		const definition = getProviderDefinition(cfg, providerId);
+		const cachedModels =
+			getCachedProviderCatalogEntry(providerId)?.models ?? [];
 		if (!definition) {
-			throw new Error(`Provider not supported: ${provider}`);
+			if (!cachedModels.length) {
+				throw new Error(`Provider not supported: ${providerId}`);
+			}
+			const entry = cachedModels.find((m) => m.id === modelId);
+			if (!entry) {
+				throwModelNotFound(providerId, modelId, cachedModels);
+			}
+			applyCapabilityValidation(modelId, entry, effectiveCap, {
+				strict: false,
+			});
+			return;
 		}
-		if (!providerAllowsAnyModel(cfg, provider)) {
-			if (!hasConfiguredModel(cfg, provider, model)) {
-				const list = getConfiguredProviderModels(cfg, provider)
-					.slice(0, 10)
-					.map((m) => m.id)
-					.join(', ');
-				throw new Error(
-					`Model not found for provider ${provider}: ${model}. Example models: ${list}${getConfiguredProviderModels(cfg, provider).length > 10 ? ', ...' : ''}`,
-				);
+		if (!providerAllowsAnyModel(cfg, providerId)) {
+			const knownModels = definition.models.length
+				? definition.models
+				: cachedModels;
+			const hasModel =
+				hasConfiguredModel(cfg, providerId, modelId) ||
+				cachedModels.some((m) => m.id === modelId);
+			if (!hasModel) {
+				throwModelNotFound(providerId, modelId, knownModels);
 			}
 		}
 
-		const entry = definition.models.find((m) => m.id === model);
+		const entry =
+			definition.models.find((m) => m.id === modelId) ??
+			cachedModels.find((m) => m.id === modelId);
 		if (entry) {
-			applyCapabilityValidation(model, entry, effectiveCap, {
+			applyCapabilityValidation(modelId, entry, effectiveCap, {
 				strict: definition.source !== 'custom',
 			});
 		}
 		return;
 	}
 
-	const p = provider as ProviderId;
-	if (!catalog[p]) {
-		throw new Error(`Provider not supported: ${provider}`);
+	const p = providerId;
+	if (!catalog[p] && !getCachedProviderCatalogEntry(p)) {
+		throw new Error(`Provider not supported: ${providerId}`);
 	}
-	const models = getCachedProviderCatalogEntry(p)?.models ?? catalog[p].models;
-	const entry = models.find((m) => m.id === model);
+	const models =
+		getCachedProviderCatalogEntry(p)?.models ?? catalog[p]?.models ?? [];
+	const entry = models.find((m) => m.id === modelId);
 	if (!entry) {
-		const list = models
-			.slice(0, 10)
-			.map((m) => m.id)
-			.join(', ');
-		throw new Error(
-			`Model not found for provider ${provider}: ${model}. Example models: ${list}${models.length > 10 ? ', ...' : ''}`,
-		);
+		throwModelNotFound(providerId, modelId, models);
 	}
-	applyCapabilityValidation(model, entry, effectiveCap, { strict: true });
+	applyCapabilityValidation(modelId, entry, effectiveCap, { strict: true });
+}
+
+function throwModelNotFound(
+	provider: ProviderId,
+	model: string,
+	models: Array<{ id: string }>,
+): never {
+	const list = models
+		.slice(0, 10)
+		.map((m) => m.id)
+		.join(', ');
+	throw new Error(
+		`Model not found for provider ${provider}: ${model}. Example models: ${list}${models.length > 10 ? ', ...' : ''}`,
+	);
 }
 
 function applyCapabilityValidation(

package/src/skills/loader.ts

@@ -12,15 +12,6 @@ import { getGlobalConfigDir, getHomeDir } from '../config/src/paths.ts';
 
 const skillCache = new Map<string, SkillDefinition>();
 
-const SKILL_DIRS = [
-	'.otto/skills',
-	'.agents/skills',
-	'.agenst/skills',
-	'.claude/skills',
-	'.opencode/skills',
-	'.codex/skills',
-];
-
 const ALLOWED_EXTENSIONS = new Set([
 	'.md',
 	'.txt',
@@ -47,8 +38,8 @@ const ALLOWED_EXTENSIONS = new Set([
 const MAX_FILE_SIZE = 256 * 1024;
 
 export async function discoverSkills(
-	cwd: string,
-	repoRoot?: string,
+	_cwd: string,
+	_repoRoot?: string,
 ): Promise<DiscoveredSkill[]> {
 	const skills = new Map<string, SkillDefinition>();
 	const home = getHomeDir();
@@ -65,27 +56,6 @@ export async function discoverSkills(
 		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)) {
-		if (repoRoot && !current.startsWith(repoRoot)) break;
-		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;
-		current = parent;
-	}
-
 	skillCache.clear();
 	for (const [name, def] of skills) {
 		skillCache.set(name, def);