SkillRegistry

import { SkillRegistry } from '@frontmcp/sdk';

// Access via scope
const skills = scope.skills;

// List all skills
const allSkills = skills.getSkills();

// Search skills
const results = await skills.search('data analysis');

// Load a skill
const skill = await skills.loadSkill('data-pipeline');

getSkills(options?: GetSkillsOptions): ReadonlyArray<SkillEntry>

// Get all visible skills
const skills = registry.getSkills();

// Get skills visible via HTTP
const httpSkills = registry.getSkills({ visibility: 'http' });

search(query: string, options?: SearchOptions): Promise<SearchResult[]>

const results = await registry.search('data analysis', {
  limit: 10,
  minScore: 0.5,
});

for (const result of results) {
  console.log(`${result.skill.name}: ${result.score}`);
}

loadSkill(skillId: string): Promise<LoadedSkill>

const skill = await registry.loadSkill('data-pipeline');
console.log(skill.content); // Full skill content
console.log(skill.tools);   // Validated tool references

listSkills(options?: ListOptions): Promise<SkillListResult>

const page = await registry.listSkills({
  offset: 0,
  limit: 20,
});

console.log(`Total: ${page.total}`);
console.log(`Skills: ${page.items.length}`);

count(options?: CountOptions): Promise<number>

findByName(name: string): SkillEntry | undefined

findByQualifiedName(qualifiedName: string): SkillEntry | undefined

getInlineSkills(): ReadonlyArray<SkillEntry>

validateAllTools(): ValidationResult

const result = registry.validateAllTools();
if (!result.valid) {
  for (const error of result.errors) {
    console.error(`${error.skill}: Missing tool ${error.tool}`);
  }
}

subscribe(
  opts: SubscribeOptions,
  cb: (event: SkillChangeEvent) => void
): () => void

getCapabilities(): { listChanged: boolean }

hasAny(): boolean

adoptFromChild(child: SkillRegistry, childOwner: Owner): void

registerSkillContent(content: SkillContent, opts?: RegisterSkillContentOptions): Promise<RegisteredSkillContent>

const handle = await scope.skills.registerSkillContent(
  { id: 'reports', name: 'reports', description: 'Quarterly reports', instructions: '# Reports', tools: [] },
  { source: 'my-plugin', supersedes: ['reports-v1'] },
);
console.log(handle.removed); // ['reports-v1'] when that skill held the path `reports`
await handle.unregister();

unregisterSkill(id: string): Promise<boolean>

setExternalProvider(provider: ExternalSkillProviderBase): void

syncToExternal(): Promise<SyncResult>

// Configure Redis-based storage
registry.setExternalProvider(new RedisSkillProvider(redisClient));

// Sync skills
const result = await registry.syncToExternal();
console.log(`Synced ${result.count} skills`);

hasExternalProvider(): boolean

getExternalProvider(): ExternalSkillProviderBase | undefined

interface SkillChangeEvent {
  kind: 'added' | 'updated' | 'removed' | 'reset';
  changeScope: 'global' | 'session';
  version: number;
  snapshot: ReadonlyArray<SkillEntry>;
  sessionId?: string;
  relatedRequestId?: string;
}

const skill = registry.findByName('review-pr');
if (skill) {
  console.log(skill.getLicense());       // 'MIT'
  console.log(skill.getCompatibility()); // 'Requires git CLI'
  console.log(skill.getResources());     // { scripts: '...', references: '...' }
}

@Skill({
  name: 'internal-task',
  visibility: 'mcp', // Only for MCP clients
})
class InternalTask extends SkillContext { }

@Skill({
  name: 'public-api',
  visibility: 'http', // Only for HTTP clients
})
class PublicAPI extends SkillContext { }

@Skill({
  name: 'data-pipeline',
  tools: ['fetch_data', 'transform', 'save_results'],
})
class DataPipeline extends SkillContext { }