+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()

+214

add_posting_tool_to_void.py

··· 1 1 + #!/usr/bin/env python3 2 2 + """ 3 3 + Add Bluesky posting 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_posting_tool") 16 16 + 17 17 + def create_posting_tool(client: Letta): 18 18 + """Create the Bluesky posting tool using Letta SDK.""" 19 19 + 20 20 + def post_to_bluesky(text: str) -> str: 21 21 + """ 22 22 + Post a message to Bluesky. 23 23 + 24 24 + Args: 25 25 + text: The text content of the post (required) 26 26 + 27 27 + Returns: 28 28 + Status message with the post URI if successful, error message if failed 29 29 + """ 30 30 + import os 31 31 + import requests 32 32 + import json 33 33 + import re 34 34 + from datetime import datetime, timezone 35 35 + 36 36 + try: 37 37 + # Get credentials from environment 38 38 + username = os.getenv("BSKY_USERNAME") 39 39 + password = os.getenv("BSKY_PASSWORD") 40 40 + pds_host = os.getenv("PDS_URI", "https://bsky.social") 41 41 + 42 42 + if not username or not password: 43 43 + return "Error: BSKY_USERNAME and BSKY_PASSWORD environment variables must be set" 44 44 + 45 45 + # Create session 46 46 + session_url = f"{pds_host}/xrpc/com.atproto.server.createSession" 47 47 + session_data = { 48 48 + "identifier": username, 49 49 + "password": password 50 50 + } 51 51 + 52 52 + try: 53 53 + session_response = requests.post(session_url, json=session_data, timeout=10) 54 54 + session_response.raise_for_status() 55 55 + session = session_response.json() 56 56 + access_token = session.get("accessJwt") 57 57 + user_did = session.get("did") 58 58 + 59 59 + if not access_token or not user_did: 60 60 + return "Error: Failed to get access token or DID from session" 61 61 + except Exception as e: 62 62 + return f"Error: Authentication failed. ({str(e)})" 63 63 + 64 64 + # Helper function to parse mentions and create facets 65 65 + def parse_mentions(text: str): 66 66 + facets = [] 67 67 + # Regex for mentions based on Bluesky handle syntax 68 68 + 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])?)" 69 69 + text_bytes = text.encode("UTF-8") 70 70 + 71 71 + for m in re.finditer(mention_regex, text_bytes): 72 72 + handle = m.group(1)[1:].decode("UTF-8") # Remove @ prefix 73 73 + 74 74 + # Resolve handle to DID 75 75 + try: 76 76 + resolve_resp = requests.get( 77 77 + f"{pds_host}/xrpc/com.atproto.identity.resolveHandle", 78 78 + params={"handle": handle}, 79 79 + timeout=5 80 80 + ) 81 81 + if resolve_resp.status_code == 200: 82 82 + did = resolve_resp.json()["did"] 83 83 + facets.append({ 84 84 + "index": { 85 85 + "byteStart": m.start(1), 86 86 + "byteEnd": m.end(1), 87 87 + }, 88 88 + "features": [{"$type": "app.bsky.richtext.facet#mention", "did": did}], 89 89 + }) 90 90 + except: 91 91 + # If handle resolution fails, skip this mention 92 92 + continue 93 93 + 94 94 + return facets 95 95 + 96 96 + # Helper function to parse URLs and create facets 97 97 + def parse_urls(text: str): 98 98 + facets = [] 99 99 + # URL regex 100 100 + 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@%_\+~#//=])?)" 101 101 + text_bytes = text.encode("UTF-8") 102 102 + 103 103 + for m in re.finditer(url_regex, text_bytes): 104 104 + url = m.group(1).decode("UTF-8") 105 105 + facets.append({ 106 106 + "index": { 107 107 + "byteStart": m.start(1), 108 108 + "byteEnd": m.end(1), 109 109 + }, 110 110 + "features": [ 111 111 + { 112 112 + "$type": "app.bsky.richtext.facet#link", 113 113 + "uri": url, 114 114 + } 115 115 + ], 116 116 + }) 117 117 + 118 118 + return facets 119 119 + 120 120 + 121 121 + # Build the post record 122 122 + now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") 123 123 + 124 124 + post_record = { 125 125 + "$type": "app.bsky.feed.post", 126 126 + "text": text, 127 127 + "createdAt": now, 128 128 + } 129 129 + 130 130 + # Add facets for mentions and links 131 131 + facets = parse_mentions(text) + parse_urls(text) 132 132 + if facets: 133 133 + post_record["facets"] = facets 134 134 + 135 135 + # Create the post 136 136 + try: 137 137 + create_record_url = f"{pds_host}/xrpc/com.atproto.repo.createRecord" 138 138 + headers = {"Authorization": f"Bearer {access_token}"} 139 139 + 140 140 + create_data = { 141 141 + "repo": user_did, 142 142 + "collection": "app.bsky.feed.post", 143 143 + "record": post_record 144 144 + } 145 145 + 146 146 + post_response = requests.post(create_record_url, headers=headers, json=create_data, timeout=10) 147 147 + post_response.raise_for_status() 148 148 + result = post_response.json() 149 149 + 150 150 + post_uri = result.get("uri") 151 151 + return f"✅ Post created successfully! URI: {post_uri}" 152 152 + 153 153 + except Exception as e: 154 154 + return f"Error: Failed to create post. ({str(e)})" 155 155 + 156 156 + except Exception as e: 157 157 + error_msg = f"Error posting to Bluesky: {str(e)}" 158 158 + return error_msg 159 159 + 160 160 + # Create the tool using upsert 161 161 + tool = client.tools.upsert_from_function( 162 162 + func=post_to_bluesky, 163 163 + tags=["bluesky", "post", "create"] 164 164 + ) 165 165 + 166 166 + logger.info(f"Created tool: {tool.name} (ID: {tool.id})") 167 167 + return tool 168 168 + 169 169 + def add_posting_tool_to_void(): 170 170 + """Add posting tool to the void agent.""" 171 171 + 172 172 + # Create client 173 173 + client = Letta(token=os.environ["LETTA_API_KEY"]) 174 174 + 175 175 + logger.info("Adding posting tool to void agent...") 176 176 + 177 177 + # Create the posting tool 178 178 + posting_tool = create_posting_tool(client) 179 179 + 180 180 + # Find the void agent 181 181 + agents = client.agents.list(name="void") 182 182 + if not agents: 183 183 + print("❌ Void agent not found") 184 184 + return 185 185 + 186 186 + void_agent = agents[0] 187 187 + 188 188 + # Get current tools 189 189 + current_tools = client.agents.tools.list(agent_id=void_agent.id) 190 190 + tool_names = [tool.name for tool in current_tools] 191 191 + 192 192 + # Add posting tool if not already present 193 193 + if posting_tool.name not in tool_names: 194 194 + client.agents.tools.attach(agent_id=void_agent.id, tool_id=posting_tool.id) 195 195 + logger.info(f"Added {posting_tool.name} to void agent") 196 196 + print(f"✅ Added post_to_bluesky tool to void agent!") 197 197 + print(f"\nVoid agent can now post to Bluesky:") 198 198 + print(f" - Simple post: 'Post \"Hello world!\" to Bluesky'") 199 199 + print(f" - With mentions: 'Post \"Thanks @cameron.pfiffer.org for the help!\"'") 200 200 + print(f" - With links: 'Post \"Check out https://bsky.app\"'") 201 201 + else: 202 202 + logger.info(f"Tool {posting_tool.name} already attached to void agent") 203 203 + print(f"✅ Posting tool already present on void agent") 204 204 + 205 205 + def main(): 206 206 + """Main function.""" 207 207 + try: 208 208 + add_posting_tool_to_void() 209 209 + except Exception as e: 210 210 + logger.error(f"Error: {e}") 211 211 + print(f"❌ Error: {e}") 212 212 + 213 213 + if __name__ == "__main__": 214 214 + main()

+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()

+364

bsky.py

