memory

type CompactionImpact struct {
	OriginalTokens              int `json:"original_tokens"`
	MicroCompactTokens          int `json:"micro_compact_tokens"`
	EstimatedFullCompactTokens  int `json:"estimated_full_compact_tokens"`
	MicroCompactSavings         int `json:"micro_compact_savings"`
	EstimatedFullCompactSavings int `json:"estimated_full_compact_savings"`
}

type CompactionResult struct {
	Messages            []types.Message           `json:"messages"`
	DidCompact          bool                      `json:"did_compact"`
	UsedMicroCompact    bool                      `json:"used_micro_compact"`
	UsedSummaryCompact  bool                      `json:"used_summary_compact"`
	PreCompactTokens    int                       `json:"pre_compact_tokens"`
	PostCompactTokens   int                       `json:"post_compact_tokens"`
	TargetTokens        int                       `json:"target_tokens"`
	Summary             string                    `json:"summary,omitempty"`
	ConsecutiveFailures int                       `json:"consecutive_failures"`
	RuntimeMetadata     *types.CompactionMetadata `json:"runtime_metadata,omitempty"`
}

type CompactionStrategy interface {
	// AutoCompact compacts messages if the token budget is exceeded.
	// It respects the circuit breaker via TrackingState.ConsecutiveFailures.
	// When no compaction is needed it returns the original messages unchanged
	// with DidCompact == false.
	AutoCompact(
		ctx context.Context,
		systemPrompt string,
		messages []types.Message,
		model types.ModelIdentifier,
		sessionID types.SessionID,
		turnID types.TurnID,
		tracking *TrackingState,
	) (CompactionResult, error)

	// CheckBlockingLimit reports whether systemPrompt+messages fit within the
	// hard blocking limit for model (BlockingLimitTokens), returning a typed
	// error (ErrCodeCompactFull) if not - even after AutoCompact has already
	// tried. Called right after AutoCompact so an oversized request fails
	// locally with a clear reason instead of at the provider (M1 in TODO.md).
	CheckBlockingLimit(systemPrompt string, messages []types.Message, model types.ModelIdentifier, tracking *TrackingState) error
}

type Config struct {
	AutoCompactThreshold      float64 `json:"auto_compact_threshold"`
	CompactTargetPercentage   float64 `json:"compact_target_percentage"`
	MaxSummaryTokens          int     `json:"max_summary_tokens"`
	AutoCompactBufferTokens   int     `json:"auto_compact_buffer_tokens"`
	ManualCompactBufferTokens int     `json:"manual_compact_buffer_tokens"`
	MaxConsecutiveFailures    int     `json:"max_consecutive_failures"`
	// SummaryModel overrides which model generates the compaction summary.
	// The zero value means "use the session's own model" (Engine.generateSummary
	// falls back to the model passed into Compact/AutoCompact), so a session on
	// any provider can compact without needing a key for a different one.
	SummaryModel types.ModelIdentifier `json:"summary_model,omitempty"`

	// SummaryModelRules choose the model that writes the summary by the provider and model of the session, first match
	// wins. They apply when SummaryModel is not set, and before the built-in rules (see resolveSummaryModel).
	SummaryModelRules []SummaryModelRule `json:"summary_model_rules,omitempty"`

	// NoDefaultSummaryModels switches off the built-in rules, so that a session without a matching rule of its own
	// summarizes with its own model.
	NoDefaultSummaryModels bool `json:"no_default_summary_models,omitempty"`
}

type ContextBudget struct {
	WindowTokens        int `json:"window_tokens"`
	AutoCompactAtTokens int `json:"auto_compact_at_tokens"`
	BlockingLimitTokens int `json:"blocking_limit_tokens"`
}

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

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

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

type SummaryModelRule struct {
	// Provider is the provider of the session this rule applies to. Empty applies to any provider.
	Provider types.APIProvider `json:"provider,omitempty"`

	// Model is the session model this rule applies to: an exact name, or a name ending in "*" for a prefix
	// ("glm-*"). Empty applies to any model of the provider.
	Model string `json:"model,omitempty"`

	// Use is the model that writes the summary. An empty Use.Provider means the session's own provider: a rule written
	// without a provider stays at the vendor the session already trusts with its conversation, and so with its key.
	Use types.ModelIdentifier `json:"use"`
}

type TrackingState struct {
	ConsecutiveFailures int `json:"consecutive_failures"`

	// ExtraTokens is the size of the request outside the system prompt and the messages: the tool definitions, which
	// cost context on every request (about 36,000 tokens for the whole builtin registry).
	ExtraTokens int `json:"extra_tokens,omitempty"`

	// Manual marks a compaction the user asked for. The automatic rules assume the window is nearly full: they keep
	// half of it as it is, and skip the summary when trimming tool results is enough. A manual compaction is asked for
	// whatever the size, so it always summarizes and keeps only the most recent fifth of the conversation.
	Manual bool `json:"manual,omitempty"`

	// Anchor is the last size the provider reported. When set, the size of the request is that figure plus an estimate
	// of the messages added since, which is exact for everything the provider counted (tools included).
	Anchor *UsageAnchor `json:"anchor,omitempty"`
}

type TrimStrategy string

type TrimmedContent struct {
	// Content is the trimmed content
	Content string `json:"content"`

	// OriginalSize is the original size
	OriginalSize int `json:"original_size"`

	// TrimmedSize is the trimmed size
	TrimmedSize int `json:"trimmed_size"`

	// Strategy is the trim strategy used
	Strategy TrimStrategy `json:"strategy"`

	// Preview is a preview of the original content
	Preview string `json:"preview,omitempty"`
}

type UsageAnchor struct {
	Tokens       int `json:"tokens"`
	MessageCount int `json:"message_count"`
}