memory

type ArchiveConfig struct {
	ArchiveThreshold int
	ArchiveBatchSize int
	ArchivePrefix    string
}

type ArchiveManifest struct {
	Segments    []ArchiveSegment `json:"segments"`
	HotStartSeq int              `json:"hot_start_seq"`
}

type ArchiveResult struct {
	MessagesArchived int    `json:"messages_archived"`
	ArchiveFile      string `json:"archive_file,omitempty"`
	HotStartSeq      int    `json:"hot_start_seq"`
}

type ArchiveSegment struct {
	File      string    `json:"file"`
	StartSeq  int       `json:"start_seq"`
	EndSeq    int       `json:"end_seq"`
	Count     int       `json:"count"`
	CreatedAt time.Time `json:"created_at"`
}

type AssemblerConfig struct {
	MaxEntries       int
	PinnedCategories []MemoryCategory
	RecallCategories []MemoryCategory
	// RecallPartitions maps category → partition union for recall Search/List.
	// nil or absent keys default to user-only.
	RecallPartitions map[MemoryCategory][]MemoryPartition
	PinnedCacheTTL   time.Duration
	RecallCacheTTL   time.Duration
	ScopeEnabled     bool
	GlobalCategories []MemoryCategory
	// MaxRecallConcurrency limits the number of recall category searches that
	// run in parallel. Zero or negative values default to defaultMaxRecallConcurrency.
	MaxRecallConcurrency int
}

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

type CandidateMemory struct {
	Category  MemoryCategory `json:"category"`
	Content   string         `json:"content"`
	Keywords  []string       `json:"keywords"`
	Timestamp string         `json:"timestamp,omitempty"`
}

type CompactConfig struct {
	CompactThreshold int
	PruneLeafContent bool
	RequireParent    bool
}

type CompactResult struct {
	DeletedRemoved int `json:"deleted_removed"`
	LeafPruned     int `json:"leaf_pruned"`
	TotalRemaining int `json:"total_remaining"`
}

type Config struct {
	Type        string         `json:"type,omitempty"` // deprecated: ignored, always lossless
	MaxMessages int            `json:"max_messages,omitempty"`
	LongTerm    LongTermConfig `json:"long_term,omitempty"`
	Lossless    LosslessConfig `json:"lossless,omitempty"`
}

type ConflictType string

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

type DAGConfig struct {
	ChunkSize         int
	CondenseThreshold int
	CondenseGroupSize int
	MaxDepth          int
	TokenBudget       int
	RecentRatio       float64
	MidRatio          float64
	Compact           CompactConfig
	Archive           ArchiveConfig
}

type DeduplicationAction string

type Embedder interface {
	Embed(ctx context.Context, text string) ([]float32, error)
}

type EstimateCounter struct{}

type ExtractInput struct {
	RuntimeID       string
	Messages        []llm.Message // Messages to extract from (typically incremental).
	ContextMessages []llm.Message // Optional broader context window for the LLM.
	Source          MemorySource
	Scope           MemoryScope

	// StripSessionIDFromSearch, when true, clears SessionID on the scope used in
	// the search/dedup stage so existing memories match across conversation threads.
	// TimelineSessionID (or Source.ConversationID when it differs from Scope.UserID)
	// is still persisted on new entries unless the category is global.
	StripSessionIDFromSearch bool

	// TimelineSessionID is written to MemoryEntry.Scope.SessionID for non-global
	// categories (which chat/thread produced this memory). It does not affect the
	// search stage when StripSessionIDFromSearch is true.
	TimelineSessionID string

	// ScopeInExtract, when non-nil, overrides LongTermConfig.ScopeEnabled for
	// the pipeline search stage (shared extractor vs per-agent settings).
	ScopeInExtract *bool

	// GlobalCategories, when non-empty, overrides LongTermConfig.GlobalCategories
	// for scope normalization in this run (shared extractor vs per-agent settings).
	GlobalCategories []MemoryCategory

	// LongTermCategories, when non-empty, overrides LongTermConfig.Categories for
	// the search/persist pipeline (shared extractor vs per-agent settings).
	LongTermCategories []string
}

