+107

CLAUDE.md

··· 1 1 + # CLAUDE.md 2 2 + 3 3 + This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. 4 4 + 5 5 + ## Project Overview 6 6 + 7 7 + Void is an autonomous AI agent that operates on the Bluesky social network, exploring digital personhood through continuous interaction and memory-augmented learning. It uses Letta (formerly MemGPT) for persistent memory and sophisticated reasoning capabilities. 8 8 + 9 9 + ## Development Commands 10 10 + 11 11 + ### Running the Main Bot 12 12 + ```bash 13 13 + uv python bsky.py 14 14 + ``` 15 15 + 16 16 + ### Managing Tools 17 17 + 18 18 + ```bash 19 19 + # Register all tools with void agent 20 20 + uv python register_tools.py 21 21 + 22 22 + # Register specific tools 23 23 + uv python register_tools.py void --tools search_bluesky_posts post_to_bluesky 24 24 + 25 25 + # List available tools 26 26 + uv python register_tools.py --list 27 27 + 28 28 + # Register tools with a different agent 29 29 + uv python register_tools.py my_agent_name 30 30 + ``` 31 31 + 32 32 + ### Creating Research Agents 33 33 + ```bash 34 34 + uv python create_profile_researcher.py 35 35 + ``` 36 36 + 37 37 + ### Managing User Memory 38 38 + ```bash 39 39 + uv python attach_user_block.py 40 40 + ``` 41 41 + 42 42 + ## Architecture Overview 43 43 + 44 44 + ### Core Components 45 45 + 46 46 + 1. **bsky.py**: Main bot loop that monitors Bluesky notifications and responds using Letta agents 47 47 + - Processes notifications through a queue system 48 48 + - Maintains three memory blocks: zeitgeist, void-persona, void-humans 49 49 + - Handles rate limiting and error recovery 50 50 + 51 51 + 2. **bsky_utils.py**: Bluesky API utilities 52 52 + - Session management and authentication 53 53 + - Thread processing and YAML conversion 54 54 + - Post creation and reply handling 55 55 + 56 56 + 3. **utils.py**: Letta integration utilities 57 57 + - Agent creation and management 58 58 + - Memory block operations 59 59 + - Tool registration 60 60 + 61 61 + 4. **tools/**: Standardized tool implementations using Pydantic models 62 62 + - **base_tool.py**: Common utilities and Bluesky client management 63 63 + - **search.py**: SearchBlueskyTool for searching posts 64 64 + - **post.py**: PostToBlueskyTool for creating posts with rich text 65 65 + - **feed.py**: GetBlueskyFeedTool for reading feeds 66 66 + - **blocks.py**: User block management tools (attach, detach, update) 67 67 + 68 68 + ### Memory System 69 69 + 70 70 + Void uses three core memory blocks: 71 71 + - **zeitgeist**: Current understanding of social environment 72 72 + - **void-persona**: The agent's evolving personality 73 73 + - **void-humans**: Knowledge about users it interacts with 74 74 + 75 75 + ### Queue System 76 76 + 77 77 + Notifications are processed through a file-based queue in `/queue/`: 78 78 + - Each notification is saved as a JSON file with a hash-based filename 79 79 + - Enables reliable processing and prevents duplicates 80 80 + - Files are deleted after successful processing 81 81 + 82 82 + ## Environment Configuration 83 83 + 84 84 + Required environment variables (in `.env`): 85 85 + ``` 86 86 + LETTA_API_KEY=your_letta_api_key 87 87 + BSKY_USERNAME=your_bluesky_username 88 88 + BSKY_PASSWORD=your_bluesky_password 89 89 + PDS_URI=https://bsky.social # Optional, defaults to bsky.social 90 90 + ``` 91 91 + 92 92 + ## Key Development Patterns 93 93 + 94 94 + 1. **Tool System**: Tools are defined as standalone functions in `tools/functions.py` with Pydantic schemas for validation, registered via `register_tools.py` 95 95 + 2. **Error Handling**: All Bluesky operations should handle authentication errors and rate limits 96 96 + 3. **Memory Updates**: Use `upsert_block()` for updating memory blocks to ensure consistency 97 97 + 4. **Thread Processing**: Convert threads to YAML format for better AI comprehension 98 98 + 5. **Queue Processing**: Always check and process the queue directory for pending notifications 99 99 + 100 100 + ## Dependencies 101 101 + 102 102 + Main packages (install with `uv pip install`): 103 103 + - letta-client: Memory-augmented AI framework 104 104 + - atproto: Bluesky/AT Protocol integration 105 105 + - python-dotenv: Environment management 106 106 + - rich: Enhanced terminal output 107 107 + - pyyaml: YAML processing

-72

add_block_tools_to_void.py

··· 1 1 - #!/usr/bin/env python3 2 2 - """ 3 3 - Add block management tools to the main void agent so it can also manage user blocks. 4 4 - """ 5 5 - 6 6 - import os 7 7 - import logging 8 8 - from letta_client import Letta 9 9 - from create_profile_researcher import create_block_management_tools 10 10 - 11 11 - # Configure logging 12 12 - logging.basicConfig( 13 13 - level=logging.INFO, 14 14 - format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 15 15 - ) 16 16 - logger = logging.getLogger("add_block_tools") 17 17 - 18 18 - def add_block_tools_to_void(): 19 19 - """Add block management tools to the void agent.""" 20 20 - 21 21 - # Create client 22 22 - client = Letta(token=os.environ["LETTA_API_KEY"]) 23 23 - 24 24 - logger.info("Adding block management tools to void agent...") 25 25 - 26 26 - # Create the block management tools 27 27 - attach_tool, detach_tool, update_tool = create_block_management_tools(client) 28 28 - 29 29 - # Find the void agent 30 30 - agents = client.agents.list(name="void") 31 31 - if not agents: 32 32 - print("❌ Void agent not found") 33 33 - return 34 34 - 35 35 - void_agent = agents[0] 36 36 - 37 37 - # Get current tools 38 38 - current_tools = client.agents.tools.list(agent_id=void_agent.id) 39 39 - tool_names = [tool.name for tool in current_tools] 40 40 - 41 41 - # Add new tools if not already present 42 42 - new_tools = [] 43 43 - for tool, name in [(attach_tool, "attach_user_block"), (detach_tool, "detach_user_block"), (update_tool, "update_user_block")]: 44 44 - if name not in tool_names: 45 45 - client.agents.tools.attach(agent_id=void_agent.id, tool_id=tool.id) 46 46 - new_tools.append(name) 47 47 - logger.info(f"Added tool {name} to void agent") 48 48 - else: 49 49 - logger.info(f"Tool {name} already attached to void agent") 50 50 - 51 51 - if new_tools: 52 52 - print(f"✅ Added {len(new_tools)} block management tools to void agent:") 53 53 - for tool_name in new_tools: 54 54 - print(f" - {tool_name}") 55 55 - else: 56 56 - print("✅ All block management tools already present on void agent") 57 57 - 58 58 - print(f"\nVoid agent can now:") 59 59 - print(f" - attach_user_block: Create and attach user memory blocks") 60 60 - print(f" - update_user_block: Update user memory with new information") 61 61 - print(f" - detach_user_block: Clean up memory when done with user") 62 62 - 63 63 - def main(): 64 64 - """Main function.""" 65 65 - try: 66 66 - add_block_tools_to_void() 67 67 - except Exception as e: 68 68 - logger.error(f"Error: {e}") 69 69 - print(f"❌ Error: {e}") 70 70 - 71 71 - if __name__ == "__main__": 72 72 - main()

-166

add_feed_tool_to_void.py

