server

type AudioResource struct {
	// URL is the URL of the audio file. Required for all versions.
	URL string
	// Data is the base64-encoded audio data. Used in 2025-03-26 version.
	Data string
	// MimeType is the MIME type of the audio file. Required for all versions.
	MimeType string
	// AltText is an optional descriptive text for the audio
	AltText string
}

type AudioSamplingContent struct {
	Data     string
	MimeType string
}

type CancelledNotificationParams struct {
	RequestID string `json:"requestId"`        // ID of the request being cancelled
	Reason    string `json:"reason,omitempty"` // Optional reason for cancellation
}

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

type ClientInfo struct {
	SamplingSupported bool
	SamplingCaps      SamplingCapabilities
	ProtocolVersion   string
	Env               map[string]string // Environment variables from the client session
	Roots             []string          // Workspace root paths from the client session

}

type ClientSession struct {
	ID                    SessionID         // Unique session identifier
	ClientInfo            ClientInfo        // Information about the client
	Created               time.Time         // When the session was created
	LastActive            time.Time         // Last time the session was active
	ProtocolVersion       string            // Negotiated protocol version
	Metadata              map[string]string // Additional session metadata
	ResourceSubscriptions []string          // List of resource URIs this session is subscribed to
}

type ContentItem struct {
	Type     string      `json:"type"`
	Text     string      `json:"text,omitempty"`
	ImageURL string      `json:"imageUrl,omitempty"`
	AltText  string      `json:"altText,omitempty"`
	URL      string      `json:"url,omitempty"`
	Title    string      `json:"title,omitempty"`
	MimeType string      `json:"mimeType,omitempty"`
	Data     interface{} `json:"data,omitempty"`
	Filename string      `json:"filename,omitempty"`
}

type ContentType string

type Context struct {

	// The raw request bytes
	RequestBytes []byte

	// The parsed request
	Request *Request

	// The response to be sent back
	Response *Response

	// Logger for this request
	Logger *slog.Logger

	// Version of the MCP protocol being used
	Version string

	// Request ID for tracing
	RequestID string

	// Progress token for long-running operations (if present)
	ProgressToken string

	// Metadata for storing contextual information during request processing
	Metadata map[string]interface{}

	// this is a session id that is used to track the session
	Session *ClientSession
	// contains filtered or unexported fields
}

type EmptyResponse struct{}

type FileResource struct {
	URL      string
	Filename string
	MimeType string
}

type ImageResource struct {
	URL      string
	AltText  string
	MimeType string
}

type ImageSamplingContent struct {
	Data     string
	MimeType string
}

type InitializeResponse struct {
	ProtocolVersion string                 `json:"protocolVersion"`
	ServerInfo      ServerInfo             `json:"serverInfo"`
	Capabilities    map[string]interface{} `json:"capabilities"`
}

type InvalidParametersError struct {
	// Message contains the error description
	Message string
}

type JSONResource struct {
	Data interface{}
}

type LinkResource struct {
	URL   string
	Title string
}

type Option func(*serverImpl)

type OverflowStrategy int

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

type ProgressRateLimitConfig struct {
	// MaxNotificationsPerSecond is the maximum number of notifications allowed per second per token
	MaxNotificationsPerSecond int `json:"maxNotificationsPerSecond"`

	// BufferSize is the maximum number of notifications to buffer when rate limited
	BufferSize int `json:"bufferSize"`

	// OverflowStrategy defines how to handle buffer overflow
	OverflowStrategy OverflowStrategy `json:"overflowStrategy"`

	// CombineThreshold is the minimum time between notifications before combining them
	CombineThreshold time.Duration `json:"combineThreshold"`

	// EnableBatching enables batching of multiple notifications into single messages
	EnableBatching bool `json:"enableBatching"`

	// BatchSize is the maximum number of notifications to batch together
	BatchSize int `json:"batchSize"`

	// BatchTimeout is the maximum time to wait before sending a partial batch
	BatchTimeout time.Duration `json:"batchTimeout"`
}

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

type Prompt struct {
	// Name is the unique identifier for this prompt
	Name string

	// Description explains what the prompt is for
	Description string

	// Templates are the ordered sequence of message templates that make up the prompt
	Templates []PromptTemplate

	// Arguments are the parameters that can be passed when rendering the prompt
	Arguments []PromptArgument
}

