memory

type AdvancedBranchInfo struct {
	BranchID     string `json:"branch_id"`
	MessageCount int    `json:"message_count"`
	UserTurns    int    `json:"user_turns"`
	IsCurrent    bool   `json:"is_current"`
	CreatedAt    string `json:"created_at"`
}

type AdvancedConversationTurn struct {
	Turn        int    `json:"turn"`
	Content     string `json:"content"`
	FullContent string `json:"full_content"`
	Timestamp   string `json:"timestamp"`
	CanBranch   bool   `json:"can_branch"`
}

type AdvancedConversationTurnItem struct {
	Type     string `json:"type"`
	ToolName string `json:"tool_name,omitempty"`
}

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

type AdvancedSQLiteSessionParams struct {
	SessionID string

	// Optional database data source name. Defaults to `file::memory:?cache=shared`.
	DBDataSourceName string

	// Optional table names (shared by all branches).
	SessionTable   string
	MessagesTable  string
	TurnUsageTable string

	// Optional session settings (e.g., default history limit).
	SessionSettings *SessionSettings
}

type AdvancedSessionUsage struct {
	Requests     uint64 `json:"requests"`
	InputTokens  uint64 `json:"input_tokens"`
	OutputTokens uint64 `json:"output_tokens"`
	TotalTokens  uint64 `json:"total_tokens"`
	TotalTurns   int    `json:"total_turns"`
}

type AdvancedToolUsage struct {
	ToolName   string `json:"tool_name"`
	UsageCount int    `json:"usage_count"`
	Turn       int    `json:"turn"`
}

type AdvancedTurnUsage struct {
	UserTurnNumber      int                                        `json:"user_turn_number"`
	Requests            uint64                                     `json:"requests"`
	InputTokens         uint64                                     `json:"input_tokens"`
	OutputTokens        uint64                                     `json:"output_tokens"`
	TotalTokens         uint64                                     `json:"total_tokens"`
	InputTokensDetails  responses.ResponseUsageInputTokensDetails  `json:"input_tokens_details"`
	OutputTokensDetails responses.ResponseUsageOutputTokensDetails `json:"output_tokens_details"`
}

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

type AsyncSQLiteSessionParams struct {
	// Unique identifier for the conversation session.
	SessionID string

	// Optional database data source name. Defaults to `file::memory:?cache=shared`.
	DBDataSourceName string

	// Optional name of the table to store session metadata.
	SessionTable string

	// Optional name of the table to store message data.
	MessagesTable string

	// Optional session settings (e.g., default history limit).
	SessionSettings *SessionSettings
}

type CompactionDecisionContext struct {
	ResponseID               string
	CompactionMode           string
	CompactionCandidateItems []TResponseInputItem
	SessionItems             []TResponseInputItem
}

type DaprConcurrencyMode string

type DaprConsistencyLevel string

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

type DaprSessionParams struct {
	SessionID       string
	StateStoreName  string
	Client          DaprStateClient
	TTL             time.Duration
	Consistency     DaprConsistencyLevel
	OwnsClient      bool
	SessionSettings *SessionSettings
}

type DaprStateClient interface {
	GetState(ctx context.Context, storeName, key string, metadata map[string]string) (DaprStateItem, error)
	SaveState(ctx context.Context, storeName, key string, value []byte, etag string, metadata map[string]string, options DaprStateOptions) error
	DeleteState(ctx context.Context, storeName, key string, metadata map[string]string, options DaprStateOptions) error
	Close() error
}

type DaprStateItem struct {
	Data []byte
	ETag string
}

type DaprStateOptions struct {
	Consistency DaprConsistencyLevel
	Concurrency DaprConcurrencyMode
}

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

type EncryptedSessionParams struct {
	// Optional session id. If omitted, it is derived from UnderlyingSession.SessionID.
	SessionID string

	// Underlying session implementation used for storage.
	UnderlyingSession Session

	// Master encryption key. Accepts either:
	// - a base64-url encoded 32-byte key
	// - any raw secret string
	EncryptionKey string

	// Token TTL. Expired encrypted entries are skipped when reading.
	// Defaults to 10 minutes when <= 0.
	TTL time.Duration

	// Optional clock source for deterministic testing.
	Now func() time.Time
}

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

type OpenAIConversationsSessionParams struct {
	ConversationID string
	Client         *openai.Client

	// Optional session settings (e.g., default history limit).
	SessionSettings *SessionSettings
	// contains filtered or unexported fields
}

type OpenAIResponsesCompactionArgs struct {
	ResponseID     string
	CompactionMode OpenAIResponsesCompactionMode
	Store          *bool
	Force          bool
}

