semanticrouter

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

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

type Config struct {
	// Threshold is the minimum similarity score to consider a route matched (default: 0.82)
	Threshold float64 `json:"threshold"`

	// SimilarityFunc is the function used to compute vector similarity (default: cosine)
	// Use core.CosineSimilarity, core.DotProduct, or core.EuclideanDist
	SimilarityFunc core.SimilarityFunc `json:"-"`

	// TopK is the number of top results to consider when finding routes (default: 1)
	TopK int `json:"topK"`

	// CacheEmbeddings enables caching of utterance embeddings (default: true)
	CacheEmbeddings bool `json:"cacheEmbeddings"`
}

type ConfigOption func(*Config)

type Embedder interface {
	// Embed converts a single text string into a vector embedding.
	Embed(ctx context.Context, text string) ([]float32, error)

	// EmbedBatch converts multiple text strings into vector embeddings.
	EmbedBatch(ctx context.Context, texts []string) ([][]float32, error)

	// Dimensions returns the dimensionality of the embedding vectors.
	Dimensions() int
}

type FunctionCall struct {
	// Function name
	Name string `json:"name"`

	// Extracted parameters
	Arguments map[string]interface{} `json:"arguments"`

	// Whether all required parameters were found
	Complete bool `json:"complete"`

	// Missing required parameters
	Missing []string `json:"missing,omitempty"`

	// Handler to execute
	Handler FunctionHandler `json:"-"`
}

type FunctionHandler func(ctx context.Context, params map[string]interface{}) (interface{}, error)

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

type FunctionSchema struct {
	// Name is the function identifier
	Name string `json:"name"`

	// Description of what the function does
	Description string `json:"description"`

	// Parameters schema for the function
	Parameters map[string]*ParameterSchema `json:"parameters"`

	// Required parameter names
	Required []string `json:"required,omitempty"`

	// Handler is the function to execute
	Handler FunctionHandler `json:"-"`

	// Extractor for parameter extraction (optional, uses default if nil)
	Extractor ParameterExtractor `json:"-"`
}

type HybridConfig struct {
	// Alpha is weight for dense (0-1). Final = alpha*dense + (1-alpha)*sparse
	Alpha float64

	// Threshold for combined score
	Threshold float64

	// DenseThreshold for dense-only decisions
	DenseThreshold float64

	// SparseThreshold for sparse-only decisions
	SparseThreshold float64

	// Similarity function for dense vectors
	SimilarityFunc core.SimilarityFunc
}

type HybridConfigOption func(*HybridConfig)

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

type HybridRouteResult struct {
	RouteResult

	// DenseScore is the similarity from dense vector matching
	DenseScore float64 `json:"denseScore"`

	// SparseScore is the similarity from sparse keyword matching
	SparseScore float64 `json:"sparseScore"`

	// CombinedScore is the weighted combination score
	CombinedScore float64 `json:"combinedScore"`
}

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

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

type ParameterExtractor interface {
	Extract(ctx context.Context, text string, schema *FunctionSchema) (map[string]interface{}, []string, error)
}

type ParameterSchema struct {
	// Type is the parameter type (string, integer, number, boolean, array, object)
	Type string `json:"type"`

	// Description of what the parameter represents
	Description string `json:"description,omitempty"`

	// Required indicates if this parameter is mandatory
	Required bool `json:"required"`

	// Default value (optional)
	Default interface{} `json:"default,omitempty"`

	// Enum for enum validation (optional)
	Enum []interface{} `json:"enum,omitempty"`

	// Properties for object type (optional)
	Properties map[string]*ParameterSchema `json:"properties,omitempty"`

	// Items for array type (optional)
	Items *ParameterSchema `json:"items,omitempty"`

	// Pattern for regex validation (optional)
	Pattern string `json:"pattern,omitempty"`

	// Minimum for numeric types
	Minimum *float64 `json:"minimum,omitempty"`

	// Maximum for numeric types
	Maximum *float64 `json:"maximum,omitempty"`
}

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

type Route struct {
	// Name is the unique identifier for this route
	Name string `json:"name"`

	// Utterances are example phrases that represent this route's intent
	Utterances []string `json:"utterances"`

	// Handler is an optional function to execute when this route is matched
	Handler RouteHandler `json:"-"`

	// Metadata stores additional information about the route
	Metadata map[string]string `json:"metadata,omitempty"`
	// contains filtered or unexported fields
}

type RouteHandler func(ctx context.Context, query string, score float64) (string, error)

type RouteResult struct {
	// RouteName is the name of the matched route, empty if no match
	RouteName string `json:"routeName"`

	// Score is the similarity score (0.0 to 1.0)
	Score float64 `json:"score"`

	// Matched indicates whether the score exceeded the threshold
	Matched bool `json:"matched"`

	// Handler is the matched route's handler function
	Handler RouteHandler `json:"-"`
}

type RouteWithFunction struct {
	*Route
	FunctionSchema *FunctionSchema
}

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

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

type SparseConfig struct {
	Threshold float64
	TopK      int
}

type SparseConfigOption func(*SparseConfig)

type SparseEncoder interface {
	// EncodeSparse converts text into a sparse vector representation.
	// Returns a map where keys are term identifiers and values are weights.
	EncodeSparse(text string) map[string]float64

	// EncodeSparseBatch converts multiple texts into sparse vectors.
	EncodeSparseBatch(texts []string) []map[string]float64

	// Vocabulary returns the encoder's vocabulary.
	Vocabulary() []string

	// Dimensions returns the size of the vocabulary (sparse vector dimensionality).
	Dimensions() int
}

type SparseRoute struct {
	Name       string
	Utterances []string
	Handler    RouteHandler
	Metadata   map[string]string
	// contains filtered or unexported fields
}

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

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

type TermFrequencyEncoder struct{}

type TermScore struct {
	Term  string
	Score float64
}