记忆

        # a dictionary of conversations, default value is list
        if chat_messages is None:
            self._oai_messages = defaultdict(list)
        else:
            self._oai_messages = chat_messages

        self._oai_system_message = [{"content": system_message, "role": "system"}]
        self._description = description if description is not None else system_message
        self._is_termination_msg = (
            is_termination_msg
            if is_termination_msg is not None
            else (lambda x: content_str(x.get("content")) == "TERMINATE")

@dataclass
class MessageStore:
    """Flat storage for all messages across all agents.

    This class stores all messages in a single flat list with agent/callerAgent
    metadata embedded in each message, replacing the previous thread-based structure.

    Attributes:
        messages (list[TResponseInputItem]): Flat list of all messages
        metadata (dict[str, Any]): Optional metadata for the entire message store
    """

    )


class Memory(Base):
    __tablename__ = "memory"
    id = Column(
        UUID(as_uuid=True) if DATABASE_TYPE != "sqlite" else String,
        primary_key=True,
        default=get_new_id if DATABASE_TYPE == "sqlite" else uuid.uuid4,
    )
    agent_id = Column(
        UUID(as_uuid=True) if DATABASE_TYPE != "sqlite" else String,
        ForeignKey("agent.id"),

}

// PRIME extraction schema for generateObject validation
const PRIMEExtractionSchema = z.object({
  memories: z.array(
    z.object({
      content: z.string(),
      type: z.enum(['working', 'episodic', 'semantic', 'procedural']),
      importance: z.number().min(0).max(1),
      reasoning: z.string().optional()
    })
  )
});