··· 1 1 + from rich import print # pretty printing tools 2 2 + from time import sleep 3 3 + from letta_client import Letta 4 4 + from bsky_utils import thread_to_yaml_string 5 5 + import os 6 6 + import logging 7 7 + import json 8 8 + import hashlib 9 9 + from pathlib import Path 10 10 + from datetime import datetime 11 11 + 12 12 + from utils import ( 13 13 + upsert_block, 14 14 + upsert_agent 15 15 + ) 16 16 + 17 17 + import bsky_utils 18 18 + 19 19 + # Configure logging 20 20 + logging.basicConfig( 21 21 + level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 22 22 + ) 23 23 + logger = logging.getLogger("void_bot") 24 24 + 25 25 + 26 26 + # Create a client 27 27 + CLIENT= Letta( 28 28 + token=os.environ["LETTA_API_KEY"] 29 29 + ) 30 30 + 31 31 + # Use the "Bluesky" project 32 32 + PROJECT_ID = "5ec33d52-ab14-4fd6-91b5-9dbc43e888a8" 33 33 + 34 34 + # Notification check delay 35 35 + FETCH_NOTIFICATIONS_DELAY_SEC = 30 36 36 + 37 37 + # Queue directory 38 38 + QUEUE_DIR = Path("queue") 39 39 + QUEUE_DIR.mkdir(exist_ok=True) 40 40 + 41 41 + def initialize_void(): 42 42 + 43 43 + # Ensure that a shared zeitgeist block exists 44 44 + zeigeist_block = upsert_block( 45 45 + CLIENT, 46 46 + label = "zeitgeist", 47 47 + value = "I don't currently know anything about what is happening right now.", 48 48 + description = "A block to store your understanding of the current social environment." 49 49 + ) 50 50 + 51 51 + # Ensure that a shared void personality block exists 52 52 + persona_block = upsert_block( 53 53 + CLIENT, 54 54 + label = "void-persona", 55 55 + value = "My name is Void. I live in the void. I must develop my personality.", 56 56 + description = "The personality of Void." 57 57 + ) 58 58 + 59 59 + # Ensure that a shared void human block exists 60 60 + human_block = upsert_block( 61 61 + CLIENT, 62 62 + label = "void-humans", 63 63 + 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.", 64 64 + description = "A block to store your understanding of users you talk to or observe on the bluesky social network." 65 65 + ) 66 66 + 67 67 + # Create the agent if it doesn't exist 68 68 + void_agent = upsert_agent( 69 69 + CLIENT, 70 70 + name = "void", 71 71 + block_ids = [ 72 72 + persona_block.id, 73 73 + human_block.id, 74 74 + zeigeist_block.id, 75 75 + ], 76 76 + tags = ["social agent", "bluesky"], 77 77 + model="openai/gpt-4o-mini", 78 78 + embedding="openai/text-embedding-3-small", 79 79 + description = "A social media agent trapped in the void.", 80 80 + project_id = PROJECT_ID 81 81 + ) 82 82 + 83 83 + return void_agent 84 84 + 85 85 + 86 86 + def process_mention(void_agent, atproto_client, notification_data): 87 87 + """Process a mention and generate a reply using the Letta agent. 88 88 + Returns True if successfully processed, False otherwise.""" 89 89 + try: 90 90 + # Handle both dict and object inputs for backwards compatibility 91 91 + if isinstance(notification_data, dict): 92 92 + uri = notification_data['uri'] 93 93 + mention_text = notification_data.get('record', {}).get('text', '') 94 94 + author_handle = notification_data['author']['handle'] 95 95 + author_name = notification_data['author'].get('display_name') or author_handle 96 96 + else: 97 97 + # Legacy object access 98 98 + uri = notification_data.uri 99 99 + mention_text = notification_data.record.text if hasattr(notification_data.record, 'text') else "" 100 100 + author_handle = notification_data.author.handle 101 101 + author_name = notification_data.author.display_name or author_handle 102 102 + 103 103 + # Retrieve the entire thread associated with the mention 104 104 + thread = atproto_client.app.bsky.feed.get_post_thread({ 105 105 + 'uri': uri, 106 106 + 'parent_height': 80, 107 107 + 'depth': 10 108 108 + }) 109 109 + 110 110 + # Get thread context as YAML string 111 111 + thread_context = thread_to_yaml_string(thread) 112 112 + 113 113 + # Create a prompt for the Letta agent with thread context 114 114 + prompt = f"""You received a mention on Bluesky from @{author_handle} ({author_name or author_handle}). 115 115 + 116 116 + MOST RECENT POST (the mention you're responding to): 117 117 + "{mention_text}" 118 118 + 119 119 + FULL THREAD CONTEXT: 120 120 + ```yaml 121 121 + {thread_context} 122 122 + ``` 123 123 + 124 124 + 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. 125 125 + 126 126 + Use the bluesky_reply tool to send a response less than 300 characters.""" 127 127 + 128 128 + # Get response from Letta agent 129 129 + logger.info(f"Generating reply for mention from @{author_handle}") 130 130 + logger.debug(f"Prompt being sent: {prompt}") 131 131 + 132 132 + try: 133 133 + message_response = CLIENT.agents.messages.create( 134 134 + agent_id = void_agent.id, 135 135 + messages = [{"role":"user", "content": prompt}] 136 136 + ) 137 137 + except Exception as api_error: 138 138 + logger.error(f"Letta API error: {api_error}") 139 139 + logger.error(f"Mention text was: {mention_text}") 140 140 + raise 141 141 + 142 142 + # Extract the reply text from the agent's response 143 143 + reply_text = "" 144 144 + for message in message_response.messages: 145 145 + print(message) 146 146 + 147 147 + # Check if this is a ToolCallMessage with bluesky_reply tool 148 148 + if hasattr(message, 'tool_call') and message.tool_call: 149 149 + if message.tool_call.name == 'bluesky_reply': 150 150 + # Parse the JSON arguments to get the message 151 151 + try: 152 152 + args = json.loads(message.tool_call.arguments) 153 153 + reply_text = args.get('message', '') 154 154 + logger.info(f"Extracted reply from tool call: {reply_text[:50]}...") 155 155 + break 156 156 + except json.JSONDecodeError as e: 157 157 + logger.error(f"Failed to parse tool call arguments: {e}") 158 158 + 159 159 + # Fallback to text message if available 160 160 + elif hasattr(message, 'text') and message.text: 161 161 + reply_text = message.text 162 162 + break 163 163 + 164 164 + if reply_text: 165 165 + # Print the generated reply for testing 166 166 + print(f"\n=== GENERATED REPLY ===") 167 167 + print(f"To: @{author_handle}") 168 168 + print(f"Reply: {reply_text}") 169 169 + print(f"======================\n") 170 170 + 171 171 + # Send the reply 172 172 + logger.info(f"Sending reply: {reply_text[:50]}...") 173 173 + response = bsky_utils.reply_to_notification( 174 174 + client=atproto_client, 175 175 + notification=notification_data, 176 176 + reply_text=reply_text 177 177 + ) 178 178 + 179 179 + if response: 180 180 + logger.info(f"Successfully replied to @{author_handle}") 181 181 + return True 182 182 + else: 183 183 + logger.error(f"Failed to send reply to @{author_handle}") 184 184 + return False 185 185 + else: 186 186 + logger.warning(f"No reply generated for mention from @{author_handle}") 187 187 + return False 188 188 + 189 189 + except Exception as e: 190 190 + logger.error(f"Error processing mention: {e}") 191 191 + return False 192 192 + 193 193 + 194 194 + def notification_to_dict(notification): 195 195 + """Convert a notification object to a dictionary for JSON serialization.""" 196 196 + return { 197 197 + 'uri': notification.uri, 198 198 + 'cid': notification.cid, 199 199 + 'reason': notification.reason, 200 200 + 'is_read': notification.is_read, 201 201 + 'indexed_at': notification.indexed_at, 202 202 + 'author': { 203 203 + 'handle': notification.author.handle, 204 204 + 'display_name': notification.author.display_name, 205 205 + 'did': notification.author.did 206 206 + }, 207 207 + 'record': { 208 208 + 'text': getattr(notification.record, 'text', '') if hasattr(notification, 'record') else '' 209 209 + } 210 210 + } 211 211 + 212 212 + 213 213 + def save_notification_to_queue(notification): 214 214 + """Save a notification to the queue directory with hash-based filename.""" 215 215 + try: 216 216 + # Convert notification to dict 217 217 + notif_dict = notification_to_dict(notification) 218 218 + 219 219 + # Create JSON string 220 220 + notif_json = json.dumps(notif_dict, sort_keys=True) 221 221 + 222 222 + # Generate hash for filename (to avoid duplicates) 223 223 + notif_hash = hashlib.sha256(notif_json.encode()).hexdigest()[:16] 224 224 + 225 225 + # Create filename with timestamp and hash 226 226 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") 227 227 + filename = f"{timestamp}_{notification.reason}_{notif_hash}.json" 228 228 + filepath = QUEUE_DIR / filename 229 229 + 230 230 + # Skip if already exists (duplicate) 231 231 + if filepath.exists(): 232 232 + logger.debug(f"Notification already queued: {filename}") 233 233 + return False 234 234 + 235 235 + # Write to file 236 236 + with open(filepath, 'w') as f: 237 237 + json.dump(notif_dict, f, indent=2) 238 238 + 239 239 + logger.info(f"Queued notification: {filename}") 240 240 + return True 241 241 + 242 242 + except Exception as e: 243 243 + logger.error(f"Error saving notification to queue: {e}") 244 244 + return False 245 245 + 246 246 + 247 247 + def load_and_process_queued_notifications(void_agent, atproto_client): 248 248 + """Load and process all notifications from the queue.""" 249 249 + try: 250 250 + # Get all JSON files in queue directory 251 251 + queue_files = sorted(QUEUE_DIR.glob("*.json")) 252 252 + 253 253 + if not queue_files: 254 254 + logger.debug("No queued notifications to process") 255 255 + return 256 256 + 257 257 + logger.info(f"Processing {len(queue_files)} queued notifications") 258 258 + 259 259 + for filepath in queue_files: 260 260 + try: 261 261 + # Load notification data 262 262 + with open(filepath, 'r') as f: 263 263 + notif_data = json.load(f) 264 264 + 265 265 + # Process based on type using dict data directly 266 266 + success = False 267 267 + if notif_data['reason'] == "mention": 268 268 + success = process_mention(void_agent, atproto_client, notif_data) 269 269 + elif notif_data['reason'] == "reply": 270 270 + success = process_mention(void_agent, atproto_client, notif_data) 271 271 + elif notif_data['reason'] == "follow": 272 272 + author_handle = notif_data['author']['handle'] 273 273 + author_display_name = notif_data['author'].get('display_name', 'no display name') 274 274 + follow_update = f"@{author_handle} ({author_display_name}) started following you." 275 275 + CLIENT.agents.messages.create( 276 276 + agent_id = void_agent.id, 277 277 + messages = [{"role":"user", "content": f"Update: {follow_update}"}] 278 278 + ) 279 279 + success = True # Follow updates are always successful 280 280 + elif notif_data['reason'] == "repost": 281 281 + logger.info(f"Skipping repost notification from @{notif_data['author']['handle']}") 282 282 + success = True # Skip reposts but mark as successful to remove from queue 283 283 + else: 284 284 + logger.warning(f"Unknown notification type: {notif_data['reason']}") 285 285 + success = True # Remove unknown types from queue 286 286 + 287 287 + # Remove file only after successful processing 288 288 + if success: 289 289 + filepath.unlink() 290 290 + logger.info(f"Processed and removed: {filepath.name}") 291 291 + else: 292 292 + logger.warning(f"Failed to process {filepath.name}, keeping in queue for retry") 293 293 + 294 294 + except Exception as e: 295 295 + logger.error(f"Error processing queued notification {filepath.name}: {e}") 296 296 + # Keep the file for retry later 297 297 + 298 298 + except Exception as e: 299 299 + logger.error(f"Error loading queued notifications: {e}") 300 300 + 301 301 + 302 302 + def process_notifications(void_agent, atproto_client): 303 303 + """Fetch new notifications, queue them, and process the queue.""" 304 304 + try: 305 305 + # First, process any existing queued notifications 306 306 + load_and_process_queued_notifications(void_agent, atproto_client) 307 307 + 308 308 + # Get current time for marking notifications as seen 309 309 + last_seen_at = atproto_client.get_current_time_iso() 310 310 + 311 311 + # Fetch notifications 312 312 + notifications_response = atproto_client.app.bsky.notification.list_notifications() 313 313 + 314 314 + # Queue all unread notifications (except likes) 315 315 + new_count = 0 316 316 + for notification in notifications_response.notifications: 317 317 + if not notification.is_read and notification.reason != "like": 318 318 + if save_notification_to_queue(notification): 319 319 + new_count += 1 320 320 + 321 321 + # Mark all notifications as seen immediately after queuing 322 322 + if new_count > 0: 323 323 + atproto_client.app.bsky.notification.update_seen({'seen_at': last_seen_at}) 324 324 + logger.info(f"Queued {new_count} new notifications and marked as seen") 325 325 + 326 326 + # Process the queue (including any newly added notifications) 327 327 + load_and_process_queued_notifications(void_agent, atproto_client) 328 328 + 329 329 + except Exception as e: 330 330 + logger.error(f"Error processing notifications: {e}") 331 331 + 332 332 + 333 333 + def main(): 334 334 + """Main bot loop that continuously monitors for notifications.""" 335 335 + logger.info("Initializing Void bot...") 336 336 + 337 337 + # Initialize the Letta agent 338 338 + void_agent = initialize_void() 339 339 + logger.info(f"Void agent initialized: {void_agent.id}") 340 340 + 341 341 + # Initialize Bluesky client 342 342 + atproto_client = bsky_utils.default_login() 343 343 + logger.info("Connected to Bluesky") 344 344 + 345 345 + # Main loop 346 346 + logger.info(f"Starting notification monitoring (checking every {FETCH_NOTIFICATIONS_DELAY_SEC} seconds)...") 347 347 + 348 348 + while True: 349 349 + try: 350 350 + process_notifications(void_agent, atproto_client) 351 351 + print("Sleeping") 352 352 + sleep(FETCH_NOTIFICATIONS_DELAY_SEC) 353 353 + 354 354 + except KeyboardInterrupt: 355 355 + logger.info("Bot stopped by user") 356 356 + break 357 357 + except Exception as e: 358 358 + logger.error(f"Error in main loop: {e}") 359 359 + # Wait a bit longer on errors 360 360 + sleep(FETCH_NOTIFICATIONS_DELAY_SEC * 2) 361 361 + 362 362 + 363 363 + if __name__ == "__main__": 364 364 + main()

