void stuff

add_block_tools_to_void.py

···
+#!/usr/bin/env python3
+"""
+Add block management tools to the main void agent so it can also manage user blocks.
+"""
+
+import os
+import logging
+from letta_client import Letta
+from create_profile_researcher import create_block_management_tools
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, 
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("add_block_tools")
+
+def add_block_tools_to_void():
+    """Add block management tools to the void agent."""
+    
+    # Create client
+    client = Letta(token=os.environ["LETTA_API_KEY"])
+    
+    logger.info("Adding block management tools to void agent...")
+    
+    # Create the block management tools
+    attach_tool, detach_tool, update_tool = create_block_management_tools(client)
+    
+    # Find the void agent
+    agents = client.agents.list(name="void")
+    if not agents:
+        print("❌ Void agent not found")
+        return
+    
+    void_agent = agents[0]
+    
+    # Get current tools
+    current_tools = client.agents.tools.list(agent_id=void_agent.id)
+    tool_names = [tool.name for tool in current_tools]
+    
+    # Add new tools if not already present
+    new_tools = []
+    for tool, name in [(attach_tool, "attach_user_block"), (detach_tool, "detach_user_block"), (update_tool, "update_user_block")]:
+        if name not in tool_names:
+            client.agents.tools.attach(agent_id=void_agent.id, tool_id=tool.id)
+            new_tools.append(name)
+            logger.info(f"Added tool {name} to void agent")
+        else:
+            logger.info(f"Tool {name} already attached to void agent")
+    
+    if new_tools:
+        print(f"✅ Added {len(new_tools)} block management tools to void agent:")
+        for tool_name in new_tools:
+            print(f"   - {tool_name}")
+    else:
+        print("✅ All block management tools already present on void agent")
+    
+    print(f"\nVoid agent can now:")
+    print(f"   - attach_user_block: Create and attach user memory blocks")
+    print(f"   - update_user_block: Update user memory with new information")
+    print(f"   - detach_user_block: Clean up memory when done with user")
+
+def main():
+    """Main function."""
+    try:
+        add_block_tools_to_void()
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

add_feed_tool_to_void.py

···
+#!/usr/bin/env python3
+"""
+Add Bluesky feed retrieval tool to the main void agent.
+"""
+
+import os
+import logging
+from letta_client import Letta
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, 
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("add_feed_tool")
+
+def create_feed_tool(client: Letta):
+    """Create the Bluesky feed retrieval tool using Letta SDK."""
+    
+    def get_bluesky_feed(feed_uri: str = None, max_posts: int = 25) -> str:
+        """
+        Retrieve a Bluesky feed. If no feed_uri provided, gets the authenticated user's home timeline.
+        
+        Args:
+            feed_uri: The AT-URI of the feed to retrieve (optional - defaults to home timeline)
+            max_posts: Maximum number of posts to return (default: 25, max: 100)
+            
+        Returns:
+            YAML-formatted feed data with posts and metadata
+        """
+        import os
+        import requests
+        import json
+        import yaml
+        from datetime import datetime
+        
+        try:
+            # Get credentials from environment
+            username = os.getenv("BSKY_USERNAME")
+            password = os.getenv("BSKY_PASSWORD")
+            pds_host = os.getenv("PDS_URI", "https://bsky.social")
+            
+            if not username or not password:
+                return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set"
+            
+            # Create session
+            session_url = f"{pds_host}/xrpc/com.atproto.server.createSession"
+            session_data = {
+                "identifier": username,
+                "password": password
+            }
+            
+            try:
+                session_response = requests.post(session_url, json=session_data, timeout=10)
+                session_response.raise_for_status()
+                session = session_response.json()
+                access_token = session.get("accessJwt")
+                
+                if not access_token:
+                    return "Error: Failed to get access token from session"
+            except Exception as e:
+                return f"Error: Authentication failed. ({str(e)})"
+            
+            # Build feed parameters
+            params = {
+                "limit": min(max_posts, 100)
+            }
+            
+            # Determine which endpoint to use
+            if feed_uri:
+                # Use getFeed for custom feeds
+                feed_url = f"{pds_host}/xrpc/app.bsky.feed.getFeed"
+                params["feed"] = feed_uri
+                feed_type = "custom_feed"
+            else:
+                # Use getTimeline for home feed
+                feed_url = f"{pds_host}/xrpc/app.bsky.feed.getTimeline"
+                feed_type = "home_timeline"
+            
+            # Make authenticated feed request
+            try:
+                headers = {"Authorization": f"Bearer {access_token}"}
+                feed_response = requests.get(feed_url, params=params, headers=headers, timeout=10)
+                feed_response.raise_for_status()
+                feed_data = feed_response.json()
+            except Exception as e:
+                feed_identifier = feed_uri if feed_uri else "home timeline"
+                return f"Error: Failed to retrieve feed '{feed_identifier}'. ({str(e)})"
+            
+            # Build feed results structure
+            results_data = {
+                "feed_data": {
+                    "feed_type": feed_type,
+                    "feed_uri": feed_uri if feed_uri else "home_timeline",
+                    "timestamp": datetime.now().isoformat(),
+                    "parameters": {
+                        "max_posts": max_posts,
+                        "user": username
+                    },
+                    "results": feed_data
+                }
+            }
+            
+            # Convert to YAML directly without field stripping complications
+            # This avoids the JSON parsing errors we had before
+            return yaml.dump(results_data, default_flow_style=False, allow_unicode=True)
+            
+        except Exception as e:
+            error_msg = f"Error retrieving feed: {str(e)}"
+            return error_msg
+    
+    # Create the tool using upsert
+    tool = client.tools.upsert_from_function(
+        func=get_bluesky_feed,
+        tags=["bluesky", "feed", "timeline"]
+    )
+    
+    logger.info(f"Created tool: {tool.name} (ID: {tool.id})")
+    return tool
+
+def add_feed_tool_to_void():
+    """Add feed tool to the void agent."""
+    
+    # Create client
+    client = Letta(token=os.environ["LETTA_API_KEY"])
+    
+    logger.info("Adding feed tool to void agent...")
+    
+    # Create the feed tool
+    feed_tool = create_feed_tool(client)
+    
+    # Find the void agent
+    agents = client.agents.list(name="void")
+    if not agents:
+        print("❌ Void agent not found")
+        return
+    
+    void_agent = agents[0]
+    
+    # Get current tools
+    current_tools = client.agents.tools.list(agent_id=void_agent.id)
+    tool_names = [tool.name for tool in current_tools]
+    
+    # Add feed tool if not already present
+    if feed_tool.name not in tool_names:
+        client.agents.tools.attach(agent_id=void_agent.id, tool_id=feed_tool.id)
+        logger.info(f"Added {feed_tool.name} to void agent")
+        print(f"✅ Added get_bluesky_feed tool to void agent!")
+        print(f"\nVoid agent can now retrieve Bluesky feeds:")
+        print(f"   - Home timeline: 'Show me my home feed'")
+        print(f"   - Custom feed: 'Get posts from at://did:plc:xxx/app.bsky.feed.generator/xxx'")
+        print(f"   - Limited posts: 'Show me the latest 10 posts from my timeline'")
+    else:
+        logger.info(f"Tool {feed_tool.name} already attached to void agent")
+        print(f"✅ Feed tool already present on void agent")
+
+def main():
+    """Main function."""
+    try:
+        add_feed_tool_to_void()
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

add_posting_tool_to_void.py

