105 lines
2.4 KiB
Go
105 lines
2.4 KiB
Go
package tools
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"sort"
|
|
|
|
coretypes "github.com/enmanuel/agents/pkg/llm"
|
|
)
|
|
|
|
// Registry holds available tools keyed by name.
|
|
type Registry struct {
|
|
tools map[string]Tool
|
|
}
|
|
|
|
// NewRegistry creates an empty registry.
|
|
func NewRegistry() *Registry {
|
|
return &Registry{tools: make(map[string]Tool)}
|
|
}
|
|
|
|
// Register adds a tool to the registry.
|
|
func (r *Registry) Register(t Tool) {
|
|
r.tools[t.Def.Name] = t
|
|
}
|
|
|
|
// Get looks up a tool by name.
|
|
func (r *Registry) Get(name string) (Tool, bool) {
|
|
t, ok := r.tools[name]
|
|
return t, ok
|
|
}
|
|
|
|
// Names returns all registered tool names in sorted order.
|
|
func (r *Registry) Names() []string {
|
|
names := make([]string, 0, len(r.tools))
|
|
for k := range r.tools {
|
|
names = append(names, k)
|
|
}
|
|
sort.Strings(names)
|
|
return names
|
|
}
|
|
|
|
// Len returns the number of registered tools.
|
|
func (r *Registry) Len() int {
|
|
return len(r.tools)
|
|
}
|
|
|
|
// Execute looks up a tool by name and runs it. Returns an error result if not found.
|
|
func (r *Registry) Execute(ctx context.Context, name string, argsJSON string) Result {
|
|
t, ok := r.tools[name]
|
|
if !ok {
|
|
return Result{Err: fmt.Errorf("tool %q not found", name)}
|
|
}
|
|
|
|
var args map[string]any
|
|
if argsJSON != "" {
|
|
if err := json.Unmarshal([]byte(argsJSON), &args); err != nil {
|
|
return Result{Err: fmt.Errorf("parse args for %q: %w", name, err)}
|
|
}
|
|
}
|
|
|
|
return t.Exec(ctx, args)
|
|
}
|
|
|
|
// ToLLMSpecs converts all registered tools to the LLM-compatible ToolSpec format.
|
|
// This is a pure transformation — no side effects.
|
|
func (r *Registry) ToLLMSpecs() []coretypes.ToolSpec {
|
|
specs := make([]coretypes.ToolSpec, 0, len(r.tools))
|
|
for _, name := range r.Names() {
|
|
t := r.tools[name]
|
|
specs = append(specs, defToLLMSpec(t.Def))
|
|
}
|
|
return specs
|
|
}
|
|
|
|
// defToLLMSpec converts a pure Def to an LLM ToolSpec with JSON Schema.
|
|
func defToLLMSpec(d Def) coretypes.ToolSpec {
|
|
properties := make(map[string]any, len(d.Parameters))
|
|
required := make([]string, 0)
|
|
|
|
for _, p := range d.Parameters {
|
|
properties[p.Name] = map[string]any{
|
|
"type": p.Type,
|
|
"description": p.Description,
|
|
}
|
|
if p.Required {
|
|
required = append(required, p.Name)
|
|
}
|
|
}
|
|
|
|
schema := map[string]any{
|
|
"type": "object",
|
|
"properties": properties,
|
|
}
|
|
if len(required) > 0 {
|
|
schema["required"] = required
|
|
}
|
|
|
|
return coretypes.ToolSpec{
|
|
Name: d.Name,
|
|
Description: d.Description,
|
|
InputSchema: schema,
|
|
}
|
|
}
|