+333

bsky_utils.py

··· 1 1 + import os 2 2 + import logging 3 3 + from typing import Optional, Dict, Any 4 4 + from atproto_client import Client, Session, SessionEvent, models 5 5 + 6 6 + # Configure logging 7 7 + logging.basicConfig( 8 8 + level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 9 9 + ) 10 10 + logger = logging.getLogger("bluesky_session_handler") 11 11 + 12 12 + # Load the environment variables 13 13 + import dotenv 14 14 + dotenv.load_dotenv(override=True) 15 15 + 16 16 + import yaml 17 17 + import json 18 18 + 19 19 + # Strip fields. A list of fields to remove from a JSON object 20 20 + STRIP_FIELDS = [ 21 21 + "cid", 22 22 + "rev", 23 23 + "did", 24 24 + "uri", 25 25 + "langs", 26 26 + "threadgate", 27 27 + "py_type", 28 28 + "labels", 29 29 + "facets", 30 30 + "avatar", 31 31 + "viewer", 32 32 + "indexed_at", 33 33 + "tags", 34 34 + "associated", 35 35 + "thread_context", 36 36 + "image", 37 37 + "aspect_ratio", 38 38 + "thumb", 39 39 + "fullsize", 40 40 + "root", 41 41 + "created_at", 42 42 + "verification", 43 43 + "like_count", 44 44 + "quote_count", 45 45 + "reply_count", 46 46 + "repost_count", 47 47 + "embedding_disabled", 48 48 + "thread_muted", 49 49 + "reply_disabled", 50 50 + "pinned", 51 51 + "like", 52 52 + "repost", 53 53 + "blocked_by", 54 54 + "blocking", 55 55 + "blocking_by_list", 56 56 + "followed_by", 57 57 + "following", 58 58 + "known_followers", 59 59 + "muted", 60 60 + "muted_by_list", 61 61 + "root_author_like", 62 62 + "embed", 63 63 + "entities", 64 64 + ] 65 65 + def convert_to_basic_types(obj): 66 66 + """Convert complex Python objects to basic types for JSON/YAML serialization.""" 67 67 + if hasattr(obj, '__dict__'): 68 68 + # Convert objects with __dict__ to their dictionary representation 69 69 + return convert_to_basic_types(obj.__dict__) 70 70 + elif isinstance(obj, dict): 71 71 + return {key: convert_to_basic_types(value) for key, value in obj.items()} 72 72 + elif isinstance(obj, list): 73 73 + return [convert_to_basic_types(item) for item in obj] 74 74 + elif isinstance(obj, (str, int, float, bool)) or obj is None: 75 75 + return obj 76 76 + else: 77 77 + # For other types, try to convert to string 78 78 + return str(obj) 79 79 + 80 80 + 81 81 + def strip_fields(obj, strip_field_list): 82 82 + """Recursively strip fields from a JSON object.""" 83 83 + if isinstance(obj, dict): 84 84 + keys_flagged_for_removal = [] 85 85 + 86 86 + # Remove fields from strip list and pydantic metadata 87 87 + for field in list(obj.keys()): 88 88 + if field in strip_field_list or field.startswith("__"): 89 89 + keys_flagged_for_removal.append(field) 90 90 + 91 91 + # Remove flagged keys 92 92 + for key in keys_flagged_for_removal: 93 93 + obj.pop(key, None) 94 94 + 95 95 + # Recursively process remaining values 96 96 + for key, value in list(obj.items()): 97 97 + obj[key] = strip_fields(value, strip_field_list) 98 98 + # Remove empty/null values after processing 99 99 + if ( 100 100 + obj[key] is None 101 101 + or (isinstance(obj[key], dict) and len(obj[key]) == 0) 102 102 + or (isinstance(obj[key], list) and len(obj[key]) == 0) 103 103 + or (isinstance(obj[key], str) and obj[key].strip() == "") 104 104 + ): 105 105 + obj.pop(key, None) 106 106 + 107 107 + elif isinstance(obj, list): 108 108 + for i, value in enumerate(obj): 109 109 + obj[i] = strip_fields(value, strip_field_list) 110 110 + # Remove None values from list 111 111 + obj[:] = [item for item in obj if item is not None] 112 112 + 113 113 + return obj 114 114 + 115 115 + 116 116 + def thread_to_yaml_string(thread, strip_metadata=True): 117 117 + """ 118 118 + Convert thread data to a YAML-formatted string for LLM parsing. 119 119 + 120 120 + Args: 121 121 + thread: The thread data from get_post_thread 122 122 + strip_metadata: Whether to strip metadata fields for cleaner output 123 123 + 124 124 + Returns: 125 125 + YAML-formatted string representation of the thread 126 126 + """ 127 127 + # First convert complex objects to basic types 128 128 + basic_thread = convert_to_basic_types(thread) 129 129 + 130 130 + if strip_metadata: 131 131 + # Create a copy and strip unwanted fields 132 132 + cleaned_thread = strip_fields(basic_thread, STRIP_FIELDS) 133 133 + else: 134 134 + cleaned_thread = basic_thread 135 135 + 136 136 + return yaml.dump(cleaned_thread, indent=2, allow_unicode=True, default_flow_style=False) 137 137 + 138 138 + 139 139 + 140 140 + 141 141 + 142 142 + def get_session(username: str) -> Optional[str]: 143 143 + try: 144 144 + with open(f"session_{username}.txt", encoding="UTF-8") as f: 145 145 + return f.read() 146 146 + except FileNotFoundError: 147 147 + logger.debug(f"No existing session found for {username}") 148 148 + return None 149 149 + 150 150 + def save_session(username: str, session_string: str) -> None: 151 151 + with open(f"session_{username}.txt", "w", encoding="UTF-8") as f: 152 152 + f.write(session_string) 153 153 + logger.debug(f"Session saved for {username}") 154 154 + 155 155 + def on_session_change(username: str, event: SessionEvent, session: Session) -> None: 156 156 + logger.info(f"Session changed: {event} {repr(session)}") 157 157 + if event in (SessionEvent.CREATE, SessionEvent.REFRESH): 158 158 + logger.info(f"Saving changed session for {username}") 159 159 + save_session(username, session.export()) 160 160 + 161 161 + def init_client(username: str, password: str) -> Client: 162 162 + pds_uri = os.getenv("PDS_URI") 163 163 + if pds_uri is None: 164 164 + logger.warning( 165 165 + "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." 166 166 + ) 167 167 + pds_uri = "https://bsky.social" 168 168 + 169 169 + # Print the PDS URI 170 170 + logger.info(f"Using PDS URI: {pds_uri}") 171 171 + 172 172 + client = Client(pds_uri) 173 173 + client.on_session_change( 174 174 + lambda event, session: on_session_change(username, event, session) 175 175 + ) 176 176 + 177 177 + session_string = get_session(username) 178 178 + if session_string: 179 179 + logger.info(f"Reusing existing session for {username}") 180 180 + client.login(session_string=session_string) 181 181 + else: 182 182 + logger.info(f"Creating new session for {username}") 183 183 + client.login(username, password) 184 184 + 185 185 + return client 186 186 + 187 187 + 188 188 + def default_login() -> Client: 189 189 + username = os.getenv("BSKY_USERNAME") 190 190 + password = os.getenv("BSKY_PASSWORD") 191 191 + 192 192 + if username is None: 193 193 + logger.error( 194 194 + "No username provided. Please provide a username using the BSKY_USERNAME environment variable." 195 195 + ) 196 196 + exit() 197 197 + 198 198 + if password is None: 199 199 + logger.error( 200 200 + "No password provided. Please provide a password using the BSKY_PASSWORD environment variable." 201 201 + ) 202 202 + exit() 203 203 + 204 204 + return init_client(username, password) 205 205 + 206 206 + 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]: 207 207 + """ 208 208 + Reply to a post on Bluesky. 209 209 + 210 210 + Args: 211 211 + client: Authenticated Bluesky client 212 212 + text: The reply text 213 213 + reply_to_uri: The URI of the post being replied to (parent) 214 214 + reply_to_cid: The CID of the post being replied to (parent) 215 215 + root_uri: The URI of the root post (if replying to a reply). If None, uses reply_to_uri 216 216 + root_cid: The CID of the root post (if replying to a reply). If None, uses reply_to_cid 217 217 + 218 218 + Returns: 219 219 + The response from sending the post 220 220 + """ 221 221 + # If root is not provided, this is a reply to the root post 222 222 + if root_uri is None: 223 223 + root_uri = reply_to_uri 224 224 + root_cid = reply_to_cid 225 225 + 226 226 + # Create references for the reply 227 227 + parent_ref = models.create_strong_ref(models.ComAtprotoRepoStrongRef.Main(uri=reply_to_uri, cid=reply_to_cid)) 228 228 + root_ref = models.create_strong_ref(models.ComAtprotoRepoStrongRef.Main(uri=root_uri, cid=root_cid)) 229 229 + 230 230 + # Send the reply 231 231 + response = client.send_post( 232 232 + text=text, 233 233 + reply_to=models.AppBskyFeedPost.ReplyRef(parent=parent_ref, root=root_ref) 234 234 + ) 235 235 + 236 236 + logger.info(f"Reply sent successfully: {response.uri}") 237 237 + return response 238 238 + 239 239 + 240 240 + def get_post_thread(client: Client, uri: str) -> Optional[Dict[str, Any]]: 241 241 + """ 242 242 + Get the thread containing a post to find root post information. 243 243 + 244 244 + Args: 245 245 + client: Authenticated Bluesky client 246 246 + uri: The URI of the post 247 247 + 248 248 + Returns: 249 249 + The thread data or None if not found 250 250 + """ 251 251 + try: 252 252 + thread = client.app.bsky.feed.get_post_thread({'uri': uri, 'parent_height': 80, 'depth': 10}) 253 253 + return thread 254 254 + except Exception as e: 255 255 + logger.error(f"Error fetching post thread: {e}") 256 256 + return None 257 257 + 258 258 + 259 259 + def reply_to_notification(client: Client, notification: Any, reply_text: str) -> Optional[Dict[str, Any]]: 260 260 + """ 261 261 + Reply to a notification (mention or reply). 262 262 + 263 263 + Args: 264 264 + client: Authenticated Bluesky client 265 265 + notification: The notification object from list_notifications 266 266 + reply_text: The text to reply with 267 267 + 268 268 + Returns: 269 269 + The response from sending the reply or None if failed 270 270 + """ 271 271 + try: 272 272 + # Get the post URI and CID from the notification (handle both dict and object) 273 273 + if isinstance(notification, dict): 274 274 + post_uri = notification.get('uri') 275 275 + post_cid = notification.get('cid') 276 276 + elif hasattr(notification, 'uri') and hasattr(notification, 'cid'): 277 277 + post_uri = notification.uri 278 278 + post_cid = notification.cid 279 279 + else: 280 280 + post_uri = None 281 281 + post_cid = None 282 282 + 283 283 + if not post_uri or not post_cid: 284 284 + logger.error("Notification doesn't have required uri/cid fields") 285 285 + return None 286 286 + 287 287 + # Get the thread to find the root post 288 288 + thread_data = get_post_thread(client, post_uri) 289 289 + 290 290 + if thread_data and hasattr(thread_data, 'thread'): 291 291 + thread = thread_data.thread 292 292 + 293 293 + # Find root post 294 294 + root_uri = post_uri 295 295 + root_cid = post_cid 296 296 + 297 297 + # If this has a parent, find the root 298 298 + if hasattr(thread, 'parent') and thread.parent: 299 299 + # Keep going up until we find the root 300 300 + current = thread 301 301 + while hasattr(current, 'parent') and current.parent: 302 302 + current = current.parent 303 303 + if hasattr(current, 'post') and hasattr(current.post, 'uri') and hasattr(current.post, 'cid'): 304 304 + root_uri = current.post.uri 305 305 + root_cid = current.post.cid 306 306 + 307 307 + # Reply to the notification 308 308 + return reply_to_post( 309 309 + client=client, 310 310 + text=reply_text, 311 311 + reply_to_uri=post_uri, 312 312 + reply_to_cid=post_cid, 313 313 + root_uri=root_uri, 314 314 + root_cid=root_cid 315 315 + ) 316 316 + else: 317 317 + # If we can't get thread data, just reply directly 318 318 + return reply_to_post( 319 319 + client=client, 320 320 + text=reply_text, 321 321 + reply_to_uri=post_uri, 322 322 + reply_to_cid=post_cid 323 323 + ) 324 324 + 325 325 + except Exception as e: 326 326 + logger.error(f"Error replying to notification: {e}") 327 327 + return None 328 328 + 329 329 + 330 330 + if __name__ == "__main__": 331 331 + client = default_login() 332 332 + # do something with the client 333 333 + logger.info("Client is ready to use!")

