hindsight

type AutoRetainConfig struct {
	// Enabled turns auto-retain on or off. Defaults to false until explicitly enabled.
	Enabled bool

	// WindowSize is the number of recent messages passed to FactExtractorFn each
	// time a trigger fires. A larger window increases context at the cost of more
	// tokens sent to the extractor. Default: 6.
	WindowSize int

	// TriggerEvery fires extraction after every N messages that match RoleFilter.
	// Set to 1 to extract after every matching message, 2 for every pair, etc.
	// Default: 2 (extract after each user+assistant turn).
	TriggerEvery int

	// RoleFilter restricts which message roles increment the counter.
	// Nil or empty means all roles count.
	// Example: []string{"user"} to trigger only on user messages.
	RoleFilter []string
}

type Bank struct {
	// ID is the unique identifier for this bank
	ID string

	// Name is a human-readable name
	Name string

	// Disposition configures how this bank forms opinions
	*Disposition

	// Description provides context about this bank's purpose
	Description string

	// Background provides additional context for the bank
	Background string

	// CreatedAt is the Unix timestamp when this bank was created
	CreatedAt int64
}

type Config struct {
	// DBPath is the path to the SQLite database
	DBPath string

	// VectorDim is the embedding vector dimension (0 for auto-detect)
	VectorDim int

	// Collection is the cortexdb collection name for memories
	Collection string
}

type ContextRequest struct {
	// BankID specifies which memory bank to use
	BankID string

	// Query is the question or topic to reflect on
	Query string

	// QueryVector is the embedding of the query (provided by caller)
	QueryVector []float32

	// Strategy configures which TEMPR strategies to use
	Strategy *RecallStrategy

	// TopK is the maximum memories to include in context
	TopK int

	// TokenBudget is the approximate max tokens for output (0 = no limit)
	TokenBudget int
}

type ContextResponse struct {
	// Context is the formatted text ready for LLM consumption
	Context string

	// Memories are the retrieved memories that formed the context
	Memories []*Memory

	// TokenCount is the approximate token count of the context
	TokenCount int
}

type Disposition struct {
	// Skepticism: 1=Trusting, 5=Skeptical
	// Affects how strongly contradictory evidence is considered
	Skepticism int

	// Literalism: 1=Flexible interpretation, 5=Literal interpretation
	// Affects how strictly facts are treated vs interpreted
	Literalism int

	// Empathy: 1=Detached, 5=Empathetic
	// Affects how user-centric vs objective the context is
	Empathy int
}

type ExtractResult struct {
	// Retained is the count of facts successfully persisted.
	Retained int `json:"retained"`

	// Skipped is the count of facts not persisted (missing ID or Vector).
	Skipped int `json:"skipped"`

	// Errors collects non-fatal per-fact errors.
	Errors []error `json:"errors,omitempty"`
}

type ExtractedFact struct {
	// ID is a stable identifier scoped to the bank (e.g., "user_pref_lang").
	ID string `json:"id"`

	// Type categorises the memory epistemically. Defaults to WorldMemory if zero.
	Type MemoryType `json:"type"`

	// Content is the human-readable fact string.
	Content string `json:"content"`

	// Vector is the embedding for Content (caller must compute this).
	Vector []float32 `json:"vector,omitempty"`

	// Entities are related people, places, or concepts.
	Entities []string `json:"entities,omitempty"`

	// Confidence is the belief strength (0–1); meaningful for OpinionMemory.
	Confidence float64 `json:"confidence,omitempty"`

	// Metadata is optional arbitrary key-value data to attach.
	Metadata map[string]any `json:"metadata,omitempty"`
}

type FactExtractorFn func(ctx context.Context, bankID string, messages []*core.Message) ([]ExtractedFact, error)

type Memory struct {
	// ID is the unique identifier for this memory
	ID string

	// BankID identifies which memory bank this memory belongs to
	BankID string

	// Type categorizes the memory epistemically
	Type MemoryType

	// Content is the original text content
	Content string

	// Vector is the embedding vector (provided by caller)
	Vector []float32

	// Entities are related people, places, concepts (provided by caller)
	Entities []string

	// Confidence is the belief strength (0-1, only used for Opinion type)
	Confidence float64

	// Metadata holds additional information like timestamps, sources, etc.
	Metadata map[string]any

	// CreatedAt is when this memory was stored
	CreatedAt time.Time
}

type MemoryType string

type Observation struct {
	// ID is the unique identifier
	ID string

	// BankID is the memory bank this observation belongs to
	BankID string

	// Content is the derived insight/observation
	Content string

	// Vector is the embedding of the observation
	Vector []float32

	// SourceMemoryIDs are the memories that led to this observation
	SourceMemoryIDs []string

	// Confidence is the confidence in this observation (0-1)
	Confidence float64

	// ObservationType categorizes the observation
	ObservationType ObservationType

	// Reasoning explains how this observation was derived
	Reasoning string

	// CreatedAt is when this observation was created
	CreatedAt time.Time
}

type ObservationType string

type RecallRequest struct {
	// BankID specifies which memory bank to search
	BankID string

	// Query is the search query text
	Query string

	// QueryVector is the embedding of the query (provided by caller)
	QueryVector []float32

	// Strategy configures which TEMPR strategies to use
	Strategy *RecallStrategy

	// TopK is the maximum total results to return
	TopK int
}

type RecallResult struct {
	*Memory
	Score    float64 // Combined relevance score
	Strategy string  // Which strategy produced this result
}

type RecallStrategy struct {
	// Temporal filters by time range
	Temporal *TemporalFilter

	// Entity filters by specific entities
	Entity []string

	// Memory enables semantic vector search
	Memory bool

	// Priming enables keyword/BM25 search
	Priming bool

	// TopK limits results per strategy (0 = no limit)
	TopK int
}

type ReflectRequest struct {
	// BankID is the memory bank to reflect on
	BankID string

	// Query is the topic or question to reflect on
	Query string

	// QueryVector is the embedding of the query (provided by caller)
	QueryVector []float32

	// Strategy configures which TEMPR strategies to use for finding relevant memories
	Strategy *RecallStrategy

	// TopK is the maximum memories to consider for reflection
	TopK int

	// ObservationTypes specifies which types of observations to generate
	// If empty, generates all relevant types
	ObservationTypes []ObservationType

	// MinConfidence is the minimum confidence for an observation to be persisted
	MinConfidence float64
}

type ReflectResponse struct {
	// Observations are the new insights generated from reflection
	Observations []*Observation

	// Context is the formatted context (for backward compatibility)
	Context string

	// SourceMemories are the memories that informed these observations
	SourceMemories []*Memory
}

type RerankerFn func(ctx context.Context, query string, candidates []*RecallResult) ([]*RecallResult, error)

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

type TemporalFilter struct {
	Start *time.Time // Inclusive start time
	End   *time.Time // Inclusive end time
}