autobyteus 1.2.3__tar.gz → 1.3.0__tar.gz

{autobyteus-1.2.3 → autobyteus-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.2.3
+Version: 1.3.0
 Summary: Multi-Agent framework
 Author-email: Ryan Zheng <ryan.zheng.work@gmail.com>
 License: MIT License with Additional Terms for Commercial Use
@@ -34,7 +34,7 @@ Requires-Dist: botocore
 Requires-Dist: certifi==2025.4.26
 Requires-Dist: cryptography
 Requires-Dist: google-api-python-client
-Requires-Dist: google-genai==1.52.0
+Requires-Dist: google-genai
 Requires-Dist: httpx
 Requires-Dist: Jinja2
 Requires-Dist: mcp[cli]

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/agent/bootstrap_steps/__init__.py

@@ -9,6 +9,7 @@ from .workspace_context_initialization_step import WorkspaceContextInitializatio
 # ToolInitializationStep is no longer a bootstrap step.
 from .system_prompt_processing_step import SystemPromptProcessingStep
 from .mcp_server_prewarming_step import McpServerPrewarmingStep
+from .working_context_snapshot_restore_step import WorkingContextSnapshotRestoreStep
 # LLMConfigFinalizationStep and LLMInstanceCreationStep removed.
 
 __all__ = [
@@ -16,4 +17,5 @@ __all__ = [
     "WorkspaceContextInitializationStep",
     "SystemPromptProcessingStep",
     "McpServerPrewarmingStep",
+    "WorkingContextSnapshotRestoreStep",
 ]

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/agent/bootstrap_steps/agent_bootstrapper.py

@@ -5,6 +5,7 @@ from typing import List, Optional
 from .base_bootstrap_step import BaseBootstrapStep
 from .workspace_context_initialization_step import WorkspaceContextInitializationStep
 from .system_prompt_processing_step import SystemPromptProcessingStep
+from .working_context_snapshot_restore_step import WorkingContextSnapshotRestoreStep
 from .mcp_server_prewarming_step import McpServerPrewarmingStep
 
 logger = logging.getLogger(__name__)
@@ -27,6 +28,7 @@ class AgentBootstrapper:
                 WorkspaceContextInitializationStep(),
                 McpServerPrewarmingStep(),
                 SystemPromptProcessingStep(),
+                WorkingContextSnapshotRestoreStep(),
             ]
             logger.debug("AgentBootstrapper initialized with default steps.")
         else:

autobyteus-1.3.0/autobyteus/agent/bootstrap_steps/working_context_snapshot_restore_step.py

@@ -0,0 +1,38 @@
+import logging
+from typing import TYPE_CHECKING
+
+from .base_bootstrap_step import BaseBootstrapStep
+from autobyteus.memory.restore.working_context_snapshot_bootstrapper import WorkingContextSnapshotBootstrapper
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+
+class WorkingContextSnapshotRestoreStep(BaseBootstrapStep):
+    def __init__(self, bootstrapper: WorkingContextSnapshotBootstrapper | None = None) -> None:
+        self._bootstrapper = bootstrapper or WorkingContextSnapshotBootstrapper()
+        logger.debug("WorkingContextSnapshotRestoreStep initialized.")
+
+    async def execute(self, context: "AgentContext") -> bool:
+        restore_options = getattr(context.state, "restore_options", None)
+        if not restore_options:
+            return True
+
+        memory_manager = getattr(context.state, "memory_manager", None)
+        if not memory_manager:
+            logger.error("WorkingContextSnapshotRestoreStep requires a memory manager to restore working context snapshot.")
+            return False
+
+        system_prompt = context.state.processed_system_prompt
+        if not system_prompt:
+            llm_instance = context.llm_instance
+            system_prompt = llm_instance.config.system_message if llm_instance else ""
+
+        try:
+            self._bootstrapper.bootstrap(memory_manager, system_prompt, restore_options)
+            return True
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.error("WorkingContextSnapshotRestoreStep failed: %s", exc, exc_info=True)
+            return False

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/agent/context/agent_config.py

@@ -48,7 +48,8 @@ class AgentConfig:
                  workspace: Optional['BaseAgentWorkspace'] = None,
                  lifecycle_processors: Optional[List['BaseLifecycleEventProcessor']] = None,
                  initial_custom_data: Optional[Dict[str, Any]] = None,
-                 skills: Optional[List[str]] = None):
+                 skills: Optional[List[str]] = None,
+                 memory_dir: Optional[str] = None):
         """
         Initializes the AgentConfig.
 
@@ -71,6 +72,7 @@ class AgentConfig:
             initial_custom_data: An optional dictionary of data to pre-populate
                                  the agent's runtime state `custom_data`.
             skills: An optional list of skill names or paths to be preloaded for this agent.
+            memory_dir: Optional override for the agent memory base directory.
         """
         self.name = name
         self.role = role