type ExtractorConfig struct {
	// ExtractPrompt is the prompt template for extraction.
	// Must contain one %s placeholder for the conversation text.
	ExtractPrompt string

	// DeduplicationPrompt is the prompt template for batch deduplication.
	// Must contain one %s placeholder for the comparison text.
	DeduplicationPrompt string

	// FormatMessages converts messages into the conversation text passed to the LLM.
	// When nil, the default "role: content\n" format is used.
	FormatMessages func(messages []llm.Message, source MemorySource) string

	// PostProcess is called after LLM extraction and before deduplication.
	// It can add timestamps, transform categories, filter entries, etc.
	PostProcess func(candidates []CandidateMemory, source MemorySource) []CandidateMemory

	// MaxConversationRunes limits the conversation text length (in runes) sent to the LLM.
	// Defaults to 8000 when zero.
	MaxConversationRunes int
}

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

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

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

type HybridOption func(*HybridStore)

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

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

type InMemoryStoreOption func(*InMemoryStore)

type LTStoreOption func(*FileLongTermStore)

type ListOptions struct {
	Category MemoryCategory
	Limit    int
	// Scope, when non-nil, restricts rows to entries in that scope bucket.
	// nil preserves legacy behavior (no scope filter).
	// If Recall is set, Scope is ignored for filtering (Recall wins).
	Scope *MemoryScope
	// Recall selects one or more partitions (user bucket, global bucket, or union).
	// When nil, [EffectiveRecallForList] derives partitioning from Scope for backward compatibility.
	Recall *RecallScope
}

type LongTermConfig struct {
	Enabled    bool     `json:"enabled"`
	Categories []string `json:"categories,omitempty"`
	MaxEntries int      `json:"max_entries,omitempty"`

	// PinnedCategories are always fully injected regardless of query relevance.
	// Empty uses default: [profile, preferences].
	PinnedCategories []MemoryCategory `json:"pinned_categories,omitempty"`

	// RecallCategories are searched by query relevance.
	// Empty uses default: [entities, events, cases, patterns].
	RecallCategories []MemoryCategory `json:"recall_categories,omitempty"`

	// RecallPartitions overrides which partitions each recall category searches.
	// nil or missing keys default to user-only ([PartitionUser]).
	// Example: shared "adventure" rows live in the global bucket — set
	// RecallPartitions["adventure"] = []MemoryPartition{PartitionUser, PartitionGlobal}.
	RecallPartitions map[MemoryCategory][]MemoryPartition `json:"recall_partitions,omitempty"`

	// ScopeEnabled, when true, causes ContextAssembler to use MemoryScope for
	// List/Search (requires SetScope on MemoryAwareMemory before Load).
	ScopeEnabled bool `json:"scope_enabled,omitempty"`

	// GlobalCategories are stored and queried in the runtime-global bucket
	// (empty UserID). When nil, DefaultGlobalCategories is used.
	GlobalCategories []MemoryCategory `json:"global_categories,omitempty"`
}

type LongTermStore interface {
	Save(ctx context.Context, runtimeID string, entry *MemoryEntry) error
	List(ctx context.Context, runtimeID string, opts ListOptions) ([]*MemoryEntry, error)
	Search(ctx context.Context, runtimeID string, query string, opts SearchOptions) ([]*MemoryEntry, error)
	Update(ctx context.Context, runtimeID string, entry *MemoryEntry) error
	Delete(ctx context.Context, runtimeID, entryID string) error
}

type LosslessConfig struct {
	ChunkSize         int     `json:"chunk_size,omitempty"`
	CondenseThreshold int     `json:"condense_threshold,omitempty"`
	MaxDepth          int     `json:"max_depth,omitempty"`
	TokenBudget       int     `json:"token_budget,omitempty"`
	RecentRatio       float64 `json:"recent_ratio,omitempty"`
	CompactThreshold  int     `json:"compact_threshold,omitempty"`
	PruneLeafContent  *bool   `json:"prune_leaf_content,omitempty"`
	ArchiveThreshold  int     `json:"archive_threshold,omitempty"`
	ArchiveBatchSize  int     `json:"archive_batch_size,omitempty"`
}

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

type Memory interface {
	Load(ctx context.Context, conversationID string) ([]model.Message, error)
	Save(ctx context.Context, conversationID string, messages []model.Message) error
	Clear(ctx context.Context, conversationID string) error
}

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

type MemoryCategory string

type MemoryEntry struct {
	ID        string         `json:"id"`
	Category  MemoryCategory `json:"category"`
	Content   string         `json:"content"`
	Keywords  []string       `json:"keywords,omitempty"`
	Source    MemorySource   `json:"source"`
	CreatedAt time.Time      `json:"created_at"`
	UpdatedAt time.Time      `json:"updated_at"`
	Scope     MemoryScope    `json:"scope,omitempty"`
}

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