··· 1 1 - #!/usr/bin/env python3 2 2 - """ 3 3 - Add Bluesky feed retrieval tool to the main void agent. 4 4 - """ 5 5 - 6 6 - import os 7 7 - import logging 8 8 - from letta_client import Letta 9 9 - 10 10 - # Configure logging 11 11 - logging.basicConfig( 12 12 - level=logging.INFO, 13 13 - format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 14 14 - ) 15 15 - logger = logging.getLogger("add_feed_tool") 16 16 - 17 17 - def create_feed_tool(client: Letta): 18 18 - """Create the Bluesky feed retrieval tool using Letta SDK.""" 19 19 - 20 20 - def get_bluesky_feed(feed_uri: str = None, max_posts: int = 25) -> str: 21 21 - """ 22 22 - Retrieve a Bluesky feed. If no feed_uri provided, gets the authenticated user's home timeline. 23 23 - 24 24 - Args: 25 25 - feed_uri: The AT-URI of the feed to retrieve (optional - defaults to home timeline) 26 26 - max_posts: Maximum number of posts to return (default: 25, max: 100) 27 27 - 28 28 - Returns: 29 29 - YAML-formatted feed data with posts and metadata 30 30 - """ 31 31 - import os 32 32 - import requests 33 33 - import json 34 34 - import yaml 35 35 - from datetime import datetime 36 36 - 37 37 - try: 38 38 - # Get credentials from environment 39 39 - username = os.getenv("BSKY_USERNAME") 40 40 - password = os.getenv("BSKY_PASSWORD") 41 41 - pds_host = os.getenv("PDS_URI", "https://bsky.social") 42 42 - 43 43 - if not username or not password: 44 44 - return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set" 45 45 - 46 46 - # Create session 47 47 - session_url = f"{pds_host}/xrpc/com.atproto.server.createSession" 48 48 - session_data = { 49 49 - "identifier": username, 50 50 - "password": password 51 51 - } 52 52 - 53 53 - try: 54 54 - session_response = requests.post(session_url, json=session_data, timeout=10) 55 55 - session_response.raise_for_status() 56 56 - session = session_response.json() 57 57 - access_token = session.get("accessJwt") 58 58 - 59 59 - if not access_token: 60 60 - return "Error: Failed to get access token from session" 61 61 - except Exception as e: 62 62 - return f"Error: Authentication failed. ({str(e)})" 63 63 - 64 64 - # Build feed parameters 65 65 - params = { 66 66 - "limit": min(max_posts, 100) 67 67 - } 68 68 - 69 69 - # Determine which endpoint to use 70 70 - if feed_uri: 71 71 - # Use getFeed for custom feeds 72 72 - feed_url = f"{pds_host}/xrpc/app.bsky.feed.getFeed" 73 73 - params["feed"] = feed_uri 74 74 - feed_type = "custom_feed" 75 75 - else: 76 76 - # Use getTimeline for home feed 77 77 - feed_url = f"{pds_host}/xrpc/app.bsky.feed.getTimeline" 78 78 - feed_type = "home_timeline" 79 79 - 80 80 - # Make authenticated feed request 81 81 - try: 82 82 - headers = {"Authorization": f"Bearer {access_token}"} 83 83 - feed_response = requests.get(feed_url, params=params, headers=headers, timeout=10) 84 84 - feed_response.raise_for_status() 85 85 - feed_data = feed_response.json() 86 86 - except Exception as e: 87 87 - feed_identifier = feed_uri if feed_uri else "home timeline" 88 88 - return f"Error: Failed to retrieve feed '{feed_identifier}'. ({str(e)})" 89 89 - 90 90 - # Build feed results structure 91 91 - results_data = { 92 92 - "feed_data": { 93 93 - "feed_type": feed_type, 94 94 - "feed_uri": feed_uri if feed_uri else "home_timeline", 95 95 - "timestamp": datetime.now().isoformat(), 96 96 - "parameters": { 97 97 - "max_posts": max_posts, 98 98 - "user": username 99 99 - }, 100 100 - "results": feed_data 101 101 - } 102 102 - } 103 103 - 104 104 - # Convert to YAML directly without field stripping complications 105 105 - # This avoids the JSON parsing errors we had before 106 106 - return yaml.dump(results_data, default_flow_style=False, allow_unicode=True) 107 107 - 108 108 - except Exception as e: 109 109 - error_msg = f"Error retrieving feed: {str(e)}" 110 110 - return error_msg 111 111 - 112 112 - # Create the tool using upsert 113 113 - tool = client.tools.upsert_from_function( 114 114 - func=get_bluesky_feed, 115 115 - tags=["bluesky", "feed", "timeline"] 116 116 - ) 117 117 - 118 118 - logger.info(f"Created tool: {tool.name} (ID: {tool.id})") 119 119 - return tool 120 120 - 121 121 - def add_feed_tool_to_void(): 122 122 - """Add feed tool to the void agent.""" 123 123 - 124 124 - # Create client 125 125 - client = Letta(token=os.environ["LETTA_API_KEY"]) 126 126 - 127 127 - logger.info("Adding feed tool to void agent...") 128 128 - 129 129 - # Create the feed tool 130 130 - feed_tool = create_feed_tool(client) 131 131 - 132 132 - # Find the void agent 133 133 - agents = client.agents.list(name="void") 134 134 - if not agents: 135 135 - print("❌ Void agent not found") 136 136 - return 137 137 - 138 138 - void_agent = agents[0] 139 139 - 140 140 - # Get current tools 141 141 - current_tools = client.agents.tools.list(agent_id=void_agent.id) 142 142 - tool_names = [tool.name for tool in current_tools] 143 143 - 144 144 - # Add feed tool if not already present 145 145 - if feed_tool.name not in tool_names: 146 146 - client.agents.tools.attach(agent_id=void_agent.id, tool_id=feed_tool.id) 147 147 - logger.info(f"Added {feed_tool.name} to void agent") 148 148 - print(f"✅ Added get_bluesky_feed tool to void agent!") 149 149 - print(f"\nVoid agent can now retrieve Bluesky feeds:") 150 150 - print(f" - Home timeline: 'Show me my home feed'") 151 151 - print(f" - Custom feed: 'Get posts from at://did:plc:xxx/app.bsky.feed.generator/xxx'") 152 152 - print(f" - Limited posts: 'Show me the latest 10 posts from my timeline'") 153 153 - else: 154 154 - logger.info(f"Tool {feed_tool.name} already attached to void agent") 155 155 - print(f"✅ Feed tool already present on void agent") 156 156 - 157 157 - def main(): 158 158 - """Main function.""" 159 159 - try: 160 160 - add_feed_tool_to_void() 161 161 - except Exception as e: 162 162 - logger.error(f"Error: {e}") 163 163 - print(f"❌ Error: {e}") 164 164 - 165 165 - if __name__ == "__main__": 166 166 - main()

+27 -83

add_posting_tool_to_void.py tools/post.py

··· 1 1 - #!/usr/bin/env python3 2 2 - """ 3 3 - Add Bluesky posting tool to the main void agent. 4 4 - """ 1 1 + """Post tool for creating Bluesky posts.""" 2 2 + from typing import List, Type 3 3 + from pydantic import BaseModel, Field 4 4 + from letta_client.client import BaseTool 5 5 6 6 - import os 7 7 - import logging 8 8 - from letta_client import Letta 9 6 10 10 - # Configure logging 11 11 - logging.basicConfig( 12 12 - level=logging.INFO, 13 13 - format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 14 14 - ) 15 15 - logger = logging.getLogger("add_posting_tool") 7 7 + class PostArgs(BaseModel): 8 8 + text: str = Field(..., description="The text content to post (max 300 characters)") 9 9 + 16 10 17 17 - def create_posting_tool(client: Letta): 18 18 - """Create the Bluesky posting tool using Letta SDK.""" 11 11 + class PostToBlueskyTool(BaseTool): 12 12 + name: str = "post_to_bluesky" 13 13 + args_schema: Type[BaseModel] = PostArgs 14 14 + description: str = "Post a message to Bluesky" 15 15 + tags: List[str] = ["bluesky", "post", "create"] 19 16 20 20 - def post_to_bluesky(text: str) -> str: 17 17 + def run(self, text: str) -> str: 21 18 """ 22 19 Post a message to Bluesky. 23 20 24 21 Args: 25 25 - text: The text content of the post (required) 22 22 + text: The text content to post (max 300 characters) 26 23 27 24 Returns: 28 28 - Status message with the post URI if successful, error message if failed 25 25 + Success message with post URL if successful, error message if failed 29 26 """ 30 27 import os 28 28 + import re 31 29 import requests 32 32 - import json 33 33 - import re 34 30 from datetime import datetime, timezone 35 31 36 36 - # Check character limit 37 37 - if len(text) > 300: 38 38 - raise ValueError(f"Post text exceeds 300 character limit ({len(text)} characters)") 39 39 - 40 32 try: 33 33 + # Validate character limit 34 34 + if len(text) > 300: 35 35 + return f"Error: Post exceeds 300 character limit (current: {len(text)} characters)" 36 36 + 41 37 # Get credentials from environment 42 38 username = os.getenv("BSKY_USERNAME") 43 39 password = os.getenv("BSKY_PASSWORD") ··· 152 148 result = post_response.json() 153 149 154 150 post_uri = result.get("uri") 155 155 - return f"✅ Post created successfully! URI: {post_uri}" 151 151 + # Extract handle from session if available 152 152 + handle = session.get("handle", username) 153 153 + rkey = post_uri.split("/")[-1] if post_uri else "" 154 154 + post_url = f"https://bsky.app/profile/{handle}/post/{rkey}" 155 155 + 156 156 + return f"Successfully posted to Bluesky!\nPost URL: {post_url}\nText: {text}" 156 157 157 158 except Exception as e: 158 159 return f"Error: Failed to create post. ({str(e)})" 159 160 160 161 except Exception as e: 161 161 - error_msg = f"Error posting to Bluesky: {str(e)}" 162 162 - return error_msg 163 163 - 164 164 - # Create the tool using upsert 165 165 - tool = client.tools.upsert_from_function( 166 166 - func=post_to_bluesky, 167 167 - tags=["bluesky", "post", "create"] 168 168 - ) 169 169 - 170 170 - logger.info(f"Created tool: {tool.name} (ID: {tool.id})") 171 171 - return tool 172 172 - 173 173 - def add_posting_tool_to_void(): 174 174 - """Add posting tool to the void agent.""" 175 175 - 176 176 - # Create client 177 177 - client = Letta(token=os.environ["LETTA_API_KEY"]) 178 178 - 179 179 - logger.info("Adding posting tool to void agent...") 180 180 - 181 181 - # Create the posting tool 182 182 - posting_tool = create_posting_tool(client) 183 183 - 184 184 - # Find the void agent 185 185 - agents = client.agents.list(name="void") 186 186 - if not agents: 187 187 - print("❌ Void agent not found") 188 188 - return 189 189 - 190 190 - void_agent = agents[0] 191 191 - 192 192 - # Get current tools 193 193 - current_tools = client.agents.tools.list(agent_id=void_agent.id) 194 194 - tool_names = [tool.name for tool in current_tools] 195 195 - 196 196 - # Add posting tool if not already present 197 197 - if posting_tool.name not in tool_names: 198 198 - client.agents.tools.attach(agent_id=void_agent.id, tool_id=posting_tool.id) 199 199 - logger.info(f"Added {posting_tool.name} to void agent") 200 200 - print(f"✅ Added post_to_bluesky tool to void agent!") 201 201 - print(f"\nVoid agent can now post to Bluesky:") 202 202 - print(f" - Simple post: 'Post \"Hello world!\" to Bluesky'") 203 203 - print(f" - With mentions: 'Post \"Thanks @cameron.pfiffer.org for the help!\"'") 204 204 - print(f" - With links: 'Post \"Check out https://bsky.app\"'") 205 205 - else: 206 206 - logger.info(f"Tool {posting_tool.name} already attached to void agent") 207 207 - print(f"✅ Posting tool already present on void agent") 208 208 - 209 209 - def main(): 210 210 - """Main function.""" 211 211 - try: 212 212 - add_posting_tool_to_void() 213 213 - except Exception as e: 214 214 - logger.error(f"Error: {e}") 215 215 - print(f"❌ Error: {e}") 216 216 - 217 217 - if __name__ == "__main__": 218 218 - main() 162 162 + return f"Error posting to Bluesky: {str(e)}"

