session

type CompactOptions struct {
	// ProviderOptions are provider-specific options (store, promptCacheKey, etc.)
	ProviderOptions map[string]any

	// MaxOutputTokens limits the compaction response length.
	MaxOutputTokens int

	// TransformMessages runs on the complete request, including the compaction
	// system prompt. Callers use it to enforce outbound redaction.
	TransformMessages func([]goai.Message) []goai.Message
}

type CompactionAgent interface {
	// SystemPrompt returns the system prompt for the compaction agent.
	SystemPrompt() string

	// Model returns the model ID to use for compaction, or empty to use session's model.
	Model() string
}

type CompactionConfig struct {
	// Auto enables automatic compaction when context overflows. Default: true.
	Auto bool

	// Prune enables pruning of old tool outputs. Default: true.
	Prune bool

	// Agent is the agent to use for compaction. If nil, uses the model directly.
	// When set, the agent's system prompt is used for the compaction request.
	Agent CompactionAgent

	// PrunedMessage generates replacement text when content is pruned or excluded.
	// Called with metadata about the removed content. If nil, a default message is used.
	PrunedMessage func(info PrunedInfo) string
}

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

type FilePart struct {
	DataType  string         `json:"dataType,omitempty"`
	Reference map[string]any `json:"reference,omitempty"`
	Data      string         `json:"data"`               // base64-encoded content, text, or URL
	MimeType  string         `json:"mimeType"`           // e.g., "application/pdf", "image/png"
	Filename  string         `json:"filename,omitempty"` // optional filename
	// Source identifies where this file came from (e.g. a file key, URL, or ID).
	// Session-level metadata only — not passed to goai or LLM providers.
	Source string `json:"source,omitempty"`
}

type MemoryStore struct{}

type Message struct {
	ProviderOptions map[string]any `json:"providerOptions,omitempty"`
	ID              string         `json:"id"`
	Role            string         `json:"role"` // "system", "user", "assistant", "tool"
	Content         string         `json:"content,omitempty"`
	Parts           []Part         `json:"parts,omitempty"`
	ParentID        string         `json:"parentId,omitempty"`  // For assistant messages, links to user message
	Summary         bool           `json:"summary,omitempty"`   // True if this is a compaction summary
	Tokens          Tokens         `json:"tokens,omitempty"`    // Token usage for this message
	Compacted       bool           `json:"compacted,omitempty"` // True if tool outputs have been pruned
}

type ModelLimits struct {
	Context int // Total context window size
	Input   int // Independent max input tokens
	Output  int // Max output tokens
}

type Part struct {
	ID               string                            `json:"id"`
	Type             string                            `json:"type"` // "text", "tool", "reasoning", "compaction", "file"
	Text             string                            `json:"text,omitempty"`
	ProviderOptions  map[string]any                    `json:"providerOptions,omitempty"`
	Tool             *ToolPart                         `json:"tool,omitempty"`
	File             *FilePart                         `json:"file,omitempty"`
	Compacted        bool                              `json:"compacted,omitempty"` // True if output has been pruned
	ApprovalRequest  *message.ToolApprovalRequestPart  `json:"approvalRequest,omitempty"`
	ApprovalResponse *message.ToolApprovalResponsePart `json:"approvalResponse,omitempty"`
}

type PrunedInfo struct {
	Type     string // "tool_output", "image", "file"
	MimeType string // for images/files
	Filename string // FilePart.Filename
	Source   string // FilePart.Source (e.g. S3 key)
}

type Session struct {
	ID        string
	AgentName string
	ModelID   string

	// Message history
	Messages []Message

	// Token tracking
	Tokens Tokens

	// Model limits for overflow detection
	ModelLimits ModelLimits

	// Compaction configuration
	CompactionConfig CompactionConfig
	// contains filtered or unexported fields
}

type SessionOptions struct {
	ID               string
	AgentName        string
	ModelID          string
	Limits           ModelLimits
	CompactionConfig *CompactionConfig // nil = use defaults
	Bus              *bus.Bus
}

type SessionStore interface {
	// Load returns the messages that should form the LLM context for the next
	// turn. Implementations may hide pre-checkpoint history here — Sol only
	// sees what the store decides to return. Returns empty slice (not error)
	// if the conversation has no post-checkpoint messages yet.
	Load(ctx context.Context) ([]Message, error)

	// Append persists new messages from the current turn.
	// Called after each step with the messages produced during that step.
	Append(ctx context.Context, msgs []Message) error

	// Compact atomically records a compaction: the summary messages become
	// the head of the new context window, and the store advances its
	// checkpoint so that subsequent Load calls return only `summary` + any
	// later Appends. Pre-checkpoint messages are not deleted — the store
	// decides how to keep them available for UI / audit.
	// tokensFreed is the delta between pre- and post-compaction input tokens,
	// recorded so the UI can show how much context was freed.
	Compact(ctx context.Context, summary []Message, tokensFreed int) error
}

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

type Tokens struct {
	Input     int `json:"input"`
	Output    int `json:"output"`
	Reasoning int `json:"reasoning"`
	Cache     struct {
		Read  int `json:"read"`
		Write int `json:"write"`
	} `json:"cache"`
}

type ToolCallRecord struct {
	Name  string `json:"name"`
	Input string `json:"input"` // JSON string for comparison
}

type ToolPart struct {
	// OutputType preserves the discriminated result type. Empty uses Outcome
	// and Output for persisted records without a discriminant.
	OutputType            string         `json:"outputType,omitempty"`
	OutputProviderOptions map[string]any `json:"outputProviderOptions,omitempty"`
	ProviderExecuted      bool           `json:"providerExecuted,omitempty"`
	// Result distinguishes assistant-side provider results from calls.
	Result bool   `json:"result,omitempty"`
	CallID string `json:"callId"`
	Name   string `json:"name"`
	Input  string `json:"input,omitempty"`
	Output string `json:"output,omitempty"`
	Status string `json:"status"` // lifecycle: "pending", "running", "completed"
	// Outcome is the structured tool-result outcome, decoupled from the
	// lifecycle Status so compaction (which prunes Status=="completed")
	// keeps working: "" | "success" | "error" | "denied". It survives the
	// goai↔session round-trip so the persisted/UI tool status is correct.
	Outcome   string `json:"outcome,omitempty"`
	Compacted bool   `json:"compacted,omitempty"` // True if output has been pruned
}