embedding

type AdvancedSearchService interface {
	SearchService

	// CrossModelSearch performs search across embeddings from different models
	CrossModelSearch(ctx context.Context, req CrossModelSearchRequest) ([]CrossModelSearchResult, error)

	// HybridSearch performs hybrid search combining semantic and keyword search
	HybridSearch(ctx context.Context, req HybridSearchRequest) ([]HybridSearchResult, error)
}

type AgentService interface {
	GetConfig(ctx context.Context, agentID string) (*agents.AgentConfig, error)
	GetModelsForAgent(ctx context.Context, agentID string, taskType agents.TaskType) (primary []string, fallback []string, err error)
	CreateConfig(ctx context.Context, config *agents.AgentConfig) error
	UpdateConfig(ctx context.Context, agentID string, update *agents.ConfigUpdateRequest) (*agents.AgentConfig, error)
}

type AnthropicBatchEmbeddingRequest struct {
	Model string   `json:"model"`
	Texts []string `json:"texts"`
}

type AnthropicBatchEmbeddingResponse struct {
	Object     string      `json:"object"`
	Embeddings [][]float32 `json:"embeddings"`
	Model      string      `json:"model"`
	Error      interface{} `json:"error,omitempty"`
}

type AnthropicConfig struct {
	// Anthropic API key
	APIKey string
	// Anthropic API endpoint (optional)
	Endpoint string
	// Anthropic model name
	Model string
	// For testing environments
	UseMockEmbeddings bool
}

type AnthropicEmbeddingRequest struct {
	Model string `json:"model"`
	Text  string `json:"text"`
}

type AnthropicEmbeddingResponse struct {
	Object    string      `json:"object"`
	Embedding []float32   `json:"embedding"`
	Model     string      `json:"model"`
	Error     interface{} `json:"error,omitempty"`
}

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

type BedrockConfig struct {
	// AWS Region
	Region string
	// AWS credentials
	AccessKeyID     string
	SecretAccessKey string
	SessionToken    string
	// Model ID
	ModelID string
	// For testing environments when AWS credentials aren't available
	UseMockEmbeddings bool
}

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

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

type BedrockRuntimeClient interface {
	InvokeModel(ctx context.Context, params *bedrockruntime.InvokeModelInput, optFns ...func(*bedrockruntime.Options)) (*bedrockruntime.InvokeModelOutput, error)
}

type CachedEmbedding struct {
	Embedding  []float32              `json:"embedding"`
	Model      string                 `json:"model"`
	Provider   string                 `json:"provider"`
	Dimensions int                    `json:"dimensions"`
	Metadata   map[string]interface{} `json:"metadata"`
	CachedAt   time.Time              `json:"cached_at"`
}

type ChunkingInterface interface {
	// Here we define the minimum methods needed from the chunking service
	// These methods should match what we actually use in the pipeline
	ChunkCode(ctx context.Context, content string, path string) ([]*chunking.CodeChunk, error)
}

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

type CircuitBreakerConfig struct {
	FailureThreshold    int
	SuccessThreshold    int
	Timeout             time.Duration
	HalfOpenMaxRequests int
}

type CircuitBreakerState string

type CircuitBreakerStatus struct {
	State               string    `json:"state"`
	FailureCount        int       `json:"failure_count"`
	SuccessCount        int       `json:"success_count"`
	LastFailureTime     time.Time `json:"last_failure_time,omitempty"`
	LastStateChangeTime time.Time `json:"last_state_change_time"`
}

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

type CostOptimizerConfig struct {
	MaxCostPerRequest float64
}

type CostSummary struct {
	AgentID      string             `json:"agent_id"`
	Period       string             `json:"period"`
	TotalCostUSD float64            `json:"total_cost_usd"`
	ByProvider   map[string]float64 `json:"by_provider"`
	ByModel      map[string]float64 `json:"by_model"`
	RequestCount int                `json:"request_count"`
	TokensUsed   int                `json:"tokens_used"`
}

type CrossModelSearchRequest struct {
	// Query is the search query text
	Query string `json:"query"`
	// QueryEmbedding is the pre-computed query embedding (optional)
	QueryEmbedding []float32 `json:"query_embedding,omitempty"`
	// SearchModel is the model to use for generating query embeddings
	SearchModel string `json:"search_model"`
	// IncludeModels limits results to specific models (empty means all)
	IncludeModels []string `json:"include_models,omitempty"`
	// ExcludeModels excludes results from specific models
	ExcludeModels []string `json:"exclude_models,omitempty"`
	// TenantID is the tenant to search within
	TenantID uuid.UUID `json:"tenant_id"`
	// ContextID optionally limits search to a specific context
	ContextID *uuid.UUID `json:"context_id,omitempty"`
	// Limit is the maximum number of results to return
	Limit int `json:"limit"`
	// MinSimilarity is the minimum similarity threshold
	MinSimilarity float32 `json:"min_similarity"`
	// MetadataFilter is a JSONB filter for metadata
	MetadataFilter map[string]interface{} `json:"metadata_filter,omitempty"`
	// TaskType optionally specifies the type of task for scoring
	TaskType string `json:"task_type,omitempty"`
	// Options for additional search parameters
	Options *SearchOptions `json:"options,omitempty"`
}

type CrossModelSearchResult struct {
	// ID is the embedding ID
	ID uuid.UUID `json:"id"`
	// ContextID is the context this embedding belongs to
	ContextID *uuid.UUID `json:"context_id,omitempty"`
	// Content is the text content
	Content string `json:"content"`
	// OriginalModel is the model that created this embedding
	OriginalModel string `json:"original_model"`
	// OriginalDimension is the original embedding dimension
	OriginalDimension int `json:"original_dimension"`
	// Similarity is the normalized similarity score
	Similarity float32 `json:"similarity"`
	// RawSimilarity is the raw similarity score before normalization
	RawSimilarity float32 `json:"raw_similarity"`
	// AgentID is the agent that created this content
	AgentID string `json:"agent_id,omitempty"`
	// Metadata contains additional information
	Metadata map[string]interface{} `json:"metadata,omitempty"`
	// CreatedAt is when the embedding was created
	CreatedAt time.Time `json:"created_at"`
	// ModelQualityScore is the quality score for this model
	ModelQualityScore float32 `json:"model_quality_score"`
	// FinalScore is the final weighted score
	FinalScore float32 `json:"final_score"`
}

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

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

type Embedding struct {
	ID                   uuid.UUID       `json:"id" db:"id"`
	ContextID            uuid.UUID       `json:"context_id" db:"context_id"`
	ContentIndex         int             `json:"content_index" db:"content_index"`
	ChunkIndex           int             `json:"chunk_index" db:"chunk_index"`
	Content              string          `json:"content" db:"content"`
	ContentHash          string          `json:"content_hash" db:"content_hash"`
	ContentTokens        *int            `json:"content_tokens,omitempty" db:"content_tokens"`
	ModelID              uuid.UUID       `json:"model_id" db:"model_id"`
	ModelProvider        string          `json:"model_provider" db:"model_provider"`
	ModelName            string          `json:"model_name" db:"model_name"`
	ModelDimensions      int             `json:"model_dimensions" db:"model_dimensions"`
	ConfiguredDimensions *int            `json:"configured_dimensions,omitempty" db:"configured_dimensions"`
	ProcessingTimeMS     *int            `json:"processing_time_ms,omitempty" db:"processing_time_ms"`
	EmbeddingCreatedAt   time.Time       `json:"embedding_created_at" db:"embedding_created_at"`
	Magnitude            float64         `json:"magnitude" db:"magnitude"`
	TenantID             uuid.UUID       `json:"tenant_id" db:"tenant_id"`
	Metadata             json.RawMessage `json:"metadata" db:"metadata"`
	CreatedAt            time.Time       `json:"created_at" db:"created_at"`
	UpdatedAt            time.Time       `json:"updated_at" db:"updated_at"`
}

type EmbeddingCache interface {
	Get(ctx context.Context, key string) (*CachedEmbedding, error)
	Set(ctx context.Context, key string, embedding *CachedEmbedding, ttl time.Duration) error
	Delete(ctx context.Context, key string) error
}

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

type EmbeddingFactoryConfig struct {
	// Model configuration
	ModelType       ModelType `json:"model_type"`
	ModelName       string    `json:"model_name"`
	ModelAPIKey     string    `json:"model_api_key,omitempty"`
	ModelEndpoint   string    `json:"model_endpoint,omitempty"`
	ModelDimensions int       `json:"model_dimensions"`

	// Additional model parameters (used for provider-specific configurations)
	Parameters map[string]interface{} `json:"parameters,omitempty"`

	// Storage configuration
	DatabaseConnection *sql.DB `json:"-"`
	DatabaseSchema     string  `json:"database_schema"`

	// Pipeline configuration
	Concurrency     int  `json:"concurrency"`
	BatchSize       int  `json:"batch_size"`
	IncludeComments bool `json:"include_comments"`
	EnrichMetadata  bool `json:"enrich_metadata"`
}

