mcp

type ClientPool interface {
	// Server management
	RegisterServer(ctx context.Context, name string, config ServerDefinition) error
	UnregisterServer(name string) error
	GetServerNames() []string

	// Client access
	GetClientSession(ctx context.Context, server string) (*mcpSdk.ClientSession, error)
	GetClientWrapper(server string) (ClientWrapper, error)

	// Health management
	StartHealthCheck(ctx context.Context, interval time.Duration) error
	StopHealthCheck() error
	PerformHealthCheck(ctx context.Context) error

	// Lifecycle
	Close(ctx context.Context) error

	// Statistics and monitoring
	GetPoolStats() PoolStats
	GetHealthyServers() []string
	GetUnhealthyServers() []string
}

type ClientProvider interface {
	GetClientSession(server string) (*mcpSdk.ClientSession, error)
	RegisterServer(name string, config ServerDefinition) error
	UnregisterServer(name string) error
	GetServerNames() []string
	StartHealthCheck(interval time.Duration)
	StopHealthCheck()
	Close() error
}

type ClientWrapper interface {
	// Connection management
	GetSession() *mcpSdk.ClientSession
	IsHealthy() bool
	GetLastHealthyTime() time.Time
	Reconnect(ctx context.Context) error
	Close() error

	// Configuration
	GetConfig() ServerDefinition
	GetRetryCount() int

	// Tool management
	CacheAllTools(ctx context.Context) error
	GetToolSignatures() map[string]*ToolSignature
	GetToolSignature(toolName string) (*ToolSignature, bool)

	// Health status
	SetHealthy(healthy bool)
	IncrementRetryCount() int
	ResetRetryCount()
}

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

type HealthChecker interface {
	CheckHealth(ctx context.Context, wrapper ClientWrapper) error
	GetCheckInterval() time.Duration
	GetCheckTimeout() time.Duration
}

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

type MCPClientWrapper struct {
	ToolSignatures map[string]*ToolSignature
	// contains filtered or unexported fields
}

type PoolConfig struct {
	MaxConcurrentHealthChecks int           `json:"max_concurrent_health_checks"`
	HealthCheckInterval       time.Duration `json:"health_check_interval"`
	HealthCheckTimeout        time.Duration `json:"health_check_timeout"`
}

type PoolStats struct {
	TotalServers     int                   `json:"total_servers"`
	HealthyServers   int                   `json:"healthy_servers"`
	UnhealthyServers int                   `json:"unhealthy_servers"`
	ServerStats      map[string]ServerStat `json:"server_stats"`
	PoolConfig       PoolConfig            `json:"pool_config"`
}

type ServerDefinition types.MCPServerDefinition

type ServerStat struct {
	Name            string    `json:"name"`
	Healthy         bool      `json:"healthy"`
	LastHealthyTime time.Time `json:"last_healthy_time"`
	RetryCount      int       `json:"retry_count"`
	ToolCount       int       `json:"tool_count"`
}

type ServerToolInfo struct {
	ServerName string         `json:"server_name"`
	Tool       *ToolSignature `json:"tool"`
}

type ToolCallResult struct {
	ServerName string                 `json:"server_name"`
	ToolName   string                 `json:"tool_name"`
	Success    bool                   `json:"success"`
	Result     map[string]interface{} `json:"result,omitempty"`
	Error      string                 `json:"error,omitempty"`
	Duration   time.Duration          `json:"duration"`
	Timestamp  time.Time              `json:"timestamp"`
}

type ToolManager interface {
	// Tool discovery
	GetAllTools(ctx context.Context) (map[string][]*ToolSignature, error)
	GetToolsByServer(ctx context.Context, serverName string) ([]*ToolSignature, error)
	FindToolByName(ctx context.Context, toolName string) ([]ServerToolInfo, error)

	// Tool calling
	CallTool(ctx context.Context, serverName, toolName string, args map[string]interface{}) (*ToolCallResult, error)
	CallToolAnyServer(ctx context.Context, toolName string, args map[string]interface{}) (*ToolCallResult, error)
	CallToolWithRetry(ctx context.Context, serverName, toolName string, args map[string]interface{}, maxRetries int) (*ToolCallResult, error)
}

type ToolParameter struct {
	Name        string      // Parameter name
	Type        string      // Parameter type (string, integer, number, boolean, array, object)
	Description string      // Parameter description
	Required    bool        // Whether required
	Default     interface{} // Default value
	Enum        []string    // Enum values
}

type ToolSignature struct {
	Name        string           // Tool name
	Description string           // Tool description
	Parameters  []*ToolParameter // Parameter list
	Required    []string         // Required parameter name list
}