memory

type EmbeddingProvider interface {
	// Embed generates an embedding for text.
	Embed(ctx context.Context, text string) ([]float64, error)

	// Dimension returns the embedding dimension.
	Dimension() int
}

type EndlessClient interface {
	// StoreContext stores messages in endless compressed context.
	StoreContext(ctx context.Context, sessionID string, messages []map[string]interface{}, metadata map[string]interface{}) error

	// RetrieveContext retrieves compressed context from endless.
	RetrieveContext(ctx context.Context, sessionID string, query string, limit int) ([]map[string]interface{}, error)

	// SummarizeContext gets summary of compressed context.
	SummarizeContext(ctx context.Context, sessionID string) (string, error)

	// ClearContext clears context for session.
	ClearContext(ctx context.Context, sessionID string) error
}

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

type HierarchyConfig struct {
	// WorkingCapacity is the max messages in working memory (default: 10).
	// Increase for longer context windows.
	WorkingCapacity int

	// ShortTermCapacity is the max messages in short-term memory (default: 100).
	// Increase for longer session history.
	ShortTermCapacity int

	// ShortTermTTLSeconds is time-to-live for short-term entries (default: 3600 = 1 hour).
	// Increase to retain history longer.
	ShortTermTTLSeconds int

	// LongTermMinImportance is minimum importance for long-term storage (default: 0.7).
	// Lower to store more, higher for only critical info.
	LongTermMinImportance float64

	// EnableLongTerm enables long-term memory (default: true).
	// Disable for testing or simple use cases.
	EnableLongTerm bool
}

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

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

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

type Memory interface {
	// Store saves a message to memory with optional metadata.
	//
	// Args:
	//   ctx: Context for cancellation
	//   sessionID: Unique session identifier
	//   message: Message to store
	//   metadata: Optional metadata (importance score, tags, etc.)
	//
	// Example:
	//   err := memory.Store(ctx, "session-123",
	//       Message{Role: "user", Content: "Hello"},
	//       map[string]interface{}{"importance": 0.8, "tags": []string{"greeting"}})
	Store(ctx context.Context, sessionID string, message agenkit.Message, metadata map[string]interface{}) error

	// Retrieve fetches messages from memory.
	//
	// Args:
	//   ctx: Context for cancellation
	//   sessionID: Session identifier
	//   opts: Retrieval options (query, limit, filters)
	//
	// Returns:
	//   List of messages (most recent first by default)
	//
	// Example:
	//   // Basic retrieval (most recent)
	//   // Basic retrieval with limit
	//   limit := 10
	//   messages, err := memory.Retrieve(ctx, "session-123", RetrieveOptions{Limit: &limit})
	//
	//   // Use default limit (10) by passing nil
	//   messages, err := memory.Retrieve(ctx, "session-123", RetrieveOptions{})
	//
	//   // Semantic retrieval (if supported)
	//   limit = 5
	//   messages, err := memory.Retrieve(ctx, "session-123",
	//       RetrieveOptions{Query: "What did we discuss about pricing?", Limit: &limit})
	//
	//   // Time-filtered retrieval
	//   limit = 20
	//   messages, err := memory.Retrieve(ctx, "session-123",
	//       RetrieveOptions{TimeRange: &TimeRange{Start: start, End: end}, Limit: &limit})
	Retrieve(ctx context.Context, sessionID string, opts RetrieveOptions) ([]agenkit.Message, error)

	// Summarize creates a summary of conversation history.
	//
	// Args:
	//   ctx: Context for cancellation
	//   sessionID: Session identifier
	//   opts: Summarization options
	//
	// Returns:
	//   Message containing summary
	//
	// Example:
	//   summary, err := memory.Summarize(ctx, "session-123", SummarizeOptions{})
	//   fmt.Println(summary.Content) // "Discussed pricing strategy, decided on $50/month tier..."
	Summarize(ctx context.Context, sessionID string, opts SummarizeOptions) (agenkit.Message, error)

	// Clear removes all memory for a session.
	//
	// Args:
	//   ctx: Context for cancellation
	//   sessionID: Session identifier
	//
	// Example:
	//   err := memory.Clear(ctx, "session-123")
	Clear(ctx context.Context, sessionID string) error

	// Capabilities returns the memory capabilities.
	//
	// Possible capabilities:
	//   - "basic_retrieval": Supports simple Retrieve()
	//   - "semantic_search": Supports query-based retrieval
	//   - "summarization": Supports Summarize()
	//   - "persistence": Data survives restarts
	//   - "ttl": Supports automatic expiry
	//   - "importance_weighting": Supports importance-based retrieval
	//   - "time_travel": Supports point-in-time queries
	//
	// Example:
	//   caps := memory.Capabilities()
	//   // []string{"basic_retrieval", "persistence", "ttl"}
	Capabilities() []string
}

type MessageSearchResult struct {
	Message  agenkit.Message
	Metadata map[string]interface{}
	Score    float64
}

type MessageWithMetadata struct {
	Timestamp float64                // Unix timestamp with microsecond precision
	Message   agenkit.Message        // The message
	Metadata  map[string]interface{} // Associated metadata
}

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

type RetrieveOptions struct {
	// Query is an optional semantic query for retrieval (if supported)
	Query string

	// Limit is the maximum number of messages to return (nil = default of 10)
	Limit *int

	// TimeRange filters messages by time (optional)
	TimeRange *TimeRange

	// ImportanceThreshold filters messages by importance score (optional)
	ImportanceThreshold *float64

	// Tags filters messages that have any of these tags (optional)
	Tags []string
}

type SummarizeOptions struct {
	// MaxLength is the maximum length of the summary (optional)
	MaxLength int

	// Style is the summary style: "brief" or "detailed" (optional)
	Style string
}

type TimeRange struct {
	Start int64 // Unix timestamp in seconds
	End   int64 // Unix timestamp in seconds
}

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

type VectorStore interface {
	// Add adds a message with embedding to the store.
	Add(ctx context.Context, sessionID, messageID string, embedding []float64, message agenkit.Message, metadata map[string]interface{}, timestamp float64) error

	// Search searches for similar messages.
	// Returns list of (message, metadata, score) tuples.
	Search(ctx context.Context, sessionID string, queryEmbedding []float64, limit int, opts RetrieveOptions) ([]MessageSearchResult, error)

	// GetRecent gets recent messages without search.
	GetRecent(ctx context.Context, sessionID string, limit int, opts RetrieveOptions) ([]MessageWithMetadata, error)

	// Clear clears all messages for a session.
	Clear(ctx context.Context, sessionID string) error
}