client

type BatchError struct {
	// Code is the JSON-RPC error code
	Code int `json:"code"`

	// Message is a human-readable error message
	Message string `json:"message"`

	// Data contains additional error information
	Data interface{} `json:"data,omitempty"`
}

type BatchRequest struct {
	// Method is the JSON-RPC method to call (e.g., "tools/call", "resources/read")
	Method string `json:"method"`

	// Params contains the parameters for the method call
	Params map[string]interface{} `json:"params,omitempty"`

	// ID is the request identifier. If nil, this is treated as a notification.
	// Notifications do not generate responses.
	ID interface{} `json:"id,omitempty"`
}

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

type BatchResponse struct {
	// ID is the request identifier that this response corresponds to
	ID interface{} `json:"id"`

	// Result contains the successful result of the method call
	Result interface{} `json:"result,omitempty"`

	// Error contains error information if the method call failed
	Error *BatchError `json:"error,omitempty"`
}

type Client interface {
	// CallTool invokes a tool on the connected MCP server.
	//
	// The name parameter specifies the tool to call. The args parameter contains
	// the arguments to pass to the tool as key-value pairs. The returned interface{}
	// contains the tool's output, which can be any JSON-serializable value.
	//
	// Example:
	//  result, err := client.CallTool("translate", map[string]interface{}{
	//      "text": "Hello world",
	//      "target_language": "Spanish",
	//  })
	//
	// For timeout support:
	//  result, err := client.CallTool("translate", map[string]interface{}{
	//      "text": "Hello world",
	//      "target_language": "Spanish",
	//  }, client.WithRequestTimeoutOption(10*time.Second))
	CallTool(name string, args map[string]interface{}, opts ...RequestOption) (interface{}, error)

	// GetResource retrieves a resource from the server.
	//
	// The path parameter specifies the resource URI to retrieve.
	//
	// Example:
	//  resource, err := client.GetResource("/files/readme.txt")
	//  // Access content based on protocol version:
	//  if len(resource.Content) > 0 {
	//      // 2024-11-05 format
	//      fmt.Println("Text:", resource.Content[0].Text)
	//  } else if len(resource.Contents) > 0 {
	//      // 2025-03-26 format
	//      fmt.Println("Text:", resource.Contents[0].Content[0].Text)
	//  }
	//
	// For timeout support:
	//  resource, err := client.GetResource("/files/readme.txt",
	//      client.WithRequestTimeoutOption(5*time.Second))
	//
	// For passing additional parameters:
	//  resource, err := client.GetResource("/api/users",
	//      client.WithResourceParams(map[string]interface{}{
	//          "include_posts": true,
	//          "limit": 50,
	//      }),
	//      client.WithRequestTimeoutOption(5*time.Second))
	GetResource(path string, opts ...RequestOption) (*ResourceResponse, error)

	// GetPrompt retrieves a prompt from the server.
	//
	// The name parameter specifies the prompt to retrieve. The variables parameter
	// contains any variables to substitute in the prompt template.
	//
	// Example:
	//  prompt, err := client.GetPrompt("greeting", map[string]interface{}{
	//      "name": "Alice",
	//  })
	//
	// For timeout support:
	//  prompt, err := client.GetPrompt("greeting", map[string]interface{}{
	//      "name": "Alice",
	//  }, client.WithRequestTimeoutOption(3*time.Second))
	GetPrompt(name string, variables map[string]interface{}, opts ...RequestOption) (*PromptResponse, error)

	// GetRoot retrieves the root resource from the server.
	//
	// This is a convenience method equivalent to calling GetResource("/").
	//
	// Example:
	//  root, err := client.GetRoot()
	//  // Access content based on protocol version:
	//  if len(root.Content) > 0 {
	//      // 2024-11-05 format
	//      fmt.Println("Root text:", root.Content[0].Text)
	//  } else if len(root.Contents) > 0 {
	//      // 2025-03-26 format
	//      fmt.Println("Root text:", root.Contents[0].Content[0].Text)
	//  }
	GetRoot() (*ResourceResponse, error)

	// Close closes the client connection to the server and releases all resources.
	//
	// After calling Close, the client cannot be used for further operations.
	// It is good practice to defer this call after creating a client.
	//
	// Example:
	//  client, err := client.NewClient("my-client")
	//  if err != nil {
	//      log.Fatal(err)
	//  }
	//  defer client.Close()
	Close() error

	// AddRoot registers a new root endpoint with the server.
	//
	// The uri parameter specifies the path of the root. The name parameter
	// provides a human-readable name for the root.
	//
	// Example:
	//  err := client.AddRoot("/api/v2", "API Version 2")
	AddRoot(uri string, name string) error

	// RemoveRoot unregisters a root endpoint from the server.
	//
	// The uri parameter specifies the path of the root to remove.
	//
	// Example:
	//  err := client.RemoveRoot("/api/v1")
	RemoveRoot(uri string) error

	// GetRoots retrieves the list of root endpoints from the server.
	//
	// The returned slice contains all registered roots with their URIs and names.
	//
	// Example:
	//  roots, err := client.GetRoots()
	//  for _, root := range roots {
	//      fmt.Printf("Root: %s (%s)\n", root.URI, root.Name)
	//  }
	GetRoots() ([]Root, error)

	// ListTools retrieves the list of available tools from the server.
	//
	// This method calls the tools/list endpoint as specified in the MCP protocol.
	// It automatically handles pagination internally and returns all available tools.
	// The returned slice contains all available tools with their names, descriptions,
	// and input schemas, which can be used for tool discovery and proxy patterns.
	//
	// Example:
	//  tools, err := client.ListTools()
	//  for _, tool := range tools {
	//      fmt.Printf("Tool: %s - %s\n", tool.Name, tool.Description)
	//      fmt.Printf("Schema: %+v\n", tool.InputSchema)
	//  }
	ListTools() ([]Tool, error)

	// ListResources retrieves the list of available resources from the server.
	//
	// This method calls the resources/list endpoint as specified in the MCP protocol.
	// It automatically handles pagination internally and returns all available resources.
	// The returned slice contains all available resources with their URIs, names,
	// descriptions, and MIME types, which can be used for resource discovery.
	//
	// Example:
	//  resources, err := client.ListResources()
	//  for _, resource := range resources {
	//      fmt.Printf("Resource: %s - %s\n", resource.Name, resource.Description)
	//      fmt.Printf("URI: %s, MIME Type: %s\n", resource.URI, resource.MimeType)
	//  }
	ListResources(opts ...RequestOption) ([]Resource, error)

	// ListPrompts retrieves the list of available prompts from the server.
	//
	// This method calls the prompts/list endpoint as specified in the MCP protocol.
	// It automatically handles pagination internally and returns all available prompts.
	// The returned slice contains all available prompts with their names, descriptions,
	// and argument specifications, which can be used for prompt discovery.
	//
	// Example:
	//  prompts, err := client.ListPrompts()
	//  for _, prompt := range prompts {
	//      fmt.Printf("Prompt: %s - %s\n", prompt.Name, prompt.Description)
	//      fmt.Printf("Arguments: %d\n", len(prompt.Arguments))
	//  }
	ListPrompts(opts ...RequestOption) ([]Prompt, error)

	// Version returns the negotiated protocol version with the server.
	//
	// This returns one of the standardized version strings: "draft", "2024-11-05",
	// or "2025-03-26".
	//
	// Example:
	//  version := client.Version()
	//  fmt.Printf("Connected using MCP protocol version %s\n", version)
	Version() string

	// IsInitialized returns whether the client has been initialized.
	//
	// Initialization occurs during the first operation that requires
	// server communication.
	IsInitialized() bool

	// IsConnected returns whether the client is currently connected to the server.
	//
	// Example:
	//  if client.IsConnected() {
	//      fmt.Println("Client is connected to the server")
	//  } else {
	//      fmt.Println("Client is not connected")
	//  }
	IsConnected() bool

	// WithSamplingHandler registers a handler for sampling requests.
	//
	// The handler will be called when the server requests sampling (e.g., for LLM interactions).
	// Returns the client instance for method chaining.
	//
	// Example:
	//  client = client.WithSamplingHandler(func(params SamplingCreateMessageParams) (SamplingResponse, error) {
	//      // Process sampling request
	//      return SamplingResponse{...}, nil
	//  })
	WithSamplingHandler(handler SamplingHandler) Client

	// GetSamplingHandler returns the currently registered sampling handler.
	GetSamplingHandler() SamplingHandler

	// Events returns the events subject for subscribing to client events.
	//
	// This provides access to the event system for monitoring client lifecycle,
	// errors, and other significant events. Subscribers can listen for specific
	// event types such as initialization, connection changes, and errors.
	//
	// Example:
	//  events := client.Events()
	//  events.Subscribe(events.TopicClientError, func(event events.ClientErrorEvent) {
	//      log.Printf("Client error: %s", event.Error)
	//  })
	Events() *events.Subject

	// RequestSampling initiates a sampling request to the server.
	//
	// This is the unified method for all sampling operations, supporting both
	// regular and streaming modes through options configuration.
	//
	// Example:
	//  opts := client.NewSamplingOptions(messages, prefs).
	//      WithSystemPrompt("You are a helpful assistant").
	//      WithMaxTokens(1000)
	//  response, err := client.RequestSampling(opts)
	//
	// For streaming (protocol version 2025-03-26 only):
	//  opts := client.NewSamplingOptions(messages, prefs).
	//      WithStreaming(func(chunk *SamplingResponse) error {
	//          fmt.Printf("Received chunk: %s\n", chunk.Content.Text)
	//          return nil
	//      })
	//  response, err := client.RequestSampling(opts)
	RequestSampling(opts *SamplingOptions) (*SamplingResponse, error)

	// SendBatch sends multiple requests to the server in a single batch operation.
	//
	// This method implements JSON-RPC 2.0 batch requests, allowing multiple operations
	// to be sent together for improved efficiency. The requests parameter contains
	// the individual requests to include in the batch.
	//
	// The method returns a slice of BatchResponse objects, where each response
	// corresponds to a request in the batch (excluding notifications). The order
	// of responses matches the order of requests.
	//
	// Example:
	//  requests := []BatchRequest{
	//      {Method: "tools/call", Params: map[string]interface{}{"name": "calculator", "arguments": map[string]interface{}{"op": "add", "a": 1, "b": 2}}},
	//      {Method: "resources/read", Params: map[string]interface{}{"uri": "/config.json"}},
	//      {Method: "prompts/get", Params: map[string]interface{}{"name": "greeting", "arguments": map[string]interface{}{"name": "Alice"}}},
	//  }
	//  responses, err := client.SendBatch(requests)
	//  for i, response := range responses {
	//      if response.Error != nil {
	//          fmt.Printf("Request %d failed: %v\n", i, response.Error)
	//      } else {
	//          fmt.Printf("Request %d result: %v\n", i, response.Result)
	//      }
	//  }
	//
	// For timeout support:
	//  responses, err := client.SendBatch(requests, client.WithRequestTimeoutOption(30*time.Second))
	SendBatch(requests []BatchRequest, opts ...RequestOption) ([]BatchResponse, error)

	// BatchBuilder creates a new batch builder for constructing batch requests.
	//
	// The batch builder provides a fluent interface for adding multiple requests
	// to a batch operation. Use AddRequest to add individual requests.
	//
	// Example:
	//  responses, err := client.BatchBuilder().
	//      AddRequest("tools/call", map[string]interface{}{
	//          "name": "calculator",
	//          "arguments": map[string]interface{}{"op": "add", "a": 1, "b": 2}
	//      }, 1).
	//      AddRequest("resources/read", map[string]interface{}{"uri": "/config.json"}, 2).
	//      AddRequest("prompts/get", map[string]interface{}{
	//          "name": "greeting",
	//          "arguments": map[string]interface{}{"name": "Alice"}
	//      }, 3).
	//      Execute()
	BatchBuilder() *BatchRequestBuilder

	// GetServerCapabilities returns the server's declared capabilities from initialization.
	//
	// This method returns the capabilities that the server declared during the MCP
	// initialization handshake. These capabilities indicate which optional protocol
	// features are supported by the server, such as resources, prompts, tools, and
	// logging. Returns nil if the client has not been initialized yet.
	//
	// Example:
	//  caps := client.GetServerCapabilities()
	//  if caps != nil && caps.Resources != nil {
	//      fmt.Println("Server supports resources")
	//      if caps.Resources.Subscribe {
	//          fmt.Println("Server supports resource subscriptions")
	//      }
	//  }
	GetServerCapabilities() *ServerCapabilities

	// GetServerInfo returns the server's identification information from initialization.
	//
	// This method returns the server information (name, version) that was provided
	// during the MCP initialization handshake. Returns nil if the client has not
	// been initialized yet.
	//
	// Example:
	//  info := client.GetServerInfo()
	//  if info != nil {
	//      fmt.Printf("Connected to %s version %s\n", info.Name, info.Version)
	//  }
	GetServerInfo() *ServerInfo

	// GetServerInstructions returns optional instructions provided by the server.
	//
	// This method returns any optional instructions that the server provided during
	// initialization (available in MCP protocol version 2025-03-26). Returns an
	// empty string if no instructions were provided or if using an older protocol version.
	//
	// Example:
	//  instructions := client.GetServerInstructions()
	//  if instructions != "" {
	//      fmt.Printf("Server instructions: %s\n", instructions)
	//  }
	GetServerInstructions() string

	// HasCapability checks if the server supports a specific top-level capability.
	//
	// This is a convenience method for checking server capability support. The
	// capability parameter should be one of: "logging", "prompts", "resources",
	// "tools", or "experimental". Returns false if the client has not been
	// initialized or if the capability is not supported.
	//
	// Example:
	//  if client.HasCapability("resources") {
	//      resources, err := client.ListResources()
	//      // ... handle resources
	//  }
	HasCapability(capability string) bool

	// SupportsResourceSubscriptions checks if the server supports resource change subscriptions.
	//
	// This is a convenience method for checking if the server's resource capability
	// includes the "subscribe" sub-capability, which allows clients to receive
	// notifications when specific resources change. Returns false if the server
	// doesn't support resources or subscriptions.
	//
	// Example:
	//  if client.SupportsResourceSubscriptions() {
	//      // Can subscribe to resource changes
	//  }
	SupportsResourceSubscriptions() bool

	// SupportsListChangedNotifications checks if the server supports list change notifications.
	//
	// This method checks if the server supports notifications when the list of items
	// of a specific type changes. The resourceType parameter should be one of:
	// "prompts", "resources", or "tools". Returns false if the server doesn't
	// support the specified resource type or list change notifications.
	//
	// Example:
	//  if client.SupportsListChangedNotifications("resources") {
	//      // Server will notify when the resource list changes
	//  }
	SupportsListChangedNotifications(resourceType string) bool

	// Ping sends a ping request to the server to verify connection health.
	Ping() error

	// WaitForReady waits for the client to be fully connected and ready to handle requests.
	//
	// This method blocks until the client is connected, initialized, and can successfully
	// ping the server, or until the timeout is reached. It's useful for ensuring the
	// server is fully ready before making API calls.
	//
	// Example:
	//  if err := client.WaitForReady(5 * time.Second); err != nil {
	//      log.Fatal("Server not ready:", err)
	//  }
	//  // Now safe to make API calls
	//  tools, err := client.ListTools()
	WaitForReady(timeout time.Duration) error

	// GetServerStatus returns the status of a managed MCP server.
	//
	// This method is only available for clients created with WithServersFromConfig
	// or WithServerConfig options. It returns the running status, any errors,
	// and process information for the specified server.
	//
	// Example:
	//  status := client.GetServerStatus("file-server")
	//  if !status.Running {
	//      log.Printf("File server is not running: %v", status.Error)
	//  }
	GetServerStatus(serverName string) *ServerStatus

	// RestartServer attempts to restart a managed MCP server.
	//
	// This method is only available for clients created with WithServersFromConfig
	// or WithServerConfig options. It stops the specified server if running and
	// starts it again with the same configuration.
	//
	// Example:
	//  err := client.RestartServer("file-server")
	//  if err != nil {
	//      log.Fatalf("Failed to restart server: %v", err)
	//  }
	RestartServer(serverName string) error
}