"""
Cross-Agent Persistent Memory Client for AgentField SDK.

Memory Scope Hierarchy
======================

AgentField provides four memory scopes for storing agent data:

Global Scope
------------

# ---------------------------------------------------------------------------


class Skillbook:
    """Structured context store as defined by ACE."""

    def __init__(self) -> None:
        self._skills: Dict[str, Skill] = {}
        self._sections: Dict[str, List[str]] = {}
        self._next_id = 0
        self._similarity_decisions: Dict[FrozenSet[str], SimilarityDecision] = {}
        self._lock = threading.RLock()

      query = lastMessage;
    } else {
      // limit messagesWithoutQuery to the last 10 messages
      const messagesToCondense = messagesWithoutQuery.slice(-10);

      // we need to condense the messages + last message into a single query
      query = (
        await generateText({
          model: languageModel,
          prompt: CONDENSE_SYSTEM_PROMPT.compile({
            question: lastMessage,
            chatHistory: CONDENSE_USER_PROMPT.compile({
              query: lastMessage,

@memory_registry.register("vectorstore")
class VectorStoreMemory(BaseMemory):

    """

    The main difference of this class with chat_history is that this class treat memory as a dict

    treat message.content as memory

    Attributes:
        messages (List[Message]) : used to store messages, message.content is the key of embeddings.

        Ok(tool_resps)
    }

    pub fn run_delta<'a>(
        &'a mut self,
        mut messages: Vec<Message>,
        config: Option<AgentConfig>,
    ) -> BoxStream<'a, anyhow::Result<MessageDeltaOutput>> {
        let knowledge = self.knowledge.clone();
        let tools = self.tools.clone();
        let AgentConfig {
            inference: inference_config,
            knowledge: knowledge_config,

        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        return now

    async def create_history_prompt(self) -> str:
        history_lines = [
            f"{history.role.title()}: {history.content}"
            for history in self.chat_history
        ]

        return "\n".join(history_lines) or "无"

    async def model_general_stream(
        self, messages: list, span: Span, node_trace_log: NodeTraceLog

    memories: MemoryQueryResult


class Memory(ABC, ComponentBase[BaseModel]):
    """Protocol defining the interface for memory implementations.

    A memory is the storage for data that can be used to enrich or modify the model context.

    A memory implementation can use any storage mechanism, such as a list, a database, or a file system.
    It can also use any retrieval mechanism, such as vector search or text search.
    It is up to the implementation to decide how to store and retrieve data.

    It is also a memory implementation's responsibility to update the model context

  public messages: LLMzPrompts.Message[]
  public code?: string
  public traces: HookedArray<Trace>
  public variables: Record<string, any>

  public started_ts: number
  public ended_ts?: number

  public status: IterationStatus

  private _mutations: Map<string, ObjectMutation>

  public get mutations() {

            self.logger.start_session(self.system_prompt, session_id=session.get('session_id'))
        elif self.current_session is None:
            # Initialize new session
            self.current_session = {
                'messages': [{"role": "system", "content": self.system_prompt}],
                'trace': [],
                'turn': 0  # Track conversation turns
            }
            # Start YAML session logging
            self.logger.start_session(self.system_prompt)

        # Save uploaded files to .co/uploads/ and build file path references
        saved_files = []

//
// Returns nil when the write is governance-compliant (or
// backward-compatible). Returns a typed sentinel for tests.
func validateGovernanceWrite(req *pb.UpdateMemoryRequest) error {
	if req == nil {
		return nil
	}
	wk := req.GetWriteKind()
	mutates := req.GetPolicyStateMutation() || isSharedWriteKind(wk)
	if !mutates {
		return nil
	}
	if strings.TrimSpace(req.GetWriterAgentId()) == "" {

    }

    /// Extract memories from session messages using LLM
    pub async fn extract(&self, messages: &[String]) -> Result<ExtractedMemories> {
        if messages.is_empty() {
            return Ok(ExtractedMemories::default());
        }

        tracing::info!(
            "Starting memory extraction from {} messages",
            messages.len()
        );

    return build_embedder(spec)


class Memory(BaseModel):
    """Unified memory: standalone, LLM-analyzed, with intelligent recall flow.

    Works without agent/crew. Uses LLM to infer scope, categories, importance on save.
    Uses RecallFlow for adaptive-depth recall. Supports scope/slice views and
    pluggable storage (LanceDB default).
    """

    model_config = ConfigDict(arbitrary_types_allowed=True)

    return deserialized_schema


def _validate_schema(schema: dict[str, Any]) -> None:
    """
    Validate that a schema dictionary meets all required constraints.

    Checks that each parameter definition has a valid type field and that any handler
    specified is a callable function.

    :param schema: Dictionary mapping parameter names to their type and handler configs
    :raises ValueError: If schema validation fails due to missing or invalid fields
    """

#!/usr/bin/env python3
"""
Memory Tool Module - Persistent Curated Memory

Provides bounded, file-backed memory that persists across sessions. Two stores:
  - MEMORY.md: agent's personal notes and observations (environment facts, project
    conventions, tool quirks, things learned)
  - USER.md: what the agent knows about the user (preferences, communication style,
    expectations, workflow habits)

    return None


class NodeSpec(BaseModel):
    """
    Specification for a node in the graph.

    This is the declarative definition of a node - what it does,
    what it needs, and what it produces. The actual implementation
    is separate (NodeProtocol).

    Example:
        NodeSpec(

from lagent.utils import load_class_from_string


class Memory:

    def __init__(self, recent_n=None) -> None:
        self.memory: List[AgentMessage] = []
        self.recent_n = recent_n

    def get_memory(
        self,
        recent_n: Optional[int] = None,
        filter_func: Optional[Callable[[int, dict], bool]] = None,

"""Annotation used to mark state attributes as purely internal for a given middleware."""


class AgentState(TypedDict, Generic[ResponseT]):
    """State schema for the agent."""

    messages: Required[Annotated[list[AnyMessage], add_messages]]
    jump_to: NotRequired[Annotated[JumpTo | None, EphemeralValue, PrivateStateAttr]]
    structured_response: NotRequired[Annotated[ResponseT, OmitFromInput]]


class _InputAgentState(TypedDict):  # noqa: PYI049
    """Input state schema for the agent."""

    # Create a vector database
    vector_db_id = f"test_vector_db_{uuid4()}"
    client.vector_dbs.register(
        vector_db_id=vector_db_id,
        embedding_model="all-MiniLM-L6-v2",
        embedding_dimension=384,
        provider_id=selected_vector_provider.provider_id,
    )

    # Insert documents using the RAG tool
    start_time = time.time()
    client.tool_runtime.rag_tool.insert(

        return None


class Memory(BaseMemory):
    """
    A memory module that waterfalls into memory blocks.

    Works by orchestrating around
    - a FIFO queue of messages
    - a list of memory blocks
    - various parameters (pressure size, token limit, etc.)

    When the FIFO queue reaches the token limit, the oldest messages within the pressure size are ejected from the FIFO queue.

        return {tool.name: tool for tool in self.tools}

    def run(self, question: str):
        previous_responses = []
        num_loops = 0
        prompt = self.prompt_template.format(
                today = datetime.date.today(),
                tool_description=self.tool_description,
                tool_names=self.tool_names,
                question=question,
                previous_responses='{previous_responses}'
        )
        print(prompt.format(previous_responses=''))

    auto_compress: bool = True


class GradeMemory:
    """Grade Memory"""

    def __init__(
        self,
        stm: ShortTermMemory,
        mtm: MediumTermMemory,
        ltm: LongTermMemory,
        token_counter: TokenCounter,
        config: MemoryConfig,

# Ask the user if they want to use search
use_search = input("Do you want to use search? (y/n): ").lower() == 'y'

task_exchanges = []
haiku_tasks = []

while True:
    # Call Orchestrator to break down the objective into the next sub-task or provide the final output
    previous_results = [result for _, result in task_exchanges]
    if not task_exchanges:
        # Pass the file content only in the first iteration if available
        opus_result, file_content_for_haiku, search_query = opus_orchestrator(objective, file_content, previous_results, use_search)
    else:

 * - Working memory templates for structured conversation state
 * - Handles memory processors to manipulate messages before they are sent to the LLM
 */
export abstract class MastraMemory extends MastraBase {
  /**
   * Unique identifier for the memory instance.
   * If not provided, defaults to a static name 'default-memory'.
   */
  readonly id: string;

  MAX_CONTEXT_TOKENS?: number;

  protected _storage?: MastraCompositeStore;

from metagpt.utils.exceptions import handle_exception


class Memory(BaseModel):
    """The most basic memory: super-memory"""

    storage: list[SerializeAsAny[Message]] = []
    index: DefaultDict[str, list[SerializeAsAny[Message]]] = Field(default_factory=lambda: defaultdict(list))
    ignore_id: bool = False

    def add(self, message: Message):
        """Add a new message to storage, while updating the index"""
        if self.ignore_id:

// This method should return the current state of the agent as a string.
// Any format is fine, but it should be consistent and easy to parse.
func (a *CounterAgent) GetState() *string {
	s := strconv.Itoa(a.count)
	return &s
}

// This method should set the state of the agent from a string.
// The string should be in the same format as the one returned by GetState.
// Be sure to consider data compatibility when changing the format of the state.
func (a *CounterAgent) SetState(data *string) {
	if data == nil {

# MemoryStore — pure file I/O layer
# ---------------------------------------------------------------------------

class MemoryStore:
    """Pure file I/O for memory files: MEMORY.md, history.jsonl, SOUL.md, USER.md."""

    _DEFAULT_MAX_HISTORY = 1000
    _LEGACY_ENTRY_START_RE = re.compile(r"^\[(\d{4}-\d{2}-\d{2}[^\]]*)\]\s*")
    _LEGACY_TIMESTAMP_RE = re.compile(r"^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2})\]\s*")
    _LEGACY_RAW_MESSAGE_RE = re.compile(
        r"^\[\d{4}-\d{2}-\d{2}[^\]]*\]\s+[A-Z][A-Z0-9_]*(?:\s+\[tools:\s*[^\]]+\])?:"
    )

  private state: AgentState
  private readonly _toolRegistry: ToolRegistry
  private readonly _toolExecutor: ToolExecutor
  private messageHistory: LLMMessage[] = []

  /**
   * @param config       - Static configuration for this agent.
   * @param toolRegistry - Registry used to resolve and manage tools.
   * @param toolExecutor - Executor that dispatches tool calls.
   *
   * `toolRegistry` and `toolExecutor` are injected rather than instantiated
   * internally so that teams of agents can share a single registry.
   */

/**
 * Session memory hook handler
 *
 * Saves session context to memory when /new or /reset command is triggered
 * Creates a new dated memory file with a timestamp slug by default
 */

import fs from "node:fs/promises";
import os from "node:os";
import path from "node:path";

LLMContextMessage: TypeAlias = LLMStandardMessage | LLMSpecificMessage


class LLMContext:
    """Manages conversation context for LLM interactions.

    Handles message history, tool definitions, tool choices, and multimedia
    content for LLM conversations. Provides methods for message manipulation,
    and content formatting.
    """

    def __init__(
        self,

class Memory(StorageMixin, SearchMixin, MemoryCoreMixin):
    """
    A single-file memory manager covering:
    - Short-term memory (STM) for ephemeral context
    - Long-term memory (LTM) for persistent knowledge
    - Entity memory (structured data about named entities)
    - User memory (preferences/history for each user)
    - Quality score logic for deciding which data to store in LTM
    - Context building from multiple memory sources
    - Graph memory support for complex relationship storage (via Mem0)

/// is provided (recommended), reduction will scan within the threshold window in an attempt to
/// avoid orphaning a user message from an assistant response.
/// </remarks>
public class ChatHistorySummarizationReducer : IChatHistoryReducer
{
    /// <summary>
    /// Metadata key to indicate a summary message.
    /// </summary>
    public const string SummaryMetadataKey = "__summary__";

    /// <summary>
    /// The default summarization system instructions.
    /// </summary>

    output: Any


class AgentMemory:
    """Memory for the agent, containing the system prompt and all steps taken by the agent.

    This class is used to store the agent's steps, including tasks, actions, and planning steps.
    It allows for resetting the memory, retrieving succinct or full step information, and replaying the agent's steps.

    Args:
        system_prompt (`str`): System prompt for the agent, which sets the context and instructions for the agent's behavior.

    **Attributes**:

* Tool X: Result Y"""


class SummarizingConversationManager(ConversationManager):
    """Implements a summarizing window manager.

    This manager provides a configurable option to summarize older context instead of
    simply trimming it, helping preserve important information while staying within
    context limits.
    """

    def __init__(
        self,

import type { MemoryEntry } from '@/types'

export type MemoryTier = 'working' | 'durable' | 'archive'

const WORKING_CATEGORIES = new Set(['execution', 'working', 'scratch', 'breadcrumb'])
const ARCHIVE_CATEGORIES = new Set(['session_archive'])

export function getMemoryTierForCategory(category: unknown): MemoryTier {
  const normalized = typeof category === 'string' ? category.trim().toLowerCase() : ''
  if (ARCHIVE_CATEGORIES.has(normalized)) return 'archive'
  if (normalized.startsWith('session_archive/')) return 'archive'
  if (normalized === 'operations/execution' || normalized.startsWith('operations/execution/')) return 'working'

    return conversation_dir


class Conversation:
    """
    A class to manage a conversation history, allowing for the addition, deletion,
    and retrieval of messages, as well as saving and loading the conversation
    history in various formats.

    The Conversation class uses in-memory storage for conversation history.

    Attributes:
        system_prompt (Optional[str]): The system prompt for the conversation.

)


class Memory:
    """Orchestrator for session and user memory with runtime session type selection.
    
    This class serves as the central coordinator for memory operations:
    - Session memory: Chat history, summaries, session metadata
    - User memory: User profiles and traits extracted from conversations
    
    **Save vs Load flag separation:**
    
    Save flags control what is persisted to storage:

            or f"{topic}:{date.today().isoformat()}"
        )

        self.memory = Memory.from_defaults(
            session_id=self.session_id, token_limit=65536
        )
        if chat_history:
            msgs = []
            for u, a in chat_history:
                msgs.append(ChatMessage.from_str(u, role=MessageRole.USER))
                msgs.append(ChatMessage.from_str(a, role=MessageRole.ASSISTANT))
            self.memory.put_messages(msgs)

 * Memory Class
 * Handles conversation memory with optional vector search capabilities
 */
export class Memory {
  private readonly storage: StorageAdapter;
  private readonly embedding?: EmbeddingAdapter;
  private readonly vector?: VectorAdapter;
  private embeddingCache?: BatchEmbeddingCache;
  private readonly workingMemoryConfig?: WorkingMemoryConfig;
  private readonly titleGenerationConfig?: MemoryConfig["generateTitle"];

  // Internal properties for Agent integration
  private resourceId?: string;