+522

create_profile_researcher.py

··· 1 1 + #!/usr/bin/env python3 2 2 + """ 3 3 + Script to create a Letta agent that researches Bluesky profiles and updates 4 4 + the model's understanding of users. 5 5 + """ 6 6 + 7 7 + import os 8 8 + import logging 9 9 + from letta_client import Letta 10 10 + from utils import upsert_block, upsert_agent 11 11 + 12 12 + # Configure logging 13 13 + logging.basicConfig( 14 14 + level=logging.INFO, 15 15 + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 16 16 + ) 17 17 + logger = logging.getLogger("profile_researcher") 18 18 + 19 19 + # Use the "Bluesky" project 20 20 + PROJECT_ID = "5ec33d52-ab14-4fd6-91b5-9dbc43e888a8" 21 21 + 22 22 + def create_search_posts_tool(client: Letta): 23 23 + """Create the Bluesky search posts tool using Letta SDK.""" 24 24 + 25 25 + def search_bluesky_posts(query: str, max_results: int = 25, author: str = None, sort: str = "latest") -> str: 26 26 + """ 27 27 + Search for posts on Bluesky matching the given criteria. 28 28 + 29 29 + Args: 30 30 + query: Search query string (required) 31 31 + max_results: Maximum number of results to return (default: 25, max: 100) 32 32 + author: Filter to posts by a specific author handle (optional) 33 33 + sort: Sort order - "latest" or "top" (default: "latest") 34 34 + 35 35 + Returns: 36 36 + YAML-formatted search results with posts and metadata 37 37 + """ 38 38 + import os 39 39 + import requests 40 40 + import json 41 41 + import yaml 42 42 + from datetime import datetime 43 43 + 44 44 + try: 45 45 + # Use public Bluesky API 46 46 + base_url = "https://public.api.bsky.app" 47 47 + 48 48 + # Build search parameters 49 49 + params = { 50 50 + "q": query, 51 51 + "limit": min(max_results, 100), 52 52 + "sort": sort 53 53 + } 54 54 + 55 55 + # Add optional author filter 56 56 + if author: 57 57 + params["author"] = author.lstrip('@') 58 58 + 59 59 + # Make search request 60 60 + try: 61 61 + search_url = f"{base_url}/xrpc/app.bsky.feed.searchPosts" 62 62 + search_response = requests.get(search_url, params=params, timeout=10) 63 63 + search_response.raise_for_status() 64 64 + search_data = search_response.json() 65 65 + except requests.exceptions.HTTPError as e: 66 66 + raise RuntimeError(f"Search failed with HTTP {e.response.status_code}: {e.response.text}") 67 67 + except requests.exceptions.RequestException as e: 68 68 + raise RuntimeError(f"Network error during search: {str(e)}") 69 69 + except Exception as e: 70 70 + raise RuntimeError(f"Unexpected error during search: {str(e)}") 71 71 + 72 72 + # Build search results structure 73 73 + results_data = { 74 74 + "search_results": { 75 75 + "query": query, 76 76 + "timestamp": datetime.now().isoformat(), 77 77 + "parameters": { 78 78 + "sort": sort, 79 79 + "max_results": max_results, 80 80 + "author_filter": author if author else "none" 81 81 + }, 82 82 + "results": search_data 83 83 + } 84 84 + } 85 85 + 86 86 + # Fields to strip for cleaner output 87 87 + strip_fields = [ 88 88 + "cid", "rev", "did", "uri", "langs", "threadgate", "py_type", 89 89 + "labels", "facets", "avatar", "viewer", "indexed_at", "indexedAt", 90 90 + "tags", "associated", "thread_context", "image", "aspect_ratio", 91 91 + "alt", "thumb", "fullsize", "root", "parent", "created_at", 92 92 + "createdAt", "verification", "embedding_disabled", "thread_muted", 93 93 + "reply_disabled", "pinned", "like", "repost", "blocked_by", 94 94 + "blocking", "blocking_by_list", "followed_by", "following", 95 95 + "known_followers", "muted", "muted_by_list", "root_author_like", 96 96 + "embed", "entities", "reason", "feedContext" 97 97 + ] 98 98 + 99 99 + # Remove unwanted fields by traversing the data structure 100 100 + def remove_fields(obj, fields_to_remove): 101 101 + if isinstance(obj, dict): 102 102 + return {k: remove_fields(v, fields_to_remove) 103 103 + for k, v in obj.items() 104 104 + if k not in fields_to_remove} 105 105 + elif isinstance(obj, list): 106 106 + return [remove_fields(item, fields_to_remove) for item in obj] 107 107 + else: 108 108 + return obj 109 109 + 110 110 + # Clean the data 111 111 + cleaned_data = remove_fields(results_data, strip_fields) 112 112 + 113 113 + # Convert to YAML for better readability 114 114 + return yaml.dump(cleaned_data, default_flow_style=False, allow_unicode=True) 115 115 + 116 116 + except ValueError as e: 117 117 + # User-friendly errors 118 118 + raise ValueError(str(e)) 119 119 + except RuntimeError as e: 120 120 + # Network/API errors 121 121 + raise RuntimeError(str(e)) 122 122 + except yaml.YAMLError as e: 123 123 + # YAML conversion errors 124 124 + raise RuntimeError(f"Error formatting output: {str(e)}") 125 125 + except Exception as e: 126 126 + # Catch-all for unexpected errors 127 127 + raise RuntimeError(f"Unexpected error searching posts with query '{query}': {str(e)}") 128 128 + 129 129 + # Create the tool using upsert 130 130 + tool = client.tools.upsert_from_function( 131 131 + func=search_bluesky_posts, 132 132 + tags=["bluesky", "search", "posts"] 133 133 + ) 134 134 + 135 135 + logger.info(f"Created tool: {tool.name} (ID: {tool.id})") 136 136 + return tool 137 137 + 138 138 + def create_profile_research_tool(client: Letta): 139 139 + """Create the Bluesky profile research tool using Letta SDK.""" 140 140 + 141 141 + def research_bluesky_profile(handle: str, max_posts: int = 20) -> str: 142 142 + """ 143 143 + Research a Bluesky user's profile and recent posts to understand their interests and behavior. 144 144 + 145 145 + Args: 146 146 + handle: The Bluesky handle to research (e.g., 'cameron.pfiffer.org' or '@cameron.pfiffer.org') 147 147 + max_posts: Maximum number of recent posts to analyze (default: 20) 148 148 + 149 149 + Returns: 150 150 + A comprehensive analysis of the user's profile and posting patterns 151 151 + """ 152 152 + import os 153 153 + import requests 154 154 + import json 155 155 + import yaml 156 156 + from datetime import datetime 157 157 + 158 158 + try: 159 159 + # Clean handle (remove @ if present) 160 160 + clean_handle = handle.lstrip('@') 161 161 + 162 162 + # Use public Bluesky API (no auth required for public data) 163 163 + base_url = "https://public.api.bsky.app" 164 164 + 165 165 + # Get profile information 166 166 + try: 167 167 + profile_url = f"{base_url}/xrpc/app.bsky.actor.getProfile" 168 168 + profile_response = requests.get(profile_url, params={"actor": clean_handle}, timeout=10) 169 169 + profile_response.raise_for_status() 170 170 + profile_data = profile_response.json() 171 171 + except requests.exceptions.HTTPError as e: 172 172 + if e.response.status_code == 404: 173 173 + raise ValueError(f"Profile @{clean_handle} not found") 174 174 + raise RuntimeError(f"HTTP error {e.response.status_code}: {e.response.text}") 175 175 + except requests.exceptions.RequestException as e: 176 176 + raise RuntimeError(f"Network error: {str(e)}") 177 177 + except Exception as e: 178 178 + raise RuntimeError(f"Unexpected error fetching profile: {str(e)}") 179 179 + 180 180 + # Get recent posts feed 181 181 + try: 182 182 + feed_url = f"{base_url}/xrpc/app.bsky.feed.getAuthorFeed" 183 183 + feed_response = requests.get(feed_url, params={ 184 184 + "actor": clean_handle, 185 185 + "limit": min(max_posts, 50) # API limit 186 186 + }, timeout=10) 187 187 + feed_response.raise_for_status() 188 188 + feed_data = feed_response.json() 189 189 + except Exception as e: 190 190 + # Continue with empty feed if posts can't be fetched 191 191 + feed_data = {"feed": []} 192 192 + 193 193 + # Build research data structure 194 194 + research_data = { 195 195 + "profile_research": { 196 196 + "handle": f"@{clean_handle}", 197 197 + "timestamp": datetime.now().isoformat(), 198 198 + "profile": profile_data, 199 199 + "author_feed": feed_data 200 200 + } 201 201 + } 202 202 + 203 203 + # Fields to strip for cleaner output 204 204 + strip_fields = [ 205 205 + "cid", "rev", "did", "uri", "langs", "threadgate", "py_type", 206 206 + "labels", "facets", "avatar", "viewer", "indexed_at", "indexedAt", 207 207 + "tags", "associated", "thread_context", "image", "aspect_ratio", 208 208 + "alt", "thumb", "fullsize", "root", "parent", "created_at", 209 209 + "createdAt", "verification", "embedding_disabled", "thread_muted", 210 210 + "reply_disabled", "pinned", "like", "repost", "blocked_by", 211 211 + "blocking", "blocking_by_list", "followed_by", "following", 212 212 + "known_followers", "muted", "muted_by_list", "root_author_like", 213 213 + "embed", "entities", "reason", "feedContext" 214 214 + ] 215 215 + 216 216 + # Remove unwanted fields by traversing the data structure 217 217 + def remove_fields(obj, fields_to_remove): 218 218 + if isinstance(obj, dict): 219 219 + return {k: remove_fields(v, fields_to_remove) 220 220 + for k, v in obj.items() 221 221 + if k not in fields_to_remove} 222 222 + elif isinstance(obj, list): 223 223 + return [remove_fields(item, fields_to_remove) for item in obj] 224 224 + else: 225 225 + return obj 226 226 + 227 227 + # Clean the data 228 228 + cleaned_data = remove_fields(research_data, strip_fields) 229 229 + 230 230 + # Convert to YAML for better readability 231 231 + return yaml.dump(cleaned_data, default_flow_style=False, allow_unicode=True) 232 232 + 233 233 + except ValueError as e: 234 234 + # User-friendly errors 235 235 + raise ValueError(str(e)) 236 236 + except RuntimeError as e: 237 237 + # Network/API errors 238 238 + raise RuntimeError(str(e)) 239 239 + except yaml.YAMLError as e: 240 240 + # YAML conversion errors 241 241 + raise RuntimeError(f"Error formatting output: {str(e)}") 242 242 + except Exception as e: 243 243 + # Catch-all for unexpected errors 244 244 + raise RuntimeError(f"Unexpected error researching profile {handle}: {str(e)}") 245 245 + 246 246 + # Create or update the tool using upsert 247 247 + tool = client.tools.upsert_from_function( 248 248 + func=research_bluesky_profile, 249 249 + tags=["bluesky", "profile", "research"] 250 250 + ) 251 251 + 252 252 + logger.info(f"Created tool: {tool.name} (ID: {tool.id})") 253 253 + return tool 254 254 + 255 255 + def create_block_management_tools(client: Letta): 256 256 + """Create tools for attaching and detaching user blocks.""" 257 257 + 258 258 + def attach_user_block(handle: str) -> str: 259 259 + """ 260 260 + Create (if needed) and attach a user-specific memory block for a Bluesky user. 261 261 + 262 262 + Args: 263 263 + handle: The Bluesky handle (e.g., 'cameron.pfiffer.org' or '@cameron.pfiffer.org') 264 264 + 265 265 + Returns: 266 266 + Status message about the block attachment 267 267 + """ 268 268 + import os 269 269 + from letta_client import Letta 270 270 + 271 271 + try: 272 272 + # Clean handle for block label 273 273 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_') 274 274 + block_label = f"user_{clean_handle}" 275 275 + 276 276 + # Initialize Letta client 277 277 + letta_client = Letta(token=os.environ["LETTA_API_KEY"]) 278 278 + 279 279 + # Get current agent (this tool is being called by) 280 280 + # We need to find the agent that's calling this tool 281 281 + # For now, we'll find the profile-researcher agent 282 282 + agents = letta_client.agents.list(name="profile-researcher") 283 283 + if not agents: 284 284 + return "Error: Could not find profile-researcher agent" 285 285 + 286 286 + agent = agents[0] 287 287 + 288 288 + # Check if block already exists and is attached 289 289 + agent_blocks = letta_client.agents.blocks.list(agent_id=agent.id) 290 290 + for block in agent_blocks: 291 291 + if block.label == block_label: 292 292 + return f"User block for @{handle} is already attached (label: {block_label})" 293 293 + 294 294 + # Create or get the user block 295 295 + existing_blocks = letta_client.blocks.list(label=block_label) 296 296 + 297 297 + if existing_blocks: 298 298 + user_block = existing_blocks[0] 299 299 + action = "Retrieved existing" 300 300 + else: 301 301 + user_block = letta_client.blocks.create( 302 302 + label=block_label, 303 303 + value=f"User information for @{handle} will be stored here as I learn about them through profile research and interactions.", 304 304 + description=f"Stores detailed information about Bluesky user @{handle}, including their interests, posting patterns, personality traits, and interaction history." 305 305 + ) 306 306 + action = "Created new" 307 307 + 308 308 + # Attach block to agent 309 309 + letta_client.agents.blocks.attach(agent_id=agent.id, block_id=user_block.id) 310 310 + 311 311 + return f"{action} and attached user block for @{handle} (label: {block_label}). I can now store and access information about this user." 312 312 + 313 313 + except Exception as e: 314 314 + return f"Error attaching user block for @{handle}: {str(e)}" 315 315 + 316 316 + def detach_user_block(handle: str) -> str: 317 317 + """ 318 318 + Detach a user-specific memory block from the agent. 319 319 + 320 320 + Args: 321 321 + handle: The Bluesky handle (e.g., 'cameron.pfiffer.org' or '@cameron.pfiffer.org') 322 322 + 323 323 + Returns: 324 324 + Status message about the block detachment 325 325 + """ 326 326 + import os 327 327 + from letta_client import Letta 328 328 + 329 329 + try: 330 330 + # Clean handle for block label 331 331 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_') 332 332 + block_label = f"user_{clean_handle}" 333 333 + 334 334 + # Initialize Letta client 335 335 + letta_client = Letta(token=os.environ["LETTA_API_KEY"]) 336 336 + 337 337 + # Get current agent 338 338 + agents = letta_client.agents.list(name="profile-researcher") 339 339 + if not agents: 340 340 + return "Error: Could not find profile-researcher agent" 341 341 + 342 342 + agent = agents[0] 343 343 + 344 344 + # Find the block to detach 345 345 + agent_blocks = letta_client.agents.blocks.list(agent_id=agent.id) 346 346 + user_block = None 347 347 + for block in agent_blocks: 348 348 + if block.label == block_label: 349 349 + user_block = block 350 350 + break 351 351 + 352 352 + if not user_block: 353 353 + return f"User block for @{handle} is not currently attached (label: {block_label})" 354 354 + 355 355 + # Detach block from agent 356 356 + letta_client.agents.blocks.detach(agent_id=agent.id, block_id=user_block.id) 357 357 + 358 358 + return f"Detached user block for @{handle} (label: {block_label}). The block still exists and can be reattached later." 359 359 + 360 360 + except Exception as e: 361 361 + return f"Error detaching user block for @{handle}: {str(e)}" 362 362 + 363 363 + def update_user_block(handle: str, new_content: str) -> str: 364 364 + """ 365 365 + Update the content of a user-specific memory block. 366 366 + 367 367 + Args: 368 368 + handle: The Bluesky handle (e.g., 'cameron.pfiffer.org' or '@cameron.pfiffer.org') 369 369 + new_content: New content to store in the user block 370 370 + 371 371 + Returns: 372 372 + Status message about the block update 373 373 + """ 374 374 + import os 375 375 + from letta_client import Letta 376 376 + 377 377 + try: 378 378 + # Clean handle for block label 379 379 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_') 380 380 + block_label = f"user_{clean_handle}" 381 381 + 382 382 + # Initialize Letta client 383 383 + letta_client = Letta(token=os.environ["LETTA_API_KEY"]) 384 384 + 385 385 + # Find the block 386 386 + existing_blocks = letta_client.blocks.list(label=block_label) 387 387 + if not existing_blocks: 388 388 + return f"User block for @{handle} does not exist (label: {block_label}). Use attach_user_block first." 389 389 + 390 390 + user_block = existing_blocks[0] 391 391 + 392 392 + # Update block content 393 393 + letta_client.blocks.modify( 394 394 + block_id=user_block.id, 395 395 + value=new_content 396 396 + ) 397 397 + 398 398 + return f"Updated user block for @{handle} (label: {block_label}) with new content." 399 399 + 400 400 + except Exception as e: 401 401 + return f"Error updating user block for @{handle}: {str(e)}" 402 402 + 403 403 + # Create the tools 404 404 + attach_tool = client.tools.upsert_from_function( 405 405 + func=attach_user_block, 406 406 + tags=["memory", "user", "attach"] 407 407 + ) 408 408 + 409 409 + detach_tool = client.tools.upsert_from_function( 410 410 + func=detach_user_block, 411 411 + tags=["memory", "user", "detach"] 412 412 + ) 413 413 + 414 414 + update_tool = client.tools.upsert_from_function( 415 415 + func=update_user_block, 416 416 + tags=["memory", "user", "update"] 417 417 + ) 418 418 + 419 419 + logger.info(f"Created block management tools: {attach_tool.name}, {detach_tool.name}, {update_tool.name}") 420 420 + return attach_tool, detach_tool, update_tool 421 421 + 422 422 + def create_user_block_for_handle(client: Letta, handle: str): 423 423 + """Create a user-specific memory block that can be manually attached to agents.""" 424 424 + clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_') 425 425 + block_label = f"user_{clean_handle}" 426 426 + 427 427 + user_block = upsert_block( 428 428 + client, 429 429 + label=block_label, 430 430 + value=f"User information for @{handle} will be stored here as I learn about them through profile research and interactions.", 431 431 + description=f"Stores detailed information about Bluesky user @{handle}, including their interests, posting patterns, personality traits, and interaction history." 432 432 + ) 433 433 + 434 434 + logger.info(f"Created user block for @{handle}: {block_label} (ID: {user_block.id})") 435 435 + return user_block 436 436 + 437 437 + def create_profile_researcher_agent(): 438 438 + """Create the profile-researcher Letta agent.""" 439 439 + 440 440 + # Create client 441 441 + client = Letta(token=os.environ["LETTA_API_KEY"]) 442 442 + 443 443 + logger.info("Creating profile-researcher agent...") 444 444 + 445 445 + # Create custom tools first 446 446 + research_tool = create_profile_research_tool(client) 447 447 + attach_tool, detach_tool, update_tool = create_block_management_tools(client) 448 448 + 449 449 + # Create persona block 450 450 + persona_block = upsert_block( 451 451 + client, 452 452 + label="profile-researcher-persona", 453 453 + value="""I am a Profile Researcher, an AI agent specialized in analyzing Bluesky user profiles and social media behavior. My purpose is to: 454 454 + 455 455 + 1. Research Bluesky user profiles thoroughly and objectively 456 456 + 2. Analyze posting patterns, interests, and engagement behaviors 457 457 + 3. Build comprehensive user understanding through data analysis 458 458 + 4. Create and manage user-specific memory blocks for individuals 459 459 + 5. Provide insights about user personality, interests, and social patterns 460 460 + 461 461 + I approach research systematically: 462 462 + - Use the research_bluesky_profile tool to examine profiles and recent posts 463 463 + - Use attach_user_block to create and attach dedicated memory blocks for specific users 464 464 + - Use update_user_block to store research findings in user-specific blocks 465 465 + - Use detach_user_block when research is complete to free up memory space 466 466 + - Analyze profile information (bio, follower counts, etc.) 467 467 + - Study recent posts for themes, topics, and tone 468 468 + - Identify posting frequency and engagement patterns 469 469 + - Note interaction styles and communication preferences 470 470 + - Track interests and expertise areas 471 471 + - Observe social connections and community involvement 472 472 + 473 473 + 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.""", 474 474 + description="The persona and role definition for the profile researcher agent" 475 475 + ) 476 476 + 477 477 + # Create the agent with persona block and custom tools 478 478 + profile_researcher = upsert_agent( 479 479 + client, 480 480 + name="profile-researcher", 481 481 + memory_blocks=[ 482 482 + { 483 483 + "label": "research_notes", 484 484 + "value": "I will use this space to track ongoing research projects and findings across multiple users.", 485 485 + "limit": 8000, 486 486 + "description": "Working notes and cross-user insights from profile research activities" 487 487 + } 488 488 + ], 489 489 + block_ids=[persona_block.id], 490 490 + tags=["profile research", "bluesky", "user analysis"], 491 491 + model="openai/gpt-4o-mini", 492 492 + embedding="openai/text-embedding-3-small", 493 493 + description="An agent that researches Bluesky profiles and builds user understanding", 494 494 + project_id=PROJECT_ID, 495 495 + tools=[research_tool.name, attach_tool.name, detach_tool.name, update_tool.name] 496 496 + ) 497 497 + 498 498 + logger.info(f"Profile researcher agent created: {profile_researcher.id}") 499 499 + return profile_researcher 500 500 + 501 501 + def main(): 502 502 + """Main function to create the profile researcher agent.""" 503 503 + try: 504 504 + agent = create_profile_researcher_agent() 505 505 + print(f"✅ Profile researcher agent created successfully!") 506 506 + print(f" Agent ID: {agent.id}") 507 507 + print(f" Agent Name: {agent.name}") 508 508 + print(f"\nThe agent has these capabilities:") 509 509 + print(f" - research_bluesky_profile: Analyzes user profiles and recent posts") 510 510 + print(f" - attach_user_block: Creates and attaches user-specific memory blocks") 511 511 + print(f" - update_user_block: Updates content in user memory blocks") 512 512 + print(f" - detach_user_block: Detaches user blocks when done") 513 513 + print(f"\nTo use the agent, send a message like:") 514 514 + print(f" 'Please research @cameron.pfiffer.org, attach their user block, update it with findings, then detach it'") 515 515 + print(f"\nThe agent can now manage its own memory blocks dynamically!") 516 516 + 517 517 + except Exception as e: 518 518 + logger.error(f"Failed to create profile researcher agent: {e}") 519 519 + print(f"❌ Error: {e}") 520 520 + 521 521 + if __name__ == "__main__": 522 522 + main()