type EmbeddingMetric struct {
	ID                     uuid.UUID `json:"id" db:"id"`
	AgentID                string    `json:"agent_id" db:"agent_id"`
	ModelProvider          string    `json:"model_provider" db:"model_provider"`
	ModelName              string    `json:"model_name" db:"model_name"`
	ModelDimensions        int       `json:"model_dimensions" db:"model_dimensions"`
	RequestID              uuid.UUID `json:"request_id" db:"request_id"`
	TokenCount             int       `json:"token_count" db:"token_count"`
	TotalLatencyMs         int       `json:"total_latency_ms" db:"total_latency_ms"`
	ProviderLatencyMs      int       `json:"provider_latency_ms" db:"provider_latency_ms"`
	NormalizationLatencyMs int       `json:"normalization_latency_ms" db:"normalization_latency_ms"`
	CostUSD                float64   `json:"cost_usd" db:"cost_usd"`
	Status                 string    `json:"status" db:"status"`
	ErrorMessage           string    `json:"error_message" db:"error_message"`
	RetryCount             int       `json:"retry_count" db:"retry_count"`
	FinalProvider          string    `json:"final_provider" db:"final_provider"`
	TenantID               uuid.UUID `json:"tenant_id" db:"tenant_id"`
	Timestamp              time.Time `json:"timestamp" db:"timestamp"`
}

type EmbeddingPipelineConfig struct {
	// Number of goroutines to use for parallel processing
	Concurrency int

	// Batch size for processing
	BatchSize int

	// Whether to include code comments in embeddings
	IncludeComments bool

	// Whether to enrich embeddings with metadata
	EnrichMetadata bool
}

type EmbeddingProviderSelector struct {
	// Explicit configuration overrides
	PreferredProvider string
	PreferredModel    string

	// Auto-detection settings
	EnableAutoDetection bool
	ValidationMode      string // "strict" or "permissive"
	// contains filtered or unexported fields
}

type EmbeddingSearchResult struct {
	ID            uuid.UUID       `json:"id" db:"id"`
	ContextID     uuid.UUID       `json:"context_id" db:"context_id"`
	Content       string          `json:"content" db:"content"`
	Similarity    float64         `json:"similarity" db:"similarity"`
	Metadata      json.RawMessage `json:"metadata" db:"metadata"`
	ModelProvider string          `json:"model_provider" db:"model_provider"`
}

type EmbeddingService interface {
	GenerateEmbedding(ctx context.Context, text string, contentType string, contentID string) (*EmbeddingVector, error)
	BatchGenerateEmbeddings(ctx context.Context, texts []string, contentType string, contentIDs []string) ([]*EmbeddingVector, error)
	GetModelConfig() ModelConfig
	GetModelDimensions() int
}

type EmbeddingStorage interface {
	StoreEmbedding(ctx context.Context, embedding *EmbeddingVector) error
	BatchStoreEmbeddings(ctx context.Context, embeddings []*EmbeddingVector) error
	FindSimilarEmbeddings(ctx context.Context, embedding *EmbeddingVector, limit int, threshold float32) ([]*EmbeddingVector, error)
	GetEmbeddingsByContentIDs(ctx context.Context, contentIDs []string) ([]*EmbeddingVector, error)
	DeleteEmbeddingsByContentIDs(ctx context.Context, contentIDs []string) error
}