type ClientCapabilities struct {
	Roots        RootsCapability        `json:"roots,omitempty"`
	Sampling     map[string]interface{} `json:"sampling,omitempty"`
	Experimental map[string]interface{} `json:"experimental,omitempty"`
}

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"`
	Blob     string      `json:"blob,omitempty"`
	MimeType string      `json:"mimeType,omitempty"`
	Data     interface{} `json:"data,omitempty"`
	Filename string      `json:"filename,omitempty"`
}

type EmbeddedOption func(*embeddedConfig)

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

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

type HTTPOption func(*httpConfig)

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

type LoggerOption func(*loggerConfig)

type LoggingCapability struct {
}

type MCPServer struct {
	Name   string
	Client Client
	// contains filtered or unexported fields
}

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

type MQTTTransportOption func(*MQTTTransport)

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

type NATSTransportOption func(*NATSTransport)

type Option func(*clientImpl)

type ProcessInfo struct {
	PID        int
	ServerName string
	Command    string
	StartTime  time.Time
	Children   []int // Child process PIDs
}

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

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

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

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

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

type PromptsCapability struct {
	ListChanged bool `json:"listChanged,omitempty"`
}

type RequestOption interface {
	// contains filtered or unexported methods
}

type RequestOptions struct {
	// Timeout specifies the timeout for this specific request
	// If not set, uses the client's default timeout
	Timeout *time.Duration

	// MaxTimeout specifies the maximum timeout regardless of progress notifications
	// If not set, uses 2x the regular timeout as the maximum
	MaxTimeout *time.Duration

	// AllowProgressReset indicates whether progress notifications should reset the timeout clock
	// Default is true as per MCP specification
	AllowProgressReset bool
}

