massgen 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

massgen/orchestrator.py

@@ -42,6 +42,7 @@ from .logger_config import (
     log_stream_chunk,
     log_tool_call,
 )
+from .memory import ConversationMemory, PersistentMemoryBase
 from .message_templates import MessageTemplates
 from .stream_chunk import ChunkType
 from .tool import get_post_evaluation_tools, get_workflow_tools
@@ -118,6 +119,9 @@ class Orchestrator(ChatAgent):
         snapshot_storage: Optional[str] = None,
         agent_temporary_workspace: Optional[str] = None,
         previous_turns: Optional[List[Dict[str, Any]]] = None,
+        winning_agents_history: Optional[List[Dict[str, Any]]] = None,
+        shared_conversation_memory: Optional[ConversationMemory] = None,
+        shared_persistent_memory: Optional[PersistentMemoryBase] = None,
     ):
         """
         Initialize MassGen orchestrator.
@@ -130,13 +134,22 @@ class Orchestrator(ChatAgent):
             snapshot_storage: Optional path to store agent workspace snapshots
             agent_temporary_workspace: Optional path for agent temporary workspaces
             previous_turns: List of previous turn metadata for multi-turn conversations (loaded by CLI)
+            winning_agents_history: List of previous winning agents for memory sharing
+                                   Format: [{"agent_id": "agent_b", "turn": 1}, ...]
+                                   Loaded from session storage to persist across orchestrator recreations
+            shared_conversation_memory: Optional shared conversation memory for all agents
+            shared_persistent_memory: Optional shared persistent memory for all agents
         """
-        super().__init__(session_id)
+        super().__init__(session_id, shared_conversation_memory, shared_persistent_memory)
         self.orchestrator_id = orchestrator_id
         self.agents = agents
         self.agent_states = {aid: AgentState() for aid in agents.keys()}
         self.config = config or AgentConfig.create_openai_config()
 
+        # Shared memory for all agents
+        self.shared_conversation_memory = shared_conversation_memory
+        self.shared_persistent_memory = shared_persistent_memory
+
         # Get message templates from config
         self.message_templates = self.config.message_templates or MessageTemplates(
             voting_sensitivity=self.config.voting_sensitivity,
@@ -158,6 +171,14 @@ class Orchestrator(ChatAgent):
         self._selected_agent: Optional[str] = None
         self._final_presentation_content: Optional[str] = None
 
+        # Track winning agents by turn for memory sharing
+        # Format: [{"agent_id": "agent_b", "turn": 1}, {"agent_id": "agent_a", "turn": 2}]
+        # Restore from session storage if provided (for multi-turn persistence)
+        self._winning_agents_history: List[Dict[str, Any]] = winning_agents_history or []
+        if self._winning_agents_history:
+            logger.info(f"📚 Restored {len(self._winning_agents_history)} winning agent(s) from session: {self._winning_agents_history}")
+        self._current_turn: int = 0
+
         # Timeout and resource tracking
         self.total_tokens: int = 0
         self.coordination_start_time: float = 0
@@ -365,6 +386,113 @@ class Orchestrator(ChatAgent):
             "full_messages": messages,
         }
 
