tools

type Category ¶

type Category string

Category classifies tools by their source/purpose.

const (
	CategoryBuiltin Category = "builtin"
	CategoryAdapter Category = "adapter"
	CategoryDev     Category = "dev"
	CategoryCustom  Category = "custom"
)

type CommandExecutor ¶

type CommandExecutor interface {
	Run(ctx context.Context, command string, args []string, stdin []byte) (stdout string, err error)
}

CommandExecutor abstracts command execution for custom tools.

type CustomTool ¶

type CustomTool struct {
	// contains filtered or unexported fields
}

CustomTool wraps a discovered script as a Tool implementation. It delegates execution to an injected CommandExecutor rather than calling os/exec directly, keeping this package free of OS dependencies.

func NewCustomTool(dt DiscoveredTool, executor CommandExecutor) *CustomTool

func (t *CustomTool) Category() Category

func (t *CustomTool) Description() string

func (t *CustomTool) Execute(ctx context.Context, args json.RawMessage) (string, error)

func (t *CustomTool) InputSchema() json.RawMessage

func (t *CustomTool) Name() string

func (t *CustomTool) ValidateEntrypoint(basedir string) error

type DiscoveredTool ¶

type DiscoveredTool struct {
	Name       string
	Path       string
	Language   string
	Entrypoint string
}

DiscoveredTool represents a tool found via filesystem discovery.

func DiscoverToolsFS(fsys fs.FS) []DiscoveredTool

type MCPSource ¶

type MCPSource interface {
	Tool
	MCPSource() // marker — body is empty
}

MCPSource is an optional interface signalling that a tool was discovered from an MCP server. The registry uses this to permit "__" in the tool's name — that separator is reserved for the namespaced form "<server-name>__<tool-name>" so MCP tools cannot collide with builtin or adapter tool names. Tools that do NOT implement MCPSource are rejected at registration time if their name contains "__".

Implementing this is a single no-op method; see forge-core/tools/adapters/mcp_tool.go.

type NamespacedSource ¶ added in v0.18.1

type NamespacedSource interface {
	Tool
	NamespacedSource() // marker — body is empty
}

NamespacedSource is a sibling marker to MCPSource for non-MCP tools that legitimately use the "<server>__<op>" namespaced form — notably per-op API tools materialized from an admitted OpenAPI entry. Implementing it opts the tool into the "__" separator at registration (same as MCPSource) without falsely claiming to be an MCP tool.

type NetworkPolicy ¶

type NetworkPolicy struct {
	AllowedHosts []string `json:"allowed_hosts,omitempty"`
	DenyAll      bool     `json:"deny_all,omitempty"`
}

NetworkPolicy describes network requirements for registered tools.

func GenerateNetworkPolicy(reg *Registry) NetworkPolicy

type Registry ¶

type Registry struct {
	// contains filtered or unexported fields
}

Registry is a thread-safe tool registry. It implements engine.ToolExecutor via Go structural typing -- no direct import of the engine package is needed.

func NewRegistry() *Registry

func (r *Registry) Execute(ctx context.Context, name string, arguments json.RawMessage) (string, error)

func (r *Registry) Filter(allowed []string) *Registry

func (r *Registry) Get(name string) Tool

func (r *Registry) List() []string

func (r *Registry) Register(t Tool) error

func (r *Registry) Remove(name string)

func (r *Registry) ToolDefinitions() []llm.ToolDefinition

type SkillTool ¶

type SkillTool struct {
	// contains filtered or unexported fields
}

SkillTool wraps a parsed skill entry as a Tool. Execution shape is pinned at construction time via NewSkillTool (bash + script path) or NewBinarySkillTool (external executable). Both pass the JSON input as a single positional argument so script-side and binary-side share the same `argv[1] == JSON` contract.

func NewBinarySkillTool(name, description, inputSpec, binaryPath string, executor CommandExecutor) *SkillTool

func NewScriptSkillTool(name, description, inputSpec, interpreter, scriptPath string, executor CommandExecutor) *SkillTool

func NewSkillTool(name, description, inputSpec, scriptPath string, executor CommandExecutor) *SkillTool

func (t *SkillTool) Category() Category

func (t *SkillTool) Description() string

func (t *SkillTool) Execute(ctx context.Context, args json.RawMessage) (string, error)

func (t *SkillTool) InputSchema() json.RawMessage

func (t *SkillTool) Name() string

type Tool ¶

type Tool interface {
	// Name returns the unique tool name.
	Name() string
	// Description returns a human-readable description of the tool.
	Description() string
	// Category returns the tool's category.
	Category() Category
	// InputSchema returns the JSON Schema for the tool's input parameters.
	InputSchema() json.RawMessage
	// Execute runs the tool with the given JSON arguments.
	Execute(ctx context.Context, args json.RawMessage) (string, error)
}

Tool is the interface that all tools must implement.