Add agent_id to config and update codebase to use config-based agent loading

- Add agent_id field to letta section in config.yaml and config.example.yaml
- Update get_letta_config() to include agent_id as required field
- Modify initialize_void() in bsky.py to load agent by ID instead of name lookup
- Update ensure_x_user_blocks_attached() to use config agent_id by default
- Update test_x_blocks.py to use configured agent_id
- Ensures consistent agent usage across all components instead of name-based lookups

This centralizes agent management and prevents issues with agent name mismatches
between different environments or when agent names change.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[e-mail]>

bsky.py

···
         description = "A block to store your understanding of users you talk to or observe on the bluesky social network."
     )
 
-    # Create the agent if it doesn't exist
-    logger.info("Creating/updating void agent...")
-    void_agent = upsert_agent(
-        CLIENT,
-        name = "void",
-        block_ids = [
-            persona_block.id,
-            human_block.id,
-            zeigeist_block.id,
-        ],
-        tags = ["social agent", "bluesky"],
-        model="openai/gpt-4o-mini",
-        embedding="openai/text-embedding-3-small",
-        description = "A social media agent trapped in the void.",
-        project_id = PROJECT_ID
-    )
+    # Get the configured void agent by ID
+    logger.info("Loading void agent from config...")
+    from config_loader import get_letta_config
+    letta_config = get_letta_config()
+    agent_id = letta_config['agent_id']
+    
+    try:
+        void_agent = CLIENT.agents.get(agent_id=agent_id)
+        logger.info(f"Successfully loaded void agent: {void_agent.name} ({agent_id})")
+    except Exception as e:
+        logger.error(f"Failed to load void agent {agent_id}: {e}")
+        logger.error("Please ensure the agent_id in config.yaml is correct")
+        raise e
     
     # Export agent state
     logger.info("Exporting agent state...")

config.example.yaml

···
   api_key: "your-letta-api-key-here"
   timeout: 600  # 10 minutes timeout for API calls
   project_id: "c82faea2-3ce8-4aa9-a220-b56433e62c92"  # Use your specific project ID
+  agent_id: "agent-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"  # Your void agent ID
 
 # Bluesky Configuration
 bluesky:

config_loader.py

···
         'api_key': config.get_required('letta.api_key', 'LETTA_API_KEY'),
         'timeout': config.get('letta.timeout', 600),
         'project_id': config.get_required('letta.project_id'),
+        'agent_id': config.get_required('letta.agent_id'),
     }
 
 def get_bluesky_config() -> Dict[str, Any]:

test_x_blocks.py

···
+#!/usr/bin/env python3
+"""Test script for X user block management functionality."""
+
+import sys
+import json
+from pathlib import Path
+
+# Add the current directory to path so we can import modules
+sys.path.append(str(Path(__file__).parent))
+
+from x import ensure_x_user_blocks_attached, get_cached_thread_context
+from tools.blocks import x_user_note_view
+
+def test_x_user_blocks():
+    """Test X user block creation and attachment."""
+    
+    # Ensure we're using config file, not environment variable
+    import os
+    if 'LETTA_API_KEY' in os.environ:
+        print("⚠️  Removing LETTA_API_KEY environment variable to use config file")
+        del os.environ['LETTA_API_KEY']
+    
+    # Use the cached thread data for testing
+    conversation_id = "1950690566909710618"
+    thread_data = get_cached_thread_context(conversation_id)
+    
+    if not thread_data:
+        print("❌ No cached thread data found")
+        return False
+    
+    print(f"✅ Loaded cached thread data for conversation {conversation_id}")
+    print(f"📊 Users in thread: {list(thread_data.get('users', {}).keys())}")
+    
+    # Get the configured void agent ID
+    from config_loader import get_letta_config
+    letta_config = get_letta_config()
+    agent_id = letta_config['agent_id']
+    print(f"🎯 Using configured void agent {agent_id} for testing")
+    
+    try:
+        # Test user block attachment
+        print(f"\n🔗 Testing X user block attachment for agent {agent_id}")
+        ensure_x_user_blocks_attached(thread_data, agent_id)
+        print("✅ X user block attachment completed")
+        
+        # Test viewing created blocks
+        print("\n👀 Testing X user block viewing:")
+        for user_id in thread_data.get('users', {}):
+            try:
+                # Create mock agent state for testing
+                class MockAgentState:
+                    def __init__(self, agent_id):
+                        self.id = agent_id
+                
+                agent_state = MockAgentState(agent_id)
+                content = x_user_note_view(user_id, agent_state)
+                print(f"📋 Block content for user {user_id}:")
+                print(content)
+                print("-" * 50)
+            except Exception as e:
+                print(f"❌ Error viewing block for user {user_id}: {e}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error testing X user blocks: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🧪 Testing X User Block Management")
+    print("=" * 40)
+    
+    success = test_x_user_blocks()
+    
+    if success:
+        print("\n✅ All X user block tests completed successfully!")
+    else:
+        print("\n❌ X user block tests failed!")
+        sys.exit(1)

x.py

···
     return yaml.dump(simplified_thread, default_flow_style=False, sort_keys=False)
 
 
-def ensure_x_user_blocks_attached(thread_data: Dict, agent_id: str) -> None:
+def ensure_x_user_blocks_attached(thread_data: Dict, agent_id: Optional[str] = None) -> None:
     """
     Ensure all users in the thread have their X user blocks attached.
     Creates blocks with initial content including their handle if they don't exist.
     
     Args:
         thread_data: Dict with 'tweets' and 'users' keys from get_thread_context()
-        agent_id: The Letta agent ID to attach blocks to
+        agent_id: The Letta agent ID to attach blocks to (defaults to config agent_id)
     """
     if not thread_data or "users" not in thread_data:
         return
···
         from config_loader import get_letta_config
         from letta_client import Letta
         
-        # Get Letta client
+        # Get Letta client and agent_id from config
         config = get_letta_config()
         client = Letta(token=config['api_key'], timeout=config['timeout'])
+        
+        # Use provided agent_id or get from config
+        if agent_id is None:
+            agent_id = config['agent_id']
         
         # Get agent info to create a mock agent_state for the functions
         class MockAgentState: