memory

package
v0.49.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 20, 2026 License: AGPL-3.0 Imports: 9 Imported by: 0

Documentation

Overview

Package memory defines the pluggable memory provider contract.

Every memory plugin implements Provider as its core interface. Optional capabilities are discovered via type assertion at runtime, following the same pattern as github.com/CherryHQ/stella/pkg/hooks.

Index

Constants

View Source 
const (
	SummarizePolicyNormal     = "normal"
	SummarizePolicyAggressive = "aggressive"
)

SummarizePolicy constants control how aggressively content is compressed.

Variables

This section is empty.

Functions

func AgentIDFromContext 

func AgentIDFromContext(ctx context.Context) string

AgentIDFromContext extracts the agent ID from context.

func BuildPrompt 

func BuildPrompt(text string, opts SummarizeOptions) string

BuildPrompt constructs the appropriate summarization prompt.

func BuildTool 

func BuildTool(provider Provider, opts ...ToolOption) tools.Tool

BuildTool inspects provider capabilities and returns a memory tool whose available actions match exactly what the provider supports. If the provider supports no optional capabilities, the tool still exists but only offers a "status" action.

func EstimateTokens 

func EstimateTokens(text string) int

EstimateTokens returns a rough token count (~4 chars per token).

func GroupSeqFromContext added in v0.42.0 

func GroupSeqFromContext(ctx context.Context) int64

GroupSeqFromContext extracts the triggering event-log seq from context.

func MessageRole 

func MessageRole(msg ai.Message) string

MessageRole returns the role string for an ai.Message.

func MessageText 

func MessageText(msg ai.Message) string

MessageText extracts the plain text content from an ai.Message. Returns the text for user/assistant messages, or the tool result for tool messages.

func MessageTimestamp 

func MessageTimestamp(msg ai.Message) time.Time

MessageTimestamp returns the timestamp of an ai.Message.

func NeutralizeTags added in v0.46.0 

func NeutralizeTags(s string, tags ...string) string

NeutralizeTags prevents user-derived text from opening or closing structural prompt tags while keeping the text readable for the model.

func ProjectIDFromContext added in v0.40.0 

func ProjectIDFromContext(ctx context.Context) string

ProjectIDFromContext extracts the project ID from context.

func SessionIDFromContext 

func SessionIDFromContext(ctx context.Context) string

SessionIDFromContext extracts the session ID from context.

func UserIDFromContext 

func UserIDFromContext(ctx context.Context) string

UserIDFromContext extracts the user ID from context.

func WithAgentID 

func WithAgentID(ctx context.Context, agentID string) context.Context

WithAgentID attaches an agent ID to the context.

func WithChangeSource 

func WithChangeSource(ctx context.Context, source ChangeSource) context.Context

WithChangeSource stores a ChangeSource in the context. This lets callers (e.g. Reflect) tag writes without changing function signatures.

func WithCurrentSpeaker added in v0.43.0 

func WithCurrentSpeaker(ctx context.Context, speaker CurrentSpeaker) context.Context

WithCurrentSpeaker attaches the current-turn speaker to the context.

func WithGroupSeq added in v0.42.0 

func WithGroupSeq(ctx context.Context, seq int64) context.Context

WithGroupSeq attaches the triggering event-log seq to the context.

func WithProjectID added in v0.40.0 

func WithProjectID(ctx context.Context, projectID string) context.Context

WithProjectID attaches a project ID to the context.

func WithSessionID 

func WithSessionID(ctx context.Context, sessionID string) context.Context

WithSessionID attaches a session ID to the context.

func WithUserID 

func WithUserID(ctx context.Context, userID string) context.Context

WithUserID attaches a user ID to the context.

Types

type ChangeEntry 

type ChangeEntry struct {
	ID                  string
	UserID              string
	AgentID             string
	SessionID           string
	Scope               string // "profile", "soul", "constraint", "skill", "compaction"
	Action              string // "create", "update", "delete", "compact"
	Source              ChangeSource
	MemoryVersionBefore *int64
	MemoryVersionAfter  *int64
	BeforeText          string
	AfterText           string
	CreatedAt           string
}

ChangeEntry represents one changelog record.

type ChangeSource 

type ChangeSource string

ChangeSource identifies who triggered a memory write. 

