api

type Ai interface {
	InferenceAttributes() InferenceAttributes
	ToolEnabledCount() int
	ToolCount() int
	Reset()
	Session() Session
	Input() chan Message
}

type BasicFeatureAttributes struct {
	FeatureAttributes  `json:"-"`
	FeatureName        string `json:"name"`
	FeatureDescription string `json:"description"`
	SupportsSetupAttr  bool   `json:"-"`
}

type BasicInferenceAttributes struct {
	BasicFeatureAttributes
	LocalAttr  bool `json:"local"`
	PublicAttr bool `json:"public"`
}

type BasicInferenceProvider struct {
	InferenceProvider `json:"-"`
	BasicInferenceAttributes
	Available         bool     `json:"-"`
	IsAvailableReason string   `json:"reason"`
	ProviderModels    []string `json:"models"`
	InferenceParameters
}

type BasicToolsAttributes struct {
	BasicFeatureAttributes
}

type BasicToolsProvider struct {
	ToolsProvider `json:"-"`
	BasicToolsAttributes
	Available         bool         `json:"-"`
	IsAvailableReason string       `json:"reason"`
	McpSettings       *McpSettings `json:"mcp_settings,omitempty"`
	ToolsParameters
}

type Feature[a FeatureAttributes] interface {
	Attributes() a
	// Initialize Performs the discovery and initialization of the feature based on the user configuration and policies
	// Populates the internal state of the feature and its availability
	Initialize(ctx context.Context)
	// IsAvailable Returns true if the feature is available
	IsAvailable() bool
	// Reason provides the reason why the feature is or is not available
	Reason() string
}

type FeatureAttributes interface {
	// Name of the feature
	Name() string
	// Description of the feature
	Description() string
	// SupportsSetup indicates if the inference provider supports setup
	SupportsSetup() bool
}

type InferenceAttributes interface {
	FeatureAttributes
	// Local indicates if the inference provider is a local service
	Local() bool
	// Public indicates if the inference provider is public (e.g. OpenAI, Gemini) or private (e.g. Enterprise internal)
	Public() bool
}

type InferenceParameters struct {
	Enabled *bool   `json:"-" toml:"enabled"`
	Model   *string `json:"-" toml:"enabled"` // A model to use, if not set, the best model will be used
}

type InferencePolicies struct {
	// inference providers by property
	Property InferencePropertyPolicies `toml:"property,omitempty"`
	// inference providers by name
	Provider map[string]InferenceProviderPolicies `toml:"provider,omitempty"`
	// policies for all inference providers
	InferenceProviderPolicies
}

type InferencePropertyPolicies struct {
	Remote InferenceProviderPolicies `toml:"remote,omitempty"`
	Public InferenceProviderPolicies `toml:"public,omitempty"`
}

type InferenceProvider interface {
	Feature[InferenceAttributes]
	GetInference(ctx context.Context) (model.ToolCallingChatModel, error)
	GetModel(ctx context.Context) (string, error)
	// Models returns the list of supported models by the inference provider
	Models() []string
	SystemPrompt() string
	InstallHelp() error
	Clear(ctx context.Context) (bool, error)
}

type InferenceProviderPolicies struct {
	Enabled *bool `toml:"enabled,omitempty"`
}

type IsFeatureEnabled[a FeatureAttributes] func(feature Feature[a]) bool

type MCPConfig interface {
	// GetFile returns the path to the MCP config file
	GetFile() string
	// GetConfig returns the MCP config for the given tools in format expected by the editor
	GetConfig(tools []ToolsProvider) ([]byte, error)
}

type McpSettings struct {
	Type    McpType           `json:"type"`              // Type of MCP (STDIO, SSE, or HTTP)
	Command string            `json:"command,omitempty"` // Command to run for STDIO type
	Args    []string          `json:"args,omitempty"`    // Arguments for the command (STDIO)
	Env     []string          `json:"env,omitempty"`     // Environment variables for the command (STDIO)
	Url     string            `json:"url,omitempty"`     // URL for SSE or HTTP type
	Headers map[string]string `json:"headers,omitempty"` // Headers for HTTP requests (SSE or HTTP)
}

type McpType int

type Message struct {
	Type MessageType
	Text string

	// ToolMessage specific fields
	ToolName string
}

type MessageType string

type Policies struct {
	Inferences InferencePolicies `toml:"inferences,omitempty"`
	Tools      ToolsPolicies     `toml:"tools,omitempty"`
}

type PoliciesProvider interface {
	Read(policiesFile string) (*Policies, error)
}

type Session interface {
	HasMessages() bool
	Messages() []Message
	SystemPrompt() Message
	IsRunning() bool
}

type Tool struct {
	Name        string
	Description string
	// Parameters in map format (if ParametersSchema is not set)
	Parameters map[string]ToolParameter
	Function   func(args map[string]interface{}) (string, error)
}

type ToolParameter struct {
	Type        ToolParameterType
	Description string
	Required    bool
}

type ToolParameterType string

type ToolsAttributes interface {
	FeatureAttributes
}

type ToolsParameters struct {
	Enabled            *bool `json:"-" toml:"enabled"`
	ReadOnly           *bool `json:"-" toml:"read-only"`
	DisableDestructive *bool `json:"-" toml:"disable-destructive"`
}

type ToolsPolicies struct {

	// tools providers by name
	Provider map[string]ToolsProviderPolicies `toml:"provider,omitempty"`
	// policies for all tools providers
	ToolsProviderPolicies
}

type ToolsProvider interface {
	Feature[ToolsAttributes]
	// GetMcpSettings returns the MCP settings if the provider uses an MCP server, or nil otherwise
	GetMcpSettings() *McpSettings
	// GetTools returns the list of built-in, native, available tools
	GetTools(ctx context.Context) []*Tool
	InstallHelp() error
	Clear(ctx context.Context) (bool, error)
}

type ToolsProviderPolicies struct {
	Enabled        *bool `toml:"enabled,omitempty"`
	ReadOnly       *bool `toml:"read-only,omitempty"`
	NonDestructive *bool `toml:"non-destructive,omitempty"`
	// Local indicates if the tool cannot connect to a remote MCP server
	Local *bool `toml:"local,omitempty"`
}