chore

Author: meguminnnnnnnnn

adk/middlewares/skill/local.go

@@ -65,19 +65,40 @@ func NewLocalBackend(config *LocalBackendConfig) (*LocalBackend, error) {
 	}, nil
 }
 
-// skillFrontmatter represents the YAML frontmatter in a SKILL.md file.
-type skillFrontmatter struct {
-	Name          string         `yaml:"name"`
-	Description   string         `yaml:"description"`
-	License       *string        `yaml:"license"`
-	Compatibility *string        `yaml:"compatibility"`
-	Metadata      map[string]any `yaml:"metadata"`
-	AllowedTools  []string       `yaml:"allowed-tools"`
-}
-
 // List returns all skills from the local filesystem.
 // It scans subdirectories of baseDir for SKILL.md files and parses them as skills.
-func (b *LocalBackend) List(ctx context.Context) ([]Skill, error) {
+func (b *LocalBackend) List(ctx context.Context) ([]FrontMatter, error) {
+	skills, err := b.list(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list skills: %w", err)
+	}
+
+	matters := make([]FrontMatter, 0, len(skills))
+	for _, skill := range skills {
+		matters = append(matters, skill.FrontMatter)
+	}
+
+	return matters, nil
+}
+
+// Get returns a skill by name from the local filesystem.
+// It searches subdirectories for a SKILL.md file with matching name.
+func (b *LocalBackend) Get(ctx context.Context, name string) (Skill, error) {
+	skills, err := b.list(ctx)
+	if err != nil {
+		return Skill{}, fmt.Errorf("failed to list skills: %w", err)
+	}
+
+	for _, skill := range skills {
+		if skill.Name == name {
+			return skill, nil
+		}
+	}
+
+	return Skill{}, fmt.Errorf("skill not found: %s", name)
+}
+
+func (b *LocalBackend) list(ctx context.Context) ([]Skill, error) {
 	var skills []Skill
 
 	entries, err := os.ReadDir(b.baseDir)
@@ -109,23 +130,6 @@ func (b *LocalBackend) List(ctx context.Context) ([]Skill, error) {
 	return skills, nil
 }
 
-// Get returns a skill by name from the local filesystem.
-// It searches subdirectories for a SKILL.md file with matching name.
-func (b *LocalBackend) Get(ctx context.Context, name string) (Skill, error) {
-	skills, err := b.List(ctx)
-	if err != nil {
-		return Skill{}, fmt.Errorf("failed to list skills: %w", err)
-	}
-
-	for _, skill := range skills {
-		if skill.Name == name {
-			return skill, nil
-		}
-	}
-
-	return Skill{}, fmt.Errorf("skill not found: %s", name)
-}
-
 // loadSkillFromFile loads a skill from a SKILL.md file.
 // The file format is:
 //
@@ -145,7 +149,7 @@ func (b *LocalBackend) loadSkillFromFile(path string) (Skill, error) {
 		return Skill{}, fmt.Errorf("failed to parse frontmatter: %w", err)
 	}
 
-	var fm skillFrontmatter
+	var fm FrontMatter
 	if err = yaml.Unmarshal([]byte(frontmatter), &fm); err != nil {
 		return Skill{}, fmt.Errorf("failed to unmarshal frontmatter: %w", err)
 	}
@@ -157,12 +161,10 @@ func (b *LocalBackend) loadSkillFromFile(path string) (Skill, error) {
 	}
 
 	return Skill{
-		Name:          fm.Name,
-		Description:   fm.Description,
-		License:       fm.License,
-		Compatibility: fm.Compatibility,
-		Metadata:      fm.Metadata,
-		AllowedTools:  fm.AllowedTools,
+		FrontMatter: FrontMatter{
+			Name:        fm.Name,
+			Description: fm.Description,
+		},
 		Content:       strings.TrimSpace(content),
 		BaseDirectory: absDir,
 	}, nil

adk/middlewares/skill/local_test.go

@@ -162,10 +162,6 @@ This is the skill content.`), 0644))
 		require.Len(t, skills, 1)
 		assert.Equal(t, "pdf-processing", skills[0].Name)
 		assert.Equal(t, "Extract text and tables from PDF files, fill forms, merge documents.", skills[0].Description)
-		assert.Equal(t, "Apache-2.0", *skills[0].License)
-		assert.Equal(t, map[string]any{"author": "example-org", "version": "1.0"}, skills[0].Metadata)
-		assert.Equal(t, "This is the skill content.", skills[0].Content)
-		assert.Equal(t, skillDir, skills[0].BaseDirectory)
 	})
 
 	t.Run("multiple skill directories returns all skills", func(t *testing.T) {

adk/middlewares/skill/prompt.go

@@ -17,7 +17,39 @@
 package skill
 
 const (
-	skillToolDescriptionBase = `Execute a skill within the main conversation
+	systemPrompt = `
+# Skills System
+
+**How to Use Skills (Progressive Disclosure):**
+
+Skills follow a **progressive disclosure** pattern - you see their name and description above, but only read full instructions when needed:
+
+1. **Recognize when a skill applies**: Check if the user's task matches a skill's description
+2. **Read the skill's full instructions**: Use the '{tool_name}' tool to load SKILL.md with the skill name
+3. **Follow the skill's instructions**: SKILL.md contains step-by-step workflows, best practices, and examples
+4. **Access supporting files**: Skills may include helper scripts, configs, or reference docs - use absolute paths
+
+**When to Use Skills:**
+- User's request matches a skill's domain (e.g., "research X" -> web-research skill)
+- You need specialized knowledge or structured workflows
+- A skill provides proven patterns for complex tasks
+
+**Executing Skill Scripts:**
+Skills may contain Python scripts or other executable files. Always use absolute paths.
+
+**Example Workflow:**
+
+User: "Can you research the latest developments in quantum computing?"
+
+1. Check available skills -> See "web-research" skill
+2. Call '{tool_name}' tool to read the full skill instructions
+3. Follow the skill's research workflow (search -> organize -> synthesize)
+4. Use any helper scripts with absolute paths
+
+Remember: Skills make you more capable and consistent. When in doubt, check if a skill exists for the task!
+`
+
+	toolDescriptionBase = `Execute a skill within the main conversation
 
 <skills_instructions>
 When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
@@ -39,9 +71,9 @@ Important:
 </skills_instructions>
 
 `
-	skillToolDescriptionTemplate = `
+	toolDescriptionTemplate = `
 <available_skills>
-{{- range .Skills }}
+{{- range .Matters }}
 <skill>
 <name>
 {{ .Name }}
@@ -53,8 +85,9 @@ Important:
 {{- end }}
 </available_skills>
 `
-	skillToolResult  = "Launching skill: %s\n"
-	skillUserContent = `Base directory for this skill: %s
+	toolResult  = "Launching skill: %s\n"
+	userContent = `Base directory for this skill: %s
 
 %s`
+	toolName = "skill"
 )

adk/middlewares/skill/skill.go

@@ -22,34 +22,34 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"regexp"
 	"text/template"
 
+	"github.com/slongfield/pyfmt"
+
 	"github.com/cloudwego/eino/adk"
 	"github.com/cloudwego/eino/components/tool"
 	"github.com/cloudwego/eino/schema"
 )
 