const (
	SourceUser    ChangeSource = "user"
	SourceAgent   ChangeSource = "agent"
	SourceReflect ChangeSource = "reflect"
	SourceSystem  ChangeSource = "system"
)

func ChangeSourceFromContext 

func ChangeSourceFromContext(ctx context.Context) ChangeSource

ChangeSourceFromContext retrieves the ChangeSource from context. Returns SourceAgent if not set.

type ChangelogReader 

type ChangelogReader interface {
	// ReadChangelog returns the last N changelog entries for a given scope.
	ReadChangelog(ctx context.Context, userID string, agentID string, scope string, limit int) ([]ChangeEntry, error)
}

ChangelogReader is implemented by providers that expose memory write history.

type ChangelogWriter 

type ChangelogWriter interface {
	// WriteChangelog records a memory change.
	WriteChangelog(ctx context.Context, entry ChangeEntry) error
}

ChangelogWriter is implemented by providers that record memory write history.

type CompactionMode 

type CompactionMode int

CompactionMode controls compaction behavior. 

const (
	// CompactionIncremental runs one leaf pass + one condensed pass.
	CompactionIncremental CompactionMode = iota
	// CompactionFull repeats until no more compaction is possible.
	CompactionFull
)

func (CompactionMode) String 

func (m CompactionMode) String() string

String returns the human-readable name of the compaction mode.

type CompactionResult 

type CompactionResult struct {
	LeafSummariesCreated      int
	CondensedSummariesCreated int
	MessagesCompacted         int
	TokensBefore              int
	TokensAfter               int
	Duration                  time.Duration
}

CompactionResult reports what a compaction cycle accomplished.

type Compactor 

type Compactor interface {
	// NeedsCompaction returns true if the session's context token count exceeds
	// threshold, an absolute token count.
	NeedsCompaction(ctx context.Context, session Session, threshold float64) bool

	// Compact runs the compaction algorithm on the session.
	// Incremental mode runs a single summarisation pass (fast, called automatically).
	// Full mode runs repeated passes until no further reduction is possible
	// (slow, called on demand e.g. via /compact slash command).
	Compact(ctx context.Context, session Session, mode CompactionMode) (*CompactionResult, error)
}

Compactor is implemented by providers that support background compaction. The runtime calls NeedsCompaction before each chat turn and Compact when needed.

type ConstraintEntry 

type ConstraintEntry struct {
	ID        string `json:"id"`
	Text      string `json:"text"`
	CreatedAt string `json:"created_at"`
}

ConstraintEntry represents a single user constraint.

type ConstraintStore 

type ConstraintStore interface {
	// GetConstraints returns all active constraints for the (userID, agentID) pair.
	GetConstraints(ctx context.Context, userID string, agentID string) ([]ConstraintEntry, error)

	// AddConstraint adds a new constraint with a generated UUID-like ID.
	// Returns the updated list of constraints.
	AddConstraint(ctx context.Context, userID string, agentID string, text string) ([]ConstraintEntry, error)

	// RemoveConstraint removes the constraint with the given ID.
	// Returns the updated list of constraints.
	RemoveConstraint(ctx context.Context, userID string, agentID string, id string) ([]ConstraintEntry, error)
}

ConstraintStore is implemented by providers that support storing user-defined hard constraints (rules the agent must always follow). Constraints are separate from Profile to give them special protection: Reflect cannot modify them; only user-initiated writes are allowed by convention.

type CurrentSpeaker added in v0.43.0 

type CurrentSpeaker struct {
	Platform       string // source platform (telegram, feishu, web, ...)
	PlatformUserID string // platform sender id / Web auth user id; lookup/audit only
	DisplayName    string // sender display name when available
	UserID         string // resolved Stella auth user id when linked; empty when unlinked
}

CurrentSpeaker carries the human who sent the current turn in a group session, where the runtime/session identity is the group (D9), not any one person.

D9 WARNING: CurrentSpeaker.UserID is a per-turn personalization target ONLY, never a runtime identity. Do not pass it to WithUserID, sandbox config, vault/token code, plugin contexts, delegate sessions, notify routing, or hook user metadata. Session/runtime ownership keeps flowing from the group id; this axis only selects whose profile the prompt and memory tool personalize.

func CurrentSpeakerFromContext added in v0.43.0 

func CurrentSpeakerFromContext(ctx context.Context) (CurrentSpeaker, bool)

