6d4d2bc61e
- Add adhocore/gronx dependency for cron expression parsing - Fix CronService race conditions and add cron expression support - Add CronTool with add/list/remove/enable/disable actions - Add ContextualTool interface for tools needing channel/chatID context - Add ProcessDirectWithChannel to AgentLoop for cron job execution - Register CronTool in gateway and wire up onJob handler - Fix slice bounds panic in addJob for short messages Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
126 lines
2.9 KiB
Go
126 lines
2.9 KiB
Go
package tools
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/sipeed/picoclaw/pkg/logger"
|
|
)
|
|
|
|
type ToolRegistry struct {
|
|
tools map[string]Tool
|
|
mu sync.RWMutex
|
|
}
|
|
|
|
func NewToolRegistry() *ToolRegistry {
|
|
return &ToolRegistry{
|
|
tools: make(map[string]Tool),
|
|
}
|
|
}
|
|
|
|
func (r *ToolRegistry) Register(tool Tool) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
r.tools[tool.Name()] = tool
|
|
}
|
|
|
|
func (r *ToolRegistry) Get(name string) (Tool, bool) {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
tool, ok := r.tools[name]
|
|
return tool, ok
|
|
}
|
|
|
|
func (r *ToolRegistry) Execute(ctx context.Context, name string, args map[string]interface{}) (string, error) {
|
|
return r.ExecuteWithContext(ctx, name, args, "", "")
|
|
}
|
|
|
|
func (r *ToolRegistry) ExecuteWithContext(ctx context.Context, name string, args map[string]interface{}, channel, chatID string) (string, error) {
|
|
logger.InfoCF("tool", "Tool execution started",
|
|
map[string]interface{}{
|
|
"tool": name,
|
|
"args": args,
|
|
})
|
|
|
|
tool, ok := r.Get(name)
|
|
if !ok {
|
|
logger.ErrorCF("tool", "Tool not found",
|
|
map[string]interface{}{
|
|
"tool": name,
|
|
})
|
|
return "", fmt.Errorf("tool '%s' not found", name)
|
|
}
|
|
|
|
// If tool implements ContextualTool, set context
|
|
if contextualTool, ok := tool.(ContextualTool); ok && channel != "" && chatID != "" {
|
|
contextualTool.SetContext(channel, chatID)
|
|
}
|
|
|
|
start := time.Now()
|
|
result, err := tool.Execute(ctx, args)
|
|
duration := time.Since(start)
|
|
|
|
if err != nil {
|
|
logger.ErrorCF("tool", "Tool execution failed",
|
|
map[string]interface{}{
|
|
"tool": name,
|
|
"duration": duration.Milliseconds(),
|
|
"error": err.Error(),
|
|
})
|
|
} else {
|
|
logger.InfoCF("tool", "Tool execution completed",
|
|
map[string]interface{}{
|
|
"tool": name,
|
|
"duration_ms": duration.Milliseconds(),
|
|
"result_length": len(result),
|
|
})
|
|
}
|
|
|
|
return result, err
|
|
}
|
|
|
|
func (r *ToolRegistry) GetDefinitions() []map[string]interface{} {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
|
|
definitions := make([]map[string]interface{}, 0, len(r.tools))
|
|
for _, tool := range r.tools {
|
|
definitions = append(definitions, ToolToSchema(tool))
|
|
}
|
|
return definitions
|
|
}
|
|
|
|
// List returns a list of all registered tool names.
|
|
func (r *ToolRegistry) List() []string {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
|
|
names := make([]string, 0, len(r.tools))
|
|
for name := range r.tools {
|
|
names = append(names, name)
|
|
}
|
|
return names
|
|
}
|
|
|
|
// Count returns the number of registered tools.
|
|
func (r *ToolRegistry) Count() int {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
return len(r.tools)
|
|
}
|
|
|
|
// GetSummaries returns human-readable summaries of all registered tools.
|
|
// Returns a slice of "name - description" strings.
|
|
func (r *ToolRegistry) GetSummaries() []string {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
|
|
summaries := make([]string, 0, len(r.tools))
|
|
for _, tool := range r.tools {
|
|
summaries = append(summaries, fmt.Sprintf("- `%s` - %s", tool.Name(), tool.Description()))
|
|
}
|
|
return summaries
|
|
}
|