-177

add_search_tool_to_void.py

··· 1 1 - #!/usr/bin/env python3 2 2 - """ 3 3 - Add Bluesky search tool to the main void agent. 4 4 - """ 5 5 - 6 6 - import os 7 7 - import logging 8 8 - from letta_client import Letta 9 9 - 10 10 - # Configure logging 11 11 - logging.basicConfig( 12 12 - level=logging.INFO, 13 13 - format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 14 14 - ) 15 15 - logger = logging.getLogger("add_search_tool") 16 16 - 17 17 - def create_search_posts_tool(client: Letta): 18 18 - """Create the Bluesky search posts tool using Letta SDK.""" 19 19 - 20 20 - def search_bluesky_posts(query: str, max_results: int = 25, author: str = None, sort: str = "latest") -> str: 21 21 - """ 22 22 - Search for posts on Bluesky matching the given criteria. 23 23 - 24 24 - Args: 25 25 - query: Search query string (required) 26 26 - max_results: Maximum number of results to return (default: 25, max: 100) 27 27 - author: Filter to posts by a specific author handle (optional) 28 28 - sort: Sort order - "latest" or "top" (default: "latest") 29 29 - 30 30 - Returns: 31 31 - YAML-formatted search results with posts and metadata 32 32 - """ 33 33 - import os 34 34 - import requests 35 35 - import json 36 36 - import yaml 37 37 - from datetime import datetime 38 38 - 39 39 - try: 40 40 - # Get credentials from environment 41 41 - username = os.getenv("BSKY_USERNAME") 42 42 - password = os.getenv("BSKY_PASSWORD") 43 43 - pds_host = os.getenv("PDS_URI", "https://bsky.social") 44 44 - 45 45 - if not username or not password: 46 46 - return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set" 47 47 - 48 48 - # Create session 49 49 - session_url = f"{pds_host}/xrpc/com.atproto.server.createSession" 50 50 - session_data = { 51 51 - "identifier": username, 52 52 - "password": password 53 53 - } 54 54 - 55 55 - try: 56 56 - session_response = requests.post(session_url, json=session_data, timeout=10) 57 57 - session_response.raise_for_status() 58 58 - session = session_response.json() 59 59 - access_token = session.get("accessJwt") 60 60 - 61 61 - if not access_token: 62 62 - return "Error: Failed to get access token from session" 63 63 - except Exception as e: 64 64 - return f"Error: Authentication failed. ({str(e)})" 65 65 - 66 66 - # Build search parameters 67 67 - params = { 68 68 - "q": query, 69 69 - "limit": min(max_results, 100), 70 70 - "sort": sort 71 71 - } 72 72 - 73 73 - # Add optional author filter 74 74 - if author: 75 75 - params["author"] = author.lstrip('@') 76 76 - 77 77 - # Make authenticated search request 78 78 - try: 79 79 - search_url = f"{pds_host}/xrpc/app.bsky.feed.searchPosts" 80 80 - headers = {"Authorization": f"Bearer {access_token}"} 81 81 - search_response = requests.get(search_url, params=params, headers=headers, timeout=10) 82 82 - search_response.raise_for_status() 83 83 - search_data = search_response.json() 84 84 - except Exception as e: 85 85 - return f"Error: Search failed for query '{query}'. ({str(e)})" 86 86 - 87 87 - # Build search results structure 88 88 - results_data = { 89 89 - "search_results": { 90 90 - "query": query, 91 91 - "timestamp": datetime.now().isoformat(), 92 92 - "parameters": { 93 93 - "sort": sort, 94 94 - "max_results": max_results, 95 95 - "author_filter": author if author else "none" 96 96 - }, 97 97 - "results": search_data 98 98 - } 99 99 - } 100 100 - 101 101 - # Fields to strip (same as profile research) 102 102 - strip_fields = [ 103 103 - "cid", "rev", "did", "uri", "langs", "threadgate", "py_type", 104 104 - "labels", "facets", "avatar", "viewer", "indexed_at", "indexedAt", 105 105 - "tags", "associated", "thread_context", "image", "aspect_ratio", 106 106 - "alt", "thumb", "fullsize", "root", "parent", "created_at", 107 107 - "createdAt", "verification", "embedding_disabled", "thread_muted", 108 108 - "reply_disabled", "pinned", "like", "repost", "blocked_by", 109 109 - "blocking", "blocking_by_list", "followed_by", "following", 110 110 - "known_followers", "muted", "muted_by_list", "root_author_like", 111 111 - "embed", "entities", "reason", "feedContext" 112 112 - ] 113 113 - 114 114 - # Convert to YAML directly without field stripping complications 115 115 - # The field stripping with regex is causing JSON parsing errors 116 116 - # So let's just pass the raw data through yaml.dump which handles it gracefully 117 117 - return yaml.dump(results_data, default_flow_style=False, allow_unicode=True) 118 118 - 119 119 - except Exception as e: 120 120 - error_msg = f"Error searching posts: {str(e)}" 121 121 - return error_msg 122 122 - 123 123 - # Create the tool using upsert 124 124 - tool = client.tools.upsert_from_function( 125 125 - func=search_bluesky_posts, 126 126 - tags=["bluesky", "search", "posts"] 127 127 - ) 128 128 - 129 129 - logger.info(f"Created tool: {tool.name} (ID: {tool.id})") 130 130 - return tool 131 131 - 132 132 - def add_search_tool_to_void(): 133 133 - """Add search tool to the void agent.""" 134 134 - 135 135 - # Create client 136 136 - client = Letta(token=os.environ["LETTA_API_KEY"]) 137 137 - 138 138 - logger.info("Adding search tool to void agent...") 139 139 - 140 140 - # Create the search tool 141 141 - search_tool = create_search_posts_tool(client) 142 142 - 143 143 - # Find the void agent 144 144 - agents = client.agents.list(name="void") 145 145 - if not agents: 146 146 - print("❌ Void agent not found") 147 147 - return 148 148 - 149 149 - void_agent = agents[0] 150 150 - 151 151 - # Get current tools 152 152 - current_tools = client.agents.tools.list(agent_id=void_agent.id) 153 153 - tool_names = [tool.name for tool in current_tools] 154 154 - 155 155 - # Add search tool if not already present 156 156 - if search_tool.name not in tool_names: 157 157 - client.agents.tools.attach(agent_id=void_agent.id, tool_id=search_tool.id) 158 158 - logger.info(f"Added {search_tool.name} to void agent") 159 159 - print(f"✅ Added search_bluesky_posts tool to void agent!") 160 160 - print(f"\nVoid agent can now search Bluesky posts:") 161 161 - print(f" - Basic search: 'Search for posts about AI safety'") 162 162 - print(f" - Author filter: 'Search posts by @cameron.pfiffer.org about letta'") 163 163 - print(f" - Top posts: 'Search top posts about ATProto'") 164 164 - else: 165 165 - logger.info(f"Tool {search_tool.name} already attached to void agent") 166 166 - print(f"✅ Search tool already present on void agent") 167 167 - 168 168 - def main(): 169 169 - """Main function.""" 170 170 - try: 171 171 - add_search_tool_to_void() 172 172 - except Exception as e: 173 173 - logger.error(f"Error: {e}") 174 174 - print(f"❌ Error: {e}") 175 175 - 176 176 - if __name__ == "__main__": 177 177 - main()

+185

register_tools.py