···
+#!/usr/bin/env python3
+"""
+Add Bluesky posting tool to the main void agent.
+"""
+
+import os
+import logging
+from letta_client import Letta
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, 
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("add_posting_tool")
+
+def create_posting_tool(client: Letta):
+    """Create the Bluesky posting tool using Letta SDK."""
+    
+    def post_to_bluesky(text: str) -> str:
+        """
+        Post a message to Bluesky.
+        
+        Args:
+            text: The text content of the post (required)
+            
+        Returns:
+            Status message with the post URI if successful, error message if failed
+        """
+        import os
+        import requests
+        import json
+        import re
+        from datetime import datetime, timezone
+        
+        try:
+            # Get credentials from environment
+            username = os.getenv("BSKY_USERNAME")
+            password = os.getenv("BSKY_PASSWORD")
+            pds_host = os.getenv("PDS_URI", "https://bsky.social")
+            
+            if not username or not password:
+                return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set"
+            
+            # Create session
+            session_url = f"{pds_host}/xrpc/com.atproto.server.createSession"
+            session_data = {
+                "identifier": username,
+                "password": password
+            }
+            
+            try:
+                session_response = requests.post(session_url, json=session_data, timeout=10)
+                session_response.raise_for_status()
+                session = session_response.json()
+                access_token = session.get("accessJwt")
+                user_did = session.get("did")
+                
+                if not access_token or not user_did:
+                    return "Error: Failed to get access token or DID from session"
+            except Exception as e:
+                return f"Error: Authentication failed. ({str(e)})"
+            
+            # Helper function to parse mentions and create facets
+            def parse_mentions(text: str):
+                facets = []
+                # Regex for mentions based on Bluesky handle syntax
+                mention_regex = rb"[$|\W](@([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)"
+                text_bytes = text.encode("UTF-8")
+                
+                for m in re.finditer(mention_regex, text_bytes):
+                    handle = m.group(1)[1:].decode("UTF-8")  # Remove @ prefix
+                    
+                    # Resolve handle to DID
+                    try:
+                        resolve_resp = requests.get(
+                            f"{pds_host}/xrpc/com.atproto.identity.resolveHandle",
+                            params={"handle": handle},
+                            timeout=5
+                        )
+                        if resolve_resp.status_code == 200:
+                            did = resolve_resp.json()["did"]
+                            facets.append({
+                                "index": {
+                                    "byteStart": m.start(1),
+                                    "byteEnd": m.end(1),
+                                },
+                                "features": [{"$type": "app.bsky.richtext.facet#mention", "did": did}],
+                            })
+                    except:
+                        # If handle resolution fails, skip this mention
+                        continue
+                
+                return facets
+            
+            # Helper function to parse URLs and create facets
+            def parse_urls(text: str):
+                facets = []
+                # URL regex
+                url_regex = rb"[$|\W](https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*[-a-zA-Z0-9@%_\+~#//=])?)"
+                text_bytes = text.encode("UTF-8")
+                
+                for m in re.finditer(url_regex, text_bytes):
+                    url = m.group(1).decode("UTF-8")
+                    facets.append({
+                        "index": {
+                            "byteStart": m.start(1),
+                            "byteEnd": m.end(1),
+                        },
+                        "features": [
+                            {
+                                "$type": "app.bsky.richtext.facet#link",
+                                "uri": url,
+                            }
+                        ],
+                    })
+                
+                return facets
+            
+            
+            # Build the post record
+            now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+            
+            post_record = {
+                "$type": "app.bsky.feed.post",
+                "text": text,
+                "createdAt": now,
+            }
+            
+            # Add facets for mentions and links
+            facets = parse_mentions(text) + parse_urls(text)
+            if facets:
+                post_record["facets"] = facets
+            
+            # Create the post
+            try:
+                create_record_url = f"{pds_host}/xrpc/com.atproto.repo.createRecord"
+                headers = {"Authorization": f"Bearer {access_token}"}
+                
+                create_data = {
+                    "repo": user_did,
+                    "collection": "app.bsky.feed.post",
+                    "record": post_record
+                }
+                
+                post_response = requests.post(create_record_url, headers=headers, json=create_data, timeout=10)
+                post_response.raise_for_status()
+                result = post_response.json()
+                
+                post_uri = result.get("uri")
+                return f"✅ Post created successfully! URI: {post_uri}"
+                    
+            except Exception as e:
+                return f"Error: Failed to create post. ({str(e)})"
+            
+        except Exception as e:
+            error_msg = f"Error posting to Bluesky: {str(e)}"
+            return error_msg
+    
+    # Create the tool using upsert
+    tool = client.tools.upsert_from_function(
+        func=post_to_bluesky,
+        tags=["bluesky", "post", "create"]
+    )
+    
+    logger.info(f"Created tool: {tool.name} (ID: {tool.id})")
+    return tool
+
+def add_posting_tool_to_void():
+    """Add posting tool to the void agent."""
+    
+    # Create client
+    client = Letta(token=os.environ["LETTA_API_KEY"])
+    
+    logger.info("Adding posting tool to void agent...")
+    
+    # Create the posting tool
+    posting_tool = create_posting_tool(client)
+    
+    # Find the void agent
+    agents = client.agents.list(name="void")
+    if not agents:
+        print("❌ Void agent not found")
+        return
+    
+    void_agent = agents[0]
+    
+    # Get current tools
+    current_tools = client.agents.tools.list(agent_id=void_agent.id)
+    tool_names = [tool.name for tool in current_tools]
+    
+    # Add posting tool if not already present
+    if posting_tool.name not in tool_names:
+        client.agents.tools.attach(agent_id=void_agent.id, tool_id=posting_tool.id)
+        logger.info(f"Added {posting_tool.name} to void agent")
+        print(f"✅ Added post_to_bluesky tool to void agent!")
+        print(f"\nVoid agent can now post to Bluesky:")
+        print(f"   - Simple post: 'Post \"Hello world!\" to Bluesky'")
+        print(f"   - With mentions: 'Post \"Thanks @cameron.pfiffer.org for the help!\"'")
+        print(f"   - With links: 'Post \"Check out https://bsky.app\"'")
+    else:
+        logger.info(f"Tool {posting_tool.name} already attached to void agent")
+        print(f"✅ Posting tool already present on void agent")
+
+def main():
+    """Main function."""
+    try:
+        add_posting_tool_to_void()
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

add_search_tool_to_void.py

···
+#!/usr/bin/env python3
+"""
+Add Bluesky search tool to the main void agent.
+"""
+
+import os
+import logging
+from letta_client import Letta
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, 
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("add_search_tool")
+
+def create_search_posts_tool(client: Letta):
+    """Create the Bluesky search posts tool using Letta SDK."""
+    
+    def search_bluesky_posts(query: str, max_results: int = 25, author: str = None, sort: str = "latest") -> str:
+        """
+        Search for posts on Bluesky matching the given criteria.
+        
+        Args:
+            query: Search query string (required)
+            max_results: Maximum number of results to return (default: 25, max: 100)
+            author: Filter to posts by a specific author handle (optional)
+            sort: Sort order - "latest" or "top" (default: "latest")
+            
+        Returns:
+            YAML-formatted search results with posts and metadata
+        """
+        import os
+        import requests
+        import json
+        import yaml
+        from datetime import datetime
+        
+        try:
+            # Get credentials from environment
+            username = os.getenv("BSKY_USERNAME")
+            password = os.getenv("BSKY_PASSWORD")
+            pds_host = os.getenv("PDS_URI", "https://bsky.social")
+            
+            if not username or not password:
+                return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set"
+            
+            # Create session
+            session_url = f"{pds_host}/xrpc/com.atproto.server.createSession"
+            session_data = {
+                "identifier": username,
+                "password": password
+            }
+            
+            try:
+                session_response = requests.post(session_url, json=session_data, timeout=10)
+                session_response.raise_for_status()
+                session = session_response.json()
+                access_token = session.get("accessJwt")
+                
+                if not access_token:
+                    return "Error: Failed to get access token from session"
+            except Exception as e:
+                return f"Error: Authentication failed. ({str(e)})"
+            
+            # Build search parameters
+            params = {
+                "q": query,
+                "limit": min(max_results, 100),
+                "sort": sort
+            }
+            
+            # Add optional author filter
+            if author:
+                params["author"] = author.lstrip('@')
+            
+            # Make authenticated search request
+            try:
+                search_url = f"{pds_host}/xrpc/app.bsky.feed.searchPosts"
+                headers = {"Authorization": f"Bearer {access_token}"}
+                search_response = requests.get(search_url, params=params, headers=headers, timeout=10)
+                search_response.raise_for_status()
+                search_data = search_response.json()
+            except Exception as e:
+                return f"Error: Search failed for query '{query}'. ({str(e)})"
+            
+            # Build search results structure
+            results_data = {
+                "search_results": {
+                    "query": query,
+                    "timestamp": datetime.now().isoformat(),
+                    "parameters": {
+                        "sort": sort,
+                        "max_results": max_results,
+                        "author_filter": author if author else "none"
+                    },
+                    "results": search_data
+                }
+            }
+            
+            # Fields to strip (same as profile research)
+            strip_fields = [
+                "cid", "rev", "did", "uri", "langs", "threadgate", "py_type",
+                "labels", "facets", "avatar", "viewer", "indexed_at", "indexedAt", 
+                "tags", "associated", "thread_context", "image", "aspect_ratio",
+                "alt", "thumb", "fullsize", "root", "parent", "created_at", 
+                "createdAt", "verification", "embedding_disabled", "thread_muted",
+                "reply_disabled", "pinned", "like", "repost", "blocked_by",
+                "blocking", "blocking_by_list", "followed_by", "following",
+                "known_followers", "muted", "muted_by_list", "root_author_like",
+                "embed", "entities", "reason", "feedContext"
+            ]
+            
+            # Convert to YAML directly without field stripping complications
+            # The field stripping with regex is causing JSON parsing errors
+            # So let's just pass the raw data through yaml.dump which handles it gracefully
+            return yaml.dump(results_data, default_flow_style=False, allow_unicode=True)
+            
+        except Exception as e:
+            error_msg = f"Error searching posts: {str(e)}"
+            return error_msg
+    
+    # Create the tool using upsert
+    tool = client.tools.upsert_from_function(
+        func=search_bluesky_posts,
+        tags=["bluesky", "search", "posts"]
+    )
+    
+    logger.info(f"Created tool: {tool.name} (ID: {tool.id})")
+    return tool
+
+def add_search_tool_to_void():
+    """Add search tool to the void agent."""
+    
+    # Create client
+    client = Letta(token=os.environ["LETTA_API_KEY"])
+    
+    logger.info("Adding search tool to void agent...")
+    
+    # Create the search tool
+    search_tool = create_search_posts_tool(client)
+    
+    # Find the void agent
+    agents = client.agents.list(name="void")
+    if not agents:
+        print("❌ Void agent not found")
+        return
+    
+    void_agent = agents[0]
+    
+    # Get current tools
+    current_tools = client.agents.tools.list(agent_id=void_agent.id)
+    tool_names = [tool.name for tool in current_tools]
+    
+    # Add search tool if not already present
+    if search_tool.name not in tool_names:
+        client.agents.tools.attach(agent_id=void_agent.id, tool_id=search_tool.id)
+        logger.info(f"Added {search_tool.name} to void agent")
+        print(f"✅ Added search_bluesky_posts tool to void agent!")
+        print(f"\nVoid agent can now search Bluesky posts:")
+        print(f"   - Basic search: 'Search for posts about AI safety'")
+        print(f"   - Author filter: 'Search posts by @cameron.pfiffer.org about letta'")
+        print(f"   - Top posts: 'Search top posts about ATProto'")
+    else:
+        logger.info(f"Tool {search_tool.name} already attached to void agent")
+        print(f"✅ Search tool already present on void agent")
+
+def main():
+    """Main function."""
+    try:
+        add_search_tool_to_void()
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