+    async def _inject_shared_memory_context(
+        self,
+        messages: List[Dict[str, Any]],
+        agent_id: str,
+    ) -> List[Dict[str, Any]]:
+        """
+        Inject shared memory context into agent messages.
+
+        This allows all agents to see shared memories including what other agents
+        have stored in the shared memory.
+
+        Args:
+            messages: Original messages to send to agent
+            agent_id: ID of the agent receiving the messages
+
+        Returns:
+            Messages with shared memory context injected
+        """
+        if not self.shared_conversation_memory and not self.shared_persistent_memory:
+            # No shared memory configured, return original messages
+            return messages
+
+        memory_context_parts = []
+
+        # Get conversation memory content
+        if self.shared_conversation_memory:
+            try:
+                conv_messages = await self.shared_conversation_memory.get_messages()
+                if conv_messages:
+                    memory_context_parts.append("=== SHARED CONVERSATION MEMORY ===")
+                    for msg in conv_messages[-10:]:  # Last 10 messages
+                        role = msg.get("role", "unknown")
+                        content = msg.get("content", "")
+                        agent_source = msg.get("agent_id", "unknown")
+                        memory_context_parts.append(f"[{agent_source}] {role}: {content}")
+            except Exception as e:
+                logger.warning(f"Failed to retrieve shared conversation memory: {e}")
+
+        # Get persistent memory content
+        if self.shared_persistent_memory:
+            try:
+                # Extract user message for retrieval
+                user_messages = [msg for msg in messages if msg.get("role") == "user"]
+                if user_messages:
+                    retrieved = await self.shared_persistent_memory.retrieve(user_messages)
+                    if retrieved:
+                        memory_context_parts.append("\n=== SHARED PERSISTENT MEMORY ===")
+                        memory_context_parts.append(retrieved)
+            except NotImplementedError:
+                # Memory backend doesn't support retrieve
+                pass
+            except Exception as e:
+                logger.warning(f"Failed to retrieve shared persistent memory: {e}")
+
+        # Inject memory context if we have any
+        if memory_context_parts:
+            memory_message = {
+                "role": "system",
+                "content": ("You have access to shared memory that all agents can see and contribute to.\n" + "\n".join(memory_context_parts)),
+            }
+
+            # Insert after existing system messages but before user messages
+            system_count = sum(1 for msg in messages if msg.get("role") == "system")
+            modified_messages = messages.copy()
+            modified_messages.insert(system_count, memory_message)
+            return modified_messages
+
+        return messages
+
+    async def _record_to_shared_memory(
+        self,
+        agent_id: str,
+        content: str,
+        role: str = "assistant",
+    ) -> None:
+        """
+        Record agent's contribution to shared memory.
+
+        Args:
+            agent_id: ID of the agent contributing
+            content: Content to record
+            role: Role of the message (default: "assistant")
+        """
+        message = {
+            "role": role,
+            "content": content,
+            "agent_id": agent_id,
+            "timestamp": time.time(),
+        }
+
+        # Add to conversation memory
+        if self.shared_conversation_memory:
+            try:
+                await self.shared_conversation_memory.add(message)
+            except Exception as e:
+                logger.warning(f"Failed to add to shared conversation memory: {e}")
+
+        # Record to persistent memory
+        if self.shared_persistent_memory:
+            try:
+                await self.shared_persistent_memory.record([message])
+            except NotImplementedError:
+                # Memory backend doesn't support record
+                pass
+            except Exception as e:
+                logger.warning(f"Failed to record to shared persistent memory: {e}")
+
     def save_coordination_logs(self):
         """Public method to save coordination logs after final presentation is complete."""
         # End the coordination session
@@ -798,6 +926,18 @@ Your answer:"""
         current_answers = {aid: state.answer for aid, state in self.agent_states.items() if state.answer}
         self._selected_agent = self._determine_final_agent_from_votes(votes, current_answers)
 
+        # Track winning agent for memory sharing in future turns
+        self._current_turn += 1
+        if self._selected_agent:
+            winner_entry = {
+                "agent_id": self._selected_agent,
+                "turn": self._current_turn,
+            }
+            self._winning_agents_history.append(winner_entry)
+            logger.info(
+                f"🏆 Turn {self._current_turn} winner: {self._selected_agent} " f"(tracked for memory sharing)",
+            )
+
         log_coordination_step(
             "Final agent selected",
             {"selected_agent": self._selected_agent, "votes": votes},
@@ -1806,6 +1946,13 @@ Your answer:"""
                 {"role": "system", "content": conversation["system_message"]},
                 {"role": "user", "content": conversation["user_message"]},
             ]
+
+            # Inject shared memory context
+            conversation_messages = await self._inject_shared_memory_context(
+                conversation_messages,
+                agent_id,
+            )
+
             enforcement_msg = self.message_templates.enforcement_message()
 
             # Update agent status to STREAMING