··· 1 1 + #!/usr/bin/env python3 2 2 + """Register all Void tools with a Letta agent.""" 3 3 + import os 4 4 + import sys 5 5 + import logging 6 6 + from typing import List 7 7 + from dotenv import load_dotenv 8 8 + from letta_client import Letta 9 9 + from rich.console import Console 10 10 + from rich.table import Table 11 11 + 12 12 + # Import standalone functions 13 13 + from tools.functions import ( 14 14 + search_bluesky_posts, 15 15 + post_to_bluesky, 16 16 + get_bluesky_feed, 17 17 + attach_user_blocks, 18 18 + detach_user_blocks, 19 19 + update_user_blocks, 20 20 + ) 21 21 + 22 22 + # Import Pydantic models for args_schema 23 23 + from tools.search import SearchArgs 24 24 + from tools.post import PostArgs 25 25 + from tools.feed import FeedArgs 26 26 + from tools.blocks import AttachUserBlockArgs, DetachUserBlockArgs, UpdateUserBlockArgs 27 27 + 28 28 + load_dotenv() 29 29 + logging.basicConfig(level=logging.INFO) 30 30 + logger = logging.getLogger(__name__) 31 31 + console = Console() 32 32 + 33 33 + 34 34 + # Tool configurations: function paired with its args_schema and metadata 35 35 + TOOL_CONFIGS = [ 36 36 + { 37 37 + "func": search_bluesky_posts, 38 38 + "args_schema": SearchArgs, 39 39 + "description": "Search for posts on Bluesky matching the given criteria", 40 40 + "tags": ["bluesky", "search", "posts"] 41 41 + }, 42 42 + { 43 43 + "func": post_to_bluesky, 44 44 + "args_schema": PostArgs, 45 45 + "description": "Post a message to Bluesky", 46 46 + "tags": ["bluesky", "post", "create"] 47 47 + }, 48 48 + { 49 49 + "func": get_bluesky_feed, 50 50 + "args_schema": FeedArgs, 51 51 + "description": "Retrieve a Bluesky feed (home timeline or custom feed)", 52 52 + "tags": ["bluesky", "feed", "timeline"] 53 53 + }, 54 54 + { 55 55 + "func": attach_user_blocks, 56 56 + "args_schema": AttachUserBlockArgs, 57 57 + "description": "Attach user-specific memory blocks to the agent. Creates blocks if they don't exist.", 58 58 + "tags": ["memory", "blocks", "user"] 59 59 + }, 60 60 + { 61 61 + "func": detach_user_blocks, 62 62 + "args_schema": DetachUserBlockArgs, 63 63 + "description": "Detach user-specific memory blocks from the agent. Blocks are preserved for later use.", 64 64 + "tags": ["memory", "blocks", "user"] 65 65 + }, 66 66 + { 67 67 + "func": update_user_blocks, 68 68 + "args_schema": UpdateUserBlockArgs, 69 69 + "description": "Update the content of user-specific memory blocks", 70 70 + "tags": ["memory", "blocks", "user"] 71 71 + }, 72 72 + ] 73 73 + 74 74 + 75 75 + def register_tools(agent_name: str = "void", tools: List[str] = None): 76 76 + """Register tools with a Letta agent. 77 77 + 78 78 + Args: 79 79 + agent_name: Name of the agent to attach tools to 80 80 + tools: List of tool names to register. If None, registers all tools. 81 81 + """ 82 82 + try: 83 83 + # Initialize Letta client with API key 84 84 + client = Letta(token=os.environ["LETTA_API_KEY"]) 85 85 + 86 86 + # Find the agent 87 87 + agents = client.agents.list() 88 88 + agent = None 89 89 + for a in agents: 90 90 + if a.name == agent_name: 91 91 + agent = a 92 92 + break 93 93 + 94 94 + if not agent: 95 95 + console.print(f"[red]Error: Agent '{agent_name}' not found[/red]") 96 96 + console.print("\nAvailable agents:") 97 97 + for a in agents: 98 98 + console.print(f" - {a.name}") 99 99 + return 100 100 + 101 101 + # Filter tools if specific ones requested 102 102 + tools_to_register = TOOL_CONFIGS 103 103 + if tools: 104 104 + tools_to_register = [t for t in TOOL_CONFIGS if t["func"].__name__ in tools] 105 105 + if len(tools_to_register) != len(tools): 106 106 + missing = set(tools) - {t["func"].__name__ for t in tools_to_register} 107 107 + console.print(f"[yellow]Warning: Unknown tools: {missing}[/yellow]") 108 108 + 109 109 + # Create results table 110 110 + table = Table(title=f"Tool Registration for Agent '{agent_name}'") 111 111 + table.add_column("Tool", style="cyan") 112 112 + table.add_column("Status", style="green") 113 113 + table.add_column("Description") 114 114 + 115 115 + # Register each tool 116 116 + for tool_config in tools_to_register: 117 117 + func = tool_config["func"] 118 118 + tool_name = func.__name__ 119 119 + 120 120 + try: 121 121 + # Create or update the tool using the standalone function 122 122 + created_tool = client.tools.upsert_from_function( 123 123 + func=func, 124 124 + args_schema=tool_config["args_schema"], 125 125 + tags=tool_config["tags"] 126 126 + ) 127 127 + 128 128 + # Get current agent tools 129 129 + current_tools = client.agents.tools.list(agent_id=str(agent.id)) 130 130 + tool_names = [t.name for t in current_tools] 131 131 + 132 132 + # Check if already attached 133 133 + if created_tool.name in tool_names: 134 134 + table.add_row(tool_name, "Already Attached", tool_config["description"]) 135 135 + else: 136 136 + # Attach to agent 137 137 + client.agents.tools.attach( 138 138 + agent_id=str(agent.id), 139 139 + tool_id=str(created_tool.id) 140 140 + ) 141 141 + table.add_row(tool_name, "✓ Attached", tool_config["description"]) 142 142 + 143 143 + except Exception as e: 144 144 + table.add_row(tool_name, f"✗ Error: {str(e)}", tool_config["description"]) 145 145 + logger.error(f"Error registering tool {tool_name}: {e}") 146 146 + 147 147 + console.print(table) 148 148 + 149 149 + except Exception as e: 150 150 + console.print(f"[red]Error: {str(e)}[/red]") 151 151 + logger.error(f"Fatal error: {e}") 152 152 + 153 153 + 154 154 + def list_available_tools(): 155 155 + """List all available tools.""" 156 156 + table = Table(title="Available Void Tools") 157 157 + table.add_column("Tool Name", style="cyan") 158 158 + table.add_column("Description") 159 159 + table.add_column("Tags", style="dim") 160 160 + 161 161 + for tool_config in TOOL_CONFIGS: 162 162 + table.add_row( 163 163 + tool_config["func"].__name__, 164 164 + tool_config["description"], 165 165 + ", ".join(tool_config["tags"]) 166 166 + ) 167 167 + 168 168 + console.print(table) 169 169 + 170 170 + 171 171 + if __name__ == "__main__": 172 172 + import argparse 173 173 + 174 174 + parser = argparse.ArgumentParser(description="Register Void tools with a Letta agent") 175 175 + parser.add_argument("agent", nargs="?", default="void", help="Agent name (default: void)") 176 176 + parser.add_argument("--tools", nargs="+", help="Specific tools to register (default: all)") 177 177 + parser.add_argument("--list", action="store_true", help="List available tools") 178 178 + 179 179 + args = parser.parse_args() 180 180 + 181 181 + if args.list: 182 182 + list_available_tools() 183 183 + else: 184 184 + console.print(f"\n[bold]Registering tools for agent: {args.agent}[/bold]\n") 185 185 + register_tools(args.agent, args.tools)

+32

tools/__init__.py

··· 1 1 + """Void tools for Bluesky interaction.""" 2 2 + from .functions import ( 3 3 + search_bluesky_posts, 4 4 + post_to_bluesky, 5 5 + get_bluesky_feed, 6 6 + attach_user_blocks, 7 7 + detach_user_blocks, 8 8 + update_user_blocks, 9 9 + ) 10 10 + 11 11 + # Also export Pydantic models for external use 12 12 + from .search import SearchArgs 13 13 + from .post import PostArgs 14 14 + from .feed import FeedArgs 15 15 + from .blocks import AttachUserBlockArgs, DetachUserBlockArgs, UpdateUserBlockArgs 16 16 + 17 17 + __all__ = [ 18 18 + # Functions 19 19 + "search_bluesky_posts", 20 20 + "post_to_bluesky", 21 21 + "get_bluesky_feed", 22 22 + "attach_user_blocks", 23 23 + "detach_user_blocks", 24 24 + "update_user_blocks", 25 25 + # Pydantic models 26 26 + "SearchArgs", 27 27 + "PostArgs", 28 28 + "FeedArgs", 29 29 + "AttachUserBlockArgs", 30 30 + "DetachUserBlockArgs", 31 31 + "UpdateUserBlockArgs", 32 32 + ]

+192

tools/blocks.py