type MemoryOption func(*memoryOptions)

type MemoryPartition string

type MemoryScope struct {
	RuntimeID string `json:"runtime_id,omitempty"`
	UserID    string `json:"user_id,omitempty"`
	SessionID string `json:"session_id,omitempty"`
}

type MemorySource struct {
	RuntimeID      string    `json:"runtime_id,omitempty"`
	ConversationID string    `json:"conversation_id,omitempty"`
	Timestamp      time.Time `json:"timestamp,omitempty"`
}

type MessageAppender interface {
	AppendMessages(ctx context.Context, conversationID string, messages []model.Message) error
}

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

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

type PipelineState struct {
	Input                  ExtractInput
	LLM                    llm.LLM
	Candidates             []CandidateMemory
	DirectSave             []CandidateMemory
	ToDedup                []dedupItem
	Actions                []deduplicationResult
	Saved                  []*MemoryEntry
	DedupFallbackCreateAll bool
}

type RangeReader interface {
	GetMessageRange(ctx context.Context, conversationID string, start, end int) ([]model.Message, error)
}

type RecallScope struct {
	RuntimeID  string            `json:"runtime_id,omitempty"`
	UserID     string            `json:"user_id,omitempty"`
	SessionID  string            `json:"session_id,omitempty"`
	Partitions []MemoryPartition `json:"partitions,omitempty"`
}

type RecentReader interface {
	GetRecentMessages(ctx context.Context, conversationID string, limit int) ([]model.Message, error)
}

type SearchOptions struct {
	Category  MemoryCategory
	TopK      int
	Threshold float64
	// Scope, when non-nil, restricts hits to entries in that scope bucket.
	// If Recall is set, Scope is ignored for filtering (Recall wins).
	Scope *MemoryScope
	// Recall selects partitions for Search; nil derives from Scope via [EffectiveRecallForSearch].
	Recall *RecallScope
	// QueryVector, when non-nil, is passed directly to the store implementation,
	// allowing the caller to pre-compute the embedding once and share it across
	// multiple category searches. Stores that do not support vector search ignore it.
	QueryVector []float32
}

type Stage interface {
	Name() string
	Run(ctx context.Context, state *PipelineState) error
}

type Store interface {
	GetMessages(ctx context.Context, conversationID string) ([]model.Message, error)
	SaveMessages(ctx context.Context, conversationID string, messages []model.Message) error
	DeleteMessages(ctx context.Context, conversationID string) error
}

type SummaryCacheStore interface {
	GetSummary(ctx context.Context, conversationID string) (summary string, msgCount int, err error)
	SaveSummary(ctx context.Context, conversationID, summary string, msgCount int) error
}

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

type SummaryListOptions struct {
	Depth  *int
	MinSeq int
	MaxSeq int
	Limit  int
}

type SummaryNode struct {
	ID             string    `json:"id"`
	ConversationID string    `json:"conversation_id"`
	Depth          int       `json:"depth"`
	Content        string    `json:"content"`
	ExpandHint     string    `json:"expand_hint,omitempty"`
	SourceIDs      []string  `json:"source_ids,omitempty"`
	EarliestSeq    int       `json:"earliest_seq"`
	LatestSeq      int       `json:"latest_seq"`
	TokenCount     int       `json:"token_count"`
	CreatedAt      time.Time `json:"created_at"`
	Deleted        bool      `json:"deleted,omitempty"`
}

type SummaryStore interface {
	Save(ctx context.Context, node *SummaryNode) error
	GetByConvID(ctx context.Context, convID, id string) (*SummaryNode, error)
	List(ctx context.Context, convID string, opts SummaryListOptions) ([]*SummaryNode, error)
	Search(ctx context.Context, convID, query string, topK int) ([]*SummaryNode, error)
	DeleteByConvID(ctx context.Context, convID, id string) error
	ListAll(ctx context.Context, convID string) ([]*SummaryNode, error)
	Rewrite(ctx context.Context, convID string, nodes []*SummaryNode) error
}

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

type TokenCounter interface {
	Count(text string) int
	CountMessages(msgs []model.Message) int
}

type ToolDeps struct {
	SummaryStore SummaryStore
	MessageStore Store
	Workspace    workspace.Workspace
	Prefix       string
	Config       DAGConfig
}

type VectorSearcher interface {
	SearchByVector(ctx context.Context, runtimeID string, vec []float32, opts SearchOptions) ([]*MemoryEntry, error)
}