CurrentSpeakerFromContext extracts the current-turn speaker. The bool is false when no speaker is set (DM turns); it is true but UserID may be empty for an unlinked platform sender.

type DescribeResult 

type DescribeResult struct {
	SummaryID       string
	Kind            string     // "leaf" or "condensed"
	Depth           int        // 0 = leaf, 1+ = condensed
	Content         string     // the summary text
	EarliestAt      *time.Time // timestamp of oldest source message
	LatestAt        *time.Time // timestamp of newest source message
	DescendantCount int        // total original messages this summary covers
	ParentIDs       []string   // summaries that contain this one (condensed parents)
	ChildIDs        []string   // summaries or messages this one was built from
}

DescribeResult represents summary metadata and lineage.

type ExpandChild 

type ExpandChild struct {
	SummaryID string
	Kind      string
	Depth     int
	Content   string
}

ExpandChild is a child summary in an expand result.

type ExpandMessage 

type ExpandMessage struct {
	MessageID string
	Role      string
	Content   string
	CreatedAt time.Time
}

ExpandMessage is a source message in an expand result.

type ExpandResult 

type ExpandResult struct {
	SummaryID string
	// For leaf summaries: the original source messages.
	Messages []ExpandMessage
	// For condensed summaries: the child summaries.
	Children []ExpandChild
}

ExpandResult represents drill-down results from exploring a summary.

type Explorer 

type Explorer interface {
	// Describe returns metadata and lineage for a summary ID.
	Describe(ctx context.Context, summaryID string) (*DescribeResult, error)

	// Expand drills into a summary:
	//   - For leaf summaries: returns the original source messages
	//   - For condensed summaries: returns the child summaries
	// tokenCap limits how many tokens of content are returned.
	Expand(ctx context.Context, summaryID string, tokenCap int) (*ExpandResult, error)
}

Explorer is implemented by providers that store summaries in a navigable hierarchy. It lets the agent inspect and drill into compressed history.

Note: these methods take summaryID only, not Session. Summary IDs are globally unique (e.g. "sum_a1b2c3d4") and already scoped to a conversation internally.

type GroupCursorCommitter added in v0.43.0 

type GroupCursorCommitter interface {
	CommitGroupCursor(ctx context.Context, session Session, triggerSeq int64) error
}

GroupCursorCommitter advances group event-log ingestion only after a chat turn has completed successfully. Assemble may prepare between-turn rows, but commit owns durable cursor movement.

type GroupMemoryStore added in v0.42.0 

type GroupMemoryStore interface {
	GetGroupMemory(ctx context.Context, groupID string) (string, error)
}

GroupMemoryStore provides read access to group-scoped shared memory. Write access is through the memorywrite package (type-level isolation).

type LLMSummarizer 

type LLMSummarizer struct {
	// Generate calls the LLM with the given prompt and returns the response text.
	Generate func(ctx context.Context, prompt string) (string, error)
}

LLMSummarizer generates summaries using an LLM via a callback function.

func (*LLMSummarizer) Summarize 

func (s *LLMSummarizer) Summarize(ctx context.Context, text string, opts SummarizeOptions) (string, error)

Summarize generates a summary with escalation: normal -> aggressive -> deterministic fallback.

type ListOptions 

type ListOptions struct {
	AgentID         string // filter by agent (empty = all)
	UserID          string // filter by user (empty = all)
	Kind            string // filter by kind (empty = all)
	ProjectID       string // filter by project (empty = all)
	ProjectIDIsNull bool   // when true, require project_id IS NULL
	IncludeArchived bool
	Limit           int // 0 = no limit
	Offset          int // skip first N matching results
}

ListOptions controls session listing filters.

type MessageDetail added in v0.49.0 

type MessageDetail struct {
	MessageID         string    `json:"message_id"`
	Role              string    `json:"role"`
	Content           string    `json:"content"`
	OccurredAt        time.Time `json:"occurred_at"`        // when the message happened
	SessionID         string    `json:"session_id"`         // origin session for traceability
	ConversationTitle string    `json:"conversation_title"` // human-readable origin label (may be empty)
}

MessageDetail is the full, untruncated content of a single stored message.

type MessageReader added in v0.49.0 

type MessageReader interface {
	GetMessage(ctx context.Context, messageID string) (*MessageDetail, error)
}