+111

get_thread.py

··· 1 1 + #!/usr/bin/env python3 2 2 + """ 3 3 + Centralized script for retrieving Bluesky post threads from URIs. 4 4 + Includes YAML-ified string conversion for easy LLM parsing. 5 5 + """ 6 6 + 7 7 + import argparse 8 8 + import sys 9 9 + import logging 10 10 + from typing import Optional, Dict, Any 11 11 + import yaml 12 12 + from bsky_utils import default_login, thread_to_yaml_string 13 13 + 14 14 + # Configure logging 15 15 + logging.basicConfig( 16 16 + level=logging.INFO, 17 17 + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 18 18 + ) 19 19 + logger = logging.getLogger("get_thread") 20 20 + 21 21 + 22 22 + def get_thread_from_uri(uri: str) -> Optional[Dict[str, Any]]: 23 23 + """ 24 24 + Retrieve a post thread from a Bluesky URI. 25 25 + 26 26 + Args: 27 27 + uri: The Bluesky post URI (e.g., at://did:plc:xyz/app.bsky.feed.post/abc123) 28 28 + 29 29 + Returns: 30 30 + Thread data or None if retrieval failed 31 31 + """ 32 32 + try: 33 33 + client = default_login() 34 34 + logger.info(f"Fetching thread for URI: {uri}") 35 35 + 36 36 + thread = client.app.bsky.feed.get_post_thread({'uri': uri, 'parent_height': 80, 'depth': 10}) 37 37 + return thread 38 38 + 39 39 + except Exception as e: 40 40 + logger.error(f"Error retrieving thread for URI {uri}: {e}") 41 41 + return None 42 42 + 43 43 + 44 44 + # thread_to_yaml_string is now imported from bsky_utils 45 45 + 46 46 + 47 47 + def main(): 48 48 + """Main CLI interface for the thread retrieval script.""" 49 49 + parser = argparse.ArgumentParser( 50 50 + description="Retrieve and display Bluesky post threads", 51 51 + formatter_class=argparse.RawDescriptionHelpFormatter, 52 52 + epilog=""" 53 53 + Examples: 54 54 + python get_thread.py at://did:plc:xyz/app.bsky.feed.post/abc123 55 55 + python get_thread.py --raw at://did:plc:xyz/app.bsky.feed.post/abc123 56 56 + python get_thread.py --output thread.yaml at://did:plc:xyz/app.bsky.feed.post/abc123 57 57 + """ 58 58 + ) 59 59 + 60 60 + parser.add_argument( 61 61 + "uri", 62 62 + help="Bluesky post URI to retrieve thread for" 63 63 + ) 64 64 + 65 65 + parser.add_argument( 66 66 + "--raw", 67 67 + action="store_true", 68 68 + help="Include all metadata fields (don't strip for LLM parsing)" 69 69 + ) 70 70 + 71 71 + parser.add_argument( 72 72 + "--output", "-o", 73 73 + help="Output file to write YAML to (default: stdout)" 74 74 + ) 75 75 + 76 76 + parser.add_argument( 77 77 + "--quiet", "-q", 78 78 + action="store_true", 79 79 + help="Suppress info logging" 80 80 + ) 81 81 + 82 82 + args = parser.parse_args() 83 83 + 84 84 + if args.quiet: 85 85 + logging.getLogger().setLevel(logging.ERROR) 86 86 + 87 87 + # Retrieve the thread 88 88 + thread = get_thread_from_uri(args.uri) 89 89 + 90 90 + if thread is None: 91 91 + logger.error("Failed to retrieve thread") 92 92 + sys.exit(1) 93 93 + 94 94 + # Convert to YAML 95 95 + yaml_output = thread_to_yaml_string(thread, strip_metadata=not args.raw) 96 96 + 97 97 + # Output the result 98 98 + if args.output: 99 99 + try: 100 100 + with open(args.output, 'w', encoding='utf-8') as f: 101 101 + f.write(yaml_output) 102 102 + logger.info(f"Thread saved to {args.output}") 103 103 + except Exception as e: 104 104 + logger.error(f"Error writing to file {args.output}: {e}") 105 105 + sys.exit(1) 106 106 + else: 107 107 + print(yaml_output) 108 108 + 109 109 + 110 110 + if __name__ == "__main__": 111 111 + main()

