core

type BaseDecorator struct {
	LLM
}

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

type BaseModule struct {
	Signature Signature
	LLM       LLM
}

type BaseOptimizer struct {
	Name string
}

type BatchEmbeddingResult struct {
	// Embeddings for each input
	Embeddings []EmbeddingResult
	// Any error that occurred during processing
	Error error
	// Input index that caused the error (if applicable)
	ErrorIndex int
}

type BootstrapFewShot struct {
	BaseOptimizer
	MaxExamples int
}

type Capability string

type CompileOptions struct {
	MaxTrials int
	Teacher   *Program
}

type Composable interface {
	Module
	Compose(next Module) Module
	GetSubModules() []Module
	SetSubModules([]Module)
}

type Config struct {
	DefaultLLM       LLM
	TeacherLLM       LLM
	ConcurrencyLevel int
}

type Dataset interface {
	// Next returns the next example in the dataset
	Next() (Example, bool)
	// Reset resets the dataset iterator
	Reset()
}

type EmbeddingOption func(*EmbeddingOptions)

type EmbeddingOptions struct {
	// Model-specific options for embedding
	Model string
	// Optional batch size for bulk embeddings
	BatchSize int
	// Additional model-specific parameters
	Params map[string]interface{}
}

type EmbeddingResult struct {
	// The generated embedding vector
	Vector []float32
	// Token count and other metadata
	TokenCount int
	// Any model-specific metadata
	Metadata map[string]interface{}
}

type EndpointConfig struct {
	BaseURL    string            // Base API URL
	Path       string            // Specific endpoint path
	Headers    map[string]string // Common headers
	TimeoutSec int               // Request timeout in seconds
}

type Example struct {
	Inputs  map[string]interface{}
	Outputs map[string]interface{}
}

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

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

type Field struct {
	Name        string
	Description string
	Prefix      string
}

type FieldOption func(*Field)

type GenerateOption func(*GenerateOptions)

type GenerateOptions struct {
	MaxTokens        int
	Temperature      float64
	TopP             float64
	PresencePenalty  float64
	FrequencyPenalty float64
	Stop             []string
}

type InputField struct {
	Field
}

type LLM interface {
	// Generate produces text completions based on the given prompt
	Generate(ctx context.Context, prompt string, options ...GenerateOption) (*LLMResponse, error)

	// GenerateWithJSON produces structured JSON output based on the given prompt
	GenerateWithJSON(ctx context.Context, prompt string, options ...GenerateOption) (map[string]interface{}, error)

	CreateEmbedding(ctx context.Context, input string, options ...EmbeddingOption) (*EmbeddingResult, error)
	CreateEmbeddings(ctx context.Context, inputs []string, options ...EmbeddingOption) (*BatchEmbeddingResult, error)

	ProviderName() string
	ModelID() string
	Capabilities() []Capability
}

type LLMFactory interface {
	// CreateLLM creates a new LLM instance. It uses the global configuration
	// from core.GlobalConfig for client settings.
	CreateLLM(apiKey string, modelID ModelID) (LLM, error)
}

type LLMResponse struct {
	Content string
	Usage   *TokenInfo
}

type Metric func(expected, actual map[string]interface{}) float64

type ModelContextDecorator struct {
	BaseDecorator
}

type ModelID string

type Module interface {
	// Process executes the module's logic
	Process(ctx context.Context, inputs map[string]any, opts ...Option) (map[string]any, error)

	// GetSignature returns the module's input and output signature
	GetSignature() Signature

	// SetLLM sets the language model for the module
	SetLLM(llm LLM)

	// Clone creates a deep copy of the module
	Clone() Module
}

type ModuleChain struct {
	BaseModule
	Modules []Module
}

type ModuleOptions struct {
	// LLM generation options
	GenerateOptions []GenerateOption
}

type Optimizer interface {
	// Compile optimizes a given program using the provided dataset and metric
	Compile(ctx context.Context, program Program, dataset Dataset, metric Metric) (Program, error)
}

type OptimizerFactory func() (Optimizer, error)

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

type Option func(*ModuleOptions)

type OutputField struct {
	Field
}

type Program struct {
	Modules map[string]Module
	Forward func(ctx context.Context, inputs map[string]interface{}) (map[string]interface{}, error)
}

type ProgressReporter interface {
	Report(stage string, processed, total int)
}

type Signature struct {
	Inputs      []InputField
	Outputs     []OutputField
	Instruction string
}

type Span struct {
	ID          string
	ParentID    string
	Operation   string
	StartTime   time.Time
	EndTime     time.Time
	Error       error
	Annotations map[string]interface{}
}

type TokenInfo struct {
	PromptTokens     int
	CompletionTokens int
	TotalTokens      int
}

type TokenUsage struct {
	PromptTokens     int
	CompletionTokens int
	TotalTokens      int
	Cost             float64
}

type Tool interface {
	// Metadata returns the tool's metadata
	Metadata() *ToolMetadata

	// CanHandle checks if the tool can handle a specific action/intent
	CanHandle(ctx context.Context, intent string) bool

	// Execute runs the tool with provided parameters
	Execute(ctx context.Context, params map[string]interface{}) (ToolResult, error)

	// Validate checks if the parameters match the expected schema
	Validate(params map[string]interface{}) error
}

type ToolMetadata struct {
	Name          string            // Unique identifier for the tool
	Description   string            // Human-readable description
	InputSchema   map[string]string // Expected input parameter types
	OutputSchema  map[string]string // Expected output types
	Capabilities  []string          // List of supported capabilities
	ContextNeeded []string          // Required context keys
	Version       string            // Tool version for compatibility
}

type ToolRegistry interface {
	Register(tool Tool) error
	Get(name string) (Tool, error)
	List() []Tool
	Match(intent string) []Tool
}

type ToolResult struct {
	Data        interface{}            // The actual result data
	Metadata    map[string]interface{} // Execution metadata (timing, resources used, etc)
	Annotations map[string]interface{} // Additional context for result interpretation
}