type EmbeddingVector struct {
	Vector      []float32              `json:"vector"`
	Dimensions  int                    `json:"dimensions"`
	ModelID     string                 `json:"model_id"`
	ContentType string                 `json:"content_type"`
	ContentID   string                 `json:"content_id"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
}

type GenerateEmbeddingRequest struct {
	AgentID   string                 `json:"agent_id" validate:"required"`
	Text      string                 `json:"text" validate:"required,max=50000"`
	TaskType  agents.TaskType        `json:"task_type"`
	Metadata  map[string]interface{} `json:"metadata"`
	RequestID string                 `json:"request_id"`
	TenantID  uuid.UUID              `json:"tenant_id"`
	ContextID uuid.UUID              `json:"context_id"`
}

type GenerateEmbeddingResponse struct {
	EmbeddingID          uuid.UUID              `json:"embedding_id"`
	RequestID            string                 `json:"request_id"`
	ModelUsed            string                 `json:"model_used"`
	Provider             string                 `json:"provider"`
	Dimensions           int                    `json:"dimensions"`
	NormalizedDimensions int                    `json:"normalized_dimensions"`
	CostUSD              float64                `json:"cost_usd"`
	TokensUsed           int                    `json:"tokens_used"`
	GenerationTimeMs     int64                  `json:"generation_time_ms"`
	Cached               bool                   `json:"cached"`
	Metadata             map[string]interface{} `json:"metadata"`
}

type GitHubComment struct {
	ID        int       `json:"id"`
	Body      string    `json:"body"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
	User      struct {
		Login string `json:"login"`
	} `json:"user"`
}