@@ -1832,20 +1979,42 @@ Your answer:"""
                     # First attempt: orchestrator provides initial conversation
                     # But we need the agent to have this in its history for subsequent calls
                     # First attempt: provide complete conversation and reset agent's history
-                    chat_stream = agent.chat(conversation_messages, self.workflow_tools, reset_chat=True, current_stage=CoordinationStage.INITIAL_ANSWER)
+                    # Pass current turn and previous winners for memory sharing
+                    chat_stream = agent.chat(
+                        conversation_messages,
+                        self.workflow_tools,
+                        reset_chat=True,
+                        current_stage=CoordinationStage.INITIAL_ANSWER,
+                        orchestrator_turn=self._current_turn + 1,  # Next turn number
+                        previous_winners=self._winning_agents_history.copy(),
+                    )
                 else:
                     # Subsequent attempts: send enforcement message (set by error handling)
 
                     if isinstance(enforcement_msg, list):
                         # Tool message array
-                        chat_stream = agent.chat(enforcement_msg, self.workflow_tools, reset_chat=False, current_stage=CoordinationStage.ENFORCEMENT)
+                        chat_stream = agent.chat(
+                            enforcement_msg,
+                            self.workflow_tools,
+                            reset_chat=False,
+                            current_stage=CoordinationStage.ENFORCEMENT,
+                            orchestrator_turn=self._current_turn + 1,
+                            previous_winners=self._winning_agents_history.copy(),
+                        )
                     else:
                         # Single user message
                         enforcement_message = {
                             "role": "user",
                             "content": enforcement_msg,
                         }
-                        chat_stream = agent.chat([enforcement_message], self.workflow_tools, reset_chat=False, current_stage=CoordinationStage.ENFORCEMENT)
+                        chat_stream = agent.chat(
+                            [enforcement_message],
+                            self.workflow_tools,
+                            reset_chat=False,
+                            current_stage=CoordinationStage.ENFORCEMENT,
+                            orchestrator_turn=self._current_turn + 1,
+                            previous_winners=self._winning_agents_history.copy(),
+                        )
                 response_text = ""
                 tool_calls = []
                 workflow_tool_found = False
@@ -2101,6 +2270,14 @@ Your answer:"""
                                 "reason": reason,
                             }
 
