109 lines
2.9 KiB
Go
109 lines
2.9 KiB
Go
package tools
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/Tencent/WeKnora/internal/types"
|
|
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// ToolRegistry manages the registration and retrieval of tools
|
|
type ToolRegistry struct {
|
|
tools map[string]types.Tool
|
|
knowledgeBaseService interfaces.KnowledgeBaseService
|
|
knowledgeService interfaces.KnowledgeService
|
|
chunkService interfaces.ChunkService
|
|
db *gorm.DB // gorm.DB interface for database query tool
|
|
}
|
|
|
|
// NewToolRegistry creates a new tool registry
|
|
func NewToolRegistry(
|
|
knowledgeBaseService interfaces.KnowledgeBaseService,
|
|
knowledgeService interfaces.KnowledgeService,
|
|
chunkService interfaces.ChunkService,
|
|
db *gorm.DB, // gorm.DB for database operations
|
|
) *ToolRegistry {
|
|
return &ToolRegistry{
|
|
tools: make(map[string]types.Tool),
|
|
knowledgeBaseService: knowledgeBaseService,
|
|
knowledgeService: knowledgeService,
|
|
chunkService: chunkService,
|
|
db: db,
|
|
}
|
|
}
|
|
|
|
// RegisterTool adds a tool to the registry
|
|
func (r *ToolRegistry) RegisterTool(tool types.Tool) {
|
|
r.tools[tool.Name()] = tool
|
|
}
|
|
|
|
// GetTool retrieves a tool by name
|
|
func (r *ToolRegistry) GetTool(name string) (types.Tool, error) {
|
|
tool, exists := r.tools[name]
|
|
if !exists {
|
|
return nil, fmt.Errorf("tool not found: %s", name)
|
|
}
|
|
return tool, nil
|
|
}
|
|
|
|
// ListTools returns all registered tool names
|
|
func (r *ToolRegistry) ListTools() []string {
|
|
names := make([]string, 0, len(r.tools))
|
|
for name := range r.tools {
|
|
names = append(names, name)
|
|
}
|
|
return names
|
|
}
|
|
|
|
// GetFunctionDefinitions returns function definitions for allowed tools
|
|
// This is used for LLM function calling
|
|
func (r *ToolRegistry) GetFunctionDefinitions(allowedTools []string) []types.FunctionDefinition {
|
|
definitions := make([]types.FunctionDefinition, 0)
|
|
|
|
// If no allowed tools specified, return all tools
|
|
if len(allowedTools) == 0 {
|
|
for _, tool := range r.tools {
|
|
definitions = append(definitions, types.FunctionDefinition{
|
|
Name: tool.Name(),
|
|
Description: tool.Description(),
|
|
Parameters: tool.Parameters(),
|
|
})
|
|
}
|
|
return definitions
|
|
}
|
|
|
|
// Create a map for quick lookup
|
|
allowedMap := make(map[string]bool)
|
|
for _, name := range allowedTools {
|
|
allowedMap[name] = true
|
|
}
|
|
|
|
// Only include allowed tools
|
|
for name, tool := range r.tools {
|
|
if allowedMap[name] {
|
|
definitions = append(definitions, types.FunctionDefinition{
|
|
Name: tool.Name(),
|
|
Description: tool.Description(),
|
|
Parameters: tool.Parameters(),
|
|
})
|
|
}
|
|
}
|
|
|
|
return definitions
|
|
}
|
|
|
|
// ExecuteTool executes a tool by name with the given arguments
|
|
func (r *ToolRegistry) ExecuteTool(ctx context.Context, name string, args map[string]interface{}) (*types.ToolResult, error) {
|
|
tool, err := r.GetTool(name)
|
|
if err != nil {
|
|
return &types.ToolResult{
|
|
Success: false,
|
|
Error: err.Error(),
|
|
}, err
|
|
}
|
|
|
|
return tool.Execute(ctx, args)
|
|
}
|