MessageReader is implemented by providers that can return a single message in full by ID, scoped to (user_id, agent_id). It complements Searcher: search hits are truncated snippets, so the agent calls GetMessage to read a hit in full — including hits from other sessions of the same user+agent.

type ProfileEntry added in v0.42.0 

type ProfileEntry struct {
	ID        string `json:"id"`
	Text      string `json:"text"`
	Source    string `json:"source"`     // "manual" or "auto"
	CreatedAt string `json:"created_at"` // RFC3339
}

ProfileEntry represents a single dated profile entry, either manually edited by the user or auto-generated by async memory ingest (D6).

type ProfileEntryStore added in v0.42.0 

type ProfileEntryStore interface {
	GetProfileEntries(ctx context.Context, userID string, agentID string) ([]ProfileEntry, error)
}

ProfileEntryStore is implemented by providers that support dated profile entries (D5). Auto-generated entries live alongside the manual profile blob.

type ProfileStore 

type ProfileStore interface {
	// GetProfile returns the current user profile for the (userID, agentID) pair.
	// Returns ("", nil) if no profile exists yet (not an error).
	GetProfile(ctx context.Context, userID string, agentID string) (string, error)

	// SetProfile overwrites the user profile for the (userID, agentID) pair.
	// Callers are responsible for merging new content with existing content
	// before calling SetProfile — this method always replaces, never appends.
	SetProfile(ctx context.Context, userID string, agentID string, content string) error

	// GetAgentSoul returns the agent soul for the (userID, agentID) pair.
	// The soul defines the agent's identity, personality, and behavior as
	// customised by this specific user. Returns ("", nil) if not set.
	GetAgentSoul(ctx context.Context, userID string, agentID string) (string, error)

	// SetAgentSoul overwrites the agent soul for the (userID, agentID) pair.
	// Callers are responsible for merging; this method always replaces.
	SetAgentSoul(ctx context.Context, userID string, agentID string, content string) error
}

ProfileStore is implemented by providers that support per-user-per-agent persistent memory: agent soul (identity/personality customization) and user profile (facts/context about the user).

Both are scoped to (userID, agentID) — each user can customise the agent's soul independently, and the agent maintains separate profile notes per user. Content is free-form text managed entirely by the agent. The system injects both into the system prompt at session start.

type Provider 

type Provider interface {
	// Name returns the plugin identifier (e.g. "lcm", "simple").
	// Used in logs and admin UI.
	Name() string

	// Bootstrap ensures the session is initialized and ready for use.
	// Called once at the start of every chat turn before any Append or Assemble.
	// Implementations use this to create conversation records, initialize caches,
	// or establish remote connections for the session.
	Bootstrap(ctx context.Context, session Session) error

	// Append persists one or more messages to the session's event log.
	// Messages must be appended in the order they arrive.
	// Callers pass all messages from a single turn together so implementations
	// can store them in a single atomic transaction if they choose.
	//
	// Concurrency: implementations MUST be safe for concurrent Append calls
	// on different sessions. Concurrent Append calls on the SAME session
	// MUST be serialised by the implementation (see Concurrency Contract).
	Append(ctx context.Context, session Session, msgs ...ai.Message) error

	// Assemble builds the context window to send to the LLM.
	// budget: maximum number of tokens the returned messages may consume.
	// freshTail: number of recent user turns to prefer verbatim. Implementations
	//   may apply safety caps so oversized tails do not consume the whole budget.
	// Returns messages in chronological order (oldest first).
	// Older content that does not fit in the budget is either summarised
	// (if the plugin supports Compactor) or omitted.
	Assemble(ctx context.Context, session Session, budget, freshTail int) ([]ai.Message, error)

	// Stats returns basic statistics about a session's memory state.
	// Used by the memory tool's "status" action and by admin endpoints.
	// Returns zero-value stats (not an error) if the session does not exist.
	Stats(ctx context.Context, session Session) (SessionStats, error)

	// Close releases any resources held by the provider (DB connections, caches, etc.).
	// Called on shutdown. Must be safe to call multiple times.
	Close() error
}

Provider is the memory plugin contract. Every memory plugin must implement this interface. Optional capabilities are discovered via type assertion — see Capability Interfaces.

func Unwrap 

func Unwrap(p Provider) Provider

Unwrap returns the innermost Provider by recursively unwrapping traced layers. If p does not implement the unwrapper interface, p itself is returned.