+                            # Record vote to shared memory
+                            vote_message = f"Voted for {voted_agent}. Reason: {reason}"
+                            await self._record_to_shared_memory(
+                                agent_id=agent_id,
+                                content=vote_message,
+                                role="assistant",
+                            )
+
                             # Send tool result - orchestrator will decide if vote is accepted
                             # Vote submitted (result will be shown by orchestrator)
                             yield (
@@ -2193,6 +2370,14 @@ Your answer:"""
                                         return
                             # Send successful tool result back to agent
                             # Answer recorded (result will be shown by orchestrator)
+
+                            # Record to shared memory
+                            await self._record_to_shared_memory(
+                                agent_id=agent_id,
+                                content=content,
+                                role="assistant",
+                            )
+
                             yield ("result", ("answer", content))
                             yield ("done", None)
                             return
@@ -2513,6 +2698,20 @@ INSTRUCTIONS FOR NEXT ATTEMPT:
         elif hasattr(agent, "backend") and hasattr(agent.backend, "backend_params"):
             enable_audio_generation = agent.backend.backend_params.get("enable_audio_generation", False)
 
+        # Check if file generation is enabled for this agent
+        enable_file_generation = False
+        if hasattr(agent, "config") and agent.config:
+            enable_file_generation = agent.config.backend_params.get("enable_file_generation", False)
+        elif hasattr(agent, "backend") and hasattr(agent.backend, "backend_params"):
+            enable_file_generation = agent.backend.backend_params.get("enable_file_generation", False)
+
+        # Check if video generation is enabled for this agent
+        enable_video_generation = False
+        if hasattr(agent, "config") and agent.config:
+            enable_video_generation = agent.config.backend_params.get("enable_video_generation", False)
+        elif hasattr(agent, "backend") and hasattr(agent.backend, "backend_params"):
+            enable_video_generation = agent.backend.backend_params.get("enable_video_generation", False)
+
         # Check if agent has write access to context paths (requires file delivery)
         has_irreversible_actions = False
         if agent.backend.filesystem_manager:
@@ -2525,6 +2724,8 @@ INSTRUCTIONS FOR NEXT ATTEMPT:
             agent_system_message,
             enable_image_generation,
             enable_audio_generation,
+            enable_file_generation,
+            enable_video_generation,
             has_irreversible_actions,
             enable_command_execution,
         )
@@ -2607,7 +2808,13 @@ INSTRUCTIONS FOR NEXT ATTEMPT:
 
         try:
             # Track final round iterations (each chunk is like an iteration)
-            async for chunk in agent.chat(presentation_messages, reset_chat=True, current_stage=CoordinationStage.PRESENTATION):
+            async for chunk in agent.chat(
+                presentation_messages,
+                reset_chat=True,
+                current_stage=CoordinationStage.PRESENTATION,
+                orchestrator_turn=self._current_turn,
+                previous_winners=self._winning_agents_history.copy(),
+            ):
                 chunk_type = self._get_chunk_type_value(chunk)
                 # Start new iteration for this chunk
                 self.coordination_tracker.start_new_iteration()
@@ -2856,7 +3063,14 @@ Then call either submit(confirmed=True) if the answer is satisfactory, or restar
         try:
             timeout_seconds = self.config.timeout_config.orchestrator_timeout_seconds
             async with asyncio.timeout(timeout_seconds):
-                async for chunk in agent.chat(messages=evaluation_messages, tools=post_eval_tools, reset_chat=True, current_stage=CoordinationStage.POST_EVALUATION):
+                async for chunk in agent.chat(
+                    messages=evaluation_messages,
+                    tools=post_eval_tools,
+                    reset_chat=True,
+                    current_stage=CoordinationStage.POST_EVALUATION,
+                    orchestrator_turn=self._current_turn,
+                    previous_winners=self._winning_agents_history.copy(),
+                ):
                     chunk_type = self._get_chunk_type_value(chunk)
 
                     if chunk_type == "content" and chunk.content:
@@ -3087,7 +3301,8 @@ Then call either submit(confirmed=True) if the answer is satisfactory, or restar
         Get final result for session persistence.
 
         Returns:
-            Dict with final_answer, winning_agent_id, and workspace_path, or None if not available
+            Dict with final_answer, winning_agent_id, workspace_path, and winning_agents_history,
+            or None if not available
         """
         if not self._selected_agent or not self._final_presentation_content:
             return None
@@ -3101,6 +3316,7 @@ Then call either submit(confirmed=True) if the answer is satisfactory, or restar
             "final_answer": self._final_presentation_content,
             "winning_agent_id": self._selected_agent,
             "workspace_path": workspace_path,
+            "winning_agents_history": self._winning_agents_history.copy(),  # For cross-turn memory sharing
         }
 
     def get_status(self) -> Dict[str, Any]:

