tools

func WithConflictStrategy ¶

func WithConflictStrategy(strategy ConflictStrategy) DiscoveryOption

WithConflictStrategy sets the strategy for handling tool name conflicts.

func TypedHandler ¶

func TypedHandler[T any, R any](fn func(ctx context.Context, input T) (R, error)) Handler

TypedHandler creates a type-safe handler from a function. The input type T is automatically deserialized from map[string]any, and the output type R is returned as-is.

Example:

type GreetInput struct {
    Name string `json:"name"`
}

type GreetOutput struct {
    Message string `json:"message"`
}

handler := TypedHandler(func(ctx context.Context, input GreetInput) (GreetOutput, error) {
    return GreetOutput{Message: "Hello, " + input.Name}, nil
})

func NewMCPClient ¶

func NewMCPClient(serverURL string, transport MCPTransport) *MCPClient

NewMCPClient creates a new MCP client.

func NewMCPServer ¶

func NewMCPServer(name string, opts ...MCPServerOption) *MCPServer

NewMCPServer creates a new MCP server.

func WithMCPDescription ¶

func WithMCPDescription(desc string) MCPServerOption

WithMCPDescription sets the server description.

func WithMCPMaxJSONSize ¶

func WithMCPMaxJSONSize(maxSize int64) MCPServerOption

WithMCPMaxJSONSize sets the maximum JSON payload size.

func WithMCPVersion ¶

func WithMCPVersion(version string) MCPServerOption

WithMCPVersion sets the server version.

func WithProtocolVersion ¶

func WithProtocolVersion(version string) MCPServerOption

WithProtocolVersion sets the MCP protocol version.

func WithToolTimeout ¶ added in v0.3.0

func WithToolTimeout(timeout time.Duration) MCPServerOption

WithToolTimeout sets the default timeout for tool invocations. This timeout is applied when the incoming context has no deadline.

func NewRegistry ¶

func NewRegistry() *Registry

NewRegistry creates a new tool registry.

func Define ¶ added in v0.6.0

func Define[I, O any](name, description string, fn func(context.Context, I) (O, error)) *Tool

Define creates a type-safe tool with schema inferred from the input type. The input type's JSON schema is automatically generated from struct tags.

Example:

type SearchInput struct {
    Query string `json:"query" desc:"Search query" required:"true"`
    Limit int    `json:"limit" desc:"Max results" max:"100"`
}

type SearchOutput struct {
    Results []string `json:"results"`
}

searchTool := tools.Define("search", "Search the web",
    func(ctx context.Context, in SearchInput) (SearchOutput, error) {
        results := doSearch(in.Query, in.Limit)
        return SearchOutput{Results: results}, nil
    },
)

func DefineAsync ¶ added in v0.6.0

func DefineAsync(name, description string, fn func(context.Context, string) error) *Tool

DefineAsync creates a tool that runs asynchronously and returns immediately. The handler runs in a goroutine and results can be retrieved later.

Example:

downloadTool := tools.DefineAsync("download", "Download a file",
    func(ctx context.Context, url string) error {
        return downloadFile(url)
    },
)

func DefineSimple ¶ added in v0.6.0

func DefineSimple(name, description string, fn func(string) (string, error)) *Tool

DefineSimple creates a tool with a single string input and output. Perfect for simple transformations or queries.

Example:

reverseTool := tools.DefineSimple("reverse", "Reverse a string",
    func(s string) (string, error) {
        runes := []rune(s)
        for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
            runes[i], runes[j] = runes[j], runes[i]
        }
        return string(runes), nil
    },
)

func DefineWithSchema ¶ added in v0.6.0

func DefineWithSchema(name, description string, inputSchema map[string]any, fn Handler) *Tool

DefineWithSchema creates a tool with an explicit schema. Use when you need precise control over the schema.

Example:

calcTool := tools.DefineWithSchema("calc", "Calculate expression",
    map[string]any{
        "type": "object",
        "properties": map[string]any{
            "expression": map[string]any{
                "type": "string",
                "pattern": "^[0-9+\\-*/()\\s]+$",
            },
        },
        "required": []string{"expression"},
    },
    func(ctx context.Context, input map[string]any) (any, error) {
        expr := input["expression"].(string)
        return evaluate(expr), nil
    },
)

func NewTool ¶

func NewTool(name, description string, schema map[string]any, handler Handler) *Tool

NewTool creates a new tool.

func TypedTool ¶

func TypedTool[T any, R any](
	name, description string,
	schema map[string]any,
	fn func(ctx context.Context, input T) (R, error),
) *Tool

TypedTool creates a new tool with a typed handler.

func NewToolDiscovery ¶

func NewToolDiscovery(opts ...DiscoveryOption) *ToolDiscovery

NewToolDiscovery creates a new tool discovery service.