func WithTracing 

func WithTracing(provider Provider, hooksFn func() *hooks.HookSet) Provider

WithTracing wraps a Provider to emit PostMemoryCall hooks after each operation. hooksFn is called on each operation to get the current HookSet; it may return nil. The returned Provider implements all optional capability interfaces (Compactor, Searcher, Explorer, ProfileStore, SessionManager, Reviewer). Methods for capabilities not supported by the inner provider return sensible zero values or errors. Use Unwrap to check the inner provider's actual capabilities.

The Detail field is always populated with content previews. The trace hook decides whether to emit it based on log level (see [LevelTrace]).

type Reviewer 

type Reviewer interface {
	// BuildReviewContext returns a text representation of the conversation
	// suitable for passing to a reviewer agent's prompt.
	//
	// since: if non-zero, only include content created after this time.
	//   The provider should include prior context (e.g. summaries from before
	//   this timestamp) to give the reviewer enough background.
	//   If zero, include all content.
	//
	// Returns ("", nil) if there is no content to review.
	BuildReviewContext(ctx context.Context, session Session, since time.Time) (string, error)
}

Reviewer is implemented by providers that can format conversation content for review by a background agent (the reflect system).

This is deliberately a single method. Watermark tracking (which sessions have been reviewed, when) is not the memory plugin's concern — it belongs to the consumer (`internal/reflect`). The memory provider's only job is: "given a session and an optional time boundary, produce reviewable text."

type SearchQuery 

type SearchQuery struct {
	Text  string      // search term (keyword or natural language depending on plugin)
	Scope SearchScope // which layer of storage to search
	Limit int         // max results (default 20)
}

SearchQuery describes a search request.

type SearchResult 

type SearchResult struct {
	SourceType        string    `json:"source_type"`        // "message" or "summary"
	SourceID          string    `json:"source_id"`          // message ID or summary ID
	Content           string    `json:"content"`            // snippet of the matching content (truncated at ~500 chars)
	Score             float64   `json:"score"`              // normalized BM25 relevance (-bm25), higher is better
	OccurredAt        time.Time `json:"occurred_at"`        // when the underlying content actually happened
	SessionID         string    `json:"session_id"`         // origin session for traceability
	ConversationTitle string    `json:"conversation_title"` // human-readable origin label (may be empty)
}

SearchResult represents a single search hit. Results span every session of the current (user_id, agent_id), so each hit carries provenance — which conversation it came from — plus the time the content actually occurred so the agent can weight recency.

type SearchScope 

type SearchScope int

SearchScope controls which storage layer to search. 

const (
	SearchScopeBoth      SearchScope = iota // default: search everything
	SearchScopeMessages                     // raw messages only
	SearchScopeSummaries                    // summaries only
)

type Searcher 

type Searcher interface {
	Search(ctx context.Context, session Session, query SearchQuery) ([]SearchResult, error)
}

Searcher is implemented by providers that support history search.

type Session 

type Session struct {
	ID      string // unique session key (e.g. "default:cli:<uuid>:main")
	AgentID string // agent this session belongs to (e.g. "default")
	UserID  string // internal user ID (empty for anonymous/legacy)
	Channel string // originating channel (e.g. "cli", "telegram")
	GroupID string // non-empty for group sessions; assembles history from event log instead of ctx_message
}

Session identifies the context of a single conversation. It is created by the runtime and passed to all Provider methods.

type SessionInfo 

type SessionInfo struct {
	ID         string
	AgentID    string
	UserID     string
	GroupID    string // non-empty for group sessions; runtime uses this to isolate identity surfaces
	Channel    string
	Kind       string // session kind: main, chat, scheduler, task
	ProjectID  string // set for project-scoped sessions
	Title      string // auto-generated from first message
	CreatedAt  time.Time
	LastActive time.Time
	Archived   bool
}

SessionInfo holds metadata about a session.

type SessionManager 

type SessionManager interface {
	// SaveInfo persists or updates session metadata.
	SaveInfo(ctx context.Context, info SessionInfo) error

	// LoadInfo retrieves metadata for a single session.
	LoadInfo(ctx context.Context, sessionID string) (SessionInfo, error)

	// ListInfo lists sessions matching the options.
	ListInfo(ctx context.Context, opts ListOptions) ([]SessionInfo, error)

	// LoadHistory returns the complete raw message history for a session
	// in chronological order. Used by the Web UI viewer and export.
	LoadHistory(ctx context.Context, sessionID string) ([]ai.Message, error)
}