massgen/tests/memory/test_agent_compression.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Test Context Compression at Agent Level
+
+This script tests compression with a SingleAgent directly (not through orchestrator).
+It creates many messages to trigger compression and verifies it works.
+
+Usage:
+    uv run python massgen/configs/memory/test_agent_compression.py
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
+
+from dotenv import load_dotenv  # noqa: E402
+
+from massgen.backend.chat_completions import ChatCompletionsBackend  # noqa: E402
+from massgen.chat_agent import SingleAgent  # noqa: E402
+from massgen.memory import ConversationMemory, PersistentMemory  # noqa: E402
+from massgen.memory._context_monitor import ContextWindowMonitor  # noqa: E402
+
+load_dotenv()
+
+
+async def main():
+    """Test compression with a single agent."""
+    print("=" * 80)
+    print("Testing Context Compression at Agent Level")
+    print("=" * 80 + "\n")
+
+    # Check API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("❌ Error: OPENAI_API_KEY not set")
+        return
+
+    # Configuration
+    model_name = "gpt-4o-mini"
+    provider = "openai"
+    trigger_threshold = 0.05  # Trigger at 5% for quick testing
+    target_ratio = 0.02  # Keep only 2% after compression
+
+    print("Configuration:")
+    print(f"  Model: {model_name}")
+    print(f"  Trigger: {trigger_threshold*100:.0f}%")
+    print(f"  Target: {target_ratio*100:.0f}%\n")
+
+    # 1. Create backend
+    backend = ChatCompletionsBackend(
+        type=provider,
+        model=model_name,
+        api_key=os.getenv("OPENAI_API_KEY"),
+    )
+
+    # 2. Create memories
+    conversation_memory = ConversationMemory()
+
+    embedding_backend = ChatCompletionsBackend(
+        type="openai",
+        model="text-embedding-3-small",
+        api_key=os.getenv("OPENAI_API_KEY"),
+    )
+
+    persistent_memory = PersistentMemory(
+        agent_name="test_compression_agent",
+        session_name="test_session",
+        llm_backend=backend,
+        embedding_backend=embedding_backend,
+        on_disk=False,  # In-memory for testing
+    )
+
+    print("✅ Memories created")
+
+    # 3. Create context monitor
+    monitor = ContextWindowMonitor(
+        model_name=model_name,
+        provider=provider,
+        trigger_threshold=trigger_threshold,
+        target_ratio=target_ratio,
+        enabled=True,
+    )
+
+    print(f"✅ Monitor created (window: {monitor.context_window:,} tokens)")
+    print(f"   Will warn at: {int(monitor.context_window * trigger_threshold):,} tokens\n")
+
+    # 4. Create agent with monitor
+    agent = SingleAgent(
+        backend=backend,
+        agent_id="test_agent",
+        system_message="You are a helpful assistant. Provide detailed, thorough responses.",
+        conversation_memory=conversation_memory,
+        persistent_memory=persistent_memory,
+        context_monitor=monitor,
+    )
+
+    # Verify compressor was created
+    if agent.context_compressor:
+        print("✅ Context compressor created!\n")
+    else:
+        print("❌ Context compressor NOT created!\n")
+        return
+
+    # 5. Simulate multiple turns to fill context
+    print("=" * 80)
+    print("Simulating conversation to trigger compression...")
+    print("=" * 80 + "\n")
+
+    # Create several turns with verbose responses
+    prompts = [
+        "Explain how Python's garbage collection works in detail.",
+        "Now explain Python's Global Interpreter Lock (GIL) in detail.",
+        "Explain Python's asyncio event loop architecture in detail.",
+        "Explain Python's descriptor protocol in detail.",
+        "Explain Python's metaclasses and how they work in detail.",
+    ]
+
+    for i, prompt in enumerate(prompts, 1):
+        print(f"\n--- Turn {i} ---")
+        print(f"User: {prompt[:60]}...")
+
+        # Check context before turn
+        current_messages = await conversation_memory.get_messages()
+        print(f"Messages before turn: {len(current_messages)}")
+
+        response_text = ""
+        async for chunk in agent.chat([{"role": "user", "content": prompt}]):
+            if chunk.type == "content" and chunk.content:
+                response_text += chunk.content
+
+        print(f"Response: {len(response_text)} chars")
+
+        # Check context after turn
+        current_messages = await conversation_memory.get_messages()
+        print(f"Messages after turn: {len(current_messages)}")
+
+        # Small delay between turns
+        await asyncio.sleep(0.5)
+
+    # 6. Show final statistics
+    print("\n" + "=" * 80)
+    print("Final Statistics")
+    print("=" * 80)
+
+    stats = monitor.get_stats()
+    print("\n📊 Monitor Stats:")
+    print(f"  Total turns: {stats['turn_count']}")
+    print(f"  Total tokens: {stats['total_tokens']:,}")
+    print(f"  Peak usage: {stats['peak_usage_percent']*100:.1f}%")
+
+    if agent.context_compressor:
+        comp_stats = agent.context_compressor.get_stats()
+        print("\n📦 Compression Stats:")
+        print(f"  Total compressions: {comp_stats['total_compressions']}")
+        print(f"  Messages removed: {comp_stats['total_messages_removed']}")
+        print(f"  Tokens removed: {comp_stats['total_tokens_removed']:,}")
+
+    final_messages = await conversation_memory.get_messages()
+    print("\n💾 Final Memory State:")
+    print(f"  Messages in conversation_memory: {len(final_messages)}")
+
+    print("\n" + "=" * 80)
+    if agent.context_compressor and comp_stats["total_compressions"] > 0:
+        print("✅ SUCCESS: Compression worked!")
+    else:
+        print("⚠️  No compression occurred (context may not have reached threshold)")
+    print("=" * 80 + "\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

massgen/{configs/tools → tests}/memory/test_context_window_management.py

@@ -21,12 +21,12 @@ from pathlib import Path
 # Add parent directory to path for imports
 sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
 
-import yaml
-from dotenv import load_dotenv
+import yaml  # noqa: E402
+from dotenv import load_dotenv  # noqa: E402
 
-from massgen.backend.chat_completions import ChatCompletionsBackend
-from massgen.chat_agent import SingleAgent
-from massgen.memory import ConversationMemory, PersistentMemory
+from massgen.backend.chat_completions import ChatCompletionsBackend  # noqa: E402
+from massgen.chat_agent import SingleAgent  # noqa: E402
+from massgen.memory import ConversationMemory, PersistentMemory  # noqa: E402
 
 # Load environment variables from .env file
 load_dotenv()
@@ -38,19 +38,19 @@ def load_config(config_path: str = None) -> dict:
         # Default to the config in same directory
         config_path = Path(__file__).parent / "gpt5mini_gemini_context_window_management.yaml"
 
-    with open(config_path, 'r') as f:
+    with open(config_path, "r") as f:
         return yaml.safe_load(f)
 
 
 async def test_with_persistent_memory(config: dict):
     """Test context compression with persistent memory enabled."""
     # Check if memory is enabled in config
-    memory_config = config.get('memory', {})
-    if not memory_config.get('enabled', True):
+    memory_config = config.get("memory", {})
+    if not memory_config.get("enabled", True):
         print("\n⚠️  Skipping: memory.enabled is false in config")
         return
 
-    persistent_enabled = memory_config.get('persistent_memory', {}).get('enabled', True)
+    persistent_enabled = memory_config.get("persistent_memory", {}).get("enabled", True)
     if not persistent_enabled:
         print("\n⚠️  Skipping: memory.persistent_memory.enabled is false in config")
         return
@@ -60,10 +60,10 @@ async def test_with_persistent_memory(config: dict):
     print("=" * 70 + "\n")
 
     # Get memory settings from config
-    persistent_config = memory_config.get('persistent_memory', {})
-    agent_name = persistent_config.get('agent_name', 'storyteller_agent')
-    session_name = persistent_config.get('session_name', 'test_session')
-    on_disk = persistent_config.get('on_disk', True)
+    persistent_config = memory_config.get("persistent_memory", {})
+    agent_name = persistent_config.get("agent_name", "storyteller_agent")
+    session_name = persistent_config.get("session_name", "test_session")
+    on_disk = persistent_config.get("on_disk", True)
 
     # Create LLM backend for both agent and memory
     llm_backend = ChatCompletionsBackend(
@@ -93,18 +93,17 @@ async def test_with_persistent_memory(config: dict):
     agent = SingleAgent(
         backend=llm_backend,
         agent_id="storyteller",
-        system_message="You are a creative storyteller. Create detailed, "
-                      "immersive narratives with rich descriptions.",
+        system_message="You are a creative storyteller. Create detailed, " "immersive narratives with rich descriptions.",
         conversation_memory=conversation_memory,
         persistent_memory=persistent_memory,
     )
 
     print("✅ Agent initialized with memory")
-    print(f"   - ConversationMemory: Active")
+    print("   - ConversationMemory: Active")
     print(f"   - PersistentMemory: Active (agent={agent_name}, session={session_name}, on_disk={on_disk})")
-    print(f"   - Model context window: 128,000 tokens")
-    print(f"   - Compression triggers at: 96,000 tokens (75%)")
-    print(f"   - Target after compression: 51,200 tokens (40%)\n")
+    print("   - Model context window: 128,000 tokens")
+    print("   - Compression triggers at: 96,000 tokens (75%)")
+    print("   - Target after compression: 51,200 tokens (40%)\n")
 
     # Simulate a conversation that will fill context
     # Each turn will add significant tokens
@@ -149,8 +148,8 @@ async def test_with_persistent_memory(config: dict):
 async def test_without_persistent_memory(config: dict):
     """Test context compression without persistent memory (warning case)."""
     # Check if we should run this test
-    memory_config = config.get('memory', {})
-    persistent_enabled = memory_config.get('persistent_memory', {}).get('enabled', True)
+    memory_config = config.get("memory", {})
+    persistent_enabled = memory_config.get("persistent_memory", {}).get("enabled", True)
 
     if persistent_enabled:
         # Skip if persistent memory is enabled - we already tested that scenario
@@ -182,9 +181,9 @@ async def test_without_persistent_memory(config: dict):
     )
 
     print("⚠️  Agent initialized WITHOUT persistent memory")
-    print(f"   - ConversationMemory: Active")
-    print(f"   - PersistentMemory: NONE")
-    print(f"   - This will trigger warning messages when context fills\n")
+    print("   - ConversationMemory: Active")
+    print("   - PersistentMemory: NONE")
+    print("   - This will trigger warning messages when context fills\n")
 
     # Shorter test - just trigger compression
     story_prompts = [
@@ -224,19 +223,19 @@ async def main(config_path: str = None):
     config = load_config(config_path)
 
     # Show memory configuration
-    memory_config = config.get('memory', {})
-    print(f"\n📋 Memory Configuration (from YAML):")
+    memory_config = config.get("memory", {})
+    print("\n📋 Memory Configuration (from YAML):")
     print(f"   - Enabled: {memory_config.get('enabled', True)}")
     print(f"   - Conversation Memory: {memory_config.get('conversation_memory', {}).get('enabled', True)}")
     print(f"   - Persistent Memory: {memory_config.get('persistent_memory', {}).get('enabled', True)}")
 
-    if memory_config.get('persistent_memory', {}).get('enabled', True):
-        pm_config = memory_config.get('persistent_memory', {})
+    if memory_config.get("persistent_memory", {}).get("enabled", True):
+        pm_config = memory_config.get("persistent_memory", {})
         print(f"   - Agent Name: {pm_config.get('agent_name', 'N/A')}")
         print(f"   - Session Name: {pm_config.get('session_name', 'N/A')}")
         print(f"   - On Disk: {pm_config.get('on_disk', True)}")
 
-    compression_config = memory_config.get('compression', {})
+    compression_config = memory_config.get("compression", {})
     print(f"   - Compression Trigger: {compression_config.get('trigger_threshold', 0.75)*100}%")
     print(f"   - Target After Compression: {compression_config.get('target_ratio', 0.40)*100}%\n")
 
@@ -265,6 +264,7 @@ async def main(config_path: str = None):
     except Exception as e:
         print(f"\n\n❌ Test failed with error: {e}")
         import traceback
+
         traceback.print_exc()
 
     print("\n" + "=" * 70)
@@ -279,7 +279,7 @@ if __name__ == "__main__":
     parser.add_argument(
         "--config",
         type=str,
-        help="Path to YAML config file (default: gpt5mini_gemini_context_window_management.yaml)"
+        help="Path to YAML config file (default: gpt5mini_gemini_context_window_management.yaml)",
     )
     args = parser.parse_args()