Awesome Agent Skills MCP Server

Instructions

Implementation Reference

• src/server.ts:52-105 (registration)

  Tool registration with name 'list_skills', including inputSchema (filter, source parameters) and outputSchema (skills array, total, lastSync)

  {
    name: 'list_skills',
    description: 'List all available agent skills that can be invoked',
    inputSchema: {
      type: 'object',
      properties: {
        filter: {
          type: 'string',
          description: 'Optional filter to search skills by name or description',
        },
        source: {
          type: 'string',
          enum: ['all', 'repository', 'local'],
          description: 'Filter by skill source',
          default: 'all',
        },
      },
    },
    outputSchema: {
      type: 'object',
      properties: {
        skills: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              id: { type: 'string' },
              name: { type: 'string' },
              description: { type: 'string' },
              source: { type: 'string' },
              parameters: {
                type: 'array',
                items: {
                  type: 'object',
                  properties: {
                    name: { type: 'string' },
                    type: { type: 'string' },
                    description: { type: 'string' },
                    required: { type: 'boolean' },
                  },
                },
              },
            },
          },
        },
        total: { type: 'number' },
        lastSync: { type: 'string', format: 'date-time' },
      },
    },
    annotations: {
      readOnlyHint: true,
      openWorldHint: false,
    },
  },

• src/server.ts:230-249 (handler)

  Tool handler that processes list_skills calls, extracts filter/source args, calls executor.listSkills(), and returns formatted JSON response

  case 'list_skills': {
    const filter = (args?.filter as string) || undefined;
    const source = (args?.source as 'all' | 'repository' | 'local') || 'all';
  
    const skills = this.executor.listSkills(filter, source);
    const lastSync = this.registry.getLastSync();
  
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify({
            skills,
            total: skills.length,
            lastSync: lastSync?.toISOString(),
          }),
        },
      ],
    };
  }

• src/services/skill-executor.ts:85-122 (handler)

  Core implementation logic in SkillExecutor.listSkills() that filters skills by source and text, then maps to output format with id, name, description, source, and parameters

  listSkills(filter?: string, source?: 'all' | 'repository' | 'local'): Array<{
    id: string;
    name: string;
    description: string;
    source: string;
    parameters?: Array<{ name: string; type: string; description: string; required: boolean }>;
  }> {
    let skills = this.registry.listSkills();
  
    // Apply source filter
    if (source && source !== 'all') {
      skills = skills.filter((skill) => skill.source === source);
    }
  
    // Apply text filter
    if (filter) {
      const filterLower = filter.toLowerCase();
      skills = skills.filter(
        (skill) =>
          skill.name.toLowerCase().includes(filterLower) ||
          skill.description.toLowerCase().includes(filterLower) ||
          skill.id.toLowerCase().includes(filterLower)
      );
    }
  
    return skills.map((skill) => ({
      id: skill.id,
      name: skill.name,
      description: skill.description,
      source: skill.source,
      parameters: skill.parameters?.map((p) => ({
        name: p.name,
        type: p.type,
        description: p.description,
        required: p.required,
      })),
    }));
  }

• src/models/registry.ts:59-61 (helper)

  Registry method listSkills() that returns all skills from the internal Map

  listSkills(): Skill[] {
    return Array.from(this.skills.values());
  }

• src/models/skill.ts:15-27 (schema)

  Skill type definition using Zod schema, defining the structure of skill objects with id, name, description, source, content, parameters, and metadata

  export const skillSchema = z.object({
    id: z.string().min(1).max(100),
    name: z.string().min(1).max(100),
    description: z.string().min(1).max(500),
    source: z.enum(['repository', 'local']),
    sourcePath: z.string(),
    content: z.string(),
    parameters: z.array(parameterSchemaSchema).optional(),
    metadata: skillMetadataSchema,
    lastUpdated: z.date(),
  });
  
  export type Skill = z.infer<typeof skillSchema>;