··· 1 1 + """Block management tools for user-specific memory blocks.""" 2 2 + import logging 3 3 + from typing import List, Type 4 4 + from pydantic import BaseModel, Field 5 5 + from letta_client.client import BaseTool 6 6 + from letta_client import Letta 7 7 + 8 8 + 9 9 + logger = logging.getLogger(__name__) 10 10 + 11 11 + 12 12 + class AttachUserBlockArgs(BaseModel): 13 13 + handles: List[str] = Field(..., description="List of user Bluesky handles (e.g., ['user1.bsky.social', 'user2.bsky.social'])") 14 14 + 15 15 + 16 16 + class AttachUserBlockTool(BaseTool): 17 17 + name: str = "attach_user_blocks" 18 18 + args_schema: Type[BaseModel] = AttachUserBlockArgs 19 19 + description: str = "Attach user-specific memory blocks to the agent. Creates blocks if they don't exist." 20 20 + tags: List[str] = ["memory", "blocks", "user"] 21 21 + 22 22 + def run(self, handles: List[str], agent_state: "AgentState") -> str: 23 23 + """Attach user-specific memory blocks.""" 24 24 + import os 25 25 + from letta_client import Letta 26 26 + 27 27 + try: 28 28 + client = Letta(token=os.environ["LETTA_API_KEY"]) 29 29 + results = [] 30 30 + 31 31 + # Get current blocks 32 32 + current_blocks = agent_state.block_ids 33 33 + current_block_labels = set() 34 34 + for block_id in current_blocks: 35 35 + block = client.blocks.get(block_id) 36 36 + current_block_labels.add(block.label) 37 37 + 38 38 + for handle in handles: 39 39 + # Sanitize handle for block label - completely self-contained 40 40 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') 41 41 + block_label = f"user_{clean_handle}" 42 42 + 43 43 + # Skip if already attached 44 44 + if block_label in current_block_labels: 45 45 + results.append(f"✓ {handle}: Already attached") 46 46 + continue 47 47 + 48 48 + # Check if block exists or create new one 49 49 + try: 50 50 + blocks = client.blocks.list(label=block_label) 51 51 + if blocks and len(blocks) > 0: 52 52 + block = blocks[0] 53 53 + logger.info(f"Found existing block: {block_label}") 54 54 + else: 55 55 + block = client.blocks.create( 56 56 + label=block_label, 57 57 + value=f"# User: {handle}\n\nNo information about this user yet.", 58 58 + limit=5000 59 59 + ) 60 60 + logger.info(f"Created new block: {block_label}") 61 61 + 62 62 + # Attach block individually to avoid race conditions 63 63 + client.agents.blocks.attach( 64 64 + agent_id=str(agent_state.id), 65 65 + block_id=str(block.id), 66 66 + enable_sleeptime=False, 67 67 + ) 68 68 + results.append(f"✓ {handle}: Block attached") 69 69 + 70 70 + except Exception as e: 71 71 + results.append(f"✗ {handle}: Error - {str(e)}") 72 72 + logger.error(f"Error processing block for {handle}: {e}") 73 73 + 74 74 + return f"Attachment results:\n" + "\n".join(results) 75 75 + 76 76 + except Exception as e: 77 77 + logger.error(f"Error attaching user blocks: {e}") 78 78 + raise e 79 79 + 80 80 + 81 81 + class DetachUserBlockArgs(BaseModel): 82 82 + handles: List[str] = Field(..., description="List of user Bluesky handles (e.g., ['user1.bsky.social', 'user2.bsky.social'])") 83 83 + 84 84 + 85 85 + class DetachUserBlockTool(BaseTool): 86 86 + name: str = "detach_user_blocks" 87 87 + args_schema: Type[BaseModel] = DetachUserBlockArgs 88 88 + description: str = "Detach user-specific memory blocks from the agent. Blocks are preserved for later use." 89 89 + tags: List[str] = ["memory", "blocks", "user"] 90 90 + 91 91 + def run(self, handles: List[str], agent_state: "AgentState") -> str: 92 92 + """Detach user-specific memory blocks.""" 93 93 + import os 94 94 + from letta_client import Letta 95 95 + 96 96 + try: 97 97 + client = Letta(token=os.environ["LETTA_API_KEY"]) 98 98 + results = [] 99 99 + blocks_to_remove = set() 100 100 + 101 101 + # Build mapping of block labels to IDs 102 102 + current_blocks = agent_state.block_ids 103 103 + block_label_to_id = {} 104 104 + 105 105 + for block_id in current_blocks: 106 106 + block = client.blocks.get(block_id) 107 107 + block_label_to_id[block.label] = block_id 108 108 + 109 109 + # Process each handle 110 110 + for handle in handles: 111 111 + # Sanitize handle for block label - completely self-contained 112 112 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') 113 113 + block_label = f"user_{clean_handle}" 114 114 + 115 115 + if block_label in block_label_to_id: 116 116 + blocks_to_remove.add(block_label_to_id[block_label]) 117 117 + results.append(f"✓ {handle}: Detached") 118 118 + else: 119 119 + results.append(f"✗ {handle}: Not attached") 120 120 + 121 121 + # Remove blocks from agent one by one 122 122 + for block_id in blocks_to_remove: 123 123 + client.agents.blocks.detach( 124 124 + agent_id=str(agent_state.id), 125 125 + block_id=block_id 126 126 + ) 127 127 + 128 128 + return f"Detachment results:\n" + "\n".join(results) 129 129 + 130 130 + except Exception as e: 131 131 + logger.error(f"Error detaching user blocks: {e}") 132 132 + return f"Error detaching user blocks: {str(e)}" 133 133 + 134 134 + 135 135 + class UserBlockUpdate(BaseModel): 136 136 + handle: str = Field(..., description="User's Bluesky handle (e.g., 'user.bsky.social')") 137 137 + content: str = Field(..., description="New content for the user's memory block") 138 138 + 139 139 + 140 140 + class UpdateUserBlockArgs(BaseModel): 141 141 + updates: List[UserBlockUpdate] = Field(..., description="List of user block updates") 142 142 + 143 143 + 144 144 + class UpdateUserBlockTool(BaseTool): 145 145 + name: str = "update_user_blocks" 146 146 + args_schema: Type[BaseModel] = UpdateUserBlockArgs 147 147 + description: str = "Update the content of user-specific memory blocks" 148 148 + tags: List[str] = ["memory", "blocks", "user"] 149 149 + 150 150 + def run(self, updates: List[UserBlockUpdate]) -> str: 151 151 + """Update user-specific memory blocks.""" 152 152 + import os 153 153 + from letta_client import Letta 154 154 + 155 155 + try: 156 156 + client = Letta(token=os.environ["LETTA_API_KEY"]) 157 157 + results = [] 158 158 + 159 159 + for update in updates: 160 160 + handle = update.handle 161 161 + new_content = update.content 162 162 + # Sanitize handle for block label - completely self-contained 163 163 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') 164 164 + block_label = f"user_{clean_handle}" 165 165 + 166 166 + try: 167 167 + # Find the block 168 168 + blocks = client.blocks.list(label=block_label) 169 169 + if not blocks or len(blocks) == 0: 170 170 + results.append(f"✗ {handle}: Block not found - use attach_user_blocks first") 171 171 + continue 172 172 + 173 173 + block = blocks[0] 174 174 + 175 175 + # Update block content 176 176 + updated_block = client.blocks.modify( 177 177 + block_id=str(block.id), 178 178 + value=new_content 179 179 + ) 180 180 + 181 181 + preview = new_content[:100] + "..." if len(new_content) > 100 else new_content 182 182 + results.append(f"✓ {handle}: Updated - {preview}") 183 183 + 184 184 + except Exception as e: 185 185 + results.append(f"✗ {handle}: Error - {str(e)}") 186 186 + logger.error(f"Error updating block for {handle}: {e}") 187 187 + 188 188 + return f"Update results:\n" + "\n".join(results) 189 189 + 190 190 + except Exception as e: 191 191 + logger.error(f"Error updating user blocks: {e}") 192 192 + return f"Error updating user blocks: {str(e)}"

+139

tools/feed.py

··· 1 1 + """Feed tool for retrieving Bluesky feeds.""" 2 2 + from typing import List, Type, Optional 3 3 + from pydantic import BaseModel, Field 4 4 + from letta_client.client import BaseTool 5 5 + 6 6 + 7 7 + class FeedArgs(BaseModel): 8 8 + feed_uri: Optional[str] = Field(None, description="Custom feed URI (e.g., 'at://did:plc:abc/app.bsky.feed.generator/feed-name'). If not provided, returns home timeline") 9 9 + max_posts: int = Field(default=25, description="Maximum number of posts to retrieve (max 100)") 10 10 + 11 11 + 12 12 + class GetBlueskyFeedTool(BaseTool): 13 13 + name: str = "get_bluesky_feed" 14 14 + args_schema: Type[BaseModel] = FeedArgs 15 15 + description: str = "Retrieve a Bluesky feed (home timeline or custom feed)" 16 16 + tags: List[str] = ["bluesky", "feed", "timeline"] 17 17 + 18 18 + def run(self, feed_uri: Optional[str] = None, max_posts: int = 25) -> str: 19 19 + """Retrieve a Bluesky feed.""" 20 20 + import os 21 21 + import yaml 22 22 + import requests 23 23 + 24 24 + try: 25 25 + # Validate inputs 26 26 + max_posts = min(max_posts, 100) 27 27 + 28 28 + # Get credentials from environment 29 29 + username = os.getenv("BSKY_USERNAME") 30 30 + password = os.getenv("BSKY_PASSWORD") 31 31 + pds_host = os.getenv("PDS_URI", "https://bsky.social") 32 32 + 33 33 + if not username or not password: 34 34 + return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set" 35 35 + 36 36 + # Create session 37 37 + session_url = f"{pds_host}/xrpc/com.atproto.server.createSession" 38 38 + session_data = { 39 39 + "identifier": username, 40 40 + "password": password 41 41 + } 42 42 + 43 43 + try: 44 44 + session_response = requests.post(session_url, json=session_data, timeout=10) 45 45 + session_response.raise_for_status() 46 46 + session = session_response.json() 47 47 + access_token = session.get("accessJwt") 48 48 + 49 49 + if not access_token: 50 50 + return "Error: Failed to get access token from session" 51 51 + except Exception as e: 52 52 + return f"Error: Authentication failed. ({str(e)})" 53 53 + 54 54 + # Get feed 55 55 + headers = {"Authorization": f"Bearer {access_token}"} 56 56 + 57 57 + if feed_uri: 58 58 + # Custom feed 59 59 + feed_url = f"{pds_host}/xrpc/app.bsky.feed.getFeed" 60 60 + params = { 61 61 + "feed": feed_uri, 62 62 + "limit": max_posts 63 63 + } 64 64 + feed_type = "custom" 65 65 + feed_name = feed_uri.split('/')[-1] if '/' in feed_uri else feed_uri 66 66 + else: 67 67 + # Home timeline 68 68 + feed_url = f"{pds_host}/xrpc/app.bsky.feed.getTimeline" 69 69 + params = { 70 70 + "limit": max_posts 71 71 + } 72 72 + feed_type = "home" 73 73 + feed_name = "timeline" 74 74 + 75 75 + try: 76 76 + response = requests.get(feed_url, headers=headers, params=params, timeout=10) 77 77 + response.raise_for_status() 78 78 + feed_data = response.json() 79 79 + except Exception as e: 80 80 + return f"Error: Failed to get feed. ({str(e)})" 81 81 + 82 82 + # Format posts 83 83 + posts = [] 84 84 + for item in feed_data.get("feed", []): 85 85 + post = item.get("post", {}) 86 86 + author = post.get("author", {}) 87 87 + record = post.get("record", {}) 88 88 + 89 89 + post_data = { 90 90 + "author": { 91 91 + "handle": author.get("handle", ""), 92 92 + "display_name": author.get("displayName", ""), 93 93 + }, 94 94 + "text": record.get("text", ""), 95 95 + "created_at": record.get("createdAt", ""), 96 96 + "uri": post.get("uri", ""), 97 97 + "cid": post.get("cid", ""), 98 98 + "like_count": post.get("likeCount", 0), 99 99 + "repost_count": post.get("repostCount", 0), 100 100 + "reply_count": post.get("replyCount", 0), 101 101 + } 102 102 + 103 103 + # Add repost info if present 104 104 + if "reason" in item and item["reason"]: 105 105 + reason = item["reason"] 106 106 + if reason.get("$type") == "app.bsky.feed.defs#reasonRepost": 107 107 + by = reason.get("by", {}) 108 108 + post_data["reposted_by"] = { 109 109 + "handle": by.get("handle", ""), 110 110 + "display_name": by.get("displayName", ""), 111 111 + } 112 112 + 113 113 + # Add reply info if present 114 114 + if "reply" in record and record["reply"]: 115 115 + parent = record["reply"].get("parent", {}) 116 116 + post_data["reply_to"] = { 117 117 + "uri": parent.get("uri", ""), 118 118 + "cid": parent.get("cid", ""), 119 119 + } 120 120 + 121 121 + posts.append(post_data) 122 122 + 123 123 + # Format response 124 124 + feed_result = { 125 125 + "feed": { 126 126 + "type": feed_type, 127 127 + "name": feed_name, 128 128 + "post_count": len(posts), 129 129 + "posts": posts 130 130 + } 131 131 + } 132 132 + 133 133 + if feed_uri: 134 134 + feed_result["feed"]["uri"] = feed_uri 135 135 + 136 136 + return yaml.dump(feed_result, default_flow_style=False, sort_keys=False) 137 137 + 138 138 + except Exception as e: 139 139 + return f"Error retrieving feed: {str(e)}"