type PromptArgument struct {
	Name        string `json:"name"`
	Description string `json:"description,omitempty"`
	Required    bool   `json:"required,omitempty"`
}

type PromptContent struct {
	Type ContentType `json:"type"`
	Text string      `json:"text,omitempty"`
}

type PromptGetResponse struct {
	Description string          `json:"description"`
	Messages    []PromptMessage `json:"messages"`
}

type PromptInfo struct {
	Name        string           `json:"name"`
	Description string           `json:"description"`
	Arguments   []PromptArgument `json:"arguments,omitempty"`
}

type PromptListResponse struct {
	Prompts    []PromptInfo `json:"prompts"`
	NextCursor string       `json:"nextCursor,omitempty"`
}

type PromptMessage struct {
	Role    string        `json:"role"`
	Content PromptContent `json:"content"`
}

type PromptTemplate struct {
	// Role defines who is speaking in this template ("user" or "assistant")
	Role string

	// Content contains the template text with variables in {{variable}} format
	Content string
}

type ProtocolSamplingConfig struct {
	MaxTokens             int
	SupportedContentTypes map[string]bool
	StreamingSupported    bool
}

type RPCError struct {
	Code    int         `json:"code"`    // Error code
	Message string      `json:"message"` // Error message
	Data    interface{} `json:"data,omitempty"`
}

type Request struct {
	// JSON-RPC 2.0 fields
	JSONRPC string          `json:"jsonrpc"`
	ID      interface{}     `json:"id,omitempty"`     // string or number or null
	Method  string          `json:"method"`           // The method to call
	Params  json.RawMessage `json:"params,omitempty"` // Parameters for the method call

	// Parsed params based on method type
	// These fields are populated after parsing
	ToolName     string
	ToolArgs     map[string]interface{}
	ResourcePath string
	PromptName   string
	PromptArgs   map[string]interface{}
}

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

type RequestSamplingOptions struct {
	Timeout          time.Duration // Maximum time to wait for a response
	MaxRetries       int           // Maximum number of retry attempts on timeout
	RetryInterval    time.Duration // Time to wait between retries
	IgnoreCapability bool          // Whether to ignore client capability validation
	ForceSession     bool          // Whether to force using the specified session
}

type Resource struct {
	// Path is the URL path pattern for the resource
	Path string

	// Description explains what the resource provides
	Description string

	// Handler is the function that executes when the resource is accessed
	Handler interface{}

	// Schema defines the expected input format for the resource
	Schema interface{}

	// IsTemplate indicates if this is a template resource (path contains {})
	IsTemplate bool

	// Annotations contains additional metadata about the resource
	Annotations map[string]interface{}

	// Template is the parsed path template used for matching URLs
	Template *wilduri.Template
}

type ResourceContent struct {
	URI     string        `json:"uri"`
	Text    string        `json:"text,omitempty"`
	Content []ContentItem `json:"content,omitempty"`
}

type ResourceConverter interface {
	ToResourceResponse() map[string]interface{}
}

type ResourceInfo struct {
	URI         string `json:"uri"`
	Name        string `json:"name"`
	Description string `json:"description"`
	MimeType    string `json:"mimeType"`
}

type ResourceListResponse struct {
	Resources  []ResourceInfo `json:"resources"`
	NextCursor string         `json:"nextCursor,omitempty"`
}

type ResourceReadResponse struct {
	Contents []ResourceContent `json:"contents"`
}