@@ -91,6 +93,7 @@ class AgentConfig:
         self.lifecycle_processors = lifecycle_processors or []
         self.initial_custom_data = initial_custom_data
         self.skills = skills or []
+        self.memory_dir = memory_dir
 
         # Filter out ToolManifestInjectorProcessor if in API_TOOL_CALL mode
         tool_call_format = resolve_tool_call_format()
@@ -133,6 +136,7 @@ class AgentConfig:
             lifecycle_processors=self.lifecycle_processors.copy(), # Shallow copy the list
             initial_custom_data=copy.deepcopy(self.initial_custom_data), # Deep copy for simple data
             skills=self.skills.copy(), # Shallow copy the list
+            memory_dir=self.memory_dir,
         )
 
     def __repr__(self) -> str:

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/agent/context/agent_runtime_state.py

@@ -21,6 +21,7 @@ if TYPE_CHECKING:
     from autobyteus.tools.base_tool import BaseTool 
     from autobyteus.agent.tool_invocation import ToolInvocationTurn
     from autobyteus.memory.memory_manager import MemoryManager
+    from autobyteus.memory.restore.working_context_snapshot_bootstrapper import WorkingContextSnapshotBootstrapOptions
 
 logger = logging.getLogger(__name__)
 
@@ -62,6 +63,7 @@ class AgentRuntimeState:
         # NEW: Memory manager and active turn tracking
         self.memory_manager: Optional["MemoryManager"] = None
         self.active_turn_id: Optional[str] = None
+        self.restore_options: Optional["WorkingContextSnapshotBootstrapOptions"] = None
         
         self.processed_system_prompt: Optional[str] = None
         # self.final_llm_config_for_creation removed

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/agent/factory/agent_factory.py

@@ -1,8 +1,6 @@
 # file: autobyteus/autobyteus/agent/factory/agent_factory.py
 import logging
 import random
-import os
-from pathlib import Path
 from typing import Optional, TYPE_CHECKING, Dict, List
 
 # LLMFactory is no longer needed here.
@@ -15,7 +13,9 @@ from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
 from autobyteus.agent.handlers import *
 from autobyteus.utils.singleton import SingletonMeta
 from autobyteus.tools.base_tool import BaseTool
-from autobyteus.memory import FileMemoryStore, MemoryManager
+from autobyteus.memory import FileMemoryStore, MemoryManager, resolve_memory_base_dir
+from autobyteus.memory.store.working_context_snapshot_store import WorkingContextSnapshotStore
+from autobyteus.memory.restore.working_context_snapshot_bootstrapper import WorkingContextSnapshotBootstrapOptions
 from autobyteus.agent.input_processor.memory_ingest_input_processor import MemoryIngestInputProcessor
 from autobyteus.agent.tool_execution_result_processor.memory_ingest_tool_result_processor import (
     MemoryIngestToolResultProcessor,
@@ -105,10 +105,12 @@ class AgentFactory(metaclass=SingletonMeta):
         
         config.skills = updated_skills
 
-    def _create_runtime(self, 
-                        agent_id: str, 
-                        config: AgentConfig
-                        ) -> 'AgentRuntime': 
+    def _create_runtime_with_id(self,
+                                agent_id: str,
+                                config: AgentConfig,
+                                memory_dir_override: Optional[str] = None,
+                                restore_options: Optional[WorkingContextSnapshotBootstrapOptions] = None
+                                ) -> 'AgentRuntime':
         from autobyteus.agent.runtime.agent_runtime import AgentRuntime 
 
         # Prepare skills (resolve paths to names and register them)
@@ -122,11 +124,11 @@ class AgentFactory(metaclass=SingletonMeta):
         )
 
         # Memory manager (file-backed) initialization