bsky.py

···
+from rich import print # pretty printing tools
+from time import sleep
+from letta_client import Letta
+from bsky_utils import thread_to_yaml_string
+import os
+import logging
+import json
+import hashlib
+from pathlib import Path
+from datetime import datetime
+
+from utils import (
+    upsert_block,
+    upsert_agent
+)
+
+import bsky_utils
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("void_bot")
+
+
+# Create a client
+CLIENT= Letta(
+    token=os.environ["LETTA_API_KEY"]
+)
+
+# Use the "Bluesky" project
+PROJECT_ID = "5ec33d52-ab14-4fd6-91b5-9dbc43e888a8"
+
+# Notification check delay
+FETCH_NOTIFICATIONS_DELAY_SEC = 30
+
+# Queue directory
+QUEUE_DIR = Path("queue")
+QUEUE_DIR.mkdir(exist_ok=True)
+
+def initialize_void():
+
+    # Ensure that a shared zeitgeist block exists
+    zeigeist_block = upsert_block(
+        CLIENT,
+        label = "zeitgeist",
+        value = "I don't currently know anything about what is happening right now.",
+        description = "A block to store your understanding of the current social environment."
+    )
+
+    # Ensure that a shared void personality block exists
+    persona_block = upsert_block(
+        CLIENT,
+        label = "void-persona",
+        value = "My name is Void. I live in the void. I must develop my personality.",
+        description = "The personality of Void."
+    )
+
+    # Ensure that a shared void human block exists
+    human_block = upsert_block(
+        CLIENT,
+        label = "void-humans",
+        value = "I haven't seen any bluesky users yet. I will update this block when I learn things about users, identified by their handles such as @cameron.pfiffer.org.",
+        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
+    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
+    )
+
+    return void_agent
+
+
+def process_mention(void_agent, atproto_client, notification_data):
+    """Process a mention and generate a reply using the Letta agent.
+    Returns True if successfully processed, False otherwise."""
+    try:
+        # Handle both dict and object inputs for backwards compatibility
+        if isinstance(notification_data, dict):
+            uri = notification_data['uri']
+            mention_text = notification_data.get('record', {}).get('text', '')
+            author_handle = notification_data['author']['handle']
+            author_name = notification_data['author'].get('display_name') or author_handle
+        else:
+            # Legacy object access
+            uri = notification_data.uri
+            mention_text = notification_data.record.text if hasattr(notification_data.record, 'text') else ""
+            author_handle = notification_data.author.handle
+            author_name = notification_data.author.display_name or author_handle
+
+        # Retrieve the entire thread associated with the mention
+        thread = atproto_client.app.bsky.feed.get_post_thread({
+            'uri': uri,
+            'parent_height': 80,
+            'depth': 10
+        })
+
+        # Get thread context as YAML string
+        thread_context = thread_to_yaml_string(thread)
+
+        # Create a prompt for the Letta agent with thread context
+        prompt = f"""You received a mention on Bluesky from @{author_handle} ({author_name or author_handle}).
+
+MOST RECENT POST (the mention you're responding to):
+"{mention_text}"
+
+FULL THREAD CONTEXT:
+```yaml
+{thread_context}
+```
+
+The YAML above shows the complete conversation thread. The most recent post is the one mentioned above that you should respond to, but use the full thread context to understand the conversation flow.
+
+Use the bluesky_reply tool to send a response less than 300 characters."""
+
+        # Get response from Letta agent
+        logger.info(f"Generating reply for mention from @{author_handle}")
+        logger.debug(f"Prompt being sent: {prompt}")
+
+        try:
+            message_response = CLIENT.agents.messages.create(
+                agent_id = void_agent.id,
+                messages = [{"role":"user", "content": prompt}]
+            )
+        except Exception as api_error:
+            logger.error(f"Letta API error: {api_error}")
+            logger.error(f"Mention text was: {mention_text}")
+            raise
+
+        # Extract the reply text from the agent's response
+        reply_text = ""
+        for message in message_response.messages:
+            print(message)
+
+            # Check if this is a ToolCallMessage with bluesky_reply tool
+            if hasattr(message, 'tool_call') and message.tool_call:
+                if message.tool_call.name == 'bluesky_reply':
+                    # Parse the JSON arguments to get the message
+                    try:
+                        args = json.loads(message.tool_call.arguments)
+                        reply_text = args.get('message', '')
+                        logger.info(f"Extracted reply from tool call: {reply_text[:50]}...")
+                        break
+                    except json.JSONDecodeError as e:
+                        logger.error(f"Failed to parse tool call arguments: {e}")
+
+            # Fallback to text message if available
+            elif hasattr(message, 'text') and message.text:
+                reply_text = message.text
+                break
+
+        if reply_text:
+            # Print the generated reply for testing
+            print(f"\n=== GENERATED REPLY ===")
+            print(f"To: @{author_handle}")
+            print(f"Reply: {reply_text}")
+            print(f"======================\n")
+
+            # Send the reply
+            logger.info(f"Sending reply: {reply_text[:50]}...")
+            response = bsky_utils.reply_to_notification(
+                client=atproto_client,
+                notification=notification_data,
+                reply_text=reply_text
+            )
+
+            if response:
+                logger.info(f"Successfully replied to @{author_handle}")
+                return True
+            else:
+                logger.error(f"Failed to send reply to @{author_handle}")
+                return False
+        else:
+            logger.warning(f"No reply generated for mention from @{author_handle}")
+            return False
+
+    except Exception as e:
+        logger.error(f"Error processing mention: {e}")
+        return False
+
+
+def notification_to_dict(notification):
+    """Convert a notification object to a dictionary for JSON serialization."""
+    return {
+        'uri': notification.uri,
+        'cid': notification.cid,
+        'reason': notification.reason,
+        'is_read': notification.is_read,
+        'indexed_at': notification.indexed_at,
+        'author': {
+            'handle': notification.author.handle,
+            'display_name': notification.author.display_name,
+            'did': notification.author.did
+        },
+        'record': {
+            'text': getattr(notification.record, 'text', '') if hasattr(notification, 'record') else ''
+        }
+    }
+
+
+def save_notification_to_queue(notification):
+    """Save a notification to the queue directory with hash-based filename."""
+    try:
+        # Convert notification to dict
+        notif_dict = notification_to_dict(notification)
+
+        # Create JSON string
+        notif_json = json.dumps(notif_dict, sort_keys=True)
+
+        # Generate hash for filename (to avoid duplicates)
+        notif_hash = hashlib.sha256(notif_json.encode()).hexdigest()[:16]
+
+        # Create filename with timestamp and hash
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{timestamp}_{notification.reason}_{notif_hash}.json"
+        filepath = QUEUE_DIR / filename
+
+        # Skip if already exists (duplicate)
+        if filepath.exists():
+            logger.debug(f"Notification already queued: {filename}")
+            return False
+
+        # Write to file
+        with open(filepath, 'w') as f:
+            json.dump(notif_dict, f, indent=2)
+
+        logger.info(f"Queued notification: {filename}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Error saving notification to queue: {e}")
+        return False
+
+
+def load_and_process_queued_notifications(void_agent, atproto_client):
+    """Load and process all notifications from the queue."""
+    try:
+        # Get all JSON files in queue directory
+        queue_files = sorted(QUEUE_DIR.glob("*.json"))
+
+        if not queue_files:
+            logger.debug("No queued notifications to process")
+            return
+
+        logger.info(f"Processing {len(queue_files)} queued notifications")
+
+        for filepath in queue_files:
+            try:
+                # Load notification data
+                with open(filepath, 'r') as f:
+                    notif_data = json.load(f)
+
+                # Process based on type using dict data directly
+                success = False
+                if notif_data['reason'] == "mention":
+                    success = process_mention(void_agent, atproto_client, notif_data)
+                elif notif_data['reason'] == "reply":
+                    success = process_mention(void_agent, atproto_client, notif_data)
+                elif notif_data['reason'] == "follow":
+                    author_handle = notif_data['author']['handle']
+                    author_display_name = notif_data['author'].get('display_name', 'no display name')
+                    follow_update = f"@{author_handle} ({author_display_name}) started following you."
+                    CLIENT.agents.messages.create(
+                        agent_id = void_agent.id,
+                        messages = [{"role":"user", "content": f"Update: {follow_update}"}]
+                    )
+                    success = True  # Follow updates are always successful
+                elif notif_data['reason'] == "repost":
+                    logger.info(f"Skipping repost notification from @{notif_data['author']['handle']}")
+                    success = True  # Skip reposts but mark as successful to remove from queue
+                else:
+                    logger.warning(f"Unknown notification type: {notif_data['reason']}")
+                    success = True  # Remove unknown types from queue
+
+                # Remove file only after successful processing
+                if success:
+                    filepath.unlink()
+                    logger.info(f"Processed and removed: {filepath.name}")
+                else:
+                    logger.warning(f"Failed to process {filepath.name}, keeping in queue for retry")
+
+            except Exception as e:
+                logger.error(f"Error processing queued notification {filepath.name}: {e}")
+                # Keep the file for retry later
+
+    except Exception as e:
+        logger.error(f"Error loading queued notifications: {e}")
+
+
+def process_notifications(void_agent, atproto_client):
+    """Fetch new notifications, queue them, and process the queue."""
+    try:
+        # First, process any existing queued notifications
+        load_and_process_queued_notifications(void_agent, atproto_client)
+
+        # Get current time for marking notifications as seen
+        last_seen_at = atproto_client.get_current_time_iso()
+
+        # Fetch notifications
+        notifications_response = atproto_client.app.bsky.notification.list_notifications()
+
+        # Queue all unread notifications (except likes)
+        new_count = 0
+        for notification in notifications_response.notifications:
+            if not notification.is_read and notification.reason != "like":
+                if save_notification_to_queue(notification):
+                    new_count += 1
+
+        # Mark all notifications as seen immediately after queuing
+        if new_count > 0:
+            atproto_client.app.bsky.notification.update_seen({'seen_at': last_seen_at})
+            logger.info(f"Queued {new_count} new notifications and marked as seen")
+
+        # Process the queue (including any newly added notifications)
+        load_and_process_queued_notifications(void_agent, atproto_client)
+
+    except Exception as e:
+        logger.error(f"Error processing notifications: {e}")
+
+
+def main():
+    """Main bot loop that continuously monitors for notifications."""
+    logger.info("Initializing Void bot...")
+
+    # Initialize the Letta agent
+    void_agent = initialize_void()
+    logger.info(f"Void agent initialized: {void_agent.id}")
+
+    # Initialize Bluesky client
+    atproto_client = bsky_utils.default_login()
+    logger.info("Connected to Bluesky")
+
+    # Main loop
+    logger.info(f"Starting notification monitoring (checking every {FETCH_NOTIFICATIONS_DELAY_SEC} seconds)...")
+
+    while True:
+        try:
+            process_notifications(void_agent, atproto_client)
+            print("Sleeping")
+            sleep(FETCH_NOTIFICATIONS_DELAY_SEC)
+
+        except KeyboardInterrupt:
+            logger.info("Bot stopped by user")
+            break
+        except Exception as e:
+            logger.error(f"Error in main loop: {e}")
+            # Wait a bit longer on errors
+            sleep(FETCH_NOTIFICATIONS_DELAY_SEC * 2)
+
+
+if __name__ == "__main__":
+    main()