-type Skill struct {
-	Name          string
-	Description   string
-	License       *string
-	Compatibility *string
-	Metadata      map[string]any
-	AllowedTools  []string
-
-	Content string
+type FrontMatter struct {
+	Name        string `yaml:"name"`
+	Description string `yaml:"description"`
+}
 
+type Skill struct {
+	FrontMatter
+	Content       string
 	BaseDirectory string
 }
 
 type Backend interface {
-	List(ctx context.Context) ([]Skill, error)
+	List(ctx context.Context) ([]FrontMatter, error)
 	Get(ctx context.Context, name string) (Skill, error)
 }
 
 type Config struct {
-	Backend Backend
+	Backend       Backend
+	SkillToolName *string
 }
 
 // New creates a new skill middleware.
@@ -61,17 +61,31 @@ func New(ctx context.Context, config *Config) (adk.AgentMiddleware, error) {
 	if config.Backend == nil {
 		return adk.AgentMiddleware{}, fmt.Errorf("backend is required")
 	}
+
+	name := toolName
+	if config.SkillToolName != nil {
+		name = *config.SkillToolName
+	}
+
 	return adk.AgentMiddleware{
-		AdditionalTools: []tool.BaseTool{&skillTool{b: config.Backend}},
+		AdditionalInstruction: buildSystemPrompt(name),
+		AdditionalTools:       []tool.BaseTool{&skillTool{b: config.Backend, toolName: name}},
 	}, nil
 }
 
+func buildSystemPrompt(skillToolName string) string {
+	return pyfmt.Must(systemPrompt, map[string]string{
+		"tool_name": skillToolName,
+	})
+}
+
 type skillTool struct {
-	b Backend
+	b        Backend
+	toolName string
 }
 
 type descriptionTemplateHelper struct {
-	Skills []Skill
+	Matters []FrontMatter
 }
 
 func (s *skillTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
@@ -80,23 +94,14 @@ func (s *skillTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
 		return nil, fmt.Errorf("failed to list skills: %w", err)
 	}
 
-	err = validateSkillMetadata(skills)
-	if err != nil {
-		return nil, err
-	}
-	err = validateSkillContent(skills)
-	if err != nil {
-		return nil, err
-	}
-
 	desc, err := renderToolDescription(skills)
 	if err != nil {
 		return nil, fmt.Errorf("failed to render skill tool description: %w", err)
 	}
 
 	return &schema.ToolInfo{
-		Name: "skill",
-		Desc: skillToolDescriptionBase + desc,
+		Name: s.toolName,
+		Desc: toolDescriptionBase + desc,
 		ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
 			"skill": {
 				Type:     schema.String,
@@ -122,81 +127,20 @@ func (s *skillTool) InvokableRun(ctx context.Context, argumentsInJSON string, op
 		return "", fmt.Errorf("failed to get skill: %w", err)
 	}
 
-	err = validateSkillName(skill.Name)
-	if err != nil {
-		return "", err
-	}
-	err = validateSkillContent([]Skill{skill})
-	if err != nil {
-		return "", err
-	}
-
-	return fmt.Sprintf(skillToolResult, skill.Name) + fmt.Sprintf(skillUserContent, skill.BaseDirectory, skill.Content), nil
+	return fmt.Sprintf(toolResult, skill.Name) + fmt.Sprintf(userContent, skill.BaseDirectory, skill.Content), nil
 }
 
-func renderToolDescription(skills []Skill) (string, error) {
-	tpl, err := template.New("skills").Parse(skillToolDescriptionTemplate)
+func renderToolDescription(matters []FrontMatter) (string, error) {
+	tpl, err := template.New("skills").Parse(toolDescriptionTemplate)
 	if err != nil {
 		return "", err
 	}
 
 	var buf bytes.Buffer
-	err = tpl.Execute(&buf, descriptionTemplateHelper{Skills: skills})
+	err = tpl.Execute(&buf, descriptionTemplateHelper{Matters: matters})
 	if err != nil {
 		return "", err
 	}
 
 	return buf.String(), nil
 }
-
-const (
-	maxSkillNameLength        = 64
-	maxSkillDescriptionLength = 1024
-	maxSkillContentLength     = 10 * 1024 * 1024
-)
-
-func validateSkillMetadata(skills []Skill) error {
-	for _, skill := range skills {
-		err := validateSkillName(skill.Name)
-		if err != nil {
-			return err
-		}
-
-		if len(skill.Description) == 0 {
-			return fmt.Errorf("skill %s must have a non-empty description", skill.Name)
-		}
-		if len(skill.Description) > maxSkillDescriptionLength {
-			return fmt.Errorf("skill %s description must not exceed %d characters", skill.Name, maxSkillDescriptionLength)
-		}
-	}
-	return nil
-}
-
-var (
-	skillNameRegex = regexp.MustCompile(`^[a-z0-9]([-a-z0-9]*[a-z0-9])?$`)
-)
-
-func validateSkillName(name string) error {
-	if len(name) > maxSkillNameLength {
-		return fmt.Errorf("skill name must not exceed %d characters", maxSkillNameLength)
-	}
-
-	if len(name) == 0 {
-		return fmt.Errorf("skill name cannot be empty")
-	}
-
-	if !skillNameRegex.MatchString(name) {
-		return fmt.Errorf("skill name must contain only lowercase letters, numbers, and hyphens, and must not start or end with a hyphen: %s", name)
-	}
-
-	return nil
-}
-
-func validateSkillContent(skills []Skill) error {
-	for _, skill := range skills {
-		if len(skill.Content)+len(skill.BaseDirectory) > maxSkillContentLength {
-			return fmt.Errorf("skill content must not exceed %d characters", maxSkillContentLength)
-		}
-	}
-	return nil
-}