-        memory_dir = os.getenv("AUTOBYTEUS_MEMORY_DIR")
-        if memory_dir is None:
-            memory_dir = str(Path.cwd() / "memory")
+        memory_dir = resolve_memory_base_dir(override_dir=memory_dir_override or config.memory_dir)
         memory_store = FileMemoryStore(base_dir=memory_dir, agent_id=agent_id)
-        runtime_state.memory_manager = MemoryManager(store=memory_store)
+        working_context_snapshot_store = WorkingContextSnapshotStore(base_dir=memory_dir, agent_id=agent_id)
+        runtime_state.memory_manager = MemoryManager(store=memory_store, working_context_snapshot_store=working_context_snapshot_store)
+        runtime_state.restore_options = restore_options
 
         # Ensure memory ingest processors are present
         if not any(isinstance(p, MemoryIngestInputProcessor) for p in config.input_processors):
@@ -146,7 +148,7 @@ class AgentFactory(metaclass=SingletonMeta):
         logger.info(f"Instantiating AgentRuntime for agent_id: '{agent_id}' with config: '{config.name}'.")
         
         return AgentRuntime(
-            context=context, 
+            context=context,
             event_handler_registry=event_handler_registry
         )
 
@@ -166,7 +168,7 @@ class AgentFactory(metaclass=SingletonMeta):
         while agent_id in self._active_agents:
             agent_id = f"{config.name}_{config.role}_{random.randint(1000, 9999)}"
 
-        runtime = self._create_runtime(
+        runtime = self._create_runtime_with_id(
             agent_id=agent_id,
             config=config,
         )
@@ -176,6 +178,29 @@ class AgentFactory(metaclass=SingletonMeta):
         logger.info(f"Agent '{agent_id}' created and stored successfully.")
         return agent
 
+    def restore_agent(
+        self,
+        agent_id: str,
+        config: AgentConfig,
+        memory_dir: Optional[str] = None,
+    ) -> Agent:
+        if not agent_id or not isinstance(agent_id, str):
+            raise ValueError("restore_agent requires a non-empty string agent_id.")
+        if agent_id in self._active_agents:
+            raise ValueError(f"Agent '{agent_id}' is already active.")
+
+        restore_options = WorkingContextSnapshotBootstrapOptions()
+        runtime = self._create_runtime_with_id(
+            agent_id=agent_id,
+            config=config,
+            memory_dir_override=memory_dir,
+            restore_options=restore_options,
+        )
+        agent = Agent(runtime=runtime)
+        self._active_agents[agent_id] = agent
+        logger.info(f"Agent '{agent_id}' restored and stored successfully.")
+        return agent
+
     def get_agent(self, agent_id: str) -> Optional[Agent]:
         """Retrieves an active agent instance by its ID."""
         return self._active_agents.get(agent_id)

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/agent/input_processor/memory_ingest_input_processor.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING
 
 from autobyteus.agent.input_processor.base_user_input_processor import BaseAgentUserInputMessageProcessor
 from autobyteus.agent.message.multimodal_message_builder import build_llm_user_message
+from autobyteus.agent.sender_type import SenderType
 
 if TYPE_CHECKING:
     from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
@@ -26,6 +27,9 @@ class MemoryIngestInputProcessor(BaseAgentUserInputMessageProcessor):
         memory_manager = getattr(context.state, "memory_manager", None)
         if not memory_manager:
             return message
+        if message.sender_type == SenderType.TOOL:
+            logger.debug("MemoryIngestInputProcessor skipping TOOL-originated message to avoid duplicate tool results.")
+            return message
 
         turn_id = memory_manager.start_turn()
         context.state.active_turn_id = turn_id

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/agent/llm_request_assembler.py

@@ -60,12 +60,12 @@ class LLMRequestAssembler:
                     bundle=bundle,
                     raw_tail=raw_tail,
                 )
-                self.memory_manager.reset_transcript(snapshot_messages)
+                self.memory_manager.reset_working_context_snapshot(snapshot_messages)
                 self.memory_manager.clear_compaction_request()
                 did_compact = True
 