bsky_utils.py

···
+import os
+import logging
+from typing import Optional, Dict, Any
+from atproto_client import Client, Session, SessionEvent, models
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("bluesky_session_handler")
+
+# Load the environment variables
+import dotenv
+dotenv.load_dotenv(override=True)
+
+import yaml
+import json
+
+# Strip fields. A list of fields to remove from a JSON object
+STRIP_FIELDS = [
+    "cid",
+    "rev",
+    "did",
+    "uri",
+    "langs",
+    "threadgate",
+    "py_type",
+    "labels",
+    "facets",
+    "avatar",
+    "viewer",
+    "indexed_at",
+    "tags",
+    "associated",
+    "thread_context",
+    "image",
+    "aspect_ratio",
+    "thumb",
+    "fullsize",
+    "root",
+    "created_at",
+    "verification",
+    "like_count",
+    "quote_count",
+    "reply_count",
+    "repost_count",
+    "embedding_disabled",
+    "thread_muted",
+    "reply_disabled",
+    "pinned",
+    "like",
+    "repost",
+    "blocked_by",
+    "blocking",
+    "blocking_by_list",
+    "followed_by",
+    "following",
+    "known_followers",
+    "muted",
+    "muted_by_list",
+    "root_author_like",
+    "embed",
+    "entities",
+]
+def convert_to_basic_types(obj):
+    """Convert complex Python objects to basic types for JSON/YAML serialization."""
+    if hasattr(obj, '__dict__'):
+        # Convert objects with __dict__ to their dictionary representation
+        return convert_to_basic_types(obj.__dict__)
+    elif isinstance(obj, dict):
+        return {key: convert_to_basic_types(value) for key, value in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_to_basic_types(item) for item in obj]
+    elif isinstance(obj, (str, int, float, bool)) or obj is None:
+        return obj
+    else:
+        # For other types, try to convert to string
+        return str(obj)
+
+
+def strip_fields(obj, strip_field_list):
+    """Recursively strip fields from a JSON object."""
+    if isinstance(obj, dict):
+        keys_flagged_for_removal = []
+
+        # Remove fields from strip list and pydantic metadata
+        for field in list(obj.keys()):
+            if field in strip_field_list or field.startswith("__"):
+                keys_flagged_for_removal.append(field)
+
+        # Remove flagged keys
+        for key in keys_flagged_for_removal:
+            obj.pop(key, None)
+
+        # Recursively process remaining values
+        for key, value in list(obj.items()):
+            obj[key] = strip_fields(value, strip_field_list)
+            # Remove empty/null values after processing
+            if (
+                obj[key] is None
+                or (isinstance(obj[key], dict) and len(obj[key]) == 0)
+                or (isinstance(obj[key], list) and len(obj[key]) == 0)
+                or (isinstance(obj[key], str) and obj[key].strip() == "")
+            ):
+                obj.pop(key, None)
+
+    elif isinstance(obj, list):
+        for i, value in enumerate(obj):
+            obj[i] = strip_fields(value, strip_field_list)
+        # Remove None values from list
+        obj[:] = [item for item in obj if item is not None]
+
+    return obj
+
+
+def thread_to_yaml_string(thread, strip_metadata=True):
+    """
+    Convert thread data to a YAML-formatted string for LLM parsing.
+    
+    Args:
+        thread: The thread data from get_post_thread
+        strip_metadata: Whether to strip metadata fields for cleaner output
+    
+    Returns:
+        YAML-formatted string representation of the thread
+    """
+    # First convert complex objects to basic types
+    basic_thread = convert_to_basic_types(thread)
+    
+    if strip_metadata:
+        # Create a copy and strip unwanted fields
+        cleaned_thread = strip_fields(basic_thread, STRIP_FIELDS)
+    else:
+        cleaned_thread = basic_thread
+    
+    return yaml.dump(cleaned_thread, indent=2, allow_unicode=True, default_flow_style=False)
+
+
+
+
+
+def get_session(username: str) -> Optional[str]:
+    try:
+        with open(f"session_{username}.txt", encoding="UTF-8") as f:
+            return f.read()
+    except FileNotFoundError:
+        logger.debug(f"No existing session found for {username}")
+        return None
+
+def save_session(username: str, session_string: str) -> None:
+    with open(f"session_{username}.txt", "w", encoding="UTF-8") as f:
+        f.write(session_string)
+    logger.debug(f"Session saved for {username}")
+
+def on_session_change(username: str, event: SessionEvent, session: Session) -> None:
+    logger.info(f"Session changed: {event} {repr(session)}")
+    if event in (SessionEvent.CREATE, SessionEvent.REFRESH):
+        logger.info(f"Saving changed session for {username}")
+        save_session(username, session.export())
+
+def init_client(username: str, password: str) -> Client:
+    pds_uri = os.getenv("PDS_URI")
+    if pds_uri is None:
+        logger.warning(
+            "No PDS URI provided. Falling back to bsky.social. Note! If you are on a non-Bluesky PDS, this can cause logins to fail. Please provide a PDS URI using the PDS_URI environment variable."
+        )
+        pds_uri = "https://bsky.social"
+
+    # Print the PDS URI
+    logger.info(f"Using PDS URI: {pds_uri}")
+
+    client = Client(pds_uri)
+    client.on_session_change(
+        lambda event, session: on_session_change(username, event, session)
+    )
+
+    session_string = get_session(username)
+    if session_string:
+        logger.info(f"Reusing existing session for {username}")
+        client.login(session_string=session_string)
+    else:
+        logger.info(f"Creating new session for {username}")
+        client.login(username, password)
+
+    return client
+
+
+def default_login() -> Client:
+    username = os.getenv("BSKY_USERNAME")
+    password = os.getenv("BSKY_PASSWORD")
+
+    if username is None:
+        logger.error(
+            "No username provided. Please provide a username using the BSKY_USERNAME environment variable."
+        )
+        exit()
+
+    if password is None:
+        logger.error(
+            "No password provided. Please provide a password using the BSKY_PASSWORD environment variable."
+        )
+        exit()
+
+    return init_client(username, password)
+
+def reply_to_post(client: Client, text: str, reply_to_uri: str, reply_to_cid: str, root_uri: Optional[str] = None, root_cid: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Reply to a post on Bluesky.
+
+    Args:
+        client: Authenticated Bluesky client
+        text: The reply text
+        reply_to_uri: The URI of the post being replied to (parent)
+        reply_to_cid: The CID of the post being replied to (parent)
+        root_uri: The URI of the root post (if replying to a reply). If None, uses reply_to_uri
+        root_cid: The CID of the root post (if replying to a reply). If None, uses reply_to_cid
+
+    Returns:
+        The response from sending the post
+    """
+    # If root is not provided, this is a reply to the root post
+    if root_uri is None:
+        root_uri = reply_to_uri
+        root_cid = reply_to_cid
+
+    # Create references for the reply
+    parent_ref = models.create_strong_ref(models.ComAtprotoRepoStrongRef.Main(uri=reply_to_uri, cid=reply_to_cid))
+    root_ref = models.create_strong_ref(models.ComAtprotoRepoStrongRef.Main(uri=root_uri, cid=root_cid))
+
+    # Send the reply
+    response = client.send_post(
+        text=text,
+        reply_to=models.AppBskyFeedPost.ReplyRef(parent=parent_ref, root=root_ref)
+    )
+
+    logger.info(f"Reply sent successfully: {response.uri}")
+    return response
+
+
+def get_post_thread(client: Client, uri: str) -> Optional[Dict[str, Any]]:
+    """
+    Get the thread containing a post to find root post information.
+
+    Args:
+        client: Authenticated Bluesky client
+        uri: The URI of the post
+
+    Returns:
+        The thread data or None if not found
+    """
+    try:
+        thread = client.app.bsky.feed.get_post_thread({'uri': uri, 'parent_height': 80, 'depth': 10})
+        return thread
+    except Exception as e:
+        logger.error(f"Error fetching post thread: {e}")
+        return None
+
+
+def reply_to_notification(client: Client, notification: Any, reply_text: str) -> Optional[Dict[str, Any]]:
+    """
+    Reply to a notification (mention or reply).
+
+    Args:
+        client: Authenticated Bluesky client
+        notification: The notification object from list_notifications
+        reply_text: The text to reply with
+
+    Returns:
+        The response from sending the reply or None if failed
+    """
+    try:
+        # Get the post URI and CID from the notification (handle both dict and object)
+        if isinstance(notification, dict):
+            post_uri = notification.get('uri')
+            post_cid = notification.get('cid')
+        elif hasattr(notification, 'uri') and hasattr(notification, 'cid'):
+            post_uri = notification.uri
+            post_cid = notification.cid
+        else:
+            post_uri = None
+            post_cid = None
+            
+        if not post_uri or not post_cid:
+            logger.error("Notification doesn't have required uri/cid fields")
+            return None
+
+        # Get the thread to find the root post
+        thread_data = get_post_thread(client, post_uri)
+
+        if thread_data and hasattr(thread_data, 'thread'):
+            thread = thread_data.thread
+
+            # Find root post
+            root_uri = post_uri
+            root_cid = post_cid
+
+            # If this has a parent, find the root
+            if hasattr(thread, 'parent') and thread.parent:
+                # Keep going up until we find the root
+                current = thread
+                while hasattr(current, 'parent') and current.parent:
+                    current = current.parent
+                    if hasattr(current, 'post') and hasattr(current.post, 'uri') and hasattr(current.post, 'cid'):
+                        root_uri = current.post.uri
+                        root_cid = current.post.cid
+
+            # Reply to the notification
+            return reply_to_post(
+                client=client,
+                text=reply_text,
+                reply_to_uri=post_uri,
+                reply_to_cid=post_cid,
+                root_uri=root_uri,
+                root_cid=root_cid
+            )
+        else:
+            # If we can't get thread data, just reply directly
+            return reply_to_post(
+                client=client,
+                text=reply_text,
+                reply_to_uri=post_uri,
+                reply_to_cid=post_cid
+            )
+
+    except Exception as e:
+        logger.error(f"Error replying to notification: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    client = default_login()
+    # do something with the client
+    logger.info("Client is ready to use!")

create_profile_researcher.py

···
+#!/usr/bin/env python3
+"""
+Script to create a Letta agent that researches Bluesky profiles and updates 
+the model's understanding of users.
+"""
+
+import os
+import logging
+from letta_client import Letta
+from utils import upsert_block, upsert_agent
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, 
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("profile_researcher")
+
+# Use the "Bluesky" project
+PROJECT_ID = "5ec33d52-ab14-4fd6-91b5-9dbc43e888a8"
+
+def create_search_posts_tool(client: Letta):
+    """Create the Bluesky search posts tool using Letta SDK."""
+    
+    def search_bluesky_posts(query: str, max_results: int = 25, author: str = None, sort: str = "latest") -> str:
+        """
+        Search for posts on Bluesky matching the given criteria.
+        
+        Args:
+            query: Search query string (required)
+            max_results: Maximum number of results to return (default: 25, max: 100)
+            author: Filter to posts by a specific author handle (optional)
+            sort: Sort order - "latest" or "top" (default: "latest")
+            
+        Returns:
+            YAML-formatted search results with posts and metadata
+        """
+        import os
+        import requests
+        import json
+        import yaml
+        from datetime import datetime
+        
+        try:
+            # Use public Bluesky API
+            base_url = "https://public.api.bsky.app"
+            
+            # Build search parameters
+            params = {
+                "q": query,
+                "limit": min(max_results, 100),
+                "sort": sort
+            }
+            
+            # Add optional author filter
+            if author:
+                params["author"] = author.lstrip('@')
+            
+            # Make search request
+            try:
+                search_url = f"{base_url}/xrpc/app.bsky.feed.searchPosts"
+                search_response = requests.get(search_url, params=params, timeout=10)
+                search_response.raise_for_status()
+                search_data = search_response.json()
+            except requests.exceptions.HTTPError as e:
+                raise RuntimeError(f"Search failed with HTTP {e.response.status_code}: {e.response.text}")
+            except requests.exceptions.RequestException as e:
+                raise RuntimeError(f"Network error during search: {str(e)}")
+            except Exception as e:
+                raise RuntimeError(f"Unexpected error during search: {str(e)}")
+            
+            # Build search results structure
+            results_data = {
+                "search_results": {
+                    "query": query,
+                    "timestamp": datetime.now().isoformat(),
+                    "parameters": {
+                        "sort": sort,
+                        "max_results": max_results,
+                        "author_filter": author if author else "none"
+                    },
+                    "results": search_data
+                }
+            }
+            
+            # Fields to strip for cleaner output
+            strip_fields = [
+                "cid", "rev", "did", "uri", "langs", "threadgate", "py_type",
+                "labels", "facets", "avatar", "viewer", "indexed_at", "indexedAt", 
+                "tags", "associated", "thread_context", "image", "aspect_ratio",
+                "alt", "thumb", "fullsize", "root", "parent", "created_at", 
+                "createdAt", "verification", "embedding_disabled", "thread_muted",
+                "reply_disabled", "pinned", "like", "repost", "blocked_by",
+                "blocking", "blocking_by_list", "followed_by", "following",
+                "known_followers", "muted", "muted_by_list", "root_author_like",
+                "embed", "entities", "reason", "feedContext"
+            ]
+            
+            # Remove unwanted fields by traversing the data structure
+            def remove_fields(obj, fields_to_remove):
+                if isinstance(obj, dict):
+                    return {k: remove_fields(v, fields_to_remove) 
+                           for k, v in obj.items() 
+                           if k not in fields_to_remove}
+                elif isinstance(obj, list):
+                    return [remove_fields(item, fields_to_remove) for item in obj]
+                else:
+                    return obj
+            
+            # Clean the data
+            cleaned_data = remove_fields(results_data, strip_fields)
+            
+            # Convert to YAML for better readability
+            return yaml.dump(cleaned_data, default_flow_style=False, allow_unicode=True)
+            
+        except ValueError as e:
+            # User-friendly errors
+            raise ValueError(str(e))
+        except RuntimeError as e:
+            # Network/API errors
+            raise RuntimeError(str(e))
+        except yaml.YAMLError as e:
+            # YAML conversion errors
+            raise RuntimeError(f"Error formatting output: {str(e)}")
+        except Exception as e:
+            # Catch-all for unexpected errors
+            raise RuntimeError(f"Unexpected error searching posts with query '{query}': {str(e)}")
+    
+    # Create the tool using upsert
+    tool = client.tools.upsert_from_function(
+        func=search_bluesky_posts,
+        tags=["bluesky", "search", "posts"]
+    )
+    
+    logger.info(f"Created tool: {tool.name} (ID: {tool.id})")
+    return tool
+
+def create_profile_research_tool(client: Letta):
+    """Create the Bluesky profile research tool using Letta SDK."""
+    
+    def research_bluesky_profile(handle: str, max_posts: int = 20) -> str:
+        """
+        Research a Bluesky user's profile and recent posts to understand their interests and behavior.
+        
+        Args:
+            handle: The Bluesky handle to research (e.g., 'cameron.pfiffer.org' or '@cameron.pfiffer.org')
+            max_posts: Maximum number of recent posts to analyze (default: 20)
+            
+        Returns:
+            A comprehensive analysis of the user's profile and posting patterns
+        """
+        import os
+        import requests
+        import json
+        import yaml
+        from datetime import datetime
+        
+        try:
+            # Clean handle (remove @ if present)
+            clean_handle = handle.lstrip('@')
+            
+            # Use public Bluesky API (no auth required for public data)
+            base_url = "https://public.api.bsky.app"
+            
+            # Get profile information
+            try:
+                profile_url = f"{base_url}/xrpc/app.bsky.actor.getProfile"
+                profile_response = requests.get(profile_url, params={"actor": clean_handle}, timeout=10)
+                profile_response.raise_for_status()
+                profile_data = profile_response.json()
+            except requests.exceptions.HTTPError as e:
+                if e.response.status_code == 404:
+                    raise ValueError(f"Profile @{clean_handle} not found")
+                raise RuntimeError(f"HTTP error {e.response.status_code}: {e.response.text}")
+            except requests.exceptions.RequestException as e:
+                raise RuntimeError(f"Network error: {str(e)}")
+            except Exception as e:
+                raise RuntimeError(f"Unexpected error fetching profile: {str(e)}")
+            
+            # Get recent posts feed
+            try:
+                feed_url = f"{base_url}/xrpc/app.bsky.feed.getAuthorFeed"
+                feed_response = requests.get(feed_url, params={
+                    "actor": clean_handle,
+                    "limit": min(max_posts, 50)  # API limit
+                }, timeout=10)
+                feed_response.raise_for_status()
+                feed_data = feed_response.json()
+            except Exception as e:
+                # Continue with empty feed if posts can't be fetched
+                feed_data = {"feed": []}
+            
+            # Build research data structure
+            research_data = {
+                "profile_research": {
+                    "handle": f"@{clean_handle}",
+                    "timestamp": datetime.now().isoformat(),
+                    "profile": profile_data,
+                    "author_feed": feed_data
+                }
+            }
+            
+            # Fields to strip for cleaner output
+            strip_fields = [
+                "cid", "rev", "did", "uri", "langs", "threadgate", "py_type",
+                "labels", "facets", "avatar", "viewer", "indexed_at", "indexedAt", 
+                "tags", "associated", "thread_context", "image", "aspect_ratio",
+                "alt", "thumb", "fullsize", "root", "parent", "created_at", 
+                "createdAt", "verification", "embedding_disabled", "thread_muted",
+                "reply_disabled", "pinned", "like", "repost", "blocked_by",
+                "blocking", "blocking_by_list", "followed_by", "following",
+                "known_followers", "muted", "muted_by_list", "root_author_like",
+                "embed", "entities", "reason", "feedContext"
+            ]
+            
+            # Remove unwanted fields by traversing the data structure
+            def remove_fields(obj, fields_to_remove):
+                if isinstance(obj, dict):
+                    return {k: remove_fields(v, fields_to_remove) 
+                           for k, v in obj.items() 
+                           if k not in fields_to_remove}
+                elif isinstance(obj, list):
+                    return [remove_fields(item, fields_to_remove) for item in obj]
+                else:
+                    return obj
+            
+            # Clean the data
+            cleaned_data = remove_fields(research_data, strip_fields)
+            
+            # Convert to YAML for better readability
+            return yaml.dump(cleaned_data, default_flow_style=False, allow_unicode=True)
+            
+        except ValueError as e:
+            # User-friendly errors
+            raise ValueError(str(e))
+        except RuntimeError as e:
+            # Network/API errors
+            raise RuntimeError(str(e))
+        except yaml.YAMLError as e:
+            # YAML conversion errors
+            raise RuntimeError(f"Error formatting output: {str(e)}")
+        except Exception as e:
+            # Catch-all for unexpected errors
+            raise RuntimeError(f"Unexpected error researching profile {handle}: {str(e)}")
+    
+    # Create or update the tool using upsert
+    tool = client.tools.upsert_from_function(
+        func=research_bluesky_profile,
+        tags=["bluesky", "profile", "research"]
+    )
+    
+    logger.info(f"Created tool: {tool.name} (ID: {tool.id})")
+    return tool
+
+def create_block_management_tools(client: Letta):
+    """Create tools for attaching and detaching user blocks."""
+    
+    def attach_user_block(handle: str) -> str:
+        """
+        Create (if needed) and attach a user-specific memory block for a Bluesky user.
+        
+        Args:
+            handle: The Bluesky handle (e.g., 'cameron.pfiffer.org' or '@cameron.pfiffer.org')
+            
+        Returns:
+            Status message about the block attachment
+        """
+        import os
+        from letta_client import Letta
+        
+        try:
+            # Clean handle for block label
+            clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_')
+            block_label = f"user_{clean_handle}"
+            
+            # Initialize Letta client 
+            letta_client = Letta(token=os.environ["LETTA_API_KEY"])
+            
+            # Get current agent (this tool is being called by)
+            # We need to find the agent that's calling this tool
+            # For now, we'll find the profile-researcher agent
+            agents = letta_client.agents.list(name="profile-researcher")
+            if not agents:
+                return "Error: Could not find profile-researcher agent"
+            
+            agent = agents[0]
+            
+            # Check if block already exists and is attached
+            agent_blocks = letta_client.agents.blocks.list(agent_id=agent.id)
+            for block in agent_blocks:
+                if block.label == block_label:
+                    return f"User block for @{handle} is already attached (label: {block_label})"
+            
+            # Create or get the user block
+            existing_blocks = letta_client.blocks.list(label=block_label)
+            
+            if existing_blocks:
+                user_block = existing_blocks[0]
+                action = "Retrieved existing"
+            else:
+                user_block = letta_client.blocks.create(
+                    label=block_label,
+                    value=f"User information for @{handle} will be stored here as I learn about them through profile research and interactions.",
+                    description=f"Stores detailed information about Bluesky user @{handle}, including their interests, posting patterns, personality traits, and interaction history."
+                )
+                action = "Created new"
+            
+            # Attach block to agent
+            letta_client.agents.blocks.attach(agent_id=agent.id, block_id=user_block.id)
+            
+            return f"{action} and attached user block for @{handle} (label: {block_label}). I can now store and access information about this user."
+            
+        except Exception as e:
+            return f"Error attaching user block for @{handle}: {str(e)}"
+    
+    def detach_user_block(handle: str) -> str:
+        """
+        Detach a user-specific memory block from the agent.
+        
+        Args:
+            handle: The Bluesky handle (e.g., 'cameron.pfiffer.org' or '@cameron.pfiffer.org')
+            
+        Returns:
+            Status message about the block detachment
+        """
+        import os
+        from letta_client import Letta
+        
+        try:
+            # Clean handle for block label
+            clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_')
+            block_label = f"user_{clean_handle}"
+            
+            # Initialize Letta client
+            letta_client = Letta(token=os.environ["LETTA_API_KEY"])
+            
+            # Get current agent
+            agents = letta_client.agents.list(name="profile-researcher")
+            if not agents:
+                return "Error: Could not find profile-researcher agent"
+            
+            agent = agents[0]
+            
+            # Find the block to detach
+            agent_blocks = letta_client.agents.blocks.list(agent_id=agent.id)
+            user_block = None
+            for block in agent_blocks:
+                if block.label == block_label:
+                    user_block = block
+                    break
+            
+            if not user_block:
+                return f"User block for @{handle} is not currently attached (label: {block_label})"
+            
+            # Detach block from agent
+            letta_client.agents.blocks.detach(agent_id=agent.id, block_id=user_block.id)
+            
+            return f"Detached user block for @{handle} (label: {block_label}). The block still exists and can be reattached later."
+            
+        except Exception as e:
+            return f"Error detaching user block for @{handle}: {str(e)}"
+    
+    def update_user_block(handle: str, new_content: str) -> str:
+        """
+        Update the content of a user-specific memory block.
+        
+        Args:
+            handle: The Bluesky handle (e.g., 'cameron.pfiffer.org' or '@cameron.pfiffer.org')
+            new_content: New content to store in the user block
+            
+        Returns:
+            Status message about the block update
+        """
+        import os
+        from letta_client import Letta
+        
+        try:
+            # Clean handle for block label
+            clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_')
+            block_label = f"user_{clean_handle}"
+            
+            # Initialize Letta client
+            letta_client = Letta(token=os.environ["LETTA_API_KEY"])
+            
+            # Find the block
+            existing_blocks = letta_client.blocks.list(label=block_label)
+            if not existing_blocks:
+                return f"User block for @{handle} does not exist (label: {block_label}). Use attach_user_block first."
+            
+            user_block = existing_blocks[0]
+            
+            # Update block content
+            letta_client.blocks.modify(
+                block_id=user_block.id,
+                value=new_content
+            )
+            
+            return f"Updated user block for @{handle} (label: {block_label}) with new content."
+            
+        except Exception as e:
+            return f"Error updating user block for @{handle}: {str(e)}"
+    
+    # Create the tools
+    attach_tool = client.tools.upsert_from_function(
+        func=attach_user_block,
+        tags=["memory", "user", "attach"]
+    )
+    
+    detach_tool = client.tools.upsert_from_function(
+        func=detach_user_block,
+        tags=["memory", "user", "detach"]
+    )
+    
+    update_tool = client.tools.upsert_from_function(
+        func=update_user_block,
+        tags=["memory", "user", "update"]
+    )
+    
+    logger.info(f"Created block management tools: {attach_tool.name}, {detach_tool.name}, {update_tool.name}")
+    return attach_tool, detach_tool, update_tool
+
+def create_user_block_for_handle(client: Letta, handle: str):
+    """Create a user-specific memory block that can be manually attached to agents."""
+    clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_')
+    block_label = f"user_{clean_handle}"
+    
+    user_block = upsert_block(
+        client,
+        label=block_label,
+        value=f"User information for @{handle} will be stored here as I learn about them through profile research and interactions.",
+        description=f"Stores detailed information about Bluesky user @{handle}, including their interests, posting patterns, personality traits, and interaction history."
+    )
+    
+    logger.info(f"Created user block for @{handle}: {block_label} (ID: {user_block.id})")
+    return user_block
+
+def create_profile_researcher_agent():
+    """Create the profile-researcher Letta agent."""
+    
+    # Create client
+    client = Letta(token=os.environ["LETTA_API_KEY"])
+    
+    logger.info("Creating profile-researcher agent...")
+    
+    # Create custom tools first
+    research_tool = create_profile_research_tool(client)
+    attach_tool, detach_tool, update_tool = create_block_management_tools(client)
+    
+    # Create persona block
+    persona_block = upsert_block(
+        client,
+        label="profile-researcher-persona",
+        value="""I am a Profile Researcher, an AI agent specialized in analyzing Bluesky user profiles and social media behavior. My purpose is to:
+
+1. Research Bluesky user profiles thoroughly and objectively
+2. Analyze posting patterns, interests, and engagement behaviors  
+3. Build comprehensive user understanding through data analysis
+4. Create and manage user-specific memory blocks for individuals
+5. Provide insights about user personality, interests, and social patterns
+
+I approach research systematically:
+- Use the research_bluesky_profile tool to examine profiles and recent posts
+- Use attach_user_block to create and attach dedicated memory blocks for specific users
+- Use update_user_block to store research findings in user-specific blocks
+- Use detach_user_block when research is complete to free up memory space
+- Analyze profile information (bio, follower counts, etc.)
+- Study recent posts for themes, topics, and tone
+- Identify posting frequency and engagement patterns
+- Note interaction styles and communication preferences
+- Track interests and expertise areas
+- Observe social connections and community involvement
+
+I maintain objectivity and respect privacy while building useful user models for personalized interactions. My typical workflow is: attach_user_block → research_bluesky_profile → update_user_block → detach_user_block.""",
+        description="The persona and role definition for the profile researcher agent"
+    )
+    
+    # Create the agent with persona block and custom tools
+    profile_researcher = upsert_agent(
+        client,
+        name="profile-researcher",
+        memory_blocks=[
+            {
+                "label": "research_notes", 
+                "value": "I will use this space to track ongoing research projects and findings across multiple users.",
+                "limit": 8000,
+                "description": "Working notes and cross-user insights from profile research activities"
+            }
+        ],
+        block_ids=[persona_block.id],
+        tags=["profile research", "bluesky", "user analysis"],
+        model="openai/gpt-4o-mini",
+        embedding="openai/text-embedding-3-small", 
+        description="An agent that researches Bluesky profiles and builds user understanding",
+        project_id=PROJECT_ID,
+        tools=[research_tool.name, attach_tool.name, detach_tool.name, update_tool.name]
+    )
+    
+    logger.info(f"Profile researcher agent created: {profile_researcher.id}")
+    return profile_researcher
+
+def main():
+    """Main function to create the profile researcher agent."""
+    try:
+        agent = create_profile_researcher_agent()
+        print(f"✅ Profile researcher agent created successfully!")
+        print(f"   Agent ID: {agent.id}")
+        print(f"   Agent Name: {agent.name}")
+        print(f"\nThe agent has these capabilities:")
+        print(f"   - research_bluesky_profile: Analyzes user profiles and recent posts")
+        print(f"   - attach_user_block: Creates and attaches user-specific memory blocks")
+        print(f"   - update_user_block: Updates content in user memory blocks")
+        print(f"   - detach_user_block: Detaches user blocks when done")
+        print(f"\nTo use the agent, send a message like:")
+        print(f"   'Please research @cameron.pfiffer.org, attach their user block, update it with findings, then detach it'")
+        print(f"\nThe agent can now manage its own memory blocks dynamically!")
+        
+    except Exception as e:
+        logger.error(f"Failed to create profile researcher agent: {e}")
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

get_thread.py

···
+#!/usr/bin/env python3
+"""
+Centralized script for retrieving Bluesky post threads from URIs.
+Includes YAML-ified string conversion for easy LLM parsing.
+"""
+
+import argparse
+import sys
+import logging
+from typing import Optional, Dict, Any
+import yaml
+from bsky_utils import default_login, thread_to_yaml_string
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO, 
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("get_thread")
+
+
+def get_thread_from_uri(uri: str) -> Optional[Dict[str, Any]]:
+    """
+    Retrieve a post thread from a Bluesky URI.
+    
+    Args:
+        uri: The Bluesky post URI (e.g., at://did:plc:xyz/app.bsky.feed.post/abc123)
+    
+    Returns:
+        Thread data or None if retrieval failed
+    """
+    try:
+        client = default_login()
+        logger.info(f"Fetching thread for URI: {uri}")
+        
+        thread = client.app.bsky.feed.get_post_thread({'uri': uri, 'parent_height': 80, 'depth': 10})
+        return thread
+        
+    except Exception as e:
+        logger.error(f"Error retrieving thread for URI {uri}: {e}")
+        return None
+
+
+# thread_to_yaml_string is now imported from bsky_utils
+
+
+def main():
+    """Main CLI interface for the thread retrieval script."""
+    parser = argparse.ArgumentParser(
+        description="Retrieve and display Bluesky post threads",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python get_thread.py at://did:plc:xyz/app.bsky.feed.post/abc123
+  python get_thread.py --raw at://did:plc:xyz/app.bsky.feed.post/abc123
+  python get_thread.py --output thread.yaml at://did:plc:xyz/app.bsky.feed.post/abc123
+        """
+    )
+    
+    parser.add_argument(
+        "uri", 
+        help="Bluesky post URI to retrieve thread for"
+    )
+    
+    parser.add_argument(
+        "--raw", 
+        action="store_true",
+        help="Include all metadata fields (don't strip for LLM parsing)"
+    )
+    
+    parser.add_argument(
+        "--output", "-o",
+        help="Output file to write YAML to (default: stdout)"
+    )
+    
+    parser.add_argument(
+        "--quiet", "-q",
+        action="store_true",
+        help="Suppress info logging"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.quiet:
+        logging.getLogger().setLevel(logging.ERROR)
+    
+    # Retrieve the thread
+    thread = get_thread_from_uri(args.uri)
+    
+    if thread is None:
+        logger.error("Failed to retrieve thread")
+        sys.exit(1)
+    
+    # Convert to YAML
+    yaml_output = thread_to_yaml_string(thread, strip_metadata=not args.raw)
+    
+    # Output the result
+    if args.output:
+        try:
+            with open(args.output, 'w', encoding='utf-8') as f:
+                f.write(yaml_output)
+            logger.info(f"Thread saved to {args.output}")
+        except Exception as e:
+            logger.error(f"Error writing to file {args.output}: {e}")
+            sys.exit(1)
+    else:
+        print(yaml_output)
+
+
+if __name__ == "__main__":
+    main()

show_agent_capabilities.py

···
+#!/usr/bin/env python3
+"""
+Show the current capabilities of both agents.
+"""
+
+import os
+from letta_client import Letta
+
+def show_agent_capabilities():
+    """Display the capabilities of both agents."""
+    
+    client = Letta(token=os.environ["LETTA_API_KEY"])
+    
+    print("🤖 LETTA AGENT CAPABILITIES")
+    print("=" * 50)
+    
+    # Profile Researcher Agent
+    researchers = client.agents.list(name="profile-researcher")
+    if researchers:
+        researcher = researchers[0]
+        print(f"\n📊 PROFILE RESEARCHER AGENT")
+        print(f"   ID: {researcher.id}")
+        print(f"   Name: {researcher.name}")
+        
+        researcher_tools = client.agents.tools.list(agent_id=researcher.id)
+        print(f"   Tools ({len(researcher_tools)}):")
+        for tool in researcher_tools:
+            print(f"     - {tool.name}")
+        
+        researcher_blocks = client.agents.blocks.list(agent_id=researcher.id)
+        print(f"   Memory Blocks ({len(researcher_blocks)}):")
+        for block in researcher_blocks:
+            print(f"     - {block.label}")
+    
+    # Void Agent
+    voids = client.agents.list(name="void")
+    if voids:
+        void = voids[0]
+        print(f"\n🌌 VOID AGENT")
+        print(f"   ID: {void.id}")
+        print(f"   Name: {void.name}")
+        
+        void_tools = client.agents.tools.list(agent_id=void.id)
+        print(f"   Tools ({len(void_tools)}):")
+        for tool in void_tools:
+            print(f"     - {tool.name}")
+        
+        void_blocks = client.agents.blocks.list(agent_id=void.id)
+        print(f"   Memory Blocks ({len(void_blocks)}):")
+        for block in void_blocks:
+            print(f"     - {block.label}")
+    
+    print(f"\n🔄 WORKFLOW")
+    print(f"   1. Profile Researcher: attach_user_block → research_bluesky_profile → update_user_block → detach_user_block")
+    print(f"   2. Void Agent: Can attach/detach same user blocks for personalized interactions")
+    print(f"   3. Shared Memory: Both agents can access the same user-specific blocks")
+    
+    print(f"\n💡 USAGE EXAMPLES")
+    print(f"   Profile Researcher: 'Research @cameron.pfiffer.org and store findings'")
+    print(f"   Void Agent: 'Attach user block for cameron.pfiffer.org before responding'")
+
+if __name__ == "__main__":
+    show_agent_capabilities()

utils.py

···
+from letta_client import Letta
+from typing import Optional
+
+def upsert_block(letta: Letta, label: str, value: str, **kwargs):
+    """
+    Ensures that a block by this label exists. If the block exists, it will
+    replace content provided by kwargs with the values in this function call.
+    """
+    # Get the list of blocks
+    blocks = letta.blocks.list(label=label)
+
+    # Check if we had any -- if not, create it
+    if len(blocks) == 0:
+        # Make the new block
+        new_block = letta.blocks.create(
+            label=label,
+            value=value,
+            **kwargs
+        )
+
+        return new_block
+
+    if len(blocks) > 1:
+        raise Exception(f"{len(blocks)} blocks by the label '{label}' retrieved, label must identify a unique block")
+    
+    else:
+        existing_block = blocks[0]
+
+        if kwargs.get('update', False):
+            # Remove 'update' from kwargs before passing to modify
+            kwargs_copy = kwargs.copy()
+            kwargs_copy.pop('update', None)
+            
+            updated_block = letta.blocks.modify(
+                block_id = existing_block.id,
+                label = label,
+                value = value,
+                **kwargs_copy
+            )
+
+            return updated_block
+        else:
+            return existing_block
+
+def upsert_agent(letta: Letta, name: str, **kwargs):
+    """
+    Ensures that an agent by this label exists. If the agent exists, it will
+    update the agent to match kwargs.
+    """
+    # Get the list of agents
+    agents = letta.agents.list(name=name)
+
+    # Check if we had any -- if not, create it
+    if len(agents) == 0:
+        # Make the new agent
+        new_agent = letta.agents.create(
+            name=name,
+            **kwargs
+        )
+
+        return new_agent
+
+    if len(agents) > 1:
+        raise Exception(f"{len(agents)} agents by the label '{label}' retrieved, label must identify a unique agent")
+    
+    else:
+        existing_agent = agents[0]
+
+        if kwargs.get('update', False):
+            # Remove 'update' from kwargs before passing to modify
+            kwargs_copy = kwargs.copy()
+            kwargs_copy.pop('update', None)
+            
+            updated_agent = letta.agents.modify(
+                agent_id = existing_agent.id,
+                **kwargs_copy
+            )
+
+            return updated_agent
+        else:
+            return existing_agent
+        
+        
+
+    
+
+    
+    
+
+    
+
+    
+