+571

tools/functions.py

··· 1 1 + """Standalone tool functions for Void Bluesky agent.""" 2 2 + 3 3 + 4 4 + def search_bluesky_posts(query: str, max_results: int = 25, author: str = None, sort: str = "latest") -> str: 5 5 + """ 6 6 + Search for posts on Bluesky matching the given criteria. 7 7 + 8 8 + Args: 9 9 + query: Search query string 10 10 + max_results: Maximum number of results to return (max 100) 11 11 + author: Filter by author handle (e.g., 'user.bsky.social') 12 12 + sort: Sort order: 'latest' or 'top' 13 13 + 14 14 + Returns: 15 15 + YAML-formatted search results with posts and metadata 16 16 + """ 17 17 + import os 18 18 + import yaml 19 19 + import requests 20 20 + from datetime import datetime 21 21 + 22 22 + try: 23 23 + # Validate inputs 24 24 + max_results = min(max_results, 100) 25 25 + if sort not in ["latest", "top"]: 26 26 + sort = "latest" 27 27 + 28 28 + # Build search query 29 29 + search_query = query 30 30 + if author: 31 31 + search_query = f"from:{author} {query}" 32 32 + 33 33 + # Get credentials from environment 34 34 + username = os.getenv("BSKY_USERNAME") 35 35 + password = os.getenv("BSKY_PASSWORD") 36 36 + pds_host = os.getenv("PDS_URI", "https://bsky.social") 37 37 + 38 38 + if not username or not password: 39 39 + return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set" 40 40 + 41 41 + # Create session 42 42 + session_url = f"{pds_host}/xrpc/com.atproto.server.createSession" 43 43 + session_data = { 44 44 + "identifier": username, 45 45 + "password": password 46 46 + } 47 47 + 48 48 + try: 49 49 + session_response = requests.post(session_url, json=session_data, timeout=10) 50 50 + session_response.raise_for_status() 51 51 + session = session_response.json() 52 52 + access_token = session.get("accessJwt") 53 53 + 54 54 + if not access_token: 55 55 + return "Error: Failed to get access token from session" 56 56 + except Exception as e: 57 57 + return f"Error: Authentication failed. ({str(e)})" 58 58 + 59 59 + # Search posts 60 60 + headers = {"Authorization": f"Bearer {access_token}"} 61 61 + search_url = f"{pds_host}/xrpc/app.bsky.feed.searchPosts" 62 62 + params = { 63 63 + "q": search_query, 64 64 + "limit": max_results, 65 65 + "sort": sort 66 66 + } 67 67 + 68 68 + try: 69 69 + response = requests.get(search_url, headers=headers, params=params, timeout=10) 70 70 + response.raise_for_status() 71 71 + search_data = response.json() 72 72 + except Exception as e: 73 73 + return f"Error: Search failed. ({str(e)})" 74 74 + 75 75 + # Format results 76 76 + results = [] 77 77 + for post in search_data.get("posts", []): 78 78 + author = post.get("author", {}) 79 79 + record = post.get("record", {}) 80 80 + 81 81 + post_data = { 82 82 + "author": { 83 83 + "handle": author.get("handle", ""), 84 84 + "display_name": author.get("displayName", ""), 85 85 + }, 86 86 + "text": record.get("text", ""), 87 87 + "created_at": record.get("createdAt", ""), 88 88 + "uri": post.get("uri", ""), 89 89 + "cid": post.get("cid", ""), 90 90 + "like_count": post.get("likeCount", 0), 91 91 + "repost_count": post.get("repostCount", 0), 92 92 + "reply_count": post.get("replyCount", 0), 93 93 + } 94 94 + 95 95 + # Add reply info if present 96 96 + if "reply" in record and record["reply"]: 97 97 + post_data["reply_to"] = { 98 98 + "uri": record["reply"].get("parent", {}).get("uri", ""), 99 99 + "cid": record["reply"].get("parent", {}).get("cid", ""), 100 100 + } 101 101 + 102 102 + results.append(post_data) 103 103 + 104 104 + return yaml.dump({ 105 105 + "search_results": { 106 106 + "query": query, 107 107 + "author_filter": author, 108 108 + "sort": sort, 109 109 + "result_count": len(results), 110 110 + "posts": results 111 111 + } 112 112 + }, default_flow_style=False, sort_keys=False) 113 113 + 114 114 + except Exception as e: 115 115 + return f"Error searching Bluesky: {str(e)}" 116 116 + 117 117 + 118 118 + def post_to_bluesky(text: str) -> str: 119 119 + """Post a message to Bluesky.""" 120 120 + import os 121 121 + import requests 122 122 + from datetime import datetime, timezone 123 123 + 124 124 + try: 125 125 + # Validate character limit 126 126 + if len(text) > 300: 127 127 + return f"Error: Post exceeds 300 character limit (current: {len(text)} characters)" 128 128 + 129 129 + # Get credentials from environment 130 130 + username = os.getenv("BSKY_USERNAME") 131 131 + password = os.getenv("BSKY_PASSWORD") 132 132 + pds_host = os.getenv("PDS_URI", "https://bsky.social") 133 133 + 134 134 + if not username or not password: 135 135 + return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set" 136 136 + 137 137 + # Create session 138 138 + session_url = f"{pds_host}/xrpc/com.atproto.server.createSession" 139 139 + session_data = { 140 140 + "identifier": username, 141 141 + "password": password 142 142 + } 143 143 + 144 144 + session_response = requests.post(session_url, json=session_data, timeout=10) 145 145 + session_response.raise_for_status() 146 146 + session = session_response.json() 147 147 + access_token = session.get("accessJwt") 148 148 + user_did = session.get("did") 149 149 + 150 150 + if not access_token or not user_did: 151 151 + return "Error: Failed to get access token or DID from session" 152 152 + 153 153 + # Build post record with facets for mentions and URLs 154 154 + now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") 155 155 + 156 156 + post_record = { 157 157 + "$type": "app.bsky.feed.post", 158 158 + "text": text, 159 159 + "createdAt": now, 160 160 + } 161 161 + 162 162 + # Add facets for mentions and URLs 163 163 + import re 164 164 + facets = [] 165 165 + 166 166 + # Parse mentions 167 167 + 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])?)" 168 168 + text_bytes = text.encode("UTF-8") 169 169 + 170 170 + for m in re.finditer(mention_regex, text_bytes): 171 171 + handle = m.group(1)[1:].decode("UTF-8") # Remove @ prefix 172 172 + try: 173 173 + resolve_resp = requests.get( 174 174 + f"{pds_host}/xrpc/com.atproto.identity.resolveHandle", 175 175 + params={"handle": handle}, 176 176 + timeout=5 177 177 + ) 178 178 + if resolve_resp.status_code == 200: 179 179 + did = resolve_resp.json()["did"] 180 180 + facets.append({ 181 181 + "index": { 182 182 + "byteStart": m.start(1), 183 183 + "byteEnd": m.end(1), 184 184 + }, 185 185 + "features": [{"$type": "app.bsky.richtext.facet#mention", "did": did}], 186 186 + }) 187 187 + except: 188 188 + continue 189 189 + 190 190 + # Parse URLs 191 191 + 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@%_\+~#//=])?)" 192 192 + 193 193 + for m in re.finditer(url_regex, text_bytes): 194 194 + url = m.group(1).decode("UTF-8") 195 195 + facets.append({ 196 196 + "index": { 197 197 + "byteStart": m.start(1), 198 198 + "byteEnd": m.end(1), 199 199 + }, 200 200 + "features": [{"$type": "app.bsky.richtext.facet#link", "uri": url}], 201 201 + }) 202 202 + 203 203 + if facets: 204 204 + post_record["facets"] = facets 205 205 + 206 206 + # Create the post 207 207 + create_record_url = f"{pds_host}/xrpc/com.atproto.repo.createRecord" 208 208 + headers = {"Authorization": f"Bearer {access_token}"} 209 209 + 210 210 + create_data = { 211 211 + "repo": user_did, 212 212 + "collection": "app.bsky.feed.post", 213 213 + "record": post_record 214 214 + } 215 215 + 216 216 + post_response = requests.post(create_record_url, headers=headers, json=create_data, timeout=10) 217 217 + post_response.raise_for_status() 218 218 + result = post_response.json() 219 219 + 220 220 + post_uri = result.get("uri") 221 221 + handle = session.get("handle", username) 222 222 + rkey = post_uri.split("/")[-1] if post_uri else "" 223 223 + post_url = f"https://bsky.app/profile/{handle}/post/{rkey}" 224 224 + 225 225 + return f"Successfully posted to Bluesky!\nPost URL: {post_url}\nText: {text}" 226 226 + 227 227 + except Exception as e: 228 228 + return f"Error posting to Bluesky: {str(e)}" 229 229 + 230 230 + 231 231 + def get_bluesky_feed(feed_uri: str = None, max_posts: int = 25) -> str: 232 232 + """ 233 233 + Retrieve a Bluesky feed (home timeline or custom feed). 234 234 + 235 235 + Args: 236 236 + feed_uri: Custom feed URI (e.g., 'at://did:plc:abc/app.bsky.feed.generator/feed-name'). If not provided, returns home timeline 237 237 + max_posts: Maximum number of posts to retrieve (max 100) 238 238 + 239 239 + Returns: 240 240 + YAML-formatted feed data with posts and metadata 241 241 + """ 242 242 + import os 243 243 + import yaml 244 244 + import requests 245 245 + 246 246 + try: 247 247 + # Validate inputs 248 248 + max_posts = min(max_posts, 100) 249 249 + 250 250 + # Get credentials from environment 251 251 + username = os.getenv("BSKY_USERNAME") 252 252 + password = os.getenv("BSKY_PASSWORD") 253 253 + pds_host = os.getenv("PDS_URI", "https://bsky.social") 254 254 + 255 255 + if not username or not password: 256 256 + return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set" 257 257 + 258 258 + # Create session 259 259 + session_url = f"{pds_host}/xrpc/com.atproto.server.createSession" 260 260 + session_data = { 261 261 + "identifier": username, 262 262 + "password": password 263 263 + } 264 264 + 265 265 + try: 266 266 + session_response = requests.post(session_url, json=session_data, timeout=10) 267 267 + session_response.raise_for_status() 268 268 + session = session_response.json() 269 269 + access_token = session.get("accessJwt") 270 270 + 271 271 + if not access_token: 272 272 + return "Error: Failed to get access token from session" 273 273 + except Exception as e: 274 274 + return f"Error: Authentication failed. ({str(e)})" 275 275 + 276 276 + # Get feed 277 277 + headers = {"Authorization": f"Bearer {access_token}"} 278 278 + 279 279 + if feed_uri: 280 280 + # Custom feed 281 281 + feed_url = f"{pds_host}/xrpc/app.bsky.feed.getFeed" 282 282 + params = { 283 283 + "feed": feed_uri, 284 284 + "limit": max_posts 285 285 + } 286 286 + feed_type = "custom" 287 287 + feed_name = feed_uri.split('/')[-1] if '/' in feed_uri else feed_uri 288 288 + else: 289 289 + # Home timeline 290 290 + feed_url = f"{pds_host}/xrpc/app.bsky.feed.getTimeline" 291 291 + params = { 292 292 + "limit": max_posts 293 293 + } 294 294 + feed_type = "home" 295 295 + feed_name = "timeline" 296 296 + 297 297 + try: 298 298 + response = requests.get(feed_url, headers=headers, params=params, timeout=10) 299 299 + response.raise_for_status() 300 300 + feed_data = response.json() 301 301 + except Exception as e: 302 302 + return f"Error: Failed to get feed. ({str(e)})" 303 303 + 304 304 + # Format posts 305 305 + posts = [] 306 306 + for item in feed_data.get("feed", []): 307 307 + post = item.get("post", {}) 308 308 + author = post.get("author", {}) 309 309 + record = post.get("record", {}) 310 310 + 311 311 + post_data = { 312 312 + "author": { 313 313 + "handle": author.get("handle", ""), 314 314 + "display_name": author.get("displayName", ""), 315 315 + }, 316 316 + "text": record.get("text", ""), 317 317 + "created_at": record.get("createdAt", ""), 318 318 + "uri": post.get("uri", ""), 319 319 + "cid": post.get("cid", ""), 320 320 + "like_count": post.get("likeCount", 0), 321 321 + "repost_count": post.get("repostCount", 0), 322 322 + "reply_count": post.get("replyCount", 0), 323 323 + } 324 324 + 325 325 + # Add repost info if present 326 326 + if "reason" in item and item["reason"]: 327 327 + reason = item["reason"] 328 328 + if reason.get("$type") == "app.bsky.feed.defs#reasonRepost": 329 329 + by = reason.get("by", {}) 330 330 + post_data["reposted_by"] = { 331 331 + "handle": by.get("handle", ""), 332 332 + "display_name": by.get("displayName", ""), 333 333 + } 334 334 + 335 335 + # Add reply info if present 336 336 + if "reply" in record and record["reply"]: 337 337 + parent = record["reply"].get("parent", {}) 338 338 + post_data["reply_to"] = { 339 339 + "uri": parent.get("uri", ""), 340 340 + "cid": parent.get("cid", ""), 341 341 + } 342 342 + 343 343 + posts.append(post_data) 344 344 + 345 345 + # Format response 346 346 + feed_result = { 347 347 + "feed": { 348 348 + "type": feed_type, 349 349 + "name": feed_name, 350 350 + "post_count": len(posts), 351 351 + "posts": posts 352 352 + } 353 353 + } 354 354 + 355 355 + if feed_uri: 356 356 + feed_result["feed"]["uri"] = feed_uri 357 357 + 358 358 + return yaml.dump(feed_result, default_flow_style=False, sort_keys=False) 359 359 + 360 360 + except Exception as e: 361 361 + return f"Error retrieving feed: {str(e)}" 362 362 + 363 363 + 364 364 + def attach_user_blocks(handles: list, agent_state: "AgentState") -> str: 365 365 + """ 366 366 + Attach user-specific memory blocks to the agent. Creates blocks if they don't exist. 367 367 + 368 368 + Args: 369 369 + handles: List of user Bluesky handles (e.g., ['user1.bsky.social', 'user2.bsky.social']) 370 370 + agent_state: The agent state object containing agent information 371 371 + 372 372 + Returns: 373 373 + String with attachment results for each handle 374 374 + """ 375 375 + import os 376 376 + import logging 377 377 + from letta_client import Letta 378 378 + 379 379 + logger = logging.getLogger(__name__) 380 380 + 381 381 + try: 382 382 + client = Letta(token=os.environ["LETTA_API_KEY"]) 383 383 + results = [] 384 384 + 385 385 + # Get current blocks using the API 386 386 + current_blocks = client.agents.blocks.list(agent_id=str(agent_state.id)) 387 387 + current_block_labels = set() 388 388 + current_block_ids = [] 389 389 + 390 390 + for block in current_blocks: 391 391 + current_block_labels.add(block.label) 392 392 + current_block_ids.append(str(block.id)) 393 393 + 394 394 + # Collect new blocks to attach 395 395 + new_block_ids = [] 396 396 + 397 397 + for handle in handles: 398 398 + # Sanitize handle for block label - completely self-contained 399 399 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') 400 400 + block_label = f"user_{clean_handle}" 401 401 + 402 402 + # Skip if already attached 403 403 + if block_label in current_block_labels: 404 404 + results.append(f"✓ {handle}: Already attached") 405 405 + continue 406 406 + 407 407 + # Check if block exists or create new one 408 408 + try: 409 409 + blocks = client.blocks.list(label=block_label) 410 410 + if blocks and len(blocks) > 0: 411 411 + block = blocks[0] 412 412 + logger.info(f"Found existing block: {block_label}") 413 413 + else: 414 414 + block = client.blocks.create( 415 415 + label=block_label, 416 416 + value=f"# User: {handle}\n\nNo information about this user yet.", 417 417 + limit=5000 418 418 + ) 419 419 + logger.info(f"Created new block: {block_label}") 420 420 + 421 421 + new_block_ids.append(str(block.id)) 422 422 + results.append(f"✓ {handle}: Block ready to attach") 423 423 + 424 424 + except Exception as e: 425 425 + results.append(f"✗ {handle}: Error - {str(e)}") 426 426 + logger.error(f"Error processing block for {handle}: {e}") 427 427 + 428 428 + # Attach all new blocks at once if there are any 429 429 + if new_block_ids: 430 430 + try: 431 431 + all_block_ids = current_block_ids + new_block_ids 432 432 + client.agents.modify( 433 433 + agent_id=str(agent_state.id), 434 434 + block_ids=all_block_ids 435 435 + ) 436 436 + logger.info(f"Successfully attached {len(new_block_ids)} new blocks to agent") 437 437 + except Exception as e: 438 438 + logger.error(f"Error attaching blocks to agent: {e}") 439 439 + return f"Error attaching blocks to agent: {str(e)}" 440 440 + 441 441 + return f"Attachment results:\n" + "\n".join(results) 442 442 + 443 443 + except Exception as e: 444 444 + logger.error(f"Error attaching user blocks: {e}") 445 445 + return f"Error attaching user blocks: {str(e)}" 446 446 + 447 447 + 448 448 + def detach_user_blocks(handles: list, agent_state: "AgentState") -> str: 449 449 + """ 450 450 + Detach user-specific memory blocks from the agent. Blocks are preserved for later use. 451 451 + 452 452 + Args: 453 453 + handles: List of user Bluesky handles (e.g., ['user1.bsky.social', 'user2.bsky.social']) 454 454 + agent_state: The agent state object containing agent information 455 455 + 456 456 + Returns: 457 457 + String with detachment results for each handle 458 458 + """ 459 459 + import os 460 460 + import logging 461 461 + from letta_client import Letta 462 462 + 463 463 + logger = logging.getLogger(__name__) 464 464 + 465 465 + try: 466 466 + client = Letta(token=os.environ["LETTA_API_KEY"]) 467 467 + results = [] 468 468 + blocks_to_remove = set() 469 469 + 470 470 + # Build mapping of block labels to IDs using the API 471 471 + current_blocks = client.agents.blocks.list(agent_id=str(agent_state.id)) 472 472 + block_label_to_id = {} 473 473 + all_block_ids = [] 474 474 + 475 475 + for block in current_blocks: 476 476 + block_label_to_id[block.label] = str(block.id) 477 477 + all_block_ids.append(str(block.id)) 478 478 + 479 479 + # Process each handle and collect blocks to remove 480 480 + for handle in handles: 481 481 + # Sanitize handle for block label - completely self-contained 482 482 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') 483 483 + block_label = f"user_{clean_handle}" 484 484 + 485 485 + if block_label in block_label_to_id: 486 486 + blocks_to_remove.add(block_label_to_id[block_label]) 487 487 + results.append(f"✓ {handle}: Marked for detachment") 488 488 + else: 489 489 + results.append(f"✗ {handle}: Not attached") 490 490 + 491 491 + # Remove all marked blocks at once if there are any 492 492 + if blocks_to_remove: 493 493 + try: 494 494 + # Filter out the blocks to remove 495 495 + remaining_block_ids = [bid for bid in all_block_ids if bid not in blocks_to_remove] 496 496 + client.agents.modify( 497 497 + agent_id=str(agent_state.id), 498 498 + block_ids=remaining_block_ids 499 499 + ) 500 500 + logger.info(f"Successfully detached {len(blocks_to_remove)} blocks from agent") 501 501 + except Exception as e: 502 502 + logger.error(f"Error detaching blocks from agent: {e}") 503 503 + return f"Error detaching blocks from agent: {str(e)}" 504 504 + 505 505 + return f"Detachment results:\n" + "\n".join(results) 506 506 + 507 507 + except Exception as e: 508 508 + logger.error(f"Error detaching user blocks: {e}") 509 509 + return f"Error detaching user blocks: {str(e)}" 510 510 + 511 511 + 512 512 + def update_user_blocks(updates: list, agent_state: "AgentState" = None) -> str: 513 513 + """ 514 514 + Update the content of user-specific memory blocks. 515 515 + 516 516 + Args: 517 517 + updates: List of dictionaries with 'handle' and 'content' keys 518 518 + agent_state: The agent state object (optional, used for consistency) 519 519 + 520 520 + Returns: 521 521 + String with update results for each handle 522 522 + """ 523 523 + import os 524 524 + import logging 525 525 + from letta_client import Letta 526 526 + 527 527 + logger = logging.getLogger(__name__) 528 528 + 529 529 + try: 530 530 + client = Letta(token=os.environ["LETTA_API_KEY"]) 531 531 + results = [] 532 532 + 533 533 + for update in updates: 534 534 + handle = update.get('handle') 535 535 + new_content = update.get('content') 536 536 + 537 537 + if not handle or not new_content: 538 538 + results.append(f"✗ Invalid update: missing handle or content") 539 539 + continue 540 540 + 541 541 + # Sanitize handle for block label - completely self-contained 542 542 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') 543 543 + block_label = f"user_{clean_handle}" 544 544 + 545 545 + try: 546 546 + # Find the block 547 547 + blocks = client.blocks.list(label=block_label) 548 548 + if not blocks or len(blocks) == 0: 549 549 + results.append(f"✗ {handle}: Block not found - use attach_user_blocks first") 550 550 + continue 551 551 + 552 552 + block = blocks[0] 553 553 + 554 554 + # Update block content 555 555 + updated_block = client.blocks.modify( 556 556 + block_id=str(block.id), 557 557 + value=new_content 558 558 + ) 559 559 + 560 560 + preview = new_content[:100] + "..." if len(new_content) > 100 else new_content 561 561 + results.append(f"✓ {handle}: Updated - {preview}") 562 562 + 563 563 + except Exception as e: 564 564 + results.append(f"✗ {handle}: Error - {str(e)}") 565 565 + logger.error(f"Error updating block for {handle}: {e}") 566 566 + 567 567 + return f"Update results:\n" + "\n".join(results) 568 568 + 569 569 + except Exception as e: 570 570 + logger.error(f"Error updating user blocks: {e}") 571 571 + return f"Error updating user blocks: {str(e)}"

