Function parseAndRegister

packages/agent-core/src/skill/scanner.ts:362–415

(input: {
  readonly parse: NonNullable<DiscoverSkillsOptions['parse']>;
  readonly byName: Map<string, SkillDefinition>;
  readonly skillMdPath: string;
  readonly skillDirName: string;
  readonly root: SkillRoot;
  readonly onDiscoveredSkill?: (skill: SkillDefinition) => void;
  readonly warn: (message: string, cause?: unknown) => void;
  readonly skip: (skill: SkippedSkill) => void;
  readonly subSkillParentName?: string;
})

}

async function parseAndRegister(input: {
  readonly parse: NonNullable<DiscoverSkillsOptions['parse']>;
  readonly byName: Map<string, SkillDefinition>;
  readonly skillMdPath: string;
  readonly skillDirName: string;
  readonly root: SkillRoot;
  readonly onDiscoveredSkill?: (skill: SkillDefinition) => void;
  readonly warn: (message: string, cause?: unknown) => void;
  readonly skip: (skill: SkippedSkill) => void;
  readonly subSkillParentName?: string;
}): Promise<SkillDefinition | undefined> {
  try {
    const parsed = await input.parse({
      skillMdPath: input.skillMdPath,
      skillDirName: input.skillDirName,
      source: input.root.source,
    });
    const subSkillParentName = input.subSkillParentName;
    const skill =
      subSkillParentName !== undefined
        ? {
            ...parsed,
            name: qualifySubSkillName(subSkillParentName, parsed.name),
            metadata: {
              ...parsed.metadata,
              isSubSkill: true,
            },
          }
        : parsed;
    const discovered = input.root.plugin === undefined ? skill : {
      ...skill,
      plugin: input.root.plugin,
    };
    input.onDiscoveredSkill?.(discovered);
    const key = normalizeSkillName(discovered.name);
    if (!input.byName.has(key)) {
      input.byName.set(key, discovered);
    }
    return discovered;
  } catch (error) {
    if (error instanceof UnsupportedSkillTypeError) {
      input.skip({
        path: input.skillMdPath,
        type: error.skillType,
        reason: `unsupported skill type "${error.skillType}"`,
      });
    } else if (error instanceof SkillParseError) {
      input.warn(`Skipping invalid skill at ${input.skillMdPath}: ${error.message}`, error);
    } else {
      input.warn(`Skipping skill at ${input.skillMdPath} due to unexpected error`, error);
    }
    return undefined;
  }
}

function qualifySubSkillName(parentName: string, skillName: string): string {
  if (skillName === parentName || skillName.startsWith(`${parentName}.`)) return skillName;