type ResourceResponse struct {
	Content  []ContentItem          `json:"content"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
	IsError  bool                   `json:"isError,omitempty"`
}

type ResourceTemplateInfo struct {
	URITemplate string                 `json:"uriTemplate"`
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	MimeType    string                 `json:"mimeType,omitempty"`
	Annotations map[string]interface{} `json:"annotations,omitempty"`
}

type ResourceTemplatesListResponse struct {
	ResourceTemplates []ResourceTemplateInfo `json:"resourceTemplates"`
	NextCursor        string                 `json:"nextCursor,omitempty"`
}

type Response struct {
	// JSON-RPC 2.0 fields
	JSONRPC string      `json:"jsonrpc"`
	ID      interface{} `json:"id,omitempty"`     // Must match request ID
	Result  interface{} `json:"result,omitempty"` // Result data, null if error
	Error   *RPCError   `json:"error,omitempty"`  // Error data, null if success
}

type RootInfo struct {
	URI  string `json:"uri"`
	Name string `json:"name,omitempty"`
}

type RootsListResponse struct {
	Roots []RootInfo `json:"roots"`
}

type SamplingCapabilities struct {
	Supported    bool
	TextSupport  bool
	ImageSupport bool
	AudioSupport bool
}

type SamplingConfig struct {
	// Rate limiting settings
	MaxRequestsPerMinute  int  // Maximum number of sampling requests per minute
	MaxConcurrentRequests int  // Maximum number of concurrent sampling requests
	MaxTokensPerRequest   int  // Maximum tokens allowed per request
	PerClientRateLimit    bool // Whether to apply rate limits per client

	// Timeout settings
	DefaultTimeout time.Duration // Default timeout for sampling requests
	MaxTimeout     time.Duration // Maximum allowed timeout for sampling requests

	// Retry settings
	DefaultMaxRetries    int           // Default number of retries for failed requests
	DefaultRetryInterval time.Duration // Default interval between retries

	// Priority settings
	EnablePrioritization bool // Whether to enable request prioritization
	DefaultPriority      int  // Default priority for sampling requests (1-10, 10 being highest)

	// Resource allocation
	ResourceQuota map[string]int // Resource quotas for different content types

	// Error handling
	GracefulDegradation bool // Whether to enable graceful degradation on errors

	// Protocol-specific settings
	ProtocolDefaults map[string]*ProtocolSamplingConfig // Protocol-specific settings
}

type SamplingContentHandler interface {
	ToMessageContent() SamplingMessageContent
	Validate() error
}

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

type SamplingCreateMessageParams struct {
	Messages         []SamplingMessage        `json:"messages"`
	ModelPreferences SamplingModelPreferences `json:"modelPreferences"`
	SystemPrompt     string                   `json:"systemPrompt,omitempty"`
	MaxTokens        int                      `json:"maxTokens,omitempty"`
}

type SamplingMessage struct {
	Role    string                 `json:"role"`
	Content SamplingMessageContent `json:"content"`
}

type SamplingMessageContent struct {
	Type     string `json:"type"`
	Text     string `json:"text,omitempty"`
	Data     string `json:"data,omitempty"`
	MimeType string `json:"mimeType,omitempty"`
}

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

type SamplingModelPreferences struct {
	Hints                []SamplingModelHint `json:"hints,omitempty"`
	CostPriority         *float64            `json:"costPriority,omitempty"`
	SpeedPriority        *float64            `json:"speedPriority,omitempty"`
	IntelligencePriority *float64            `json:"intelligencePriority,omitempty"`
}

type SamplingResponse struct {
	Role       string                 `json:"role"`
	Content    SamplingMessageContent `json:"content"`
	Model      string                 `json:"model,omitempty"`
	StopReason string                 `json:"stopReason,omitempty"`
}

type Server interface {
	// Run starts the server and blocks until it exits.
	//
	// This method initializes the server, starts listening for connections,
	// and processes incoming requests. It blocks until the server encounters
	// an error or is explicitly stopped.
	//
	// Example:
	//  if err := server.Run(); err != nil {
	//      log.Fatalf("Server error: %v", err)
	//  }
	Run() error

	// Shutdown gracefully shuts down the server.
	//
	// This method stops accepting new connections and gracefully terminates
	// existing connections. It returns any error encountered during shutdown.
	//
	// Example:
	//  if err := server.Shutdown(); err != nil {
	//      log.Printf("Server shutdown error: %v", err)
	//  }
	Shutdown() error

	// Tool registers a tool with the server.
	//
	// The name parameter is the unique identifier for the tool. The description
	// parameter provides human-readable documentation. The handler parameter must
	// be a function with the signature:
	//   func(ctx *Context, args *StructType) (interface{}, error)
	//
	// Where StructType is a pointer to a struct and can be nil. The schema is automatically
	// extracted from the struct type using reflection and JSON tags.
	//
	// Optional annotations can be provided as additional map parameters to add
	// metadata that can be used by clients.
	//
	// Example:
	//  server.Tool("calculator", "Perform calculations", func(ctx *Context, args struct{
	//		Operation string `json:"operation"`
	//		A float64 `json:"a"`
	//		B float64 `json:"b"`
	//	}) (interface{}, error) {
	//      // Implementation here - args.Operation, args.A, args.B are fully typed
	//      return result, nil
	//  })
	Tool(name, description string, handler interface{}, annotations ...map[string]interface{}) Server

	// Resource registers a resource with the server.
	//
	// The pattern parameter is a URL path pattern that matches requests to this
	// resource. The description parameter provides human-readable documentation.
	// The handler parameter must be a function with signature:
	//   func(ctx *Context, args *StructType) (interface{}, error)
	//
	// Where StructType is a pointer to a struct and can be nil. The schema is automatically
	// extracted from the struct type using reflection and JSON tags.
	//
	// Path parameters are extracted from URI templates (e.g., /users/{id}) and
	// JSON parameters come from request body. Use struct tags to map them:
	//   - `path:"name"` for URI template parameters
	//   - `json:"name"` for JSON body parameters
	//
	// Example:
	//  server.Resource("/users/{id}", "Update user name", func(ctx *Context, args struct{
	//		ID   string `path:"id"`
	//		Name string `json:"name"`
	//	}) (interface{}, error) {
	//      // args.ID contains the path parameter from /users/{id}
	//      // args.Name contains the JSON body parameter
	//      user, err := getUserById(args.ID)
	//      if err != nil {
	//          return nil, err
	//      }
	//      user.Name = args.Name
	//      user, err = updateUser(user)
	//      if err != nil {
	//          return nil, err
	//      }
	//      return user, nil
	//  })
	Resource(path, description string, handler interface{}) Server

	// Prompt registers a prompt template with the server.
	//
	// The name parameter is the unique identifier for the prompt. The description
	// parameter provides human-readable documentation. The templates parameter
	// contains one or more prompt templates created using User() or Assistant().
	//
	// At least one template must be provided. Use server.User() and server.Assistant()
	// helper functions to create templates with the appropriate roles.
	//
	// Example:
	//  server.Prompt("greeting", "A friendly greeting",
	//      server.User("Hello, {{name}}! How are you today?"))
	//
	//  server.Prompt("conversation", "A multi-turn conversation",
	//      server.User("Please help me with {{task}}."),
	//      server.Assistant("I'll be happy to help you with that."))
	Prompt(name, description string, templates ...PromptTemplate) Server

	// Root sets the allowed root paths.
	//
	// Root paths are the entry points for resource navigation. At least one
	// root path must be defined for resources to be accessible.
	//
	// Example:
	//  server.Root("/api/v1", "/api/v2")
	Root(paths ...string) Server

	// IsPathInRoots checks if the given path is within any of the registered roots.
	// This security method ensures that file operations can only access paths within
	// the authorized boundaries defined by the registered root paths, preventing
	// directory traversal attacks and unauthorized file system access.
	//
	// Parameters:
	IsPathInRoots(path string) bool

	// Logger returns the server's logger.
	//
	// This method provides access to the server's configured logger for custom logging needs.
	// It can be used to log additional information or to reconfigure logging at runtime.
	//
	// Example:
	//
	//	// Log a custom message with the server's logger
	//	server.Logger().Info("custom event occurred",
	//	    "correlation_id", correlationID,
	//	    "user_id", userID,
	//	)
	Logger() *slog.Logger

	// Events returns the server's event system.
	//
	// This method provides access to the server's event system for subscribing to
	// server lifecycle events. External consumers can hook into events like server
	// initialization, client connections, tool executions, and more.
	//
	// Example:
	//
	//	// Subscribe to server initialization events
	//	events.Subscribe[MyServerEvent](server.Events(), events.TopicServerInitialized,
	//	    func(ctx context.Context, evt MyServerEvent) error {
	//	        log.Printf("Server %s initialized with %d tools", evt.Name, evt.ToolCount)
	//	        return nil
	//	    })
	//
	//	// Subscribe to client connection events
	//	events.Subscribe[MyClientEvent](server.Events(), events.TopicClientConnected,
	//	    func(ctx context.Context, evt MyClientEvent, conn net.Conn) error {
	//	        log.Printf("Client connected from %s", conn.RemoteAddr())
	//	        return nil
	//	    })
	Events() *events.Subject

	// ListTools returns a list of all registered tools.
	//
	// This method provides programmatic access to the server's tool registry,
	// returning the same information that would be provided via the tools/list
	// MCP endpoint but in a convenient Go slice format. This is useful for
	// debugging, monitoring, and multi-proxy aggregation scenarios.
	//
	// Example:
	//  tools, err := server.ListTools()
	//  if err != nil {
	//      log.Printf("Failed to list tools: %v", err)
	//      return
	//  }
	//  for _, tool := range tools {
	//      fmt.Printf("Tool: %s - %s\n", tool.Name, tool.Description)
	//  }
	ListTools() ([]mcp.Tool, error)

	// ListResources returns a list of all registered resources.
	//
	// This method provides programmatic access to the server's resource registry,
	// returning the same information that would be provided via the resources/list
	// MCP endpoint but in a convenient Go slice format. This is useful for
	// debugging, monitoring, and multi-proxy aggregation scenarios.
	//
	// Example:
	//  resources, err := server.ListResources()
	//  if err != nil {
	//      log.Printf("Failed to list resources: %v", err)
	//      return
	//  }
	//  for _, resource := range resources {
	//      fmt.Printf("Resource: %s - %s\n", resource.URI, resource.Description)
	//  }
	ListResources() ([]mcp.Resource, error)

	// ListPrompts returns a list of all registered prompts.
	//
	// This method provides programmatic access to the server's prompt registry,
	// returning the same information that would be provided via the prompts/list
	// MCP endpoint but in a convenient Go slice format. This is useful for
	// debugging, monitoring, and multi-proxy aggregation scenarios.
	//
	// Example:
	//  prompts, err := server.ListPrompts()
	//  if err != nil {
	//      log.Printf("Failed to list prompts: %v", err)
	//      return
	//  }
	//  for _, prompt := range prompts {
	//      fmt.Printf("Prompt: %s - %s\n", prompt.Name, prompt.Description)
	//  }
	ListPrompts() ([]mcp.Prompt, error)

	// AsHTTP configures the server to use HTTP for communication.
	//
	// The address parameter specifies the host and port to listen on.
	// Additional options can be provided to customize the HTTP transport behavior.
	//
	// Example:
	//  server.AsHTTP("localhost:8080")
	//  server.AsHTTP("localhost:8080", http.WithPathPrefix("/api/v1"), http.WithMCPEndpoint("/custom-mcp"))
	AsHTTP(address string, options ...http.Option) Server

	// AsGRPC configures the server to use gRPC for communication.
	//
	// gRPC provides high-performance, bidirectional streaming communication
	// with strong typing through Protocol Buffers. It supports TLS encryption,
	// configurable message sizes, and keepalive parameters for production deployments.
	//
	// The address parameter specifies the host and port to listen on.
	// Additional options can be provided to customize the gRPC transport behavior.
	//
	// Example:
	//  // Basic configuration
	//  server.AsGRPC(":50051")
	//
	//  // With TLS and custom options
	//  server.AsGRPC(":50051",
	//      grpc.WithTLS("cert.pem", "key.pem", "ca.pem"),
	//      grpc.WithMaxMessageSize(8*1024*1024),
	//      grpc.WithConnectionTimeout(20*time.Second))
	AsGRPC(address string, options ...grpc.Option) Server

	// AsWebsocket configures the server to use WebSocket for communication.
	//
	// The address parameter specifies the host and port to listen on.
	//
	// Example:
	//  server.AsWebsocket("localhost:8080")
	AsWebsocket(address string) Server

	// AsSSE configures the server to use Server-Sent Events for communication.
	//
	// The address parameter specifies the host and port to listen on.
	// Optional SSE configuration options can be provided using sse.SSE.With* functions.
	//
	// Example:
	//  // Basic configuration
	//  server.AsSSE("localhost:8080")
	//
	//  // With custom paths
	//  server.AsSSE("localhost:8080", sse.SSE.WithPathPrefix("/api"), sse.SSE.WithEventsPath("/events"))
	AsSSE(address string, options ...sse.Option) Server

	// AsUnixSocket configures the server to use Unix Domain Sockets for communication.
	//
	// Unix Domain Sockets provide high-performance inter-process communication for
	// processes running on the same machine.
	//
	// Example:
	//
	//	server.AsUnixSocket("/tmp/mcp.sock")
	//	// With options:
	//	server.AsUnixSocket("/tmp/mcp.sock", unix.WithPermissions(0600))
	AsUnixSocket(socketPath string, options ...unix.UnixSocketOption) Server

	// AsUDP configures the server to use UDP for communication.
	//
	// UDP provides low-latency communication with minimal overhead,
	// suitable for high-throughput scenarios where occasional packet
	// loss is acceptable.
	//
	// Example:
	//
	//	server.AsUDP(":8080")
	//	// With options:
	//	server.AsUDP(":8080", udp.WithMaxPacketSize(2048))
	AsUDP(address string, options ...udp.UDPOption) Server

	// AsMQTT configures the server to use MQTT for communication
	// with optional configuration options.
	//
	// MQTT provides a publish/subscribe-based communication model,
	// suitable for IoT applications and distributed systems with
	// potentially intermittent connectivity.
	//
	// Example:
	//
	//	server.AsMQTT("tcp://broker.example.com:1883")
	//	// With options:
	//	server.AsMQTT("tcp://broker.example.com:1883",
	//	    mqtt.WithQoS(1),
	//	    mqtt.WithCredentials("username", "password"),
	//	    mqtt.WithTopicPrefix("custom/topic/prefix"))
	AsMQTT(brokerURL string, options ...mqtt.MQTTOption) Server

	// AsStdio configures the server to use Standard I/O for communication.
	//
	// This is useful for child processes or integration with other MCP systems.
	// An optional logFile parameter can be provided to redirect stdio logs.
	//
	// Example:
	//  server.AsStdio("./mcp-server.log")
	AsStdio(logFile ...string) Server

	// AsNATS configures the server to use NATS for communication
	// with optional configuration options.
	//
	// NATS provides a high-performance, cloud native communication system,
	// suitable for microservices architectures, IoT messaging, and
	// event-driven applications.
	//
	// Example:
	//
	//	server.AsNATS("nats://localhost:4222")
	//	// With options:
	//	server.AsNATS("nats://localhost:4222",
	//	    nats.WithCredentials("username", "password"),
	//	    nats.WithSubjectPrefix("custom/subject/prefix"))
	AsNATS(serverURL string, options ...nats.NATSOption) Server

	// AsEmbedded configures the server to use embedded (in-process) transport for communication.
	//
	// Embedded transport provides zero-overhead in-process communication, perfect for
	// testing, library integration, and embedded use cases where network overhead
	// should be minimized.
	//
	// The transport parameter should be the server-side transport from a transport pair
	// created using embedded.NewTransportPair().
	//
	// Example:
	//
	//	// Create transport pair
	//	serverTransport, clientTransport := embedded.NewTransportPair()
	//
	//	// Configure server with the server-side transport
	//	server.AsEmbedded(serverTransport)
	//
	//	// Use clientTransport with your MCP client
	//	client := client.NewEmbeddedTransport(clientTransport)
	AsEmbedded(transport *embedded.Transport) Server

	// GetServer returns the underlying server implementation
	// This is primarily for internal use and testing.
	GetServer() *serverImpl
}

type ServerInfo struct {
	Name    string `json:"name"`
	Version string `json:"version"`
}

type Session = ClientSession

type SessionID string

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

type ShutdownResponse struct {
	Success bool `json:"success"`
}

type TextResource struct {
	Text string
}

type TextSamplingContent struct {
	Text string
}

type Tool struct {
	// Name is the unique identifier for the tool
	Name string

	// Description explains what the tool does
	Description string

	// Handler is the function that executes when the tool is called
	Handler interface{}

	// Schema defines the expected input format for the tool
	Schema interface{}

	// Annotations contains additional metadata about the tool
	Annotations map[string]interface{}
}

type ToolCallResponse struct {
	Content []ContentItem `json:"content"`
	IsError bool          `json:"isError"`
}

type ToolInfo struct {
	Name        string                 `json:"name"`
	Description string                 `json:"description"`
	InputSchema interface{}            `json:"inputSchema"`
	Annotations map[string]interface{} `json:"annotations,omitempty"`
}

type ToolListResponse struct {
	Tools      []ToolInfo `json:"tools"`
	NextCursor string     `json:"nextCursor,omitempty"`
}