api

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

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"`
}

type BasicToolsAttributes struct {
	BasicFeatureAttributes
}

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

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
	// TODO: Policies should not be treated in a per-feature way but rather in a global way
	// TODO: for each feature proider (inferences, tools, etc.) this should be handled in the Initialize function
	Initialize(ctx context.Context, policies any)
	// IsAvailable Returns true if the feature is available
	IsAvailable() bool
	// Reason provides the reason why the feature is or is not available
	Reason() string
	GetDefaultPolicies() map[string]any
}

type FeatureAttributes interface {
	// Name of the feature
	Name() string
	// Description of the feature
	Description() string
}

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 InferenceProvider interface {
	Feature[InferenceAttributes]
	GetInference(ctx context.Context) (model.ToolCallingChatModel, error)
	// Models returns the list of supported models by the inference provider
	Models() []string
}

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 Tool struct {
	Name        string
	Description string
	// Parameters in JSONSchema format
	JSONSchema *jsonschema.Schema
	// 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 ToolsProvider interface {
	Feature[ToolsAttributes]
	GetTools(ctx context.Context) ([]*Tool, error)
	GetMcpSettings() *McpSettings
}