SessionManager is implemented by providers that support session lifecycle management.

type SessionSnapshot 

type SessionSnapshot struct {
	SessionID string
	UserID    string
	AgentID   string
	Version   int64
	// UpdatedAt is the wall-clock time when this snapshot was last advanced.
	// Used to filter knowledge entries so that knowledge activated after the
	// snapshot was taken does not appear in the frozen session.
	UpdatedAt time.Time
}

SessionSnapshot holds the frozen version for a session.

type SessionSnapshotStore 

type SessionSnapshotStore interface {
	// GetOrCreateSessionSnapshot returns the snapshot for the session, creating it
	// if it doesn't exist. When creating, freezes the current ctx_agent_memory.version.
	GetOrCreateSessionSnapshot(ctx context.Context, sessionID string, userID string, agentID string) (SessionSnapshot, error)

	// AdvanceSessionSnapshot updates the snapshot version to the current
	// ctx_agent_memory.version for (userID, agentID).
	// Called after front-end memory writes so the current session sees the update.
	AdvanceSessionSnapshot(ctx context.Context, sessionID string, userID string, agentID string) error
}

SessionSnapshotStore is implemented by providers that support session snapshots.

type SessionStats 

type SessionStats struct {
	MessageCount int       // total messages stored for this session
	TokenCount   int       // estimated total tokens across all stored messages
	SummaryCount int       // number of summaries (0 for providers without Compactor)
	OldestAt     time.Time // timestamp of the earliest message (zero if empty)
	NewestAt     time.Time // timestamp of the most recent message (zero if empty)
}

SessionStats contains basic statistics about a session's memory state. Every provider can produce this since it only requires knowledge of what was stored via Append.

type StaticSummarizer 

type StaticSummarizer struct {
	Response string
	Err      error
}

StaticSummarizer always returns a fixed response (for testing).

func (*StaticSummarizer) Summarize 

func (s *StaticSummarizer) Summarize(_ context.Context, _ string, _ SummarizeOptions) (string, error)

Summarize returns the static response.

type SummarizeOptions 

type SummarizeOptions struct {
	IsCondensed  bool
	Depth        int
	Aggressive   bool
	Previous     string // previous summary for continuity
	TargetTokens int
}

SummarizeOptions controls summarization behavior.

type Summarizer 

type Summarizer interface {
	Summarize(ctx context.Context, text string, opts SummarizeOptions) (string, error)
}

Summarizer generates summaries from content.

type ToolOption 

type ToolOption func(*toolConfig)

ToolOption configures the generated memory tool.

func WithActionsOnly 

func WithActionsOnly(actions ...string) ToolOption

WithActionsOnly restricts the tool to the named actions only. Actions not in the list are omitted even if the provider supports them.

func WithReadOnlyProfile 

func WithReadOnlyProfile() ToolOption

WithReadOnlyProfile disables the profile_update action. Used when building the tool for the self-improve reviewer agent, which should read but not arbitrarily overwrite profile notes.

func WithReadOnlySoul 

func WithReadOnlySoul() ToolOption

WithReadOnlySoul disables the soul_update action.

type VersionedConstraintStore 

type VersionedConstraintStore interface {
	GetConstraintsAt(ctx context.Context, userID string, agentID string, version int64) ([]ConstraintEntry, error)
}

VersionedConstraintStore is implemented by providers that can read constraints at a specific memory version.

type VersionedProfileStore 

type VersionedProfileStore interface {
	GetProfileAt(ctx context.Context, userID string, agentID string, version int64) (string, error)
	GetAgentSoulAt(ctx context.Context, userID string, agentID string, version int64) (string, error)
}

VersionedProfileStore is implemented by providers that can read profile/soul at a specific memory version (from the changelog). Version 0 or negative means "current" (same as ProfileStore).

Source Files

View all Source files

Directories

Path Synopsis
Package memorytest provides test doubles and conformance testing for memory.Provider implementations.
 Package memorytest provides test doubles and conformance testing for memory.Provider implementations.
Package memorywrite provides shared transactional write helpers for profile and soul memory updates.
 Package memorywrite provides shared transactional write helpers for profile and soul memory updates.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.