type OpenAIResponsesCompactionAwareSession interface {
	Session
	RunCompaction(ctx context.Context, args *OpenAIResponsesCompactionArgs) error
}

type OpenAIResponsesCompactionMode string

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

type OpenAIResponsesCompactionSessionParams struct {
	SessionID         string
	UnderlyingSession Session
	Client            *openai.Client
	Model             string
	CompactionMode    OpenAIResponsesCompactionMode

	ShouldTriggerCompaction shouldTriggerCompactionFunc

	// Internal dependency injection hook used in tests.
	CompactionService responseCompactionService
}

type PgConnInterface interface {
	Query(ctx context.Context, sql string, args ...any) (PgRowsInterface, error)
	QueryRow(ctx context.Context, sql string, args ...any) PgRowInterface
	Exec(ctx context.Context, sql string, args ...any) (any, error)
	Close(ctx context.Context) error
}

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

type PgRowInterface interface {
	Scan(dest ...any) error
}

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

type PgRowsInterface interface {
	Next() bool
	Scan(dest ...any) error
	Err() error
	Close()
}

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

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

type PgSessionParams struct {
	// Unique identifier for the conversation session
	SessionID string

	// PostgreSQL connection string.
	// Example: "postgres://user:password@localhost:5432/database"
	ConnectionString string

	// Optional name of the table to store session metadata.
	// Defaults to "agent_sessions".
	SessionTable string

	// Optional name of the table to store message data.
	// Defaults to "agent_messages".
	MessagesTable string

	// Optional connection interface for dependency injection (mainly for testing)
	Conn PgConnInterface

	// Optional session settings (e.g., default history limit).
	SessionSettings *SessionSettings
}

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

type RedisSessionParams struct {
	// Unique identifier for the conversation session.
	SessionID string

	// Existing Redis client. When provided, this session does not close the client.
	Client redis.UniversalClient

	// Redis URL used to create a dedicated client when Client is nil.
	// Example: redis://localhost:6379/0
	URL string

	// Optional key prefix for all session keys.
	// Defaults to "agents:session".
	KeyPrefix string

	// Optional TTL for session keys. Zero means no expiration.
	TTL time.Duration

	// Optional session settings (e.g., default history limit).
	SessionSettings *SessionSettings
}

type RunUsageTrackingAwareSession interface {
	Session
	StoreRunUsage(ctx context.Context, runUsage *usage.Usage) error
}

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

type SQLAlchemySessionParams struct {
	// Optional pre-configured backend session.
	Session Session

	// SQLAlchemy-like connection URL.
	URL string

	// Session id used when URL-based construction is used.
	SessionID string

	// Optional table overrides used when URL-based construction is used.
	SessionsTable string
	MessagesTable string

	// Optional session settings (e.g., default history limit).
	SessionSettings *SessionSettings
}

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

type SQLiteSessionParams struct {
	// Unique identifier for the conversation session
	SessionID string

	// Optional database data source name.
	// Defaults to ':memory:' (in-memory database).
	DBDataSourceName string

	// Optional name of the table to store session metadata.
	// Defaults to "file::memory:?cache=shared".
	SessionTable string

	// Optional name of the table to store message data.
	// Defaults to "agent_messages".
	MessagesTable string

	// Optional session settings (e.g., default history limit).
	SessionSettings *SessionSettings
}

type Session interface {
	SessionID(context.Context) string

	// GetItems retrieves the conversation history for this session.
	//
	// `limit` is the maximum number of items to retrieve. If <= 0, retrieves all items.
	// When specified, returns the latest N items in chronological order.
	GetItems(ctx context.Context, limit int) ([]TResponseInputItem, error)

	// AddItems adds new items to the conversation history.
	AddItems(ctx context.Context, items []TResponseInputItem) error

	// PopItem removes and returns the most recent item from the session.
	// It returns nil if the session is empty.
	PopItem(context.Context) (*TResponseInputItem, error)

	// ClearSession clears all items for this session.
	ClearSession(context.Context) error
}

type SessionIgnoreIDsProvider interface {
	IgnoreIDsForMatching() bool
}

type SessionInputCallback func(history []TResponseInputItem, newInput []TResponseInputItem) ([]TResponseInputItem, error)

type SessionItemSanitizer interface {
	SanitizeInputItemsForPersistence(items []TResponseInputItem) []TResponseInputItem
}

type SessionSettings struct {
	// Limit sets the maximum number of items to retrieve. If nil, retrieves all items.
	Limit *int
}

type SessionSettingsProvider interface {
	SessionSettings() *SessionSettings
}

type TResponseInputItem = responses.ResponseInputItemUnionParam