type GitHubCommentData struct {
	ID        int       `json:"id"`
	Body      string    `json:"body"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
	User      struct {
		Login string `json:"login"`
	} `json:"user"`
}

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

type GitHubContentProvider interface {
	// GetContent retrieves file content from GitHub
	GetContent(ctx context.Context, owner, repo, path string) ([]byte, error)

	// GetIssue retrieves issue details from GitHub
	GetIssue(ctx context.Context, owner, repo string, issueNumber int) (*GitHubIssueData, error)

	// GetIssueComments retrieves issue comments from GitHub
	GetIssueComments(ctx context.Context, owner, repo string, issueNumber int) ([]*GitHubCommentData, error)
}

type GitHubIssue struct {
	Title     string    `json:"title"`
	Body      string    `json:"body"`
	State     string    `json:"state"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

type GitHubIssueData struct {
	Title     string    `json:"title"`
	Body      string    `json:"body"`
	State     string    `json:"state"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

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

type HybridSearchRequest struct {
	// Query is the main search query for semantic search
	Query string `json:"query"`
	// Keywords are additional keywords for keyword-based search
	Keywords []string `json:"keywords,omitempty"`
	// HybridWeight determines the balance between semantic and keyword results (0.0 to 1.0)
	HybridWeight float32 `json:"hybrid_weight"`
	// TenantID is the tenant to search within
	TenantID uuid.UUID `json:"tenant_id"`
	// ModelName is the embedding model to use
	ModelName string `json:"model_name"`
	// Limit is the maximum number of results
	Limit int `json:"limit"`
	// MinSimilarity is the minimum similarity threshold
	MinSimilarity float32 `json:"min_similarity"`
	// MetadataFilter is a JSONB filter for metadata
	MetadataFilter map[string]interface{} `json:"metadata_filter,omitempty"`
	// Options for additional search parameters
	Options *SearchOptions `json:"options,omitempty"`
	// QueryEmbedding allows pre-computed embedding to be passed
	QueryEmbedding []float32 `json:"query_embedding,omitempty"`
}

type HybridSearchResult struct {
	// Embed the cross-model search result
	CrossModelSearchResult
	// Result is the combined search result
	Result *SearchResult `json:"result"`
	// SemanticScore is the semantic similarity score
	SemanticScore float32 `json:"semantic_score"`
	// KeywordScore is the keyword relevance score
	KeywordScore float32 `json:"keyword_score"`
	// HybridScore is the combined score
	HybridScore float32 `json:"hybrid_score"`
}

type InsertRequest struct {
	ContextID            uuid.UUID       `json:"context_id"`
	Content              string          `json:"content"`
	Embedding            []float32       `json:"embedding"`
	ModelName            string          `json:"model_name"`
	TenantID             uuid.UUID       `json:"tenant_id"`
	Metadata             json.RawMessage `json:"metadata,omitempty"`
	ContentIndex         int             `json:"content_index"`
	ChunkIndex           int             `json:"chunk_index"`
	ConfiguredDimensions *int            `json:"configured_dimensions,omitempty"` // For models that support reduction
}

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

type LoadBalancerConfig struct {
	Strategy string
}

type MetricsFilter struct {
	AgentID   string
	Provider  string
	StartTime time.Time
	EndTime   time.Time
	Status    string
	Limit     int
}

type MetricsRepository interface {
	RecordMetric(ctx context.Context, metric *EmbeddingMetric) error
	GetMetrics(ctx context.Context, filter MetricsFilter) ([]*EmbeddingMetric, error)
	GetAgentCosts(ctx context.Context, agentID string, period time.Duration) (*CostSummary, error)
}

type MockBedrockClient struct{}

type MockGitHubContentProvider struct{}

type Model struct {
	ID                              uuid.UUID       `json:"id" db:"id"`
	Provider                        string          `json:"provider" db:"provider"`
	ModelName                       string          `json:"model_name" db:"model_name"`
	ModelVersion                    *string         `json:"model_version,omitempty" db:"model_version"`
	Dimensions                      int             `json:"dimensions" db:"dimensions"`
	MaxTokens                       *int            `json:"max_tokens,omitempty" db:"max_tokens"`
	SupportsBinary                  bool            `json:"supports_binary" db:"supports_binary"`
	SupportsDimensionalityReduction bool            `json:"supports_dimensionality_reduction" db:"supports_dimensionality_reduction"`
	MinDimensions                   *int            `json:"min_dimensions,omitempty" db:"min_dimensions"`
	CostPerMillionTokens            *float64        `json:"cost_per_million_tokens,omitempty" db:"cost_per_million_tokens"`
	ModelID                         *string         `json:"model_id,omitempty" db:"model_id"` // For Bedrock models
	ModelType                       *string         `json:"model_type,omitempty" db:"model_type"`
	IsActive                        bool            `json:"is_active" db:"is_active"`
	Capabilities                    json.RawMessage `json:"capabilities" db:"capabilities"`
	CreatedAt                       time.Time       `json:"created_at" db:"created_at"`
}

type ModelConfig struct {
	Type       ModelType              `json:"type"`
	Name       string                 `json:"name"`
	APIKey     string                 `json:"api_key,omitempty"`
	Endpoint   string                 `json:"endpoint,omitempty"`
	Dimensions int                    `json:"dimensions"`
	Parameters map[string]interface{} `json:"parameters,omitempty"`
}

type ModelFilter struct {
	Provider  *string `json:"provider,omitempty"`
	ModelType *string `json:"model_type,omitempty"`
	IsActive  *bool   `json:"is_active,omitempty"`
}

type ModelInfo struct {
	ModelID    string
	Dimensions int
	MaxTokens  int
	CostPer1M  float64
	Notes      string
}

type ModelType string

type OpenAIEmbeddingData struct {
	Embedding []float32 `json:"embedding"`
	Index     int       `json:"index"`
}

type OpenAIEmbeddingRequest struct {
	Model string   `json:"model"`
	Input []string `json:"input"`
}

type OpenAIEmbeddingResponse struct {
	Data  []OpenAIEmbeddingData `json:"data"`
	Model string                `json:"model"`
	Usage OpenAIUsage           `json:"usage"`
}

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

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

type OpenAIUsage struct {
	PromptTokens int `json:"prompt_tokens"`
	TotalTokens  int `json:"total_tokens"`
}

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

type ProjectionMatrix struct {
	ID             int       `json:"id" db:"id"`
	FromDimensions int       `json:"from_dimensions" db:"from_dimensions"`
	ToDimensions   int       `json:"to_dimensions" db:"to_dimensions"`
	FromProvider   string    `json:"from_provider" db:"from_provider"`
	FromModel      string    `json:"from_model" db:"from_model"`
	Matrix         []float32 `json:"matrix" db:"matrix"`
	QualityScore   float64   `json:"quality_score" db:"quality_score"`
	IsActive       bool      `json:"is_active" db:"is_active"`
}

type Provider interface {
	GenerateEmbedding(ctx context.Context, content string, model string) ([]float32, error)
	GetSupportedModels() []string
	ValidateAPIKey() error
}

type ProviderCandidate struct {
	Provider string
	Model    string
	Score    float64
	Reasons  []string
}

type ProviderCapability struct {
	SupportsEmbeddings bool
	EmbeddingModels    []ModelInfo
	DefaultModel       string
}

type ProviderConfig struct {
	// OpenAI configuration
	OpenAIAPIKey string

	// AWS/Bedrock configuration
	AWSRegion string

	// Google configuration
	GoogleProjectID string
	GoogleLocation  string
	GoogleAPIKey    string

	// Voyage AI configuration
	VoyageAPIKey string
}

type ProviderHealth struct {
	Name                string `json:"name"`
	Status              string `json:"status"`
	Error               string `json:"error,omitempty"`
	CircuitBreakerState string `json:"circuit_breaker_state,omitempty"`
	FailureCount        int    `json:"failure_count,omitempty"`
}

type ProviderLoad struct {
	CurrentRequests int
	AvgLatency      time.Duration
	LastUpdated     time.Time
}

type QualityConfig struct {
	MinQualityScore float64
}

type QualityScore struct {
	SuccessCount int
	FailureCount int
	LastUpdated  time.Time
}

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

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

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

type RouterConfig struct {
	CircuitBreakerConfig CircuitBreakerConfig
	LoadBalancerConfig   LoadBalancerConfig
	CostOptimizerConfig  CostOptimizerConfig
	QualityConfig        QualityConfig
}

type RoutingDecision struct {
	Candidates []ProviderCandidate
	Strategy   string
}

type RoutingRequest struct {
	AgentConfig *agents.AgentConfig
	TaskType    agents.TaskType
	RequestID   string
}

type SearchFilter struct {
	// Field is the metadata field to filter on
	Field string `json:"field"`
	// Value is the value to match
	Value interface{} `json:"value"`
	// Operator is the comparison operator (eq, ne, gt, lt, gte, lte, in, contains)
	Operator string `json:"operator"`
}

type SearchOptions struct {
	// ContentTypes filters results to specific content types
	ContentTypes []string `json:"content_types,omitempty"`
	// Filters are metadata filters to apply to the search
	Filters []SearchFilter `json:"filters,omitempty"`
	// Sorts defines the sort order for results
	Sorts []SearchSort `json:"sorts,omitempty"`
	// Limit is the maximum number of results to return
	Limit int `json:"limit"`
	// Offset is the number of results to skip (for pagination)
	Offset int `json:"offset"`
	// MinSimilarity is the minimum similarity score required (0.0 to 1.0)
	MinSimilarity float32 `json:"min_similarity"`
	// WeightFactors defines how to weight different scoring factors
	WeightFactors map[string]float32 `json:"weight_factors,omitempty"`
}

type SearchRequest struct {
	QueryEmbedding []float32       `json:"query_embedding"`
	ModelName      string          `json:"model_name"`
	TenantID       uuid.UUID       `json:"tenant_id"`
	ContextID      *uuid.UUID      `json:"context_id,omitempty"`
	Limit          int             `json:"limit"`
	Threshold      float64         `json:"threshold"`
	MetadataFilter json.RawMessage `json:"metadata_filter,omitempty"` // JSONB filter
}

type SearchResult struct {
	// Content is the embedding that matched
	Content *EmbeddingVector `json:"content"`
	// Score is the calculated relevance score (0.0 to 1.0)
	Score float32 `json:"score"`
	// Matches contains information about why this result matched
	Matches map[string]interface{} `json:"matches,omitempty"`
}

type SearchResults struct {
	// Results is the list of search results
	Results []*SearchResult `json:"results"`
	// Total is the total number of results found (for pagination)
	Total int `json:"total"`
	// HasMore indicates if there are more results available
	HasMore bool `json:"has_more"`
}

type SearchService interface {
	// Search performs a vector search with the given text
	Search(ctx context.Context, text string, options *SearchOptions) (*SearchResults, error)

	// SearchByVector performs a vector search with a pre-computed vector
	SearchByVector(ctx context.Context, vector []float32, options *SearchOptions) (*SearchResults, error)

	// SearchByContentID performs a "more like this" search based on an existing content ID
	SearchByContentID(ctx context.Context, contentID string, options *SearchOptions) (*SearchResults, error)
}

type SearchSort struct {
	// Field is the field to sort on (can be "similarity" or any metadata field)
	Field string `json:"field"`
	// Direction is the sort direction ("asc" or "desc")
	Direction string `json:"direction"`
}

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

type ServiceV2Config struct {
	Providers    map[string]providers.Provider
	AgentService AgentService
	Repository   *Repository
	MetricsRepo  MetricsRepository
	Cache        EmbeddingCache
	RouterConfig *RouterConfig
}

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

type UnifiedSearchConfig struct {
	DB               *sql.DB
	Repository       *Repository
	SearchRepository repositorySearch.Repository
	EmbeddingService EmbeddingService
	DimensionAdapter *DimensionAdapter
	Logger           observability.Logger
	Metrics          observability.MetricsClient
}

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

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