compaction

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

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

type AlertSink interface {
	Create(alertType, message, sessionID string) error
}

type CompactOptions struct {
	MaxTokens       int     `json:"max_tokens"`
	PreserveLast    int     `json:"preserve_last"`
	Model           string  `json:"model"`
	CompactionModel string  `json:"compaction_model"`
	SoftThreshold   float64 `json:"soft_threshold"`
	HardThreshold   float64 `json:"hard_threshold"`
}

type CompactionResult struct {
	Summary           string              `json:"summary"`
	Messages          []providers.Message `json:"messages"` // preserved trailing messages
	Level             Level               `json:"level"`
	OriginalTokens    int                 `json:"original_tokens"`
	CompactedTokens   int                 `json:"compacted_tokens"`
	Ratio             float64             `json:"ratio"`
	MessagesCompacted int                 `json:"messages_compacted"`
	MessagesPreserved int                 `json:"messages_preserved"`
	Error             string              `json:"error,omitempty"`
}

type Compactor interface {
	Compact(ctx context.Context, messages []providers.Message, opts CompactOptions) (*CompactionResult, error)
	EstimateUsage(messages []providers.Message, model string) int
	ShouldCompact(messages []providers.Message, opts CompactOptions) (bool, float64)
}

type CompressionResult struct {
	OriginalTokens   int
	CompressedTokens int
	Ratio            float64
	Skipped          bool
	SkippedReason    string
	ModelUsed        string
}

type EvictionTarget struct {
	// MaxTokens caps the total token budget after eviction. Caller
	// usually sets this to the model's context window minus a
	// safety margin.
	MaxTokens int
	// MinKeep guarantees at least this many segments survive even
	// if they exceed MaxTokens. Protects the agent from over-
	// compacting itself into amnesia.
	MinKeep int
}

type HistoryFactory struct {
	Store *seahorse.PostgresStore
	// contains filtered or unexported fields
}

type HistoryStrategy interface {
	Compact(context.Context, []providers.Message, string, int) ([]providers.Message, string, error)
}

type ImportanceOptions struct {
	// RecencyHalfLife after which the recency contribution drops
	// to 0.5. Default 30 minutes — context compaction operates on
	// much shorter horizons than memory segments.
	RecencyHalfLife time.Duration
	// RecencyWeight, ReuseWeight, CostWeight scale each axis.
	// Pinned is binary — pinned segments score Infinity, never
	// evict.
	RecencyWeight float64
	ReuseWeight   float64
	// CostWeight is INVERTED: bigger segments get LOWER scores
	// (more attractive to evict). Default 0.5.
	CostWeight float64
	// Now lets tests inject a deterministic clock.
	Now func() time.Time
}

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

type Level int

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

type Segment struct {
	// ID is a stable identifier used to track segments across
	// scoring passes. Could be a message ID, tool-call ID, or any
	// opaque caller-supplied tag.
	ID string
	// Content is the actual context bytes. Token-cost estimate
	// derived from len(Content) when TokenCost is 0.
	Content string
	// TokenCost is the caller's estimate (or measured count) for
	// this segment. 0 → estimate as len(Content) / 4 (rough English
	// rule of thumb).
	TokenCost int
	// CreatedAt is when the segment first entered the context.
	CreatedAt time.Time
	// LastAccessed is bumped whenever the agent re-reads the
	// segment. Recency component of the score.
	LastAccessed time.Time
	// AccessCount tracks how often the segment has been re-read.
	// Reuse component of the score.
	AccessCount int
	// Pinned, when true, never evicts. Use for the user's current
	// turn, the active plan, or anything the caller wants to keep
	// regardless of score.
	Pinned bool
	// Kind is operator-readable: "user_input", "agent_reply",
	// "tool_call", "tool_result", "system". Same vocabulary as the
	// flight recorder but here it's just metadata.
	Kind string
}

type SummaryWriter interface {
	WriteSummary(ctx context.Context, segment *Segment, summary string) error
}

type SummaryWriterFunc func(ctx context.Context, segment *Segment, summary string) error