-        self.memory_manager.active_transcript.append_message(user_message)
-        final_messages = self.memory_manager.get_transcript_messages()
+        self.memory_manager.working_context_snapshot.append_message(user_message)
+        final_messages = self.memory_manager.get_working_context_messages()
         rendered_payload = await self.render_payload(final_messages)
 
         return RequestPackage(
@@ -91,8 +91,8 @@ class LLMRequestAssembler:
     def _ensure_system_prompt(self, system_prompt: Optional[str]) -> None:
         if not system_prompt:
             return
-        existing = self.memory_manager.get_transcript_messages()
+        existing = self.memory_manager.get_working_context_messages()
         if not existing:
-            self.memory_manager.active_transcript.append_message(
+            self.memory_manager.working_context_snapshot.append_message(
                 Message(role=MessageRole.SYSTEM, content=system_prompt)
             )

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/agent/streaming/segments/segment_events.py

@@ -17,6 +17,7 @@ class SegmentType(str, Enum):
     PATCH_FILE = "patch_file"
     RUN_BASH = "run_bash"
     REASONING = "reasoning"
+    MEDIA = "media"
 
 
 class SegmentEventType(str, Enum):

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/memory/__init__.py

@@ -12,6 +12,7 @@ from autobyteus.memory.compaction.compaction_result import CompactionResult
 from autobyteus.memory.compaction.summarizer import Summarizer
 from autobyteus.memory.retrieval.memory_bundle import MemoryBundle
 from autobyteus.memory.retrieval.retriever import Retriever
+from autobyteus.memory.path_resolver import resolve_memory_base_dir, resolve_agent_memory_dir
 
 __all__ = [
     "MemoryType",
@@ -29,4 +30,6 @@ __all__ = [
     "Summarizer",
     "MemoryBundle",
     "Retriever",
+    "resolve_memory_base_dir",
+    "resolve_agent_memory_dir",
 ]

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/memory/memory_manager.py

@@ -13,8 +13,10 @@ from autobyteus.memory.compaction.compactor import Compactor
 from autobyteus.memory.retrieval.retriever import Retriever
 from autobyteus.memory.store.base_store import MemoryStore
 from autobyteus.memory.turn_tracker import TurnTracker
-from autobyteus.memory.active_transcript import ActiveTranscript
+from autobyteus.memory.working_context_snapshot import WorkingContextSnapshot
 from autobyteus.memory.tool_interaction_builder import build_tool_interactions
+from autobyteus.memory.working_context_snapshot_serializer import WorkingContextSnapshotSerializer
+from autobyteus.memory.store.working_context_snapshot_store import WorkingContextSnapshotStore
 
 
 class MemoryManager:
@@ -25,7 +27,8 @@ class MemoryManager:
         compaction_policy: Optional[CompactionPolicy] = None,
         compactor: Optional[Compactor] = None,
         retriever: Optional[Retriever] = None,
-        active_transcript: Optional[ActiveTranscript] = None,
+        working_context_snapshot: Optional[WorkingContextSnapshot] = None,
+        working_context_snapshot_store: Optional[WorkingContextSnapshotStore] = None,
     ):
         self.store = store
         self.turn_tracker = turn_tracker or TurnTracker()
@@ -34,8 +37,9 @@ class MemoryManager:
         self.retriever = retriever or Retriever(store=store)
         self.memory_types = MemoryType
         self._seq_by_turn: dict[str, int] = {}
-        self.active_transcript = active_transcript or ActiveTranscript()
+        self.working_context_snapshot = working_context_snapshot or WorkingContextSnapshot()
         self.compaction_required: bool = False
+        self.working_context_snapshot_store = working_context_snapshot_store
 
     def start_turn(self) -> str:
         return self.turn_tracker.next_turn_id()
@@ -86,7 +90,7 @@ class MemoryManager:
             tool_args=tool_invocation.arguments,
         )
         self.store.add([trace])
-        self.active_transcript.append_tool_calls(
+        self.working_context_snapshot.append_tool_calls(
             [ToolCallSpec(id=tool_invocation.id, name=tool_invocation.name, arguments=tool_invocation.arguments)]
         )
 
@@ -109,7 +113,7 @@ class MemoryManager:
             tool_error=event.error,
         )
         self.store.add([trace])
-        self.active_transcript.append_tool_result(
+        self.working_context_snapshot.append_tool_result(
             tool_call_id=event.tool_invocation_id or "",
             tool_name=event.tool_name,
             tool_result=event.result,
@@ -129,10 +133,11 @@ class MemoryManager:
         )
         self.store.add([trace])
         if response.content or response.reasoning:
-            self.active_transcript.append_assistant(
+            self.working_context_snapshot.append_assistant(
                 content=response.content,
                 reasoning=response.reasoning,
             )
+        self.persist_working_context_snapshot()
 
     def _get_raw_tail(self, tail_turns: int, exclude_turn_id: Optional[str] = None) -> List[RawTraceItem]:
         raw_items = self.store.list(MemoryType.RAW_TRACE)
@@ -167,11 +172,28 @@ class MemoryManager:
     def get_raw_tail(self, tail_turns: int, exclude_turn_id: Optional[str] = None) -> List[RawTraceItem]:
         return self._get_raw_tail(tail_turns, exclude_turn_id=exclude_turn_id)
 
-    def get_transcript_messages(self):
-        return self.active_transcript.build_messages()
+    def get_working_context_messages(self):
+        return self.working_context_snapshot.build_messages()
+
+    def reset_working_context_snapshot(self, snapshot_messages):
+        self.working_context_snapshot.reset(snapshot_messages)
+        self.persist_working_context_snapshot()
+
+    def persist_working_context_snapshot(self) -> None:
+        if not self.working_context_snapshot_store:
+            return
+        agent_id = getattr(self.working_context_snapshot_store, "agent_id", None) or getattr(self.store, "agent_id", None)
+        if not agent_id:
+            return
+        metadata = {
+            "schema_version": 1,
+            "agent_id": agent_id,
+            "epoch_id": self.working_context_snapshot.epoch_id,
+            "last_compaction_ts": self.working_context_snapshot.last_compaction_ts,
+        }
+        payload = WorkingContextSnapshotSerializer.serialize(self.working_context_snapshot, metadata)
+        self.working_context_snapshot_store.write(agent_id, payload)
 
-    def reset_transcript(self, snapshot_messages):
-        self.active_transcript.reset(snapshot_messages)
 
     def get_tool_interactions(self, turn_id: Optional[str] = None):
         raw_items = self.store.list(MemoryType.RAW_TRACE)

autobyteus-1.3.0/autobyteus/memory/path_resolver.py

@@ -0,0 +1,27 @@
+import os
+from pathlib import Path
+from typing import Mapping, Optional, Union
+
+
+def resolve_memory_base_dir(
+    override_dir: Optional[str] = None,
+    env: Optional[Mapping[str, str]] = None,
+    fallback_dir: Optional[Union[str, Path]] = None,
+) -> str:
+    override_value = override_dir.strip() if override_dir else ""
+    if override_value:
+        return override_value
+
+    env_values = env if env is not None else os.environ
+    env_value = env_values.get("AUTOBYTEUS_MEMORY_DIR", "").strip()
+    if env_value:
+        return env_value
+
+    if fallback_dir is not None:
+        return str(fallback_dir)
+
+    return str(Path.cwd() / "memory")
+
+
+def resolve_agent_memory_dir(base_dir: Union[str, Path], agent_id: str) -> str:
+    return str(Path(base_dir) / "agents" / agent_id)

autobyteus-1.3.0/autobyteus/memory/restore/__init__.py

@@ -0,0 +1 @@
+# restore package

autobyteus-1.3.0/autobyteus/memory/restore/working_context_snapshot_bootstrapper.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from autobyteus.memory.working_context_snapshot_serializer import WorkingContextSnapshotSerializer
+from autobyteus.memory.compaction_snapshot_builder import CompactionSnapshotBuilder
+from autobyteus.memory.store.working_context_snapshot_store import WorkingContextSnapshotStore
+
+
+@dataclass
+class WorkingContextSnapshotBootstrapOptions:
+    max_episodic: int = 3
+    max_semantic: int = 20
+    raw_tail_turns: Optional[int] = None
+
+
+class WorkingContextSnapshotBootstrapper:
+    def __init__(
+        self,
+        working_context_snapshot_store: Optional[WorkingContextSnapshotStore] = None,
+        snapshot_builder: Optional[CompactionSnapshotBuilder] = None,
+    ) -> None:
+        self.working_context_snapshot_store = working_context_snapshot_store
+        self.snapshot_builder = snapshot_builder or CompactionSnapshotBuilder()
+
+    def bootstrap(self, memory_manager, system_prompt: str, options: WorkingContextSnapshotBootstrapOptions) -> None:
+        store = self._resolve_store(memory_manager)
+        agent_id = self._resolve_agent_id(memory_manager, store)
+
+        if store and agent_id and store.exists(agent_id):
+            payload = store.read(agent_id)
+            if payload and WorkingContextSnapshotSerializer.validate(payload):
+                snapshot, _meta = WorkingContextSnapshotSerializer.deserialize(payload)
+                memory_manager.reset_working_context_snapshot(snapshot.build_messages())
+                return
+
+        bundle = memory_manager.retriever.retrieve(
+            max_episodic=options.max_episodic,
+            max_semantic=options.max_semantic,
+        )
+        tail_turns = options.raw_tail_turns
+        if tail_turns is None:
+            policy = getattr(memory_manager, "compaction_policy", None)
+            tail_turns = getattr(policy, "raw_tail_turns", 0) if policy else 0
+        raw_tail = memory_manager.get_raw_tail(tail_turns or 0, exclude_turn_id=None)
+        snapshot_messages = self.snapshot_builder.build(
+            system_prompt=system_prompt,
+            bundle=bundle,
+            raw_tail=raw_tail,
+        )
+        memory_manager.reset_working_context_snapshot(snapshot_messages)
+
+    def _resolve_store(self, memory_manager) -> Optional[WorkingContextSnapshotStore]:
+        if self.working_context_snapshot_store is not None:
+            return self.working_context_snapshot_store
+        return getattr(memory_manager, "working_context_snapshot_store", None)
+
+    def _resolve_agent_id(self, memory_manager, store: Optional[WorkingContextSnapshotStore]) -> Optional[str]:
+        if store and getattr(store, "agent_id", None):
+            return store.agent_id
+        store_obj = getattr(memory_manager, "store", None)
+        return getattr(store_obj, "agent_id", None)

{autobyteus-1.2.3 → autobyteus-1.3.0}/autobyteus/memory/store/__init__.py

@@ -1,7 +1,9 @@
 from autobyteus.memory.store.base_store import MemoryStore
 from autobyteus.memory.store.file_store import FileMemoryStore
+from autobyteus.memory.store.working_context_snapshot_store import WorkingContextSnapshotStore
 
 __all__ = [
     "MemoryStore",
     "FileMemoryStore",
+    "WorkingContextSnapshotStore",
 ]

autobyteus-1.3.0/autobyteus/memory/store/working_context_snapshot_store.py

@@ -0,0 +1,28 @@
+import json
+from pathlib import Path
+from typing import Optional, Union, Dict, Any
+
+
+class WorkingContextSnapshotStore:
+    def __init__(self, base_dir: Union[str, Path], agent_id: str) -> None:
+        self.base_dir = Path(base_dir)
+        self.agent_id = agent_id
+
+    def exists(self, agent_id: str) -> bool:
+        return self._get_path(agent_id).exists()
+
+    def read(self, agent_id: str) -> Optional[Dict[str, Any]]:
+        path = self._get_path(agent_id)
+        if not path.exists():
+            return None
+        with path.open("r", encoding="utf-8") as handle:
+            return json.load(handle)
+
+    def write(self, agent_id: str, payload: Dict[str, Any]) -> None:
+        path = self._get_path(agent_id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("w", encoding="utf-8") as handle:
+            json.dump(payload, handle)
+
+    def _get_path(self, agent_id: str) -> Path:
+        return self.base_dir / "agents" / agent_id / "working_context_snapshot.json"

autobyteus-1.2.3/autobyteus/memory/active_transcript.py → autobyteus-1.3.0/autobyteus/memory/working_context_snapshot.py

@@ -10,7 +10,7 @@ from autobyteus.llm.utils.messages import (
 )
 
 
-class ActiveTranscript:
+class WorkingContextSnapshot:
     def __init__(self, initial_messages: Optional[Iterable[Message]] = None):
         self._messages: List[Message] = list(initial_messages) if initial_messages else []
         self.epoch_id: int = 1