// Tool arguments are plain structs with validation tags
// ormc generates Schema(), Pointers(), Validate() automatically
type SearchArgs struct {
    Query string `validate:"required,min=1,max=255"`
    Limit int64  `validate:"min=1,max=100"`
}

func handleSearch(ctx *context.Context, req mcp.Request) (*mcp.Result, error) {
    var args SearchArgs
    if err := req.Bind(&args); err != nil {
        return nil, err // server wraps as JSON-RPC error
    }
    return mcp.Text("found 3 results"), nil
}

srv := mcp.NewServer(mcp.Config{
    Name:    "my-server",
    Version: "1.0.0",
    Auth:    myAuth, // implements mcp.Authorizer
}, nil)

srv.AddTool(mcp.Tool{
    Name:        "search",
    Description: "Search items by query",
    InputSchema: new(SearchArgs).Schema(),
    Resource:    "items",
    Action:      'r',
    Execute:     handleSearch,
})

http.Handle("/mcp", srv.HTTPHandler())
http.ListenAndServe(":3030", nil)

return mcp.Text("operation completed"), nil   // text
return mcp.JSON(&MyData{Name: "test"})        // JSON (Fielder)
text, err := mcp.GetText(result)              // extract text

type Authorizer interface {
    Authorize(token string) (userID string, err error)
}

// In your app:
auth := user.NewBearerAuth(secret) // satisfies mcp.Authorizer

type CatalogProvider struct {
    db *postgres.DB
}

type CatalogSearchArgs struct {
    Query    string `validate:"required,min=1,max=255"`
    Category string `validate:"max=50"`
}

type CatalogUpdateArgs struct {
    ProductID string  `validate:"required"`
    Price     float64 `validate:"required,min=0"`
}

func (p *CatalogProvider) Tools() []mcp.Tool {
    return []mcp.Tool{
        {
            Name:        "catalog_search",
            Description: "Search product catalog",
            InputSchema: new(CatalogSearchArgs).Schema(),
            Resource:    "catalog",
            Action:      'r',
            Execute:     p.handleSearch,
        },
        {
            Name:        "catalog_update",
            Description: "Update product price",
            InputSchema: new(CatalogUpdateArgs).Schema(),
            Resource:    "catalog",
            Action:      'u',
            Execute:     p.handleUpdate,
        },
    }
}

func (p *CatalogProvider) handleSearch(ctx *context.Context, req mcp.Request) (*mcp.Result, error) {
    var args CatalogSearchArgs
    if err := req.Bind(&args); err != nil {
        return nil, err
    }
    // ... query p.db
    return mcp.Text("found 3 products"), nil
}

// Pass providers to NewServer
srv := mcp.NewServer(config, []mcp.ToolProvider{&CatalogProvider{db: db}})

handler := mcp.NewServer(config, providers)
response := handler.HandleMessage(&ctx, message)