type Resource struct {
	URI         string                 `json:"uri"`
	Name        string                 `json:"name"`
	Description string                 `json:"description,omitempty"`
	MimeType    string                 `json:"mimeType,omitempty"`
	Size        *int64                 `json:"size,omitempty"`
	Annotations map[string]interface{} `json:"annotations,omitempty"`
}

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

type ResourceParamsOption struct {
	Params map[string]interface{}
}

type ResourceResponse struct {
	// Content field (2024-11-05 format) - flat array of content items
	Content []ContentItem `json:"content,omitempty"`

	// Contents field (2025-03-26 format) - array of resource objects with content
	Contents []ResourceContent `json:"contents,omitempty"`

	// Metadata that can be present in either format
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type ResourcesCapability struct {
	Subscribe   bool `json:"subscribe,omitempty"`
	ListChanged bool `json:"listChanged,omitempty"`
}

type Root struct {
	URI      string                 `json:"uri"`
	Name     string                 `json:"name,omitempty"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type RootsCapability struct {
	ListChanged atomic.Bool `json:"-"` // Use atomic.Bool and exclude from JSON
}

type SSETransport 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 SamplingHandler func(params SamplingCreateMessageParams) (SamplingResponse, error)

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 SamplingOptions struct {
	// Core request parameters
	Messages         []SamplingMessage
	ModelPreferences SamplingModelPreferences
	SystemPrompt     string
	MaxTokens        int

	// Request configuration
	Context         context.Context
	Timeout         time.Duration
	ProtocolVersion string

	// Streaming options (only for protocol version 2025-03-26)
	Streaming      bool
	StreamHandler  func(*SamplingResponse) error // Called for each chunk when streaming
	ChunkSize      int                           // Maximum size of text chunks
	MaxChunks      int                           // Maximum number of chunks (0 for unlimited)
	StopOnComplete bool                          // Stop streaming when isComplete=true

	// Retry configuration
	MaxRetries      int
	RetryInterval   time.Duration
	RetryMultiplier float64
	MaxInterval     time.Duration
}

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

	// Streaming fields
	IsComplete bool `json:"isComplete,omitempty"` // Only for streaming responses
	ChunkIndex int  `json:"chunkIndex,omitempty"` // Only for streaming responses
}

type ServerCapabilities struct {
	Logging      *LoggingCapability     `json:"logging,omitempty"`
	Prompts      *PromptsCapability     `json:"prompts,omitempty"`
	Resources    *ResourcesCapability   `json:"resources,omitempty"`
	Tools        *ToolsCapability       `json:"tools,omitempty"`
	Experimental map[string]interface{} `json:"experimental,omitempty"`
}

type ServerConfig struct {
	MCPServers map[string]ServerDefinition `json:"mcpServers"`
}

type ServerConfigOption func(*serverConfigParams)

type ServerDefinition struct {
	Command string            `json:"command"`
	Args    []string          `json:"args"`
	Env     map[string]string `json:"env,omitempty"`
	URL     string            `json:"url,omitempty"`
}

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

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

type ServerRegistryOption func(*ServerRegistry)

type ServerStatus struct {
	Running bool  `json:"running"`
	Error   error `json:"error,omitempty"`
	PID     int   `json:"pid,omitempty"`
}

type StdioOption func(*stdioConfig)

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

type TimeoutOption struct {
	Duration time.Duration
}

type Tool = mcp.Tool

type ToolsCapability struct {
	ListChanged bool `json:"listChanged,omitempty"`
}

type Transport interface {
	// Connect establishes a connection to the server.
	Connect() error

	// ConnectWithContext establishes a connection to the server with context for timeout/cancellation.
	ConnectWithContext(ctx context.Context) error

	// Disconnect closes the connection to the server.
	Disconnect() error

	// Send sends a message to the server and waits for a response.
	Send(message []byte) ([]byte, error)

	// SendWithContext sends a message with context for timeout/cancellation.
	SendWithContext(ctx context.Context, message []byte) ([]byte, error)

	// SetRequestTimeout sets the default timeout for request operations.
	SetRequestTimeout(timeout time.Duration)

	// SetConnectionTimeout sets the default timeout for connection operations.
	SetConnectionTimeout(timeout time.Duration)

	// RegisterNotificationHandler registers a handler for server-initiated messages.
	RegisterNotificationHandler(handler func(method string, params []byte))
}

type UDPOption func(*udpConfig)

type UnixSocketOption func(*unixConfig)

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