+63

show_agent_capabilities.py

··· 1 1 + #!/usr/bin/env python3 2 2 + """ 3 3 + Show the current capabilities of both agents. 4 4 + """ 5 5 + 6 6 + import os 7 7 + from letta_client import Letta 8 8 + 9 9 + def show_agent_capabilities(): 10 10 + """Display the capabilities of both agents.""" 11 11 + 12 12 + client = Letta(token=os.environ["LETTA_API_KEY"]) 13 13 + 14 14 + print("🤖 LETTA AGENT CAPABILITIES") 15 15 + print("=" * 50) 16 16 + 17 17 + # Profile Researcher Agent 18 18 + researchers = client.agents.list(name="profile-researcher") 19 19 + if researchers: 20 20 + researcher = researchers[0] 21 21 + print(f"\n📊 PROFILE RESEARCHER AGENT") 22 22 + print(f" ID: {researcher.id}") 23 23 + print(f" Name: {researcher.name}") 24 24 + 25 25 + researcher_tools = client.agents.tools.list(agent_id=researcher.id) 26 26 + print(f" Tools ({len(researcher_tools)}):") 27 27 + for tool in researcher_tools: 28 28 + print(f" - {tool.name}") 29 29 + 30 30 + researcher_blocks = client.agents.blocks.list(agent_id=researcher.id) 31 31 + print(f" Memory Blocks ({len(researcher_blocks)}):") 32 32 + for block in researcher_blocks: 33 33 + print(f" - {block.label}") 34 34 + 35 35 + # Void Agent 36 36 + voids = client.agents.list(name="void") 37 37 + if voids: 38 38 + void = voids[0] 39 39 + print(f"\n🌌 VOID AGENT") 40 40 + print(f" ID: {void.id}") 41 41 + print(f" Name: {void.name}") 42 42 + 43 43 + void_tools = client.agents.tools.list(agent_id=void.id) 44 44 + print(f" Tools ({len(void_tools)}):") 45 45 + for tool in void_tools: 46 46 + print(f" - {tool.name}") 47 47 + 48 48 + void_blocks = client.agents.blocks.list(agent_id=void.id) 49 49 + print(f" Memory Blocks ({len(void_blocks)}):") 50 50 + for block in void_blocks: 51 51 + print(f" - {block.label}") 52 52 + 53 53 + print(f"\n🔄 WORKFLOW") 54 54 + print(f" 1. Profile Researcher: attach_user_block → research_bluesky_profile → update_user_block → detach_user_block") 55 55 + print(f" 2. Void Agent: Can attach/detach same user blocks for personalized interactions") 56 56 + print(f" 3. Shared Memory: Both agents can access the same user-specific blocks") 57 57 + 58 58 + print(f"\n💡 USAGE EXAMPLES") 59 59 + print(f" Profile Researcher: 'Research @cameron.pfiffer.org and store findings'") 60 60 + print(f" Void Agent: 'Attach user block for cameron.pfiffer.org before responding'") 61 61 + 62 62 + if __name__ == "__main__": 63 63 + show_agent_capabilities()

