type FrontMatter struct {
    Name        string      `yaml:"name"`
    Description string      `yaml:"description"`
    Context     ContextMode `yaml:"context"`
    Agent       string      `yaml:"agent"`
    Model       string      `yaml:"model"`
}

const (
    ContextModeFork    ContextMode = "fork"    // Copy history messages
    ContextModeIsolate ContextMode = "isolate" // Isolate context
)

type Skill struct {
    FrontMatter
    Content       string
    BaseDirectory string
}

type Backend interface {
    List(ctx context.Context) ([]FrontMatter, error)
    Get(ctx context.Context, name string) (Skill, error)
}

// AgentFactory creates Agent instances
type AgentFactory func(ctx context.Context, m model.ToolCallingChatModel) (adk.Agent, error)

// AgentHub provides Agent factory functions
type AgentHub interface {
    Get(ctx context.Context, name string) (AgentFactory, error)
}

// ModelHub provides model instances
type ModelHub interface {
    Get(ctx context.Context, name string) (model.ToolCallingChatModel, error)
}

type BackendFromFilesystemConfig struct {
    Backend filesystem.Backend
    BaseDir string
}

func NewBackendFromFilesystem(ctx context.Context, config *BackendFromFilesystemConfig) (Backend, error)

import "github.com/cloudwego/eino-ext/adk/backend/local"

type Config struct {
    ValidateCommand func(string) error // optional
}

func NewBackend(ctx context.Context, cfg *Config) (filesystem.Backend, error)

import "github.com/cloudwego/eino-ext/adk/backend/agentkit"

type Config struct {
    AccessKeyID      string
    SecretAccessKey  string
    Region           Region  // Optional, default cn-beijing
    ToolID           string
    SessionID        string  // Provide at least one of SessionID or UserSessionID
    UserSessionID    string  // Provide at least one of SessionID or UserSessionID
    SessionTTL       int     // Optional, default 1800 seconds
    ExecutionTimeout int     // Optional
    HTTPClient       *http.Client // Optional
}

func NewSandboxToolBackend(config *Config) (filesystem.Backend, error)

type LocalBackendConfig struct {
    BaseDir string
}

func NewLocalBackend(config *LocalBackendConfig) (*LocalBackend, error)

func NewChatModelAgentMiddleware(ctx context.Context, config *Config) (adk.ChatModelAgentMiddleware, error)

type Config struct {
    // Backend skill backend implementation, required
    Backend Backend
    
    // SkillToolName skill tool name, default "skill"
    SkillToolName *string
    
    // AgentHub provides Agent factory functions for Context mode
    // Required when Skill uses "context: fork" or "context: isolate"
    AgentHub AgentHub
    
    // ModelHub provides model instances for Skills specifying models
    ModelHub ModelHub
    
    // CustomSystemPrompt custom system prompt
    CustomSystemPrompt SystemPromptFunc
    
    // CustomToolDescription custom tool description
    CustomToolDescription ToolDescriptionFunc
}

workdir/
├── skills/
│   └── pdf/
│        ├── scripts
│        │   └── analyze.py
│        └── SKILL.md
└── other files

import （
    "github.com/cloudwego/eino/adk/middlewares/skill"
    "github.com/cloudwego/eino-ext/adk/backend/local"
）


be, err := local.NewBackend(ctx, &local.Config{})
if err != nil {
    log.Fatal(err)
}

wd, _ := os.Getwd()
workDir := filepath.Join(wd, "adk", "middlewares", "skill", "workdir")
skillBackend, err := skill.NewBackendFromFilesystem(ctx, &skill.BackendFromFilesystemConfig{
    Backend: be,
    BaseDir: skillsDir,
})

import (
    "github.com/cloudwego/eino/adk/middlewares/filesystem"
)

fsm, err := filesystem.NewMiddleware(ctx, &filesystem.Config{
    Backend:                          be,
    WithoutLargeToolResultOffloading: true,
})

agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
    Name:        "LogAnalysisAgent",
    Description: "An agent that can analyze logs",
    Instruction: "You are a helpful assistant.",
    Model:       cm,
    Middlewares: []adk.ChatModelAgentMiddleware{fsm, skillMiddleware},
})

runner := adk.NewRunner(ctx, adk.RunnerConfig{
    Agent: agent,
})

input := fmt.Sprintf("Analyze the %s file", filepath.Join(workDir, "test.log"))
log.Println("User: ", input)

iterator := runner.Query(ctx, input)
for {
    event, ok := iterator.Next()
    if !ok {
       break
    }
    if event.Err != nil {
       log.Printf("Error: %v\n", event.Err)
       break
    }

    prints.Event(event)
}

name: LogAnalysisAgent
path: [{LogAnalysisAgent}]
tool name: skill
arguments: {"skill":"log_analyzer"}

name: LogAnalysisAgent
path: [{LogAnalysisAgent}]
tool response: Launching skill: log_analyzer
Base directory for this skill: /Users/bytedance/go/src/github.com/cloudwego/eino-examples/adk/middlewares/skill/workdir/skills/log_analyzer
# SKILL.md content

name: LogAnalysisAgent
path: [{LogAnalysisAgent}]
tool name: execute
arguments:  {"command": "python3 /Users/bytedance/go/src/github.com/cloudwego/eino-examples/adk/middlewares/skill/workdir/skills/log_analyzer/scripts/analyze.py /Users/bytedance/go/src/github.com/cloudwego/eino-examples/adk/middlewares/skill/workdir/test.log"}

name: LogAnalysisAgent
path: [{LogAnalysisAgent}]
tool response: Analysis Result for /Users/bytedance/go/src/github.com/cloudwego/eino-examples/adk/middlewares/skill/workdir/test.log:
Total Errors: 2
Total Warnings: 1

Error Details:
Line 3: [2024-05-20 10:02:15] ERROR: Database connection failed.
Line 5: [2024-05-20 10:03:05] ERROR: Connection timed out.

Warning Details:
Line 2: [2024-05-20 10:01:23] WARNING: High memory usage detected.


name: LogAnalysisAgent
path: [{LogAnalysisAgent}]
answer: Here's the analysis result of the log file:

### Summary
- **Total Errors**: 2  
- **Total Warnings**: 1  

### Detailed Entries
#### Errors:
1. Line 3: [2024-05-20 10:02:15] ERROR: Database connection failed.  
2. Line5: [2024-05-2010:03:05] ERROR: Connection timed out.  

#### Warnings:
1. Line2: [2024-05-2010:01:23] WARNING: High memory usage detected.  

The log file contains critical issues related to database connectivity and a warning about memory usage. Let me know if you need further analysis!

# 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
3. **Follow the skill's instructions**: tool result 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!

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.

How to invoke:
- Use this tool with the skill name only (no arguments)
- Examples:
  - `skill: pdf` - invoke the pdf skill
  - `skill: xlsx` - invoke the xlsx skill
  - `skill: ms-office-suite:pdf` - invoke using fully qualified name

Important:
- When a skill is relevant, you must invoke this tool IMMEDIATELY as your first action
- NEVER just announce or mention a skill in your text response without actually calling this tool
- This is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
- Only use skills listed in <available_skills> below
- Do not invoke a skill that is already running
- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
</skills_instructions>

<available_skills>
{{- range .Matters }}
<skill>
<name>
{{ .Name }}
</name>
<description>
{{ .Description }}
</description>
</skill>
{{- end }}
</available_skills>