memory

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

type Config struct {
	Backend     backend.Backend
	VectorStore vector.Store
	History     *conversation.History
}

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

type ContextualMemoryItem struct {
	Data      interface{}            `json:"data"`
	Source    string                 `json:"source"` // short_term, long_term, entity
	Metadata  map[string]interface{} `json:"metadata"`
	Agent     string                 `json:"agent,omitempty"`
	Timestamp time.Time              `json:"timestamp"`
	Relevance float64                `json:"relevance,omitempty"`
}

type Embedder interface {
	Embed(text string) ([]float32, error)
	Dimension() int
}

type EntityMemory interface {
	// SaveEntity stores an entity with its relationships
	SaveEntity(ctx context.Context, item EntityMemoryItem) error

	// SearchEntities performs a search over stored entities
	SearchEntities(ctx context.Context, query string) ([]EntityMemoryItem, error)

	// SearchByType searches for entities of a specific type
	SearchByType(ctx context.Context, entityType EntityType, query string) ([]EntityMemoryItem, error)

	// GetEntity retrieves a specific entity by name
	GetEntity(ctx context.Context, name string) (*EntityMemoryItem, error)
}

type EntityMemoryItem struct {
	// Name uniquely identifies the entity
	Name string

	// Type indicates the entity type
	Type EntityType

	// Description provides entity details
	Description string

	// Properties contains entity properties
	Properties map[string]interface{}

	// Relationships maps relationship types to related entity names
	Relationships map[string][]string

	// Metadata contains additional metadata
	Metadata map[string]interface{}

	// Agent indicates which agent created/owns this entity
	Agent string

	// Timestamp indicates when the entity was created/updated
	Timestamp time.Time
}

type EntityMemoryStruct struct {
	*BaseMemory
	// contains filtered or unexported fields
}

type EntityType string

type LongTermMemory struct {
	*BaseMemory
}

type LongTermMemoryItem struct {
	ID        int64                  `json:"id"`
	Data      interface{}            `json:"data"`
	Metadata  map[string]interface{} `json:"metadata"`
	Agent     string                 `json:"agent,omitempty"`
	Timestamp time.Time              `json:"timestamp"`
}

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

type Memory interface {
	// Save stores a memory with optional metadata and expiration
	Save(value string, metadata map[string]interface{}, source string, scope MemoryScope, expiresAt *time.Time) error

	// Search queries memories based on the provided query parameters
	Search(query *MemoryQuery) ([]MemoryResult, error)

	// Subscribe registers a callback for memory notifications
	Subscribe(target string, callback func(MemoryNotification)) error

	// Unsubscribe removes a notification callback
	Unsubscribe(target string) error

	// Reset clears all stored memories
	Reset() error
}

type MemoryAccessLevel string

type MemoryConfig struct {
	MaxResults          int           `json:"max_results"`
	RelevanceThreshold  float64       `json:"relevance_threshold"`
	DefaultTTL          time.Duration `json:"default_ttl"`
	EnableNotifications bool          `json:"enable_notifications"`

	// Storage configuration for different memory types
	ShortTermStorage *StorageConfig `json:"short_term_storage,omitempty"`
	LongTermStorage  *StorageConfig `json:"long_term_storage,omitempty"`
	EntityStorage    *StorageConfig `json:"entity_storage,omitempty"`
}

type MemoryNotification struct {
	Source    string                 `json:"source"`
	Target    string                 `json:"target"`
	Value     string                 `json:"value"`
	Metadata  map[string]interface{} `json:"metadata"`
	Scope     MemoryScope            `json:"scope"`
	Type      MemoryType             `json:"type"`
	Timestamp time.Time              `json:"timestamp"`
}

type MemoryPermission struct {
	// AgentID identifies the agent
	AgentID string `json:"agent_id"`

	// Scope defines visibility scope
	Scope MemoryScope `json:"scope"`

	// AccessLevel defines interaction level
	AccessLevel MemoryAccessLevel `json:"access_level"`

	// AllowedTypes specifies which memory types this agent can access
	AllowedTypes []MemoryType `json:"allowed_types,omitempty"`
}

type MemoryQuery struct {
	Query       string                 `json:"query"`
	Type        MemoryType             `json:"type"`
	Scope       MemoryScope            `json:"scope"`
	TaskID      string                 `json:"task_id,omitempty"`
	AgentName   string                 `json:"agent_name,omitempty"`
	ProcessType string                 `json:"process_type,omitempty"`
	Metadata    map[string]interface{} `json:"metadata,omitempty"`
	MaxResults  int                    `json:"max_results"`
	MinScore    float64                `json:"min_score"`
}

type MemoryResult struct {
	Value     string                 `json:"value"`
	Score     float64                `json:"score"`
	Metadata  map[string]interface{} `json:"metadata"`
	Scope     MemoryScope            `json:"scope"`
	Type      MemoryType             `json:"type"`
	ExpiresAt *time.Time             `json:"expires_at,omitempty"`
}

type MemoryScope string

type MemoryType string

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

type RAGItem struct {
	StorageItem *StorageItem
	Embedding   []float32
}

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

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

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

type SharedMemoryContext struct {
	// Source indicates which agent shared this memory
	Source string `json:"source"`

	// Target specifies which agents can access this memory (empty means all)
	Target []string `json:"target,omitempty"`

	// Scope defines the context scope (task, process, general)
	Scope MemoryType `json:"scope"`

	// Value is the actual memory content
	Value interface{} `json:"value"`

	// Metadata contains additional context
	Metadata map[string]interface{} `json:"metadata"`

	// Timestamp indicates when this was shared
	Timestamp time.Time `json:"timestamp"`

	// Relevance indicates how relevant this context is (0-1)
	Relevance float64 `json:"relevance,omitempty"`
}

type ShortTermMemory struct {
	*BaseMemory
}

type ShortTermMemoryItem struct {
	Data      interface{}            `json:"data"`
	Metadata  map[string]interface{} `json:"metadata"`
	Agent     string                 `json:"agent,omitempty"`
	Timestamp time.Time              `json:"timestamp"`
}

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

type Storage interface {
	// Save stores a memory item
	Save(ctx context.Context, item *StorageItem) error

	// Search finds memories matching the query
	Search(ctx context.Context, query string, maxResults int) ([]*StorageItem, error)

	// Reset clears all stored memories
	Reset(ctx context.Context) error
}

type StorageConfig struct {
	// Provider specifies the storage provider to use
	Provider StorageProvider `json:"provider"`

	// Path is the storage location (e.g. file path, connection string)
	Path string `json:"path"`

	// MaxSize is the maximum number of items to store
	MaxSize int `json:"max_size"`

	// CleanupInterval is how often to remove expired items
	CleanupInterval time.Duration `json:"cleanup_interval"`

	// Additional provider-specific options
	Options map[string]interface{} `json:"options"`
}

type StorageItem struct {
	Value     string                 `json:"value"`
	Metadata  map[string]interface{} `json:"metadata"`
	Source    string                 `json:"source"`
	Scope     MemoryScope            `json:"scope"`
	Type      MemoryType             `json:"type"`
	Score     float64                `json:"score,omitempty"`
	ExpiresAt *time.Time             `json:"expires_at,omitempty"`
	Timestamp time.Time              `json:"timestamp"`
}

type StorageProvider string