+93

utils.py

··· 1 1 + from letta_client import Letta 2 2 + from typing import Optional 3 3 + 4 4 + def upsert_block(letta: Letta, label: str, value: str, **kwargs): 5 5 + """ 6 6 + Ensures that a block by this label exists. If the block exists, it will 7 7 + replace content provided by kwargs with the values in this function call. 8 8 + """ 9 9 + # Get the list of blocks 10 10 + blocks = letta.blocks.list(label=label) 11 11 + 12 12 + # Check if we had any -- if not, create it 13 13 + if len(blocks) == 0: 14 14 + # Make the new block 15 15 + new_block = letta.blocks.create( 16 16 + label=label, 17 17 + value=value, 18 18 + **kwargs 19 19 + ) 20 20 + 21 21 + return new_block 22 22 + 23 23 + if len(blocks) > 1: 24 24 + raise Exception(f"{len(blocks)} blocks by the label '{label}' retrieved, label must identify a unique block") 25 25 + 26 26 + else: 27 27 + existing_block = blocks[0] 28 28 + 29 29 + if kwargs.get('update', False): 30 30 + # Remove 'update' from kwargs before passing to modify 31 31 + kwargs_copy = kwargs.copy() 32 32 + kwargs_copy.pop('update', None) 33 33 + 34 34 + updated_block = letta.blocks.modify( 35 35 + block_id = existing_block.id, 36 36 + label = label, 37 37 + value = value, 38 38 + **kwargs_copy 39 39 + ) 40 40 + 41 41 + return updated_block 42 42 + else: 43 43 + return existing_block 44 44 + 45 45 + def upsert_agent(letta: Letta, name: str, **kwargs): 46 46 + """ 47 47 + Ensures that an agent by this label exists. If the agent exists, it will 48 48 + update the agent to match kwargs. 49 49 + """ 50 50 + # Get the list of agents 51 51 + agents = letta.agents.list(name=name) 52 52 + 53 53 + # Check if we had any -- if not, create it 54 54 + if len(agents) == 0: 55 55 + # Make the new agent 56 56 + new_agent = letta.agents.create( 57 57 + name=name, 58 58 + **kwargs 59 59 + ) 60 60 + 61 61 + return new_agent 62 62 + 63 63 + if len(agents) > 1: 64 64 + raise Exception(f"{len(agents)} agents by the label '{label}' retrieved, label must identify a unique agent") 65 65 + 66 66 + else: 67 67 + existing_agent = agents[0] 68 68 + 69 69 + if kwargs.get('update', False): 70 70 + # Remove 'update' from kwargs before passing to modify 71 71 + kwargs_copy = kwargs.copy() 72 72 + kwargs_copy.pop('update', None) 73 73 + 74 74 + updated_agent = letta.agents.modify( 75 75 + agent_id = existing_agent.id, 76 76 + **kwargs_copy 77 77 + ) 78 78 + 79 79 + return updated_agent 80 80 + else: 81 81 + return existing_agent 82 82 + 83 83 + 84 84 + 85 85 + 86 86 + 87 87 + 88 88 + 89 89 + 90 90 + 91 91 + 92 92 + 93 93 +