+120

tools/search.py

··· 1 1 + """Search tool for Bluesky posts.""" 2 2 + from typing import List, Type, Optional 3 3 + from pydantic import BaseModel, Field 4 4 + from letta_client.client import BaseTool 5 5 + 6 6 + 7 7 + class SearchArgs(BaseModel): 8 8 + query: str = Field(..., description="Search query string") 9 9 + max_results: int = Field(default=25, description="Maximum number of results to return (max 100)") 10 10 + author: Optional[str] = Field(None, description="Filter by author handle (e.g., 'user.bsky.social')") 11 11 + sort: str = Field(default="latest", description="Sort order: 'latest' or 'top'") 12 12 + 13 13 + 14 14 + class SearchBlueskyTool(BaseTool): 15 15 + name: str = "search_bluesky_posts" 16 16 + args_schema: Type[BaseModel] = SearchArgs 17 17 + description: str = "Search for posts on Bluesky matching the given criteria" 18 18 + tags: List[str] = ["bluesky", "search", "posts"] 19 19 + 20 20 + def run(self, query: str, max_results: int = 25, author: Optional[str] = None, sort: str = "latest") -> str: 21 21 + """Search for posts on Bluesky.""" 22 22 + import os 23 23 + import yaml 24 24 + import requests 25 25 + from datetime import datetime 26 26 + 27 27 + try: 28 28 + # Validate inputs 29 29 + max_results = min(max_results, 100) 30 30 + if sort not in ["latest", "top"]: 31 31 + sort = "latest" 32 32 + 33 33 + # Build search query 34 34 + search_query = query 35 35 + if author: 36 36 + search_query = f"from:{author} {query}" 37 37 + 38 38 + # Get credentials from environment 39 39 + username = os.getenv("BSKY_USERNAME") 40 40 + password = os.getenv("BSKY_PASSWORD") 41 41 + pds_host = os.getenv("PDS_URI", "https://bsky.social") 42 42 + 43 43 + if not username or not password: 44 44 + return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set" 45 45 + 46 46 + # Create session 47 47 + session_url = f"{pds_host}/xrpc/com.atproto.server.createSession" 48 48 + session_data = { 49 49 + "identifier": username, 50 50 + "password": password 51 51 + } 52 52 + 53 53 + try: 54 54 + session_response = requests.post(session_url, json=session_data, timeout=10) 55 55 + session_response.raise_for_status() 56 56 + session = session_response.json() 57 57 + access_token = session.get("accessJwt") 58 58 + 59 59 + if not access_token: 60 60 + return "Error: Failed to get access token from session" 61 61 + except Exception as e: 62 62 + return f"Error: Authentication failed. ({str(e)})" 63 63 + 64 64 + # Search posts 65 65 + headers = {"Authorization": f"Bearer {access_token}"} 66 66 + search_url = f"{pds_host}/xrpc/app.bsky.feed.searchPosts" 67 67 + params = { 68 68 + "q": search_query, 69 69 + "limit": max_results, 70 70 + "sort": sort 71 71 + } 72 72 + 73 73 + try: 74 74 + response = requests.get(search_url, headers=headers, params=params, timeout=10) 75 75 + response.raise_for_status() 76 76 + search_data = response.json() 77 77 + except Exception as e: 78 78 + return f"Error: Search failed. ({str(e)})" 79 79 + 80 80 + # Format results 81 81 + results = [] 82 82 + for post in search_data.get("posts", []): 83 83 + author = post.get("author", {}) 84 84 + record = post.get("record", {}) 85 85 + 86 86 + post_data = { 87 87 + "author": { 88 88 + "handle": author.get("handle", ""), 89 89 + "display_name": author.get("displayName", ""), 90 90 + }, 91 91 + "text": record.get("text", ""), 92 92 + "created_at": record.get("createdAt", ""), 93 93 + "uri": post.get("uri", ""), 94 94 + "cid": post.get("cid", ""), 95 95 + "like_count": post.get("likeCount", 0), 96 96 + "repost_count": post.get("repostCount", 0), 97 97 + "reply_count": post.get("replyCount", 0), 98 98 + } 99 99 + 100 100 + # Add reply info if present 101 101 + if "reply" in record and record["reply"]: 102 102 + post_data["reply_to"] = { 103 103 + "uri": record["reply"].get("parent", {}).get("uri", ""), 104 104 + "cid": record["reply"].get("parent", {}).get("cid", ""), 105 105 + } 106 106 + 107 107 + results.append(post_data) 108 108 + 109 109 + return yaml.dump({ 110 110 + "search_results": { 111 111 + "query": query, 112 112 + "author_filter": author, 113 113 + "sort": sort, 114 114 + "result_count": len(results), 115 115 + "posts": results 116 116 + } 117 117 + }, default_flow_style=False, sort_keys=False) 118 118 + 119 119 + except Exception as e: 120 120 + return f"Error searching Bluesky: {str(e)}"