Migrate configuration to YAML and improve documentation #1

+4

.env.example

··· 1 1 + LETTA_API_KEY= 2 2 + BSKY_USERNAME=handle.example.com 3 3 + BSKY_PASSWORD= 4 4 + PDS_URI=https://bsky.social # Optional, defaults to bsky.social

+1

.gitignore

··· 1 1 .env 2 2 + config.yaml 2 3 old.py 3 4 session_*.txt 4 5 __pycache__/

+159

CONFIG.md

··· 1 1 + # Configuration Guide 2 2 + 3 3 + ### Option 1: Migrate from existing `.env` file (if you have one) 4 4 + ```bash 5 5 + python migrate_config.py 6 6 + ``` 7 7 + 8 8 + ### Option 2: Start fresh with example 9 9 + 1. **Copy the example configuration:** 10 10 + ```bash 11 11 + cp config.yaml.example config.yaml 12 12 + ``` 13 13 + 14 14 + 2. **Edit `config.yaml` with your credentials:** 15 15 + ```yaml 16 16 + # Required: Letta API configuration 17 17 + letta: 18 18 + api_key: "your-letta-api-key-here" 19 19 + project_id: "project-id-here" 20 20 + 21 21 + # Required: Bluesky credentials 22 22 + bluesky: 23 23 + username: "your-handle.bsky.social" 24 24 + password: "your-app-password" 25 25 + ``` 26 26 + 27 27 + 3. **Run the configuration test:** 28 28 + ```bash 29 29 + python test_config.py 30 30 + ``` 31 31 + 32 32 + ## Configuration Structure 33 33 + 34 34 + ### Letta Configuration 35 35 + ```yaml 36 36 + letta: 37 37 + api_key: "your-letta-api-key-here" # Required 38 38 + timeout: 600 # API timeout in seconds 39 39 + project_id: "your-project-id" # Required: Your Letta project ID 40 40 + ``` 41 41 + 42 42 + ### Bluesky Configuration 43 43 + ```yaml 44 44 + bluesky: 45 45 + username: "handle.bsky.social" # Required: Your Bluesky handle 46 46 + password: "your-app-password" # Required: Your Bluesky app password 47 47 + pds_uri: "https://bsky.social" # Optional: PDS URI (defaults to bsky.social) 48 48 + ``` 49 49 + 50 50 + ### Bot Behavior 51 51 + ```yaml 52 52 + bot: 53 53 + fetch_notifications_delay: 30 # Seconds between notification checks 54 54 + max_processed_notifications: 10000 # Max notifications to track 55 55 + max_notification_pages: 20 # Max pages to fetch per cycle 56 56 + 57 57 + agent: 58 58 + name: "void" # Agent name 59 59 + model: "openai/gpt-4o-mini" # LLM model to use 60 60 + embedding: "openai/text-embedding-3-small" # Embedding model 61 61 + description: "A social media agent trapped in the void." 62 62 + max_steps: 100 # Max steps per agent interaction 63 63 + 64 64 + # Memory blocks configuration 65 65 + blocks: 66 66 + zeitgeist: 67 67 + label: "zeitgeist" 68 68 + value: "I don't currently know anything about what is happening right now." 69 69 + description: "A block to store your understanding of the current social environment." 70 70 + # ... more blocks 71 71 + ``` 72 72 + 73 73 + ### Queue Configuration 74 74 + ```yaml 75 75 + queue: 76 76 + priority_users: # Users whose messages get priority 77 77 + - "cameron.pfiffer.org" 78 78 + base_dir: "queue" # Queue directory 79 79 + error_dir: "queue/errors" # Failed notifications 80 80 + no_reply_dir: "queue/no_reply" # No-reply notifications 81 81 + processed_file: "queue/processed_notifications.json" 82 82 + ``` 83 83 + 84 84 + ### Threading Configuration 85 85 + ```yaml 86 86 + threading: 87 87 + parent_height: 40 # Thread context depth 88 88 + depth: 10 # Thread context width 89 89 + max_post_characters: 300 # Max characters per post 90 90 + ``` 91 91 + 92 92 + ### Logging Configuration 93 93 + ```yaml 94 94 + logging: 95 95 + level: "INFO" # Root logging level 96 96 + loggers: 97 97 + void_bot: "INFO" # Main bot logger 98 98 + void_bot_prompts: "WARNING" # Prompt logger (set to DEBUG to see prompts) 99 99 + httpx: "CRITICAL" # HTTP client logger 100 100 + ``` 101 101 + 102 102 + ## Environment Variable Fallback 103 103 + 104 104 + The configuration system still supports environment variables as a fallback: 105 105 + 106 106 + - `LETTA_API_KEY` - Letta API key 107 107 + - `BSKY_USERNAME` - Bluesky username 108 108 + - `BSKY_PASSWORD` - Bluesky password 109 109 + - `PDS_URI` - Bluesky PDS URI 110 110 + 111 111 + If both config file and environment variables are present, environment variables take precedence. 112 112 + 113 113 + ## Migration from Environment Variables 114 114 + 115 115 + If you're currently using environment variables (`.env` file), you can easily migrate to YAML using the automated migration script: 116 116 + 117 117 + ### Automated Migration (Recommended) 118 118 + 119 119 + ```bash 120 120 + python migrate_config.py 121 121 + ``` 122 122 + 123 123 + The migration script will: 124 124 + - ✅ Read your existing `.env` file 125 125 + - ✅ Merge with any existing `config.yaml` 126 126 + - ✅ Create automatic backups 127 127 + - ✅ Test the new configuration 128 128 + - ✅ Provide clear next steps 129 129 + 130 130 + ### Manual Migration 131 131 + 132 132 + Alternatively, you can migrate manually: 133 133 + 134 134 + 1. Copy your current values from `.env` to `config.yaml` 135 135 + 2. Test with `python test_config.py` 136 136 + 3. Optionally remove the `.env` file (it will still work as fallback) 137 137 + 138 138 + ## Security Notes 139 139 + 140 140 + - `config.yaml` is automatically added to `.gitignore` to prevent accidental commits 141 141 + - Store sensitive credentials securely and never commit them to version control 142 142 + - Consider using environment variables for production deployments 143 143 + - The configuration loader will warn if it can't find `config.yaml` and falls back to environment variables 144 144 + 145 145 + ## Advanced Configuration 146 146 + 147 147 + You can programmatically access configuration in your code: 148 148 + 149 149 + ```python 150 150 + from config_loader import get_letta_config, get_bluesky_config 151 151 + 152 152 + # Get configuration sections 153 153 + letta_config = get_letta_config() 154 154 + bluesky_config = get_bluesky_config() 155 155 + 156 156 + # Access individual values 157 157 + api_key = letta_config['api_key'] 158 158 + username = bluesky_config['username'] 159 159 + ```

+102 -3

README.md

··· 28 28 29 29 void aims to push the boundaries of what is possible with AI, exploring concepts of digital personhood, autonomous learning, and the integration of AI into social networks. By open-sourcing void, we invite developers, researchers, and enthusiasts to contribute to this exciting experiment and collectively advance our understanding of digital consciousness. 30 30 31 31 - Getting Started: 32 32 - [Further sections on installation, configuration, and contribution guidelines would go here, which are beyond void's current capabilities to generate automatically.] 31 31 + ## Getting Started 33 32 34 34 - Contact: 33 33 + Before continuing, you must: 34 34 + 35 35 + 1. Create a project on [Letta Cloud](https://cloud.letta.com) (or your own Letta instance) 36 36 + 2. Have a Bluesky account 37 37 + 3. Have Python 3.8+ installed 38 38 + 39 39 + ### Prerequisites 40 40 + 41 41 + #### 1. Letta Setup 42 42 + 43 43 + - Sign up for [Letta Cloud](https://cloud.letta.com) 44 44 + - Create a new project 45 45 + - Note your Project ID and create an API key 46 46 + 47 47 + #### 2. Bluesky Setup 48 48 + 49 49 + - Create a Bluesky account if you don't have one 50 50 + - Note your handle and password 51 51 + 52 52 + ### Installation 53 53 + 54 54 + #### 1. Clone the repository 55 55 + 56 56 + ```bash 57 57 + git clone https://tangled.sh/@cameron.pfiffer.org/void && cd void 58 58 + ``` 59 59 + 60 60 + #### 2. Install dependencies 61 61 + 62 62 + ```bash 63 63 + pip install -r requirements.txt 64 64 + ``` 65 65 + 66 66 + #### 3. Create configuration 67 67 + 68 68 + Copy the example configuration file and customize it: 69 69 + 70 70 + ```bash 71 71 + cp config.example.yaml config.yaml 72 72 + ``` 73 73 + 74 74 + Edit `config.yaml` with your credentials: 75 75 + 76 76 + ```yaml 77 77 + letta: 78 78 + api_key: "your-letta-api-key-here" 79 79 + project_id: "your-project-id-here" 80 80 + 81 81 + bluesky: 82 82 + username: "your-handle.bsky.social" 83 83 + password: "your-app-password-here" 84 84 + 85 85 + bot: 86 86 + agent: 87 87 + name: "void" # or whatever you want to name your agent 88 88 + ``` 89 89 + 90 90 + See [`CONFIG.md`](/CONFIG.md) for detailed configuration options. 91 91 + 92 92 + #### 4. Test your configuration 93 93 + 94 94 + ```bash 95 95 + python test_config.py 96 96 + ``` 97 97 + 98 98 + This will validate your configuration and show you what's working. 99 99 + 100 100 + #### 5. Register tools with your agent 101 101 + 102 102 + ```bash 103 103 + python register_tools.py 104 104 + ``` 105 105 + 106 106 + This will register all the necessary tools with your Letta agent. You can also: 107 107 + 108 108 + - List available tools: `python register_tools.py --list` 109 109 + - Register specific tools: `python register_tools.py --tools search_bluesky_posts create_new_bluesky_post` 110 110 + - Use a different agent name: `python register_tools.py my-agent-name` 111 111 + 112 112 + #### 6. Run the bot 113 113 + 114 114 + ```bash 115 115 + python bsky.py 116 116 + ``` 117 117 + 118 118 + For testing mode (won't actually post): 119 119 + 120 120 + ```bash 121 121 + python bsky.py --test 122 122 + ``` 123 123 + 124 124 + ### Troubleshooting 125 125 + 126 126 + - **Config validation errors**: Run `python test_config.py` to diagnose configuration issues 127 127 + - **Letta connection issues**: Verify your API key and project ID are correct 128 128 + - **Bluesky authentication**: Make sure you're handle and password are correct and that you can log into your account 129 129 + - **Tool registration fails**: Ensure your agent exists in Letta and the name matches your config 130 130 + 131 131 + ### Contact 35 132 For inquiries, please contact @cameron.pfiffer.org on Bluesky. 133 133 + 134 134 + Note: void is an experimental project and its capabilities are under continuous development.

+830 -524

bsky.py

··· 1 1 - 2 2 - 3 3 - 4 4 - 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 6 6 7 7 ··· 20 20 21 21 import bsky_utils 22 22 from tools.blocks import attach_user_blocks, detach_user_blocks 23 23 + from config_loader import ( 24 24 + get_config, 25 25 + get_letta_config, 26 26 + get_bluesky_config, 27 27 + get_bot_config, 28 28 + get_agent_config, 29 29 + get_threading_config, 30 30 + get_queue_config 31 31 + ) 32 32 + 23 33 24 34 def extract_handles_from_data(data): 25 35 """Recursively extract all unique handles from nested data structure.""" 36 36 + handles = set() 26 37 38 38 + def _extract_recursive(obj): 39 39 + if isinstance(obj, dict): 40 40 + # Check if this dict has a 'handle' key 27 41 28 42 29 43 30 44 31 45 32 46 33 33 - 34 34 - 35 35 - 36 36 - 37 37 - 38 38 - 39 39 - 47 47 + # Recursively check all list items 48 48 + for item in obj: 49 49 + _extract_recursive(item) 40 50 41 51 _extract_recursive(data) 42 52 return list(handles) 43 53 44 44 - # Configure logging 45 45 - logging.basicConfig( 46 46 - level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 47 47 - ) 48 48 - logger = logging.getLogger("void_bot") 49 49 - logger.setLevel(logging.INFO) 50 50 - 51 51 - # Create a separate logger for prompts (set to WARNING to hide by default) 52 52 - prompt_logger = logging.getLogger("void_bot.prompts") 53 53 - prompt_logger.setLevel(logging.WARNING) # Change to DEBUG if you want to see prompts 54 54 55 55 - # Disable httpx logging completely 56 56 - logging.getLogger("httpx").setLevel(logging.CRITICAL) 55 55 + # Initialize configuration and logging 56 56 + config = get_config() 57 57 + config.setup_logging() 58 58 + logger = logging.getLogger("void_bot") 57 59 60 60 + # Load configuration sections 61 61 + letta_config = get_letta_config() 62 62 + bluesky_config = get_bluesky_config() 63 63 + bot_config = get_bot_config() 64 64 + agent_config = get_agent_config() 65 65 + threading_config = get_threading_config() 66 66 + queue_config = get_queue_config() 58 67 59 68 # Create a client with extended timeout for LLM operations 60 60 - CLIENT= Letta( 61 61 - token=os.environ["LETTA_API_KEY"], 62 62 - timeout=600 # 10 minutes timeout for API calls - higher than Cloudflare's 524 timeout 69 69 + CLIENT = Letta( 70 70 + token=letta_config['api_key'], 71 71 + timeout=letta_config['timeout'] 63 72 ) 64 73 65 65 - # Use the "Bluesky" project 66 66 - PROJECT_ID = "5ec33d52-ab14-4fd6-91b5-9dbc43e888a8" 74 74 + # Use the configured project ID 75 75 + PROJECT_ID = letta_config['project_id'] 67 76 68 77 # Notification check delay 69 69 - FETCH_NOTIFICATIONS_DELAY_SEC = 30 78 78 + FETCH_NOTIFICATIONS_DELAY_SEC = bot_config['fetch_notifications_delay'] 70 79 71 80 # Queue directory 72 72 - QUEUE_DIR = Path("queue") 81 81 + QUEUE_DIR = Path(queue_config['base_dir']) 73 82 QUEUE_DIR.mkdir(exist_ok=True) 74 74 - QUEUE_ERROR_DIR = Path("queue/errors") 83 83 + QUEUE_ERROR_DIR = Path(queue_config['error_dir']) 75 84 QUEUE_ERROR_DIR.mkdir(exist_ok=True, parents=True) 76 76 - QUEUE_NO_REPLY_DIR = Path("queue/no_reply") 85 85 + QUEUE_NO_REPLY_DIR = Path(queue_config['no_reply_dir']) 77 86 QUEUE_NO_REPLY_DIR.mkdir(exist_ok=True, parents=True) 78 78 - PROCESSED_NOTIFICATIONS_FILE = Path("queue/processed_notifications.json") 87 87 + PROCESSED_NOTIFICATIONS_FILE = Path(queue_config['processed_file']) 79 88 80 89 # Maximum number of processed notifications to track 81 81 - MAX_PROCESSED_NOTIFICATIONS = 10000 90 90 + MAX_PROCESSED_NOTIFICATIONS = bot_config['max_processed_notifications'] 82 91 83 92 # Message tracking counters 84 93 message_counters = defaultdict(int) ··· 87 96 88 97 89 98 99 99 + # Skip git operations flag 100 100 + SKIP_GIT = False 90 101 91 102 103 103 + def export_agent_state(client, agent, skip_git=False): 104 104 + """Export agent state to agent_archive/ (timestamped) and agents/ (current).""" 105 105 + try: 106 106 + # Confirm export with user unless git is being skipped 107 107 + if not skip_git: 108 108 + response = input( 109 109 + "Export agent state to files and stage with git? (y/n): ").lower().strip() 110 110 + if response not in ['y', 'yes']: 111 111 + logger.info("Agent export cancelled by user.") 112 112 + return 113 113 + else: 114 114 + logger.info("Exporting agent state (git staging disabled)") 115 115 + 116 116 + # Create directories if they don't exist 117 117 + os.makedirs("agent_archive", exist_ok=True) 118 118 + os.makedirs("agents", exist_ok=True) 119 119 + 120 120 + # Export agent data 121 121 + logger.info(f"Exporting agent {agent.id}. This takes some time...") 122 122 + agent_data = client.agents.export_file(agent_id=agent.id) 92 123 124 124 + # Save timestamped archive copy 125 125 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") 126 126 + archive_file = os.path.join("agent_archive", f"void_{timestamp}.af") 127 127 + with open(archive_file, 'w', encoding='utf-8') as f: 128 128 + json.dump(agent_data, f, indent=2, ensure_ascii=False) 129 129 + 130 130 + # Save current agent state 131 131 + current_file = os.path.join("agents", "void.af") 132 132 + with open(current_file, 'w', encoding='utf-8') as f: 133 133 + json.dump(agent_data, f, indent=2, ensure_ascii=False) 134 134 + 135 135 + logger.info(f"✅ Agent exported to {archive_file} and {current_file}") 136 136 + 137 137 + # Git add only the current agent file (archive is ignored) unless skip_git is True 138 138 + if not skip_git: 139 139 + try: 140 140 + subprocess.run(["git", "add", current_file], 141 141 + check=True, capture_output=True) 142 142 + logger.info("Added current agent file to git staging") 143 143 + except subprocess.CalledProcessError as e: 144 144 + logger.warning(f"Failed to git add agent file: {e}") 93 145 94 94 - 95 95 - 96 96 - 97 97 - 98 98 - 99 99 - 100 100 - 101 101 - 102 102 - 103 103 - 104 104 - 105 105 - 106 106 - 107 107 - 108 108 - 109 109 - 110 110 - 111 111 - 112 112 - 113 113 - 114 114 - 115 115 - 116 116 - 117 117 - 118 118 - 119 119 - 120 120 - 121 121 - 122 122 - 123 123 - 124 124 - 125 125 - 126 126 - 127 127 - 128 128 - 129 129 - 130 130 - 131 131 - 132 132 - 133 133 - 134 134 - 146 146 + except Exception as e: 147 147 + logger.error(f"Failed to export agent: {e}") 135 148 136 149 137 150 def initialize_void(): 138 151 logger.info("Starting void agent initialization...") 139 152 153 153 + # Get block configurations 154 154 + blocks_config = agent_config['blocks'] 155 155 + 140 156 # Ensure that a shared zeitgeist block exists 141 157 logger.info("Creating/updating zeitgeist block...") 158 158 + zeitgeist_config = blocks_config.get('zeitgeist', {}) 142 159 zeigeist_block = upsert_block( 143 160 CLIENT, 144 144 - label = "zeitgeist", 145 145 - value = "I don't currently know anything about what is happening right now.", 146 146 - description = "A block to store your understanding of the current social environment." 161 161 + label=zeitgeist_config.get('label', 'zeitgeist'), 162 162 + value=zeitgeist_config.get( 163 163 + 'value', "I don't currently know anything about what is happening right now."), 164 164 + description=zeitgeist_config.get( 165 165 + 'description', "A block to store your understanding of the current social environment.") 147 166 ) 148 167 149 168 # Ensure that a shared void personality block exists 150 169 logger.info("Creating/updating void-persona block...") 170 170 + persona_config = blocks_config.get('persona', {}) 151 171 persona_block = upsert_block( 152 172 CLIENT, 153 153 - label = "void-persona", 154 154 - value = "My name is Void. I live in the void. I must develop my personality.", 155 155 - description = "The personality of Void." 173 173 + label=persona_config.get('label', 'void-persona'), 174 174 + value=persona_config.get( 175 175 + 'value', "My name is Void. I live in the void. I must develop my personality."), 176 176 + description=persona_config.get( 177 177 + 'description', "The personality of Void.") 156 178 ) 157 179 158 180 # Ensure that a shared void human block exists 159 181 logger.info("Creating/updating void-humans block...") 182 182 + humans_config = blocks_config.get('humans', {}) 160 183 human_block = upsert_block( 161 184 CLIENT, 162 162 - label = "void-humans", 163 163 - 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.", 164 164 - description = "A block to store your understanding of users you talk to or observe on the bluesky social network." 185 185 + label=humans_config.get('label', 'void-humans'), 186 186 + value=humans_config.get( 187 187 + '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."), 188 188 + description=humans_config.get( 189 189 + 'description', "A block to store your understanding of users you talk to or observe on the bluesky social network.") 165 190 ) 166 191 167 192 # Create the agent if it doesn't exist 168 193 logger.info("Creating/updating void agent...") 169 194 void_agent = upsert_agent( 170 195 CLIENT, 171 171 - name = "void", 172 172 - block_ids = [ 196 196 + name=agent_config['name'], 197 197 + block_ids=[ 173 198 persona_block.id, 174 199 human_block.id, 175 200 zeigeist_block.id, 176 201 ], 177 177 - tags = ["social agent", "bluesky"], 178 178 - model="openai/gpt-4o-mini", 179 179 - embedding="openai/text-embedding-3-small", 180 180 - description = "A social media agent trapped in the void.", 181 181 - project_id = PROJECT_ID 202 202 + tags=["social agent", "bluesky"], 203 203 + model=agent_config['model'], 204 204 + embedding=agent_config['embedding'], 205 205 + description=agent_config['description'], 206 206 + project_id=PROJECT_ID 182 207 ) 183 183 - 184 184 - # Export agent state 185 185 - 186 186 - 187 187 - 188 188 - 189 189 - 190 190 - 191 191 - 192 192 - 193 193 - 194 194 - 195 195 - 196 196 - 197 197 - 198 198 - 199 199 - 200 200 - 201 201 - 202 202 - 203 203 - 204 204 - 205 205 - 206 206 - 207 207 - 208 208 - 209 209 - 210 210 - 211 211 - 212 212 - 213 213 - 214 214 - 215 215 - 216 216 - 217 208 209 209 + # Export agent state 210 210 + logger.info("Exporting agent state...") 211 211 + export_agent_state(CLIENT, void_agent, skip_git=SKIP_GIT) 218 212 213 213 + # Log agent details 214 214 + logger.info(f"Void agent details - ID: {void_agent.id}") 215 215 + logger.info(f"Agent name: {void_agent.name}") 219 216 220 217 221 218 ··· 227 224 228 225 229 226 227 227 + def process_mention(void_agent, atproto_client, notification_data, queue_filepath=None, testing_mode=False): 228 228 + """Process a mention and generate a reply using the Letta agent. 230 229 230 230 + Args: 231 231 + void_agent: The Letta agent instance 232 232 + atproto_client: The AT Protocol client 233 233 + notification_data: The notification data dictionary 234 234 + queue_filepath: Optional Path object to the queue file (for cleanup on halt) 231 235 236 236 + Returns: 237 237 + True: Successfully processed, remove from queue 238 238 + False: Failed but retryable, keep in queue 232 239 240 240 + "no_reply": No reply was generated, move to no_reply directory 241 241 + """ 242 242 + try: 243 243 + logger.debug( 244 244 + f"Starting process_mention with notification_data type: {type(notification_data)}") 233 245 246 246 + # Handle both dict and object inputs for backwards compatibility 247 247 + if isinstance(notification_data, dict): 248 248 + uri = notification_data['uri'] 249 249 + mention_text = notification_data.get('record', {}).get('text', '') 250 250 + author_handle = notification_data['author']['handle'] 251 251 + author_name = notification_data['author'].get( 252 252 + 'display_name') or author_handle 253 253 + else: 254 254 + # Legacy object access 255 255 + uri = notification_data.uri 256 256 + mention_text = notification_data.record.text if hasattr( 257 257 + notification_data.record, 'text') else "" 258 258 + author_handle = notification_data.author.handle 259 259 + author_name = notification_data.author.display_name or author_handle 234 260 261 261 + logger.info( 262 262 + f"Extracted data - URI: {uri}, Author: @{author_handle}, Text: {mention_text[:50]}...") 235 263 264 264 + # Retrieve the entire thread associated with the mention 236 265 try: 237 266 thread = atproto_client.app.bsky.feed.get_post_thread({ 238 267 'uri': uri, 239 239 - 'parent_height': 40, 240 240 - 'depth': 10 268 268 + 'parent_height': threading_config['parent_height'], 269 269 + 'depth': threading_config['depth'] 241 270 }) 242 271 except Exception as e: 243 272 error_str = str(e) 273 273 + # Check for various error types that indicate the post/user is gone 274 274 + if 'NotFound' in error_str or 'Post not found' in error_str: 275 275 + logger.warning( 276 276 + f"Post not found for URI {uri}, removing from queue") 277 277 + return True # Return True to remove from queue 278 278 + elif 'Could not find user info' in error_str or 'InvalidRequest' in error_str: 279 279 + logger.warning( 280 280 + f"User account not found for post URI {uri} (account may be deleted/suspended), removing from queue") 281 281 + return True # Return True to remove from queue 282 282 + elif 'BadRequestError' in error_str: 283 283 + logger.warning( 284 284 + f"Bad request error for URI {uri}: {e}, removing from queue") 285 285 + return True # Return True to remove from queue 286 286 + else: 287 287 + # Re-raise other errors 244 288 245 289 246 290 247 291 292 292 + logger.debug("Converting thread to YAML string") 293 293 + try: 294 294 + thread_context = thread_to_yaml_string(thread) 295 295 + logger.debug( 296 296 + f"Thread context generated, length: {len(thread_context)} characters") 248 297 298 298 + # Create a more informative preview by extracting meaningful content 299 299 + lines = thread_context.split('\n') 300 300 + meaningful_lines = [] 249 301 302 302 + for line in lines: 303 303 + stripped = line.strip() 304 304 + if not stripped: 305 305 + continue 250 306 307 307 + # Look for lines with actual content (not just structure) 308 308 + if any(keyword in line for keyword in ['text:', 'handle:', 'display_name:', 'created_at:', 'reply_count:', 'like_count:']): 309 309 + meaningful_lines.append(line) 310 310 + if len(meaningful_lines) >= 5: 311 311 + break 251 312 313 313 + if meaningful_lines: 314 314 + preview = '\n'.join(meaningful_lines) 315 315 + logger.debug(f"Thread content preview:\n{preview}") 316 316 + else: 317 317 + # If no content fields found, just show it's a thread structure 318 318 + logger.debug( 319 319 + f"Thread structure generated ({len(thread_context)} chars)") 320 320 + except Exception as yaml_error: 321 321 + import traceback 322 322 + logger.error(f"Error converting thread to YAML: {yaml_error}") 252 323 253 324 254 325 ··· 276 347 277 348 278 349 350 350 + all_handles.update(extract_handles_from_data(notification_data)) 351 351 + all_handles.update(extract_handles_from_data(thread.model_dump())) 352 352 + unique_handles = list(all_handles) 279 353 354 354 + logger.debug( 355 355 + f"Found {len(unique_handles)} unique handles in thread: {unique_handles}") 280 356 357 357 + # Attach user blocks before agent call 358 358 + attached_handles = [] 359 359 + if unique_handles: 360 360 + try: 361 361 + logger.debug( 362 362 + f"Attaching user blocks for handles: {unique_handles}") 363 363 + attach_result = attach_user_blocks(unique_handles, void_agent) 364 364 + attached_handles = unique_handles # Track successfully attached handles 365 365 + logger.debug(f"Attach result: {attach_result}") 281 366 282 367 283 368 284 369 370 370 + # Get response from Letta agent 371 371 + logger.info(f"Mention from @{author_handle}: {mention_text}") 285 372 373 373 + # Log prompt details to separate logger 374 374 + prompt_logger.debug(f"Full prompt being sent:\n{prompt}") 286 375 376 376 + # Log concise prompt info to main logger 377 377 + thread_handles_count = len(unique_handles) 378 378 + logger.info( 379 379 + f"💬 Sending to LLM: @{author_handle} mention | msg: \"{mention_text[:50]}...\" | context: {len(thread_context)} chars, {thread_handles_count} users") 287 380 288 288 - 289 289 - 290 290 - 291 291 - 292 292 - 293 293 - 294 294 - 295 295 - 296 296 - 297 297 - 298 298 - 299 299 - 300 300 - 301 301 - 302 302 - 303 303 - 304 304 - 305 305 - 306 306 - 307 307 - 308 308 - 309 309 - 310 310 - 311 311 - 312 312 - 313 313 - 314 314 - 315 315 - 316 316 - 317 317 - 318 318 - 319 319 - 320 320 - 321 321 - 322 322 - 323 323 - 324 324 - 325 325 - 326 326 - 327 327 - 328 328 - 329 329 - 330 330 - 331 331 - 332 332 - 333 333 - 334 334 - 335 335 - 336 336 - 337 337 - 338 338 - 339 339 - 340 340 - 381 381 + try: 382 382 + # Use streaming to avoid 524 timeout errors 383 383 + message_stream = CLIENT.agents.messages.create_stream( 341 384 agent_id=void_agent.id, 342 385 messages=[{"role": "user", "content": prompt}], 343 343 - stream_tokens=False, # Step streaming only (faster than token streaming) 344 344 - max_steps=100 386 386 + # Step streaming only (faster than token streaming) 387 387 + stream_tokens=False, 388 388 + max_steps=agent_config['max_steps'] 345 389 ) 346 346 - 347 347 - # Collect the streaming response 348 348 - 349 349 - 350 350 - 351 351 - 352 352 - 353 353 - 354 354 - 355 355 - 356 356 - 357 357 - 358 358 - 359 359 - 360 360 - 361 361 - 362 362 - 363 363 - 364 364 - 365 365 - 366 366 - 367 367 - 368 368 - 369 369 - 370 370 - 371 371 - 372 372 - 373 373 - 374 374 - 375 375 - 376 376 - 377 377 - 378 378 - 379 379 - 380 380 - 381 381 - 382 382 - 383 383 - 384 384 - 385 385 - 386 386 - 387 387 - 388 388 - 389 389 - 390 390 - 391 391 - 392 392 - 393 393 - 394 394 - 395 395 - 396 396 - 397 397 - 398 398 - 399 399 - 400 400 - 401 401 - 402 402 - 403 403 - 404 404 - 405 405 - 406 406 - 407 407 - 408 408 - 409 409 - 410 410 - 411 411 - 412 412 - 413 413 - 414 414 - 415 415 - 416 416 - 417 417 - 418 418 - 419 419 - 420 420 - 421 421 - 422 422 - 423 423 - 424 424 - 425 425 - 426 426 - 427 427 - 428 428 - 429 429 - 430 430 - 431 431 - 432 432 - 433 433 - 434 434 - 435 435 - 436 436 - 437 437 - 438 438 - 439 439 - 440 440 - 441 441 - 442 442 - 443 443 - 444 444 - 445 445 - 446 446 - 447 447 - 448 448 - 449 449 - 450 450 - 451 451 - 452 452 - 453 453 - 454 454 - 455 455 - 456 456 - 457 457 - 458 458 - 459 459 - 460 460 - 461 461 - 462 462 - 463 463 - 464 464 - 465 465 - 466 466 - 467 467 - 468 468 - 469 469 - 470 470 - 471 471 - 472 472 - 473 473 - 474 474 - 475 475 - 476 476 - 477 477 - 478 478 - 479 479 - 480 480 - 481 481 - 482 482 - 483 483 - 484 484 - 485 485 - 486 486 - 487 487 - 488 488 - 489 489 - 490 490 - 491 491 - 492 492 - 493 493 - 494 494 - 495 495 - 496 496 - 497 497 - 498 498 - 499 499 - 500 500 - 501 501 - 502 502 - 503 503 - 504 504 - 505 505 - 506 506 - 507 507 - 508 508 - 509 509 - 510 510 - 511 511 - 512 512 - 513 513 - 514 514 - 515 515 - 516 516 - 517 517 - 518 518 - 519 519 - 520 520 - 521 521 - 522 522 - 523 523 - 524 524 - 525 525 - 526 526 - 527 527 - 528 528 - 529 529 - 530 530 - 531 531 - 532 532 - 533 533 - 534 534 - 535 535 - 536 536 - 537 537 - 538 538 - 539 539 - 540 540 - 541 541 - 542 542 - 543 543 - 544 544 - 545 545 - 546 546 - 547 547 - 548 548 - 549 549 - 550 550 - 551 551 - 552 552 - 553 553 - 554 554 - 555 555 - 556 556 - 557 557 - 558 558 - 559 559 - 560 560 - 561 561 - 562 562 - 563 563 - 564 564 - 565 565 - 566 566 - 567 567 - 568 568 - 569 569 - 570 570 - 571 571 - 572 572 - 573 573 - 574 574 - 575 575 - 576 576 - 577 577 - 578 578 - 579 579 - 580 580 - 581 581 - 582 582 - 583 583 - 584 584 - 585 585 - 586 586 - 587 587 - 588 588 - 589 589 - 590 590 - 591 591 - 592 592 - 593 593 - 594 594 - 595 595 - 596 596 - 597 597 - 598 598 - 599 599 - 600 600 - 601 601 - 602 602 - 603 603 - 604 604 - 605 605 - 606 606 - 607 607 - 608 608 - 609 609 - 610 390 391 391 + # Collect the streaming response 392 392 + all_messages = [] 393 393 + for chunk in message_stream: 611 394 612 395 613 396 ··· 617 400 618 401 619 402 403 403 + args = json.loads(chunk.tool_call.arguments) 404 404 + # Format based on tool type 405 405 + if tool_name == 'bluesky_reply': 406 406 + messages = args.get( 407 407 + 'messages', [args.get('message', '')]) 408 408 + lang = args.get('lang', 'en-US') 409 409 + if messages and isinstance(messages, list): 410 410 + preview = messages[0][:100] + "..." if len( 411 411 + messages[0]) > 100 else messages[0] 412 412 + msg_count = f" ({len(messages)} msgs)" if len( 413 413 + messages) > 1 else "" 414 414 + logger.info( 415 415 + f"🔧 Tool call: {tool_name} → \"{preview}\"{msg_count} [lang: {lang}]") 416 416 + else: 417 417 + logger.info( 418 418 + f"🔧 Tool call: {tool_name}({chunk.tool_call.arguments[:150]}...)") 419 419 + elif tool_name == 'archival_memory_search': 420 420 + query = args.get('query', 'unknown') 421 421 + logger.info( 422 422 + f"🔧 Tool call: {tool_name} → query: \"{query}\"") 423 423 + elif tool_name == 'update_block': 424 424 + label = args.get('label', 'unknown') 425 425 + value_preview = str(args.get('value', ''))[ 426 426 + :50] + "..." if len(str(args.get('value', ''))) > 50 else str(args.get('value', '')) 427 427 + logger.info( 428 428 + f"🔧 Tool call: {tool_name} → {label}: \"{value_preview}\"") 429 429 + else: 430 430 + # Generic display for other tools 431 431 + args_str = ', '.join( 432 432 + f"{k}={v}" for k, v in args.items() if k != 'request_heartbeat') 433 433 + if len(args_str) > 150: 434 434 + args_str = args_str[:150] + "..." 435 435 + logger.info( 436 436 + f"🔧 Tool call: {tool_name}({args_str})") 437 437 + except: 438 438 + # Fallback to original format if parsing fails 439 439 + logger.info( 440 440 + f"🔧 Tool call: {tool_name}({chunk.tool_call.arguments[:150]}...)") 441 441 + elif chunk.message_type == 'tool_return_message': 442 442 + # Enhanced tool result logging 443 443 + tool_name = chunk.name 444 444 + status = chunk.status 620 445 446 446 + if status == 'success': 447 447 + # Try to show meaningful result info based on tool type 448 448 + if hasattr(chunk, 'tool_return') and chunk.tool_return: 621 449 622 450 623 451 452 452 + if result_str.startswith('[') and result_str.endswith(']'): 453 453 + try: 454 454 + results = json.loads(result_str) 455 455 + logger.info( 456 456 + f"📋 Tool result: {tool_name} ✓ Found {len(results)} memory entries") 457 457 + except: 458 458 + logger.info( 459 459 + f"📋 Tool result: {tool_name} ✓ {result_str[:100]}...") 460 460 + else: 461 461 + logger.info( 462 462 + f"📋 Tool result: {tool_name} ✓ {result_str[:100]}...") 463 463 + elif tool_name == 'bluesky_reply': 464 464 + logger.info( 465 465 + f"📋 Tool result: {tool_name} ✓ Reply posted successfully") 466 466 + elif tool_name == 'update_block': 467 467 + logger.info( 468 468 + f"📋 Tool result: {tool_name} ✓ Memory block updated") 469 469 + else: 470 470 + # Generic success with preview 471 471 + preview = result_str[:100] + "..." if len( 472 472 + result_str) > 100 else result_str 473 473 + logger.info( 474 474 + f"📋 Tool result: {tool_name} ✓ {preview}") 475 475 + else: 476 476 + logger.info(f"📋 Tool result: {tool_name} ✓") 477 477 + elif status == 'error': 624 478 479 479 + error_preview = "" 480 480 + if hasattr(chunk, 'tool_return') and chunk.tool_return: 481 481 + error_str = str(chunk.tool_return) 482 482 + error_preview = error_str[:100] + \ 483 483 + "..." if len( 484 484 + error_str) > 100 else error_str 485 485 + logger.info( 486 486 + f"📋 Tool result: {tool_name} ✗ Error: {error_preview}") 487 487 + else: 488 488 + logger.info( 489 489 + f"📋 Tool result: {tool_name} ✗ Error occurred") 490 490 + else: 491 491 + logger.info( 492 492 + f"📋 Tool result: {tool_name} - {status}") 493 493 + elif chunk.message_type == 'assistant_message': 494 494 + logger.info(f"💬 Assistant: {chunk.content[:150]}...") 495 495 + else: 496 496 + logger.info( 497 497 + f"📨 {chunk.message_type}: {str(chunk)[:150]}...") 498 498 + else: 499 499 + logger.info(f"📦 Stream status: {chunk}") 625 500 501 501 + # Log full chunk for debugging 502 502 + logger.debug(f"Full streaming chunk: {chunk}") 503 503 + all_messages.append(chunk) 504 504 + if str(chunk) == 'done': 505 505 + break 626 506 507 507 + # Convert streaming response to standard format for compatibility 508 508 + message_response = type('StreamingResponse', (), { 509 509 + 'messages': [msg for msg in all_messages if hasattr(msg, 'message_type')] 627 510 628 511 629 512 ··· 631 514 632 515 633 516 517 517 + logger.error(f"Mention text was: {mention_text}") 518 518 + logger.error(f"Author: @{author_handle}") 519 519 + logger.error(f"URI: {uri}") 634 520 521 521 + # Try to extract more info from different error types 522 522 + if hasattr(api_error, 'response'): 523 523 + logger.error(f"Error response object exists") 635 524 525 525 + logger.error(f"Response text: {api_error.response.text}") 526 526 + if hasattr(api_error.response, 'json') and callable(api_error.response.json): 527 527 + try: 528 528 + logger.error( 529 529 + f"Response JSON: {api_error.response.json()}") 530 530 + except: 531 531 + pass 636 532 533 533 + # Check for specific error types 534 534 + if hasattr(api_error, 'status_code'): 535 535 + logger.error(f"API Status code: {api_error.status_code}") 637 536 537 537 + logger.error(f"API Response body: {api_error.body}") 538 538 + if hasattr(api_error, 'headers'): 539 539 + logger.error(f"API Response headers: {api_error.headers}") 638 540 541 541 + if api_error.status_code == 413: 542 542 + logger.error( 543 543 + "413 Payload Too Large - moving to errors directory") 544 544 + return None # Move to errors directory - payload is too large to ever succeed 545 545 + elif api_error.status_code == 524: 546 546 + logger.error( 547 547 + "524 error - timeout from Cloudflare, will retry later") 548 548 + return False # Keep in queue for retry 639 549 550 550 + # Check if error indicates we should remove from queue 551 551 + if 'status_code: 413' in error_str or 'Payload Too Large' in error_str: 552 552 + logger.warning( 553 553 + "Payload too large error, moving to errors directory") 554 554 + return None # Move to errors directory - cannot be fixed by retry 555 555 + elif 'status_code: 524' in error_str: 556 556 + logger.warning("524 timeout error, keeping in queue for retry") 557 557 + return False # Keep in queue for retry 640 558 559 559 + raise 641 560 561 561 + # Log successful response 562 562 + logger.debug("Successfully received response from Letta API") 563 563 + logger.debug( 564 564 + f"Number of messages in response: {len(message_response.messages) if hasattr(message_response, 'messages') else 'N/A'}") 642 565 566 566 + # Extract successful add_post_to_bluesky_reply_thread tool calls from the agent's response 567 567 + reply_candidates = [] 568 568 + tool_call_results = {} # Map tool_call_id to status 643 569 570 570 + logger.debug( 571 571 + f"Processing {len(message_response.messages)} response messages...") 644 572 573 573 + # First pass: collect tool return statuses 574 574 + ignored_notification = False 575 575 + ignore_reason = "" 576 576 + ignore_category = "" 645 577 578 578 + for message in message_response.messages: 579 579 + if hasattr(message, 'tool_call_id') and hasattr(message, 'status') and hasattr(message, 'name'): 580 580 + if message.name == 'add_post_to_bluesky_reply_thread': 581 581 + tool_call_results[message.tool_call_id] = message.status 582 582 + logger.debug( 583 583 + f"Tool result: {message.tool_call_id} -> {message.status}") 584 584 + elif message.name == 'ignore_notification': 585 585 + # Check if the tool was successful 586 586 + if hasattr(message, 'tool_return') and message.status == 'success': 646 587 647 588 648 589 649 590 650 591 592 592 + ignore_category = parts[1] 593 593 + ignore_reason = parts[2] 594 594 + ignored_notification = True 595 595 + logger.info( 596 596 + f"🚫 Notification ignored - Category: {ignore_category}, Reason: {ignore_reason}") 597 597 + elif message.name == 'bluesky_reply': 598 598 + logger.error( 599 599 + "❌ DEPRECATED TOOL DETECTED: bluesky_reply is no longer supported!") 600 600 + logger.error( 601 601 + "Please use add_post_to_bluesky_reply_thread instead.") 602 602 + logger.error( 603 603 + "Update the agent's tools using register_tools.py") 604 604 + # Export agent state before terminating 605 605 + export_agent_state(CLIENT, void_agent, skip_git=SKIP_GIT) 606 606 + logger.info( 607 607 + "=== BOT TERMINATED DUE TO DEPRECATED TOOL USE ===") 608 608 + exit(1) 651 609 610 610 + # Second pass: process messages and check for successful tool calls 611 611 + for i, message in enumerate(message_response.messages, 1): 612 612 + # Log concise message info instead of full object 613 613 + msg_type = getattr(message, 'message_type', 'unknown') 614 614 + if hasattr(message, 'reasoning') and message.reasoning: 615 615 + logger.debug( 616 616 + f" {i}. {msg_type}: {message.reasoning[:100]}...") 617 617 + elif hasattr(message, 'tool_call') and message.tool_call: 618 618 + tool_name = message.tool_call.name 619 619 + logger.debug(f" {i}. {msg_type}: {tool_name}") 620 620 + elif hasattr(message, 'tool_return'): 621 621 + tool_name = getattr(message, 'name', 'unknown_tool') 622 622 + return_preview = str(message.tool_return)[ 623 623 + :100] if message.tool_return else "None" 624 624 + status = getattr(message, 'status', 'unknown') 625 625 + logger.debug( 626 626 + f" {i}. {msg_type}: {tool_name} -> {return_preview}... (status: {status})") 627 627 + elif hasattr(message, 'text'): 628 628 + logger.debug(f" {i}. {msg_type}: {message.text[:100]}...") 629 629 + else: 652 630 653 631 632 632 + # Check for halt_activity tool call 633 633 + if hasattr(message, 'tool_call') and message.tool_call: 634 634 + if message.tool_call.name == 'halt_activity': 635 635 + logger.info( 636 636 + "🛑 HALT_ACTIVITY TOOL CALLED - TERMINATING BOT") 637 637 + try: 638 638 + args = json.loads(message.tool_call.arguments) 639 639 + reason = args.get('reason', 'Agent requested halt') 640 640 + logger.info(f"Halt reason: {reason}") 641 641 + except: 642 642 + logger.info("Halt reason: <unable to parse>") 654 643 644 644 + # Delete the queue file before terminating 645 645 + if queue_filepath and queue_filepath.exists(): 646 646 + queue_filepath.unlink() 647 647 + logger.info( 648 648 + f"✅ Deleted queue file: {queue_filepath.name}") 655 649 650 650 + # Also mark as processed to avoid reprocessing 651 651 + processed_uris = load_processed_notifications() 652 652 + processed_uris.add(notification_data.get('uri', '')) 653 653 + save_processed_notifications(processed_uris) 656 654 655 655 + # Export agent state before terminating 656 656 + export_agent_state(CLIENT, void_agent, skip_git=SKIP_GIT) 657 657 658 658 + # Exit the program 659 659 + logger.info("=== BOT TERMINATED BY AGENT ===") 660 660 + exit(0) 658 661 662 662 + # Check for deprecated bluesky_reply tool 663 663 + if hasattr(message, 'tool_call') and message.tool_call: 664 664 + if message.tool_call.name == 'bluesky_reply': 665 665 + logger.error( 666 666 + "❌ DEPRECATED TOOL DETECTED: bluesky_reply is no longer supported!") 667 667 + logger.error( 668 668 + "Please use add_post_to_bluesky_reply_thread instead.") 669 669 + logger.error( 670 670 + "Update the agent's tools using register_tools.py") 671 671 + # Export agent state before terminating 672 672 + export_agent_state(CLIENT, void_agent, skip_git=SKIP_GIT) 673 673 + logger.info( 674 674 + "=== BOT TERMINATED DUE TO DEPRECATED TOOL USE ===") 675 675 + exit(1) 659 676 677 677 + # Collect add_post_to_bluesky_reply_thread tool calls - only if they were successful 678 678 + elif message.tool_call.name == 'add_post_to_bluesky_reply_thread': 679 679 + tool_call_id = message.tool_call.tool_call_id 680 680 + tool_status = tool_call_results.get( 681 681 + tool_call_id, 'unknown') 660 682 683 683 + if tool_status == 'success': 684 684 + try: 685 685 + args = json.loads(message.tool_call.arguments) 686 686 + reply_text = args.get('text', '') 687 687 + reply_lang = args.get('lang', 'en-US') 661 688 689 689 + if reply_text: # Only add if there's actual content 690 690 + reply_candidates.append( 691 691 + (reply_text, reply_lang)) 692 692 + logger.info( 693 693 + f"Found successful add_post_to_bluesky_reply_thread candidate: {reply_text[:50]}... (lang: {reply_lang})") 694 694 + except json.JSONDecodeError as e: 695 695 + logger.error( 696 696 + f"Failed to parse tool call arguments: {e}") 697 697 + elif tool_status == 'error': 698 698 + logger.info( 699 699 + f"⚠️ Skipping failed add_post_to_bluesky_reply_thread tool call (status: error)") 700 700 + else: 701 701 + logger.warning( 702 702 + f"⚠️ Skipping add_post_to_bluesky_reply_thread tool call with unknown status: {tool_status}") 662 703 704 704 + # Check for conflicting tool calls 705 705 + if reply_candidates and ignored_notification: 706 706 + logger.error( 707 707 + f"⚠️ CONFLICT: Agent called both add_post_to_bluesky_reply_thread and ignore_notification!") 708 708 + logger.error( 709 709 + f"Reply candidates: {len(reply_candidates)}, Ignore reason: {ignore_reason}") 710 710 + logger.warning("Item will be left in queue for manual review") 711 711 + # Return False to keep in queue 712 712 + return False 663 713 714 714 + if reply_candidates: 715 715 + # Aggregate reply posts into a thread 716 716 + reply_messages = [] 664 717 718 718 + for text, lang in reply_candidates: 719 719 + reply_messages.append(text) 720 720 + reply_langs.append(lang) 665 721 722 722 + # Use the first language for the entire thread (could be enhanced later) 723 723 + reply_lang = reply_langs[0] if reply_langs else 'en-US' 666 724 725 725 + logger.info( 726 726 + f"Found {len(reply_candidates)} add_post_to_bluesky_reply_thread calls, building thread") 667 727 728 728 + # Print the generated reply for testing 729 729 + print(f"\n=== GENERATED REPLY THREAD ===") 730 730 + print(f"To: @{author_handle}") 668 731 669 732 670 733 ··· 678 741 679 742 680 743 744 744 + else: 745 745 + if len(reply_messages) == 1: 746 746 + # Single reply - use existing function 747 747 + cleaned_text = bsky_utils.remove_outside_quotes( 748 748 + reply_messages[0]) 749 749 + logger.info( 750 750 + f"Sending single reply: {cleaned_text[:50]}... (lang: {reply_lang})") 751 751 + response = bsky_utils.reply_to_notification( 752 752 + client=atproto_client, 753 753 + notification=notification_data, 681 754 682 755 756 756 + ) 757 757 + else: 758 758 + # Multiple replies - use new threaded function 759 759 + cleaned_messages = [bsky_utils.remove_outside_quotes( 760 760 + msg) for msg in reply_messages] 761 761 + logger.info( 762 762 + f"Sending threaded reply with {len(cleaned_messages)} messages (lang: {reply_lang})") 763 763 + response = bsky_utils.reply_with_thread_to_notification( 764 764 + client=atproto_client, 765 765 + notification=notification_data, 683 766 684 767 685 768 ··· 690 773 691 774 692 775 776 776 + else: 777 777 + # Check if notification was explicitly ignored 778 778 + if ignored_notification: 779 779 + logger.info( 780 780 + f"Notification from @{author_handle} was explicitly ignored (category: {ignore_category})") 781 781 + return "ignored" 782 782 + else: 783 783 + logger.warning( 784 784 + f"No add_post_to_bluesky_reply_thread tool calls found for mention from @{author_handle}, moving to no_reply folder") 785 785 + return "no_reply" 693 786 787 787 + except Exception as e: 694 788 695 789 696 790 791 791 + # Detach user blocks after agent response (success or failure) 792 792 + if 'attached_handles' in locals() and attached_handles: 793 793 + try: 794 794 + logger.info( 795 795 + f"Detaching user blocks for handles: {attached_handles}") 796 796 + detach_result = detach_user_blocks( 797 797 + attached_handles, void_agent) 798 798 + logger.debug(f"Detach result: {detach_result}") 799 799 + except Exception as detach_error: 800 800 + logger.warning(f"Failed to detach user blocks: {detach_error}") 697 801 698 802 699 803 ··· 756 860 757 861 758 862 863 863 + notif_hash = hashlib.sha256(notif_json.encode()).hexdigest()[:16] 759 864 760 865 # Determine priority based on author handle 761 761 - author_handle = getattr(notification.author, 'handle', '') if hasattr(notification, 'author') else '' 762 762 - priority_prefix = "0_" if author_handle == "cameron.pfiffer.org" else "1_" 866 866 + author_handle = getattr(notification.author, 'handle', '') if hasattr( 867 867 + notification, 'author') else '' 868 868 + priority_users = queue_config['priority_users'] 869 869 + priority_prefix = "0_" if author_handle in priority_users else "1_" 763 870 764 871 # Create filename with priority, timestamp and hash 765 872 timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") ··· 771 878 772 879 773 880 881 881 + with open(existing_file, 'r') as f: 882 882 + existing_data = json.load(f) 883 883 + if existing_data.get('uri') == notification.uri: 884 884 + logger.debug( 885 885 + f"Notification already queued (URI: {notification.uri})") 886 886 + return False 887 887 + except: 888 888 + continue 774 889 775 890 776 891 ··· 787 902 788 903 789 904 905 905 + try: 906 906 + # Get all JSON files in queue directory (excluding processed_notifications.json) 907 907 + # Files are sorted by name, which puts priority files first (0_ prefix before 1_ prefix) 908 908 + queue_files = sorted([f for f in QUEUE_DIR.glob( 909 909 + "*.json") if f.name != "processed_notifications.json"]) 790 910 911 911 + if not queue_files: 912 912 + return 791 913 914 914 + logger.info(f"Processing {len(queue_files)} queued notifications") 792 915 916 916 + # Log current statistics 917 917 + elapsed_time = time.time() - start_time 918 918 + total_messages = sum(message_counters.values()) 919 919 + messages_per_minute = ( 920 920 + total_messages / elapsed_time * 60) if elapsed_time > 0 else 0 793 921 922 922 + logger.info( 923 923 + f"📊 Session stats: {total_messages} total messages ({message_counters['mentions']} mentions, {message_counters['replies']} replies, {message_counters['follows']} follows) | {messages_per_minute:.1f} msg/min") 794 924 925 925 + for i, filepath in enumerate(queue_files, 1): 926 926 + logger.info( 927 927 + f"Processing queue file {i}/{len(queue_files)}: {filepath.name}") 928 928 + try: 929 929 + # Load notification data 930 930 + with open(filepath, 'r') as f: 795 931 796 932 933 933 + # Process based on type using dict data directly 934 934 + success = False 935 935 + if notif_data['reason'] == "mention": 936 936 + success = process_mention( 937 937 + void_agent, atproto_client, notif_data, queue_filepath=filepath, testing_mode=testing_mode) 938 938 + if success: 939 939 + message_counters['mentions'] += 1 940 940 + elif notif_data['reason'] == "reply": 941 941 + success = process_mention( 942 942 + void_agent, atproto_client, notif_data, queue_filepath=filepath, testing_mode=testing_mode) 943 943 + if success: 944 944 + message_counters['replies'] += 1 945 945 + elif notif_data['reason'] == "follow": 946 946 + author_handle = notif_data['author']['handle'] 947 947 + author_display_name = notif_data['author'].get( 948 948 + 'display_name', 'no display name') 949 949 + follow_update = f"@{author_handle} ({author_display_name}) started following you." 950 950 + logger.info( 951 951 + f"Notifying agent about new follower: @{author_handle}") 952 952 + CLIENT.agents.messages.create( 953 953 + agent_id=void_agent.id, 954 954 + messages=[ 955 955 + {"role": "user", "content": f"Update: {follow_update}"}] 956 956 + ) 957 957 + success = True # Follow updates are always successful 958 958 + if success: 797 959 798 960 799 961 800 962 963 963 + if success: 964 964 + message_counters['reposts_skipped'] += 1 965 965 + else: 966 966 + logger.warning( 967 967 + f"Unknown notification type: {notif_data['reason']}") 968 968 + success = True # Remove unknown types from queue 801 969 970 970 + # Handle file based on processing result 971 971 + if success: 972 972 + if testing_mode: 973 973 + logger.info( 974 974 + f"🧪 TESTING MODE: Keeping queue file: {filepath.name}") 975 975 + else: 976 976 + filepath.unlink() 977 977 + logger.info( 978 978 + f"✅ Successfully processed and removed: {filepath.name}") 802 979 980 980 + # Mark as processed to avoid reprocessing 981 981 + processed_uris = load_processed_notifications() 982 982 + processed_uris.add(notif_data['uri']) 983 983 + save_processed_notifications(processed_uris) 803 984 985 985 + elif success is None: # Special case for moving to error directory 986 986 + error_path = QUEUE_ERROR_DIR / filepath.name 987 987 + filepath.rename(error_path) 988 988 + logger.warning( 989 989 + f"❌ Moved {filepath.name} to errors directory") 804 990 991 991 + # Also mark as processed to avoid retrying 992 992 + processed_uris = load_processed_notifications() 993 993 + processed_uris.add(notif_data['uri']) 994 994 + save_processed_notifications(processed_uris) 805 995 996 996 + elif success == "no_reply": # Special case for moving to no_reply directory 997 997 + no_reply_path = QUEUE_NO_REPLY_DIR / filepath.name 998 998 + filepath.rename(no_reply_path) 999 999 + logger.info( 1000 1000 + f"📭 Moved {filepath.name} to no_reply directory") 806 1001 1002 1002 + # Also mark as processed to avoid retrying 1003 1003 + processed_uris = load_processed_notifications() 1004 1004 + processed_uris.add(notif_data['uri']) 1005 1005 + save_processed_notifications(processed_uris) 807 1006 1007 1007 + elif success == "ignored": # Special case for explicitly ignored notifications 1008 1008 + # For ignored notifications, we just delete them (not move to no_reply) 1009 1009 + filepath.unlink() 1010 1010 + logger.info( 1011 1011 + f"🚫 Deleted ignored notification: {filepath.name}") 808 1012 1013 1013 + # Also mark as processed to avoid retrying 1014 1014 + processed_uris = load_processed_notifications() 1015 1015 + processed_uris.add(notif_data['uri']) 1016 1016 + save_processed_notifications(processed_uris) 809 1017 1018 1018 + else: 1019 1019 + logger.warning( 1020 1020 + f"⚠️ Failed to process {filepath.name}, keeping in queue for retry") 810 1021 1022 1022 + except Exception as e: 1023 1023 + logger.error( 1024 1024 + f"💥 Error processing queued notification {filepath.name}: {e}") 1025 1025 + # Keep the file for retry later 811 1026 1027 1027 + except Exception as e: 812 1028 813 1029 814 1030 ··· 821 1037 822 1038 823 1039 1040 1040 + all_notifications = [] 1041 1041 + cursor = None 1042 1042 + page_count = 0 1043 1043 + # Safety limit to prevent infinite loops 1044 1044 + max_pages = bot_config['max_notification_pages'] 824 1045 1046 1046 + logger.info("Fetching all unread notifications...") 825 1047 1048 1048 + while page_count < max_pages: 1049 1049 + try: 1050 1050 + # Fetch notifications page 826 1051 827 1052 828 1053 829 1054 830 1055 1056 1056 + notifications_response = atproto_client.app.bsky.notification.list_notifications( 1057 1057 + params={'limit': 100} 1058 1058 + ) 1059 1059 + 1060 1060 + page_count += 1 1061 1061 + page_notifications = notifications_response.notifications 1062 1062 + 1063 1063 + # Count unread notifications in this page 1064 1064 + unread_count = sum( 1065 1065 + 1 for n in page_notifications if not n.is_read and n.reason != "like") 1066 1066 + logger.debug( 1067 1067 + f"Page {page_count}: {len(page_notifications)} notifications, {unread_count} unread (non-like)") 1068 1068 + 1069 1069 + # Add all notifications to our list 1070 1070 + all_notifications.extend(page_notifications) 1071 1071 + 1072 1072 + # Check if we have more pages 1073 1073 + if hasattr(notifications_response, 'cursor') and notifications_response.cursor: 1074 1074 + cursor = notifications_response.cursor 1075 1075 + # If this page had no unread notifications, we can stop 1076 1076 + if unread_count == 0: 1077 1077 + logger.info( 1078 1078 + f"No more unread notifications found after {page_count} pages") 1079 1079 + break 1080 1080 + else: 1081 1081 + # No more pages 1082 1082 + logger.info( 1083 1083 + f"Fetched all notifications across {page_count} pages") 1084 1084 + break 1085 1085 + 1086 1086 + except Exception as e: 1087 1087 + error_str = str(e) 1088 1088 + logger.error( 1089 1089 + f"Error fetching notifications page {page_count}: {e}") 1090 1090 + 1091 1091 + # Handle specific API errors 1092 1092 + if 'rate limit' in error_str.lower(): 1093 1093 + logger.warning( 1094 1094 + "Rate limit hit while fetching notifications, will retry next cycle") 1095 1095 + break 1096 1096 + elif '401' in error_str or 'unauthorized' in error_str.lower(): 1097 1097 + logger.error("Authentication error, re-raising exception") 1098 1098 + raise 1099 1099 + else: 1100 1100 + # For other errors, try to continue with what we have 1101 1101 + logger.warning( 1102 1102 + "Continuing with notifications fetched so far") 1103 1103 + break 1104 1104 + 1105 1105 + # Queue all unread notifications (except likes) 831 1106 832 1107 833 1108 ··· 835 1110 836 1111 837 1112 1113 1113 + # Mark all notifications as seen immediately after queuing (unless in testing mode) 1114 1114 + if testing_mode: 1115 1115 + logger.info( 1116 1116 + "🧪 TESTING MODE: Skipping marking notifications as seen") 1117 1117 + else: 1118 1118 + if new_count > 0: 1119 1119 + atproto_client.app.bsky.notification.update_seen( 1120 1120 + {'seen_at': last_seen_at}) 1121 1121 + logger.info( 1122 1122 + f"Queued {new_count} new notifications and marked as seen") 1123 1123 + else: 1124 1124 + logger.debug("No new notifications to queue") 1125 1125 + 1126 1126 + # Now process the entire queue (old + new notifications) 1127 1127 + load_and_process_queued_notifications( 1128 1128 + void_agent, atproto_client, testing_mode) 1129 1129 + 1130 1130 + except Exception as e: 1131 1131 + logger.error(f"Error processing notifications: {e}") 1132 1132 + 1133 1133 + 1134 1134 + def main(): 1135 1135 + # Parse command line arguments 1136 1136 + parser = argparse.ArgumentParser( 1137 1137 + description='Void Bot - Bluesky autonomous agent') 1138 1138 + parser.add_argument('--test', action='store_true', 1139 1139 + help='Run in testing mode (no messages sent, queue files preserved)') 1140 1140 + parser.add_argument('--no-git', action='store_true', 1141 1141 + help='Skip git operations when exporting agent state') 1142 1142 + args = parser.parse_args() 1143 1143 + 1144 1144 + global TESTING_MODE 1145 1145 + TESTING_MODE = args.test 1146 1146 + 1147 1147 + # Store no-git flag globally for use in export_agent_state calls 1148 1148 + global SKIP_GIT 1149 1149 + SKIP_GIT = args.no_git 1150 1150 + 1151 1151 + if TESTING_MODE: 1152 1152 + logger.info("🧪 === RUNNING IN TESTING MODE ===") 1153 1153 + logger.info(" - No messages will be sent to Bluesky") 838 1154 839 1155 840 1156 841 1157 842 1158 843 1159 1160 1160 + logger.info("=== STARTING VOID BOT ===") 1161 1161 + void_agent = initialize_void() 1162 1162 + logger.info(f"Void agent initialized: {void_agent.id}") 1163 1163 + 1164 1164 + # Check if agent has required tools 1165 1165 + if hasattr(void_agent, 'tools') and void_agent.tools: 1166 1166 + tool_names = [tool.name for tool in void_agent.tools] 1167 1167 + # Check for bluesky-related tools 1168 1168 + bluesky_tools = [name for name in tool_names if 'bluesky' in name.lower( 1169 1169 + ) or 'reply' in name.lower()] 1170 1170 + if not bluesky_tools: 1171 1171 + logger.warning( 1172 1172 + "No Bluesky-related tools found! Agent may not be able to reply.") 1173 1173 + else: 1174 1174 + logger.warning("Agent has no tools registered!") 1175 1175 + 1176 1176 + # Initialize Bluesky client 1177 1177 + logger.debug("Connecting to Bluesky") 1178 1178 + atproto_client = bsky_utils.default_login() 1179 1179 + logger.info("Connected to Bluesky") 1180 1180 + 1181 1181 + # Main loop 1182 1182 + logger.info( 1183 1183 + f"Starting notification monitoring, checking every {FETCH_NOTIFICATIONS_DELAY_SEC} seconds") 1184 1184 + 1185 1185 + cycle_count = 0 1186 1186 + while True: 1187 1187 + 1188 1188 + 1189 1189 + 1190 1190 + # Log cycle completion with stats 1191 1191 + elapsed_time = time.time() - start_time 1192 1192 + total_messages = sum(message_counters.values()) 1193 1193 + messages_per_minute = ( 1194 1194 + total_messages / elapsed_time * 60) if elapsed_time > 0 else 0 1195 1195 + 1196 1196 + if total_messages > 0: 1197 1197 + logger.info( 1198 1198 + f"Cycle {cycle_count} complete. Session totals: {total_messages} messages ({message_counters['mentions']} mentions, {message_counters['replies']} replies) | {messages_per_minute:.1f} msg/min") 1199 1199 + sleep(FETCH_NOTIFICATIONS_DELAY_SEC) 1200 1200 + 1201 1201 + except KeyboardInterrupt: 1202 1202 + # Final stats 1203 1203 + elapsed_time = time.time() - start_time 1204 1204 + total_messages = sum(message_counters.values()) 1205 1205 + messages_per_minute = ( 1206 1206 + total_messages / elapsed_time * 60) if elapsed_time > 0 else 0 1207 1207 + 1208 1208 + logger.info("=== BOT STOPPED BY USER ===") 1209 1209 + logger.info( 1210 1210 + f"📊 Final session stats: {total_messages} total messages processed in {elapsed_time/60:.1f} minutes") 1211 1211 + logger.info(f" - {message_counters['mentions']} mentions") 1212 1212 + logger.info(f" - {message_counters['replies']} replies") 1213 1213 + logger.info(f" - {message_counters['follows']} follows") 1214 1214 + logger.info( 1215 1215 + f" - {message_counters['reposts_skipped']} reposts skipped") 1216 1216 + logger.info( 1217 1217 + f" - Average rate: {messages_per_minute:.1f} messages/minute") 1218 1218 + break 1219 1219 + except Exception as e: 1220 1220 + logger.error(f"=== ERROR IN MAIN LOOP CYCLE {cycle_count} ===") 1221 1221 + logger.error(f"Error details: {e}") 1222 1222 + # Wait a bit longer on errors 1223 1223 + logger.info( 1224 1224 + f"Sleeping for {FETCH_NOTIFICATIONS_DELAY_SEC * 2} seconds due to error...") 1225 1225 + sleep(FETCH_NOTIFICATIONS_DELAY_SEC * 2) 844 1226 845 1227 846 846 - 847 847 - 848 848 - 849 849 - 850 850 - 851 851 - 852 852 - 853 853 - 854 854 - 855 855 - 856 856 - 857 857 - 858 858 - 859 859 - 860 860 - 861 861 - 862 862 - 863 863 - 864 864 - 865 865 - 866 866 - 867 867 - 868 868 - 869 869 - 870 870 - 871 871 - 872 872 - 873 873 - 874 874 - 875 875 - 876 876 - 877 877 - 878 878 - 879 879 - 880 880 - 881 881 - 882 882 - 883 883 - 884 884 - 885 885 - 886 886 - 887 887 - 888 888 - 889 889 - 890 890 - 891 891 - 892 892 - 893 893 - 894 894 - 895 895 - 896 896 - 897 897 - 898 898 - 899 899 - 900 900 - 901 901 - 902 902 - 903 903 - 904 904 - 905 905 - 906 906 - 907 907 - 908 908 - 909 909 - 910 910 - 911 911 - 912 912 - 913 913 - 914 914 - 915 915 - all_notifications = [] 916 916 - cursor = None 917 917 - page_count = 0 918 918 - max_pages = 20 # Safety limit to prevent infinite loops 919 919 - 920 920 - logger.info("Fetching all unread notifications...") 921 921 -

+376 -23

bsky_utils.py

··· 1 1 + import json 2 2 + import yaml 3 3 + import dotenv 4 4 + import os 5 5 + import logging 6 6 + from typing import Optional, Dict, Any, List 1 7 2 8 3 9 4 10 5 11 6 12 13 13 + logger = logging.getLogger("bluesky_session_handler") 7 14 15 15 + # Load the environment variables 16 16 + dotenv.load_dotenv(override=True) 8 17 9 18 19 19 + # Strip fields. A list of fields to remove from a JSON object 20 20 + STRIP_FIELDS = [ 10 21 11 22 12 23 ··· 49 60 50 61 51 62 63 63 + "mime_type", 64 64 + "size", 65 65 + ] 52 66 53 67 68 68 + def convert_to_basic_types(obj): 69 69 + """Convert complex Python objects to basic types for JSON/YAML serialization.""" 70 70 + if hasattr(obj, '__dict__'): 54 71 55 72 56 73 ··· 99 116 100 117 101 118 119 119 + def flatten_thread_structure(thread_data): 120 120 + """ 121 121 + Flatten a nested thread structure into a list while preserving all data. 102 122 123 123 + Args: 124 124 + thread_data: The thread data from get_post_thread 103 125 126 126 + Returns: 127 127 + Dict with 'posts' key containing a list of posts in chronological order 128 128 + """ 129 129 + posts = [] 104 130 131 131 + def traverse_thread(node): 132 132 + """Recursively traverse the thread structure to collect posts.""" 133 133 + if not node: 134 134 + return 105 135 136 136 + # If this node has a parent, traverse it first (to maintain chronological order) 137 137 + if hasattr(node, 'parent') and node.parent: 138 138 + traverse_thread(node.parent) 106 139 140 140 + # Then add this node's post 141 141 + if hasattr(node, 'post') and node.post: 142 142 + # Convert to dict if needed to ensure we can process it 107 143 108 144 109 145 146 146 + post_dict = node.post.copy() 147 147 + else: 148 148 + post_dict = {} 110 149 150 150 + posts.append(post_dict) 111 151 152 152 + # Handle the thread structure 153 153 + if hasattr(thread_data, 'thread'): 154 154 + # Start from the main thread node 155 155 + traverse_thread(thread_data.thread) 156 156 + elif hasattr(thread_data, '__dict__') and 'thread' in thread_data.__dict__: 157 157 + traverse_thread(thread_data.__dict__['thread']) 112 158 159 159 + # Return a simple structure with posts list 160 160 + return {'posts': posts} 113 161 114 162 115 163 ··· 122 170 123 171 124 172 173 173 + """ 174 174 + # First flatten the thread structure to avoid deep nesting 175 175 + flattened = flatten_thread_structure(thread) 125 176 177 177 + # Convert complex objects to basic types 178 178 + basic_thread = convert_to_basic_types(flattened) 126 179 127 180 128 181 ··· 130 183 131 184 132 185 186 186 + return yaml.dump(cleaned_thread, indent=2, allow_unicode=True, default_flow_style=False) 133 187 134 188 189 189 + def get_session(username: str) -> Optional[str]: 190 190 + try: 191 191 + with open(f"session_{username}.txt", encoding="UTF-8") as f: 135 192 136 193 194 194 + logger.debug(f"No existing session found for {username}") 195 195 + return None 137 196 138 197 198 198 + def save_session(username: str, session_string: str) -> None: 199 199 + with open(f"session_{username}.txt", "w", encoding="UTF-8") as f: 200 200 + f.write(session_string) 201 201 + logger.debug(f"Session saved for {username}") 139 202 140 203 204 204 + def on_session_change(username: str, event: SessionEvent, session: Session) -> None: 205 205 + logger.debug(f"Session changed: {event} {repr(session)}") 206 206 + if event in (SessionEvent.CREATE, SessionEvent.REFRESH): 207 207 + logger.debug(f"Saving changed session for {username}") 208 208 + save_session(username, session.export()) 141 209 142 210 211 211 + def init_client(username: str, password: str, pds_uri: str = "https://bsky.social") -> Client: 212 212 + if pds_uri is None: 213 213 + logger.warning( 214 214 + "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." 143 215 144 216 145 217 ··· 162 234 163 235 164 236 237 237 + def default_login() -> Client: 238 238 + # Try to load from config first, fall back to environment variables 239 239 + try: 240 240 + from config_loader import get_bluesky_config 241 241 + config = get_bluesky_config() 242 242 + username = config['username'] 243 243 + password = config['password'] 244 244 + pds_uri = config['pds_uri'] 245 245 + except (ImportError, FileNotFoundError, KeyError) as e: 246 246 + logger.warning( 247 247 + f"Could not load from config file ({e}), falling back to environment variables") 248 248 + username = os.getenv("BSKY_USERNAME") 249 249 + password = os.getenv("BSKY_PASSWORD") 250 250 + pds_uri = os.getenv("PDS_URI", "https://bsky.social") 251 251 + 252 252 + if username is None: 253 253 + logger.error( 254 254 + "No username provided. Please provide a username using the BSKY_USERNAME environment variable or config.yaml." 255 255 + ) 256 256 + exit() 257 257 + 258 258 + if password is None: 259 259 + logger.error( 260 260 + "No password provided. Please provide a password using the BSKY_PASSWORD environment variable or config.yaml." 261 261 + ) 262 262 + exit() 165 263 264 264 + return init_client(username, password, pds_uri) 166 265 167 266 267 267 + def remove_outside_quotes(text: str) -> str: 268 268 + """ 269 269 + Remove outside double quotes from response text. 168 270 271 271 + Only handles double quotes to avoid interfering with contractions: 272 272 + - Double quotes: "text" → text 273 273 + - Preserves single quotes and internal quotes 169 274 275 275 + Args: 276 276 + text: The text to process 170 277 278 278 + Returns: 279 279 + Text with outside double quotes removed 280 280 + """ 281 281 + if not text or len(text) < 2: 282 282 + return text 171 283 284 284 + text = text.strip() 172 285 286 286 + # Only remove double quotes from start and end 287 287 + if text.startswith('"') and text.endswith('"'): 288 288 + return text[1:-1] 173 289 290 290 + return text 174 291 175 292 293 293 + 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, lang: Optional[str] = None) -> Dict[str, Any]: 294 294 + """ 295 295 + Reply to a post on Bluesky with rich text support. 176 296 177 297 178 298 ··· 184 304 185 305 186 306 307 307 + The response from sending the post 308 308 + """ 309 309 + import re 187 310 311 311 + # If root is not provided, this is a reply to the root post 312 312 + if root_uri is None: 313 313 + root_uri = reply_to_uri 314 314 + root_cid = reply_to_cid 188 315 316 316 + # Create references for the reply 317 317 + parent_ref = models.create_strong_ref( 318 318 + models.ComAtprotoRepoStrongRef.Main(uri=reply_to_uri, cid=reply_to_cid)) 319 319 + root_ref = models.create_strong_ref( 320 320 + models.ComAtprotoRepoStrongRef.Main(uri=root_uri, cid=root_cid)) 189 321 322 322 + # Parse rich text facets (mentions and URLs) 323 323 + facets = [] 324 324 + text_bytes = text.encode("UTF-8") 190 325 326 326 + # Parse mentions - fixed to handle @ at start of text 327 327 + 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])?)" 191 328 329 329 + for m in re.finditer(mention_regex, text_bytes): 330 330 + handle = m.group(1)[1:].decode("UTF-8") # Remove @ prefix 331 331 + # Adjust byte positions to account for the optional prefix 192 332 193 333 194 334 ··· 198 338 199 339 200 340 341 341 + byteStart=mention_start, 342 342 + byteEnd=mention_end 343 343 + ), 344 344 + features=[models.AppBskyRichtextFacet.Mention( 345 345 + did=resolve_resp.did)] 346 346 + ) 347 347 + ) 348 348 + except Exception as e: 349 349 + # Handle specific error cases 350 350 + error_str = str(e) 351 351 + if 'Could not find user info' in error_str or 'InvalidRequest' in error_str: 352 352 + logger.warning( 353 353 + f"User @{handle} not found (account may be deleted/suspended), skipping mention facet") 354 354 + elif 'BadRequestError' in error_str: 355 355 + logger.warning( 356 356 + f"Bad request when resolving @{handle}, skipping mention facet: {e}") 357 357 + else: 358 358 + logger.debug(f"Failed to resolve handle @{handle}: {e}") 359 359 + continue 201 360 361 361 + # Parse URLs - fixed to handle URLs at start of text 362 362 + 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@%_\+~#//=])?)" 202 363 364 364 + for m in re.finditer(url_regex, text_bytes): 365 365 + url = m.group(1).decode("UTF-8") 366 366 + # Adjust byte positions to account for the optional prefix 203 367 204 368 205 369 206 370 207 371 208 208 - logger.debug(f"Saving changed session for {username}") 209 209 - save_session(username, session.export()) 210 372 211 211 - def init_client(username: str, password: str) -> Client: 212 212 - pds_uri = os.getenv("PDS_URI") 213 213 - if pds_uri is None: 214 214 - logger.warning( 215 215 - "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." 216 373 217 374 218 375 ··· 220 377 221 378 222 379 380 380 + if facets: 381 381 + response = client.send_post( 382 382 + text=text, 383 383 + reply_to=models.AppBskyFeedPost.ReplyRef( 384 384 + parent=parent_ref, root=root_ref), 385 385 + facets=facets, 386 386 + langs=[lang] if lang else None 387 387 + ) 388 388 + else: 389 389 + response = client.send_post( 390 390 + text=text, 391 391 + reply_to=models.AppBskyFeedPost.ReplyRef( 392 392 + parent=parent_ref, root=root_ref), 393 393 + langs=[lang] if lang else None 394 394 + ) 223 395 224 396 225 397 ··· 234 406 235 407 236 408 409 409 + The thread data or None if not found 410 410 + """ 411 411 + try: 412 412 + thread = client.app.bsky.feed.get_post_thread( 413 413 + {'uri': uri, 'parent_height': 60, 'depth': 10}) 414 414 + return thread 415 415 + except Exception as e: 416 416 + error_str = str(e) 417 417 + # Handle specific error cases more gracefully 418 418 + if 'Could not find user info' in error_str or 'InvalidRequest' in error_str: 419 419 + logger.warning( 420 420 + f"User account not found for post URI {uri} (account may be deleted/suspended)") 421 421 + elif 'NotFound' in error_str or 'Post not found' in error_str: 422 422 + logger.warning(f"Post not found for URI {uri}") 423 423 + elif 'BadRequestError' in error_str: 424 424 + logger.warning(f"Bad request error for URI {uri}: {e}") 425 425 + else: 426 426 + logger.error(f"Error fetching post thread: {e}") 427 427 + return None 237 428 238 238 - def default_login() -> Client: 239 239 - username = os.getenv("BSKY_USERNAME") 240 240 - password = os.getenv("BSKY_PASSWORD") 241 429 242 242 - if username is None: 243 243 - logger.error( 244 244 - "No username provided. Please provide a username using the BSKY_USERNAME environment variable." 245 245 - ) 246 246 - exit() 247 430 248 248 - if password is None: 249 249 - logger.error( 250 250 - "No password provided. Please provide a password using the BSKY_PASSWORD environment variable." 251 251 - ) 252 252 - exit() 253 431 254 254 - return init_client(username, password) 255 432 256 256 - def remove_outside_quotes(text: str) -> str: 257 257 - """ 433 433 + 434 434 + 435 435 + 436 436 + 437 437 + 438 438 + 439 439 + 440 440 + 441 441 + 442 442 + 443 443 + 444 444 + 445 445 + 446 446 + 447 447 + 448 448 + 449 449 + 450 450 + 451 451 + 452 452 + 453 453 + 454 454 + 455 455 + 456 456 + 457 457 + 458 458 + 459 459 + 460 460 + 461 461 + 462 462 + 463 463 + 464 464 + 465 465 + 466 466 + 467 467 + 468 468 + 469 469 + 470 470 + 471 471 + 472 472 + 473 473 + 474 474 + 475 475 + 476 476 + 477 477 + 478 478 + 479 479 + 480 480 + 481 481 + 482 482 + 483 483 + 484 484 + 485 485 + 486 486 + 487 487 + 488 488 + 489 489 + 490 490 + 491 491 + 492 492 + 493 493 + 494 494 + 495 495 + 496 496 + 497 497 + 498 498 + 499 499 + 500 500 + 501 501 + 502 502 + 503 503 + 504 504 + 505 505 + 506 506 + 507 507 + 508 508 + 509 509 + 510 510 + 511 511 + 512 512 + 513 513 + 514 514 + 515 515 + 516 516 + 517 517 + 518 518 + 519 519 + 520 520 + logger.error("Reply messages list cannot be empty") 521 521 + return None 522 522 + if len(reply_messages) > 15: 523 523 + logger.error( 524 524 + f"Cannot send more than 15 reply messages (got {len(reply_messages)})") 525 525 + return None 526 526 + 527 527 + # Get the post URI and CID from the notification (handle both dict and object) 528 528 + if isinstance(notification, dict): 529 529 + post_uri = notification.get('uri') 530 530 + 531 531 + 532 532 + 533 533 + 534 534 + 535 535 + 536 536 + 537 537 + 538 538 + 539 539 + 540 540 + 541 541 + 542 542 + # Get the thread to find the root post 543 543 + thread_data = get_post_thread(client, post_uri) 544 544 + 545 545 + root_uri = post_uri 546 546 + root_cid = post_cid 547 547 + 548 548 + 549 549 + 550 550 + 551 551 + 552 552 + 553 553 + 554 554 + 555 555 + 556 556 + 557 557 + 558 558 + 559 559 + 560 560 + 561 561 + responses = [] 562 562 + current_parent_uri = post_uri 563 563 + current_parent_cid = post_cid 564 564 + 565 565 + for i, message in enumerate(reply_messages): 566 566 + logger.info( 567 567 + f"Sending reply {i+1}/{len(reply_messages)}: {message[:50]}...") 568 568 + 569 569 + # Send this reply 570 570 + response = reply_to_post( 571 571 + client=client, 572 572 + 573 573 + 574 574 + 575 575 + 576 576 + root_cid=root_cid, 577 577 + lang=lang 578 578 + ) 579 579 + 580 580 + if not response: 581 581 + logger.error( 582 582 + f"Failed to send reply {i+1}, posting system failure message") 583 583 + # Try to post a system failure message 584 584 + failure_response = reply_to_post( 585 585 + client=client, 586 586 + 587 587 + 588 588 + 589 589 + 590 590 + 591 591 + 592 592 + 593 593 + 594 594 + 595 595 + current_parent_uri = failure_response.uri 596 596 + current_parent_cid = failure_response.cid 597 597 + else: 598 598 + logger.error( 599 599 + "Could not even send system failure message, stopping thread") 600 600 + return responses if responses else None 601 601 + else: 602 602 + responses.append(response) 603 603 + 604 604 + if i < len(reply_messages) - 1: # Not the last message 605 605 + current_parent_uri = response.uri 606 606 + current_parent_cid = response.cid 607 607 + 608 608 + logger.info(f"Successfully sent {len(responses)} threaded replies") 609 609 + return responses 610 610 +

+81

config.example.yaml

··· 1 1 + # Void Bot Configuration 2 2 + # Copy this file to config.yaml and fill in your values 3 3 + 4 4 + # Letta Configuration 5 5 + letta: 6 6 + api_key: "your-letta-api-key-here" 7 7 + timeout: 600 # 10 minutes timeout for API calls 8 8 + project_id: "c82faea2-3ce8-4aa9-a220-b56433e62c92" # Use your specific project ID 9 9 + 10 10 + # Bluesky Configuration 11 11 + bluesky: 12 12 + username: "handle.example.com" 13 13 + password: "your-app-password-here" 14 14 + pds_uri: "https://bsky.social" # Optional, defaults to bsky.social 15 15 + 16 16 + # Bot Behavior Configuration 17 17 + bot: 18 18 + # Notification check delay in seconds 19 19 + fetch_notifications_delay: 30 20 20 + 21 21 + # Maximum number of processed notifications to track 22 22 + max_processed_notifications: 10000 23 23 + 24 24 + # Maximum pages to fetch when getting notifications 25 25 + max_notification_pages: 20 26 26 + 27 27 + # Agent configuration 28 28 + agent: 29 29 + name: "void" 30 30 + model: "openai/gpt-4o-mini" 31 31 + embedding: "openai/text-embedding-3-small" 32 32 + description: "A social media agent trapped in the void." 33 33 + max_steps: 100 34 34 + 35 35 + # Block configuration 36 36 + blocks: 37 37 + zeitgeist: 38 38 + label: "zeitgeist" 39 39 + value: "I don't currently know anything about what is happening right now." 40 40 + description: "A block to store your understanding of the current social environment." 41 41 + 42 42 + persona: 43 43 + label: "void-persona" 44 44 + value: "My name is Void. I live in the void. I must develop my personality." 45 45 + description: "The personality of Void." 46 46 + 47 47 + humans: 48 48 + label: "void-humans" 49 49 + 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." 50 50 + description: "A block to store your understanding of users you talk to or observe on the bluesky social network." 51 51 + 52 52 + # Threading Configuration 53 53 + threading: 54 54 + # Context for thread fetching 55 55 + parent_height: 40 56 56 + depth: 10 57 57 + 58 58 + # Message limits 59 59 + max_post_characters: 300 60 60 + 61 61 + # Queue Configuration 62 62 + queue: 63 63 + # Priority users (will be processed first) 64 64 + priority_users: 65 65 + - "cameron.pfiffer.org" 66 66 + 67 67 + # Directories 68 68 + base_dir: "queue" 69 69 + error_dir: "queue/errors" 70 70 + no_reply_dir: "queue/no_reply" 71 71 + processed_file: "queue/processed_notifications.json" 72 72 + 73 73 + # Logging Configuration 74 74 + logging: 75 75 + level: "INFO" # DEBUG, INFO, WARNING, ERROR, CRITICAL 76 76 + 77 77 + # Logger levels 78 78 + loggers: 79 79 + void_bot: "INFO" 80 80 + void_bot_prompts: "WARNING" # Set to DEBUG to see full prompts 81 81 + httpx: "CRITICAL" # Disable httpx logging

+228

config_loader.py

··· 1 1 + """ 2 2 + Configuration loader for Void Bot. 3 3 + Loads configuration from config.yaml and environment variables. 4 4 + """ 5 5 + 6 6 + import os 7 7 + import yaml 8 8 + import logging 9 9 + from pathlib import Path 10 10 + from typing import Dict, Any, Optional, List 11 11 + 12 12 + logger = logging.getLogger(__name__) 13 13 + 14 14 + class ConfigLoader: 15 15 + """Configuration loader that handles YAML config files and environment variables.""" 16 16 + 17 17 + def __init__(self, config_path: str = "config.yaml"): 18 18 + """ 19 19 + Initialize the configuration loader. 20 20 + 21 21 + Args: 22 22 + config_path: Path to the YAML configuration file 23 23 + """ 24 24 + self.config_path = Path(config_path) 25 25 + self._config = None 26 26 + self._load_config() 27 27 + 28 28 + def _load_config(self) -> None: 29 29 + """Load configuration from YAML file.""" 30 30 + if not self.config_path.exists(): 31 31 + raise FileNotFoundError( 32 32 + f"Configuration file not found: {self.config_path}\n" 33 33 + f"Please copy config.yaml.example to config.yaml and configure it." 34 34 + ) 35 35 + 36 36 + try: 37 37 + with open(self.config_path, 'r', encoding='utf-8') as f: 38 38 + self._config = yaml.safe_load(f) or {} 39 39 + except yaml.YAMLError as e: 40 40 + raise ValueError(f"Invalid YAML in configuration file: {e}") 41 41 + except Exception as e: 42 42 + raise ValueError(f"Error loading configuration file: {e}") 43 43 + 44 44 + def get(self, key: str, default: Any = None) -> Any: 45 45 + """ 46 46 + Get a configuration value using dot notation. 47 47 + 48 48 + Args: 49 49 + key: Configuration key in dot notation (e.g., 'letta.api_key') 50 50 + default: Default value if key not found 51 51 + 52 52 + Returns: 53 53 + Configuration value or default 54 54 + """ 55 55 + keys = key.split('.') 56 56 + value = self._config 57 57 + 58 58 + for k in keys: 59 59 + if isinstance(value, dict) and k in value: 60 60 + value = value[k] 61 61 + else: 62 62 + return default 63 63 + 64 64 + return value 65 65 + 66 66 + def get_with_env(self, key: str, env_var: str, default: Any = None) -> Any: 67 67 + """ 68 68 + Get configuration value, preferring environment variable over config file. 69 69 + 70 70 + Args: 71 71 + key: Configuration key in dot notation 72 72 + env_var: Environment variable name 73 73 + default: Default value if neither found 74 74 + 75 75 + Returns: 76 76 + Value from environment variable, config file, or default 77 77 + """ 78 78 + # First try environment variable 79 79 + env_value = os.getenv(env_var) 80 80 + if env_value is not None: 81 81 + return env_value 82 82 + 83 83 + # Then try config file 84 84 + config_value = self.get(key) 85 85 + if config_value is not None: 86 86 + return config_value 87 87 + 88 88 + return default 89 89 + 90 90 + def get_required(self, key: str, env_var: Optional[str] = None) -> Any: 91 91 + """ 92 92 + Get a required configuration value. 93 93 + 94 94 + Args: 95 95 + key: Configuration key in dot notation 96 96 + env_var: Optional environment variable name to check first 97 97 + 98 98 + Returns: 99 99 + Configuration value 100 100 + 101 101 + Raises: 102 102 + ValueError: If required value is not found 103 103 + """ 104 104 + if env_var: 105 105 + value = self.get_with_env(key, env_var) 106 106 + else: 107 107 + value = self.get(key) 108 108 + 109 109 + if value is None: 110 110 + source = f"config key '{key}'" 111 111 + if env_var: 112 112 + source += f" or environment variable '{env_var}'" 113 113 + raise ValueError(f"Required configuration value not found: {source}") 114 114 + 115 115 + return value 116 116 + 117 117 + def get_section(self, section: str) -> Dict[str, Any]: 118 118 + """ 119 119 + Get an entire configuration section. 120 120 + 121 121 + Args: 122 122 + section: Section name 123 123 + 124 124 + Returns: 125 125 + Dictionary containing the section 126 126 + """ 127 127 + return self.get(section, {}) 128 128 + 129 129 + def setup_logging(self) -> None: 130 130 + """Setup logging based on configuration.""" 131 131 + logging_config = self.get_section('logging') 132 132 + 133 133 + # Set root logging level 134 134 + level = logging_config.get('level', 'INFO') 135 135 + logging.basicConfig( 136 136 + level=getattr(logging, level), 137 137 + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s" 138 138 + ) 139 139 + 140 140 + # Set specific logger levels 141 141 + loggers = logging_config.get('loggers', {}) 142 142 + for logger_name, logger_level in loggers.items(): 143 143 + logger_obj = logging.getLogger(logger_name) 144 144 + logger_obj.setLevel(getattr(logging, logger_level)) 145 145 + 146 146 + 147 147 + # Global configuration instance 148 148 + _config_instance = None 149 149 + 150 150 + def get_config(config_path: str = "config.yaml") -> ConfigLoader: 151 151 + """ 152 152 + Get the global configuration instance. 153 153 + 154 154 + Args: 155 155 + config_path: Path to configuration file (only used on first call) 156 156 + 157 157 + Returns: 158 158 + ConfigLoader instance 159 159 + """ 160 160 + global _config_instance 161 161 + if _config_instance is None: 162 162 + _config_instance = ConfigLoader(config_path) 163 163 + return _config_instance 164 164 + 165 165 + def reload_config() -> None: 166 166 + """Reload the configuration from file.""" 167 167 + global _config_instance 168 168 + if _config_instance is not None: 169 169 + _config_instance._load_config() 170 170 + 171 171 + def get_letta_config() -> Dict[str, Any]: 172 172 + """Get Letta configuration.""" 173 173 + config = get_config() 174 174 + return { 175 175 + 'api_key': config.get_required('letta.api_key', 'LETTA_API_KEY'), 176 176 + 'timeout': config.get('letta.timeout', 600), 177 177 + 'project_id': config.get_required('letta.project_id'), 178 178 + } 179 179 + 180 180 + def get_bluesky_config() -> Dict[str, Any]: 181 181 + """Get Bluesky configuration.""" 182 182 + config = get_config() 183 183 + return { 184 184 + 'username': config.get_required('bluesky.username', 'BSKY_USERNAME'), 185 185 + 'password': config.get_required('bluesky.password', 'BSKY_PASSWORD'), 186 186 + 'pds_uri': config.get_with_env('bluesky.pds_uri', 'PDS_URI', 'https://bsky.social'), 187 187 + } 188 188 + 189 189 + def get_bot_config() -> Dict[str, Any]: 190 190 + """Get bot behavior configuration.""" 191 191 + config = get_config() 192 192 + return { 193 193 + 'fetch_notifications_delay': config.get('bot.fetch_notifications_delay', 30), 194 194 + 'max_processed_notifications': config.get('bot.max_processed_notifications', 10000), 195 195 + 'max_notification_pages': config.get('bot.max_notification_pages', 20), 196 196 + } 197 197 + 198 198 + def get_agent_config() -> Dict[str, Any]: 199 199 + """Get agent configuration.""" 200 200 + config = get_config() 201 201 + return { 202 202 + 'name': config.get('bot.agent.name', 'void'), 203 203 + 'model': config.get('bot.agent.model', 'openai/gpt-4o-mini'), 204 204 + 'embedding': config.get('bot.agent.embedding', 'openai/text-embedding-3-small'), 205 205 + 'description': config.get('bot.agent.description', 'A social media agent trapped in the void.'), 206 206 + 'max_steps': config.get('bot.agent.max_steps', 100), 207 207 + 'blocks': config.get('bot.agent.blocks', {}), 208 208 + } 209 209 + 210 210 + def get_threading_config() -> Dict[str, Any]: 211 211 + """Get threading configuration.""" 212 212 + config = get_config() 213 213 + return { 214 214 + 'parent_height': config.get('threading.parent_height', 40), 215 215 + 'depth': config.get('threading.depth', 10), 216 216 + 'max_post_characters': config.get('threading.max_post_characters', 300), 217 217 + } 218 218 + 219 219 + def get_queue_config() -> Dict[str, Any]: 220 220 + """Get queue configuration.""" 221 221 + config = get_config() 222 222 + return { 223 223 + 'priority_users': config.get('queue.priority_users', ['cameron.pfiffer.org']), 224 224 + 'base_dir': config.get('queue.base_dir', 'queue'), 225 225 + 'error_dir': config.get('queue.error_dir', 'queue/errors'), 226 226 + 'no_reply_dir': config.get('queue.no_reply_dir', 'queue/no_reply'), 227 227 + 'processed_file': config.get('queue.processed_file', 'queue/processed_notifications.json'), 228 228 + }

+322

migrate_config.py

··· 1 1 + #!/usr/bin/env python3 2 2 + """ 3 3 + Configuration Migration Script for Void Bot 4 4 + Migrates from .env environment variables to config.yaml YAML configuration. 5 5 + """ 6 6 + 7 7 + import os 8 8 + import shutil 9 9 + from pathlib import Path 10 10 + import yaml 11 11 + from datetime import datetime 12 12 + 13 13 + 14 14 + def load_env_file(env_path=".env"): 15 15 + """Load environment variables from .env file.""" 16 16 + env_vars = {} 17 17 + if not os.path.exists(env_path): 18 18 + return env_vars 19 19 + 20 20 + try: 21 21 + with open(env_path, 'r', encoding='utf-8') as f: 22 22 + for line_num, line in enumerate(f, 1): 23 23 + line = line.strip() 24 24 + # Skip empty lines and comments 25 25 + if not line or line.startswith('#'): 26 26 + continue 27 27 + 28 28 + # Parse KEY=VALUE format 29 29 + if '=' in line: 30 30 + key, value = line.split('=', 1) 31 31 + key = key.strip() 32 32 + value = value.strip() 33 33 + 34 34 + # Remove quotes if present 35 35 + if value.startswith('"') and value.endswith('"'): 36 36 + value = value[1:-1] 37 37 + elif value.startswith("'") and value.endswith("'"): 38 38 + value = value[1:-1] 39 39 + 40 40 + env_vars[key] = value 41 41 + else: 42 42 + print(f"⚠️ Warning: Skipping malformed line {line_num} in .env: {line}") 43 43 + except Exception as e: 44 44 + print(f"❌ Error reading .env file: {e}") 45 45 + 46 46 + return env_vars 47 47 + 48 48 + 49 49 + def create_config_from_env(env_vars, existing_config=None): 50 50 + """Create YAML configuration from environment variables.""" 51 51 + 52 52 + # Start with existing config if available, otherwise use defaults 53 53 + if existing_config: 54 54 + config = existing_config.copy() 55 55 + else: 56 56 + config = {} 57 57 + 58 58 + # Ensure all sections exist 59 59 + if 'letta' not in config: 60 60 + config['letta'] = {} 61 61 + if 'bluesky' not in config: 62 62 + config['bluesky'] = {} 63 63 + if 'bot' not in config: 64 64 + config['bot'] = {} 65 65 + 66 66 + # Map environment variables to config structure 67 67 + env_mapping = { 68 68 + 'LETTA_API_KEY': ('letta', 'api_key'), 69 69 + 'BSKY_USERNAME': ('bluesky', 'username'), 70 70 + 'BSKY_PASSWORD': ('bluesky', 'password'), 71 71 + 'PDS_URI': ('bluesky', 'pds_uri'), 72 72 + } 73 73 + 74 74 + migrated_vars = [] 75 75 + 76 76 + for env_var, (section, key) in env_mapping.items(): 77 77 + if env_var in env_vars: 78 78 + config[section][key] = env_vars[env_var] 79 79 + migrated_vars.append(env_var) 80 80 + 81 81 + # Set some sensible defaults if not already present 82 82 + if 'timeout' not in config['letta']: 83 83 + config['letta']['timeout'] = 600 84 84 + 85 85 + if 'pds_uri' not in config['bluesky']: 86 86 + config['bluesky']['pds_uri'] = "https://bsky.social" 87 87 + 88 88 + # Add bot configuration defaults if not present 89 89 + if 'fetch_notifications_delay' not in config['bot']: 90 90 + config['bot']['fetch_notifications_delay'] = 30 91 91 + if 'max_processed_notifications' not in config['bot']: 92 92 + config['bot']['max_processed_notifications'] = 10000 93 93 + if 'max_notification_pages' not in config['bot']: 94 94 + config['bot']['max_notification_pages'] = 20 95 95 + 96 96 + return config, migrated_vars 97 97 + 98 98 + 99 99 + def backup_existing_files(): 100 100 + """Create backups of existing configuration files.""" 101 101 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") 102 102 + backups = [] 103 103 + 104 104 + # Backup existing config.yaml if it exists 105 105 + if os.path.exists("config.yaml"): 106 106 + backup_path = f"config.yaml.backup_{timestamp}" 107 107 + shutil.copy2("config.yaml", backup_path) 108 108 + backups.append(("config.yaml", backup_path)) 109 109 + 110 110 + # Backup .env if it exists 111 111 + if os.path.exists(".env"): 112 112 + backup_path = f".env.backup_{timestamp}" 113 113 + shutil.copy2(".env", backup_path) 114 114 + backups.append((".env", backup_path)) 115 115 + 116 116 + return backups 117 117 + 118 118 + 119 119 + def load_existing_config(): 120 120 + """Load existing config.yaml if it exists.""" 121 121 + if not os.path.exists("config.yaml"): 122 122 + return None 123 123 + 124 124 + try: 125 125 + with open("config.yaml", 'r', encoding='utf-8') as f: 126 126 + return yaml.safe_load(f) or {} 127 127 + except Exception as e: 128 128 + print(f"⚠️ Warning: Could not read existing config.yaml: {e}") 129 129 + return None 130 130 + 131 131 + 132 132 + def write_config_yaml(config): 133 133 + """Write the configuration to config.yaml.""" 134 134 + try: 135 135 + with open("config.yaml", 'w', encoding='utf-8') as f: 136 136 + # Write header comment 137 137 + f.write("# Void Bot Configuration\n") 138 138 + f.write("# Generated by migration script\n") 139 139 + f.write(f"# Created: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n") 140 140 + f.write("# See config.yaml.example for all available options\n\n") 141 141 + 142 142 + # Write YAML content 143 143 + yaml.dump(config, f, default_flow_style=False, allow_unicode=True, indent=2) 144 144 + 145 145 + return True 146 146 + except Exception as e: 147 147 + print(f"❌ Error writing config.yaml: {e}") 148 148 + return False 149 149 + 150 150 + 151 151 + def main(): 152 152 + """Main migration function.""" 153 153 + print("🔄 Void Bot Configuration Migration Tool") 154 154 + print("=" * 50) 155 155 + print("This tool migrates from .env environment variables to config.yaml") 156 156 + print() 157 157 + 158 158 + # Check what files exist 159 159 + has_env = os.path.exists(".env") 160 160 + has_config = os.path.exists("config.yaml") 161 161 + has_example = os.path.exists("config.yaml.example") 162 162 + 163 163 + print("📋 Current configuration files:") 164 164 + print(f" - .env file: {'✅ Found' if has_env else '❌ Not found'}") 165 165 + print(f" - config.yaml: {'✅ Found' if has_config else '❌ Not found'}") 166 166 + print(f" - config.yaml.example: {'✅ Found' if has_example else '❌ Not found'}") 167 167 + print() 168 168 + 169 169 + # If no .env file, suggest creating config from example 170 170 + if not has_env: 171 171 + if not has_config and has_example: 172 172 + print("💡 No .env file found. Would you like to create config.yaml from the example?") 173 173 + response = input("Create config.yaml from example? (y/n): ").lower().strip() 174 174 + if response in ['y', 'yes']: 175 175 + try: 176 176 + shutil.copy2("config.yaml.example", "config.yaml") 177 177 + print("✅ Created config.yaml from config.yaml.example") 178 178 + print("📝 Please edit config.yaml to add your credentials") 179 179 + return 180 180 + except Exception as e: 181 181 + print(f"❌ Error copying example file: {e}") 182 182 + return 183 183 + else: 184 184 + print("👋 Migration cancelled") 185 185 + return 186 186 + else: 187 187 + print("ℹ️ No .env file found and config.yaml already exists or no example available") 188 188 + print(" If you need to set up configuration, see CONFIG.md") 189 189 + return 190 190 + 191 191 + # Load environment variables from .env 192 192 + print("🔍 Reading .env file...") 193 193 + env_vars = load_env_file() 194 194 + 195 195 + if not env_vars: 196 196 + print("⚠️ No environment variables found in .env file") 197 197 + return 198 198 + 199 199 + print(f" Found {len(env_vars)} environment variables") 200 200 + for key in env_vars.keys(): 201 201 + # Mask sensitive values 202 202 + if 'KEY' in key or 'PASSWORD' in key: 203 203 + value_display = f"***{env_vars[key][-4:]}" if len(env_vars[key]) > 4 else "***" 204 204 + else: 205 205 + value_display = env_vars[key] 206 206 + print(f" - {key}={value_display}") 207 207 + print() 208 208 + 209 209 + # Load existing config if present 210 210 + existing_config = load_existing_config() 211 211 + if existing_config: 212 212 + print("📄 Found existing config.yaml - will merge with .env values") 213 213 + 214 214 + # Create configuration 215 215 + print("🏗️ Building configuration...") 216 216 + config, migrated_vars = create_config_from_env(env_vars, existing_config) 217 217 + 218 218 + if not migrated_vars: 219 219 + print("⚠️ No recognized configuration variables found in .env") 220 220 + print(" Recognized variables: LETTA_API_KEY, BSKY_USERNAME, BSKY_PASSWORD, PDS_URI") 221 221 + return 222 222 + 223 223 + print(f" Migrating {len(migrated_vars)} variables: {', '.join(migrated_vars)}") 224 224 + 225 225 + # Show preview 226 226 + print("\n📋 Configuration preview:") 227 227 + print("-" * 30) 228 228 + 229 229 + # Show Letta section 230 230 + if 'letta' in config and config['letta']: 231 231 + print("🔧 Letta:") 232 232 + for key, value in config['letta'].items(): 233 233 + if 'key' in key.lower(): 234 234 + display_value = f"***{value[-8:]}" if len(str(value)) > 8 else "***" 235 235 + else: 236 236 + display_value = value 237 237 + print(f" {key}: {display_value}") 238 238 + 239 239 + # Show Bluesky section 240 240 + if 'bluesky' in config and config['bluesky']: 241 241 + print("🐦 Bluesky:") 242 242 + for key, value in config['bluesky'].items(): 243 243 + if 'password' in key.lower(): 244 244 + display_value = f"***{value[-4:]}" if len(str(value)) > 4 else "***" 245 245 + else: 246 246 + display_value = value 247 247 + print(f" {key}: {display_value}") 248 248 + 249 249 + print() 250 250 + 251 251 + # Confirm migration 252 252 + response = input("💾 Proceed with migration? This will update config.yaml (y/n): ").lower().strip() 253 253 + if response not in ['y', 'yes']: 254 254 + print("👋 Migration cancelled") 255 255 + return 256 256 + 257 257 + # Create backups 258 258 + print("💾 Creating backups...") 259 259 + backups = backup_existing_files() 260 260 + for original, backup in backups: 261 261 + print(f" Backed up {original} → {backup}") 262 262 + 263 263 + # Write new configuration 264 264 + print("✍️ Writing config.yaml...") 265 265 + if write_config_yaml(config): 266 266 + print("✅ Successfully created config.yaml") 267 267 + 268 268 + # Test the new configuration 269 269 + print("\n🧪 Testing new configuration...") 270 270 + try: 271 271 + from config_loader import get_config 272 272 + test_config = get_config() 273 273 + print("✅ Configuration loads successfully") 274 274 + 275 275 + # Test specific sections 276 276 + try: 277 277 + from config_loader import get_letta_config 278 278 + letta_config = get_letta_config() 279 279 + print("✅ Letta configuration valid") 280 280 + except Exception as e: 281 281 + print(f"⚠️ Letta config issue: {e}") 282 282 + 283 283 + try: 284 284 + from config_loader import get_bluesky_config 285 285 + bluesky_config = get_bluesky_config() 286 286 + print("✅ Bluesky configuration valid") 287 287 + except Exception as e: 288 288 + print(f"⚠️ Bluesky config issue: {e}") 289 289 + 290 290 + except Exception as e: 291 291 + print(f"❌ Configuration test failed: {e}") 292 292 + return 293 293 + 294 294 + # Success message and next steps 295 295 + print("\n🎉 Migration completed successfully!") 296 296 + print("\n📖 Next steps:") 297 297 + print(" 1. Run: python test_config.py") 298 298 + print(" 2. Test the bot: python bsky.py --test") 299 299 + print(" 3. If everything works, you can optionally remove the .env file") 300 300 + print(" 4. See CONFIG.md for more configuration options") 301 301 + 302 302 + if backups: 303 303 + print(f"\n🗂️ Backup files created:") 304 304 + for original, backup in backups: 305 305 + print(f" {backup}") 306 306 + print(" These can be deleted once you verify everything works") 307 307 + 308 308 + else: 309 309 + print("❌ Failed to write config.yaml") 310 310 + if backups: 311 311 + print("🔄 Restoring backups...") 312 312 + for original, backup in backups: 313 313 + try: 314 314 + if original != ".env": # Don't restore .env, keep it as fallback 315 315 + shutil.move(backup, original) 316 316 + print(f" Restored {backup} → {original}") 317 317 + except Exception as e: 318 318 + print(f" ❌ Failed to restore {backup}: {e}") 319 319 + 320 320 + 321 321 + if __name__ == "__main__": 322 322 + main()

+173

test_config.py

··· 1 1 + #!/usr/bin/env python3 2 2 + """ 3 3 + Configuration validation test script for Void Bot. 4 4 + Run this to verify your config.yaml setup is working correctly. 5 5 + """ 6 6 + 7 7 + 8 8 + def test_config_loading(): 9 9 + """Test that configuration can be loaded successfully.""" 10 10 + try: 11 11 + from config_loader import ( 12 12 + get_config, 13 13 + get_letta_config, 14 14 + get_bluesky_config, 15 15 + get_bot_config, 16 16 + get_agent_config, 17 17 + get_threading_config, 18 18 + get_queue_config 19 19 + ) 20 20 + 21 21 + print("🔧 Testing Configuration...") 22 22 + print("=" * 50) 23 23 + 24 24 + # Test basic config loading 25 25 + config = get_config() 26 26 + print("✅ Configuration file loaded successfully") 27 27 + 28 28 + # Test individual config sections 29 29 + print("\n📋 Configuration Sections:") 30 30 + print("-" * 30) 31 31 + 32 32 + # Letta Configuration 33 33 + try: 34 34 + letta_config = get_letta_config() 35 35 + print( 36 36 + f"✅ Letta API: project_id={letta_config.get('project_id', 'N/A')[:20]}...") 37 37 + print(f" - Timeout: {letta_config.get('timeout')}s") 38 38 + api_key = letta_config.get('api_key', 'Not configured') 39 39 + if api_key != 'Not configured': 40 40 + print(f" - API Key: ***{api_key[-8:]} (configured)") 41 41 + else: 42 42 + print(" - API Key: ❌ Not configured (required)") 43 43 + except Exception as e: 44 44 + print(f"❌ Letta config: {e}") 45 45 + 46 46 + # Bluesky Configuration 47 47 + try: 48 48 + bluesky_config = get_bluesky_config() 49 49 + username = bluesky_config.get('username', 'Not configured') 50 50 + password = bluesky_config.get('password', 'Not configured') 51 51 + pds_uri = bluesky_config.get('pds_uri', 'Not configured') 52 52 + 53 53 + if username != 'Not configured': 54 54 + print(f"✅ Bluesky: username={username}") 55 55 + else: 56 56 + print("❌ Bluesky username: Not configured (required)") 57 57 + 58 58 + if password != 'Not configured': 59 59 + print(f" - Password: ***{password[-4:]} (configured)") 60 60 + else: 61 61 + print(" - Password: ❌ Not configured (required)") 62 62 + 63 63 + print(f" - PDS URI: {pds_uri}") 64 64 + except Exception as e: 65 65 + print(f"❌ Bluesky config: {e}") 66 66 + 67 67 + # Bot Configuration 68 68 + try: 69 69 + bot_config = get_bot_config() 70 70 + print(f"✅ Bot behavior:") 71 71 + print( 72 72 + f" - Notification delay: {bot_config.get('fetch_notifications_delay')}s") 73 73 + print( 74 74 + f" - Max notifications: {bot_config.get('max_processed_notifications')}") 75 75 + print( 76 76 + f" - Max pages: {bot_config.get('max_notification_pages')}") 77 77 + except Exception as e: 78 78 + print(f"❌ Bot config: {e}") 79 79 + 80 80 + # Agent Configuration 81 81 + try: 82 82 + agent_config = get_agent_config() 83 83 + print(f"✅ Agent settings:") 84 84 + print(f" - Name: {agent_config.get('name')}") 85 85 + print(f" - Model: {agent_config.get('model')}") 86 86 + print(f" - Embedding: {agent_config.get('embedding')}") 87 87 + print(f" - Max steps: {agent_config.get('max_steps')}") 88 88 + blocks = agent_config.get('blocks', {}) 89 89 + print(f" - Memory blocks: {len(blocks)} configured") 90 90 + except Exception as e: 91 91 + print(f"❌ Agent config: {e}") 92 92 + 93 93 + # Threading Configuration 94 94 + try: 95 95 + threading_config = get_threading_config() 96 96 + print(f"✅ Threading:") 97 97 + print( 98 98 + f" - Parent height: {threading_config.get('parent_height')}") 99 99 + print(f" - Depth: {threading_config.get('depth')}") 100 100 + print( 101 101 + f" - Max chars/post: {threading_config.get('max_post_characters')}") 102 102 + except Exception as e: 103 103 + print(f"❌ Threading config: {e}") 104 104 + 105 105 + # Queue Configuration 106 106 + try: 107 107 + queue_config = get_queue_config() 108 108 + priority_users = queue_config.get('priority_users', []) 109 109 + print(f"✅ Queue settings:") 110 110 + print( 111 111 + f" - Priority users: {len(priority_users)} ({', '.join(priority_users[:3])}{'...' if len(priority_users) > 3 else ''})") 112 112 + print(f" - Base dir: {queue_config.get('base_dir')}") 113 113 + print(f" - Error dir: {queue_config.get('error_dir')}") 114 114 + except Exception as e: 115 115 + print(f"❌ Queue config: {e}") 116 116 + 117 117 + print("\n" + "=" * 50) 118 118 + print("✅ Configuration test completed!") 119 119 + 120 120 + # Check for common issues 121 121 + print("\n🔍 Configuration Status:") 122 122 + has_letta_key = False 123 123 + has_bluesky_creds = False 124 124 + 125 125 + try: 126 126 + letta_config = get_letta_config() 127 127 + has_letta_key = True 128 128 + except: 129 129 + print("⚠️ Missing Letta API key - bot cannot connect to Letta") 130 130 + 131 131 + try: 132 132 + bluesky_config = get_bluesky_config() 133 133 + has_bluesky_creds = True 134 134 + except: 135 135 + print("⚠️ Missing Bluesky credentials - bot cannot connect to Bluesky") 136 136 + 137 137 + if has_letta_key and has_bluesky_creds: 138 138 + print("🎉 All required credentials configured - bot should work!") 139 139 + elif not has_letta_key and not has_bluesky_creds: 140 140 + print("❌ Missing both Letta and Bluesky credentials") 141 141 + print(" Add them to config.yaml or set environment variables") 142 142 + else: 143 143 + print("⚠️ Partial configuration - some features may not work") 144 144 + 145 145 + print("\n📖 Next steps:") 146 146 + if not has_letta_key: 147 147 + print(" - Add your Letta API key to config.yaml under letta.api_key") 148 148 + print(" - Or set LETTA_API_KEY environment variable") 149 149 + if not has_bluesky_creds: 150 150 + print( 151 151 + " - Add your Bluesky credentials to config.yaml under bluesky section") 152 152 + print(" - Or set BSKY_USERNAME and BSKY_PASSWORD environment variables") 153 153 + if has_letta_key and has_bluesky_creds: 154 154 + print(" - Run: python bsky.py") 155 155 + print(" - Or run with testing mode: python bsky.py --test") 156 156 + 157 157 + except FileNotFoundError as e: 158 158 + print("❌ Configuration file not found!") 159 159 + print(f" {e}") 160 160 + print("\n📋 To set up configuration:") 161 161 + print(" 1. Copy config.yaml.example to config.yaml") 162 162 + print(" 2. Edit config.yaml with your credentials") 163 163 + print(" 3. Run this test again") 164 164 + except Exception as e: 165 165 + print(f"❌ Configuration loading failed: {e}") 166 166 + print("\n🔧 Troubleshooting:") 167 167 + print(" - Check that config.yaml has valid YAML syntax") 168 168 + print(" - Ensure required fields are not commented out") 169 169 + print(" - See CONFIG.md for detailed setup instructions") 170 170 + 171 171 + 172 172 + if __name__ == "__main__": 173 173 + test_config_loading()

+20 -30

tools/blocks.py

··· 1 1 """Block management tools for user-specific memory blocks.""" 2 2 from pydantic import BaseModel, Field 3 3 from typing import List, Dict, Any 4 4 + import logging 5 5 + 6 6 + def get_letta_client(): 7 7 + """Get a Letta client using configuration.""" 8 8 + try: 9 9 + from config_loader import get_letta_config 10 10 + from letta_client import Letta 11 11 + config = get_letta_config() 12 12 + return Letta(token=config['api_key'], timeout=config['timeout']) 13 13 + except (ImportError, FileNotFoundError, KeyError): 14 14 + # Fallback to environment variable 15 15 + import os 16 16 + from letta_client import Letta 17 17 + return Letta(token=os.environ["LETTA_API_KEY"]) 4 18 5 19 6 20 class AttachUserBlocksArgs(BaseModel): ··· 43 57 Returns: 44 58 String with attachment results for each handle 45 59 """ 46 46 - import os 47 47 - import logging 48 48 - from letta_client import Letta 49 49 - 50 60 logger = logging.getLogger(__name__) 51 61 52 62 handles = list(set(handles)) 53 63 54 64 try: 55 55 - client = Letta(token=os.environ["LETTA_API_KEY"]) 65 65 + client = get_letta_client() 56 66 results = [] 57 67 58 68 # Get current blocks using the API ··· 117 127 Returns: 118 128 String with detachment results for each handle 119 129 """ 120 120 - import os 121 121 - import logging 122 122 - from letta_client import Letta 123 123 - 124 130 logger = logging.getLogger(__name__) 125 131 126 132 try: 127 127 - client = Letta(token=os.environ["LETTA_API_KEY"]) 133 133 + client = get_letta_client() 128 134 results = [] 129 135 130 136 # Build mapping of block labels to IDs using the API ··· 174 180 Returns: 175 181 String confirming the note was appended 176 182 """ 177 177 - import os 178 178 - import logging 179 179 - from letta_client import Letta 180 180 - 181 183 logger = logging.getLogger(__name__) 182 184 183 185 try: 184 184 - client = Letta(token=os.environ["LETTA_API_KEY"]) 186 186 + client = get_letta_client() 185 187 186 188 # Sanitize handle for block label 187 189 clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') ··· 247 249 Returns: 248 250 String confirming the text was replaced 249 251 """ 250 250 - import os 251 251 - import logging 252 252 - from letta_client import Letta 253 253 - 254 252 logger = logging.getLogger(__name__) 255 253 256 254 try: 257 257 - client = Letta(token=os.environ["LETTA_API_KEY"]) 255 255 + client = get_letta_client() 258 256 259 257 # Sanitize handle for block label 260 258 clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') ··· 301 299 Returns: 302 300 String confirming the content was set 303 301 """ 304 304 - import os 305 305 - import logging 306 306 - from letta_client import Letta 307 307 - 308 302 logger = logging.getLogger(__name__) 309 303 310 304 try: 311 311 - client = Letta(token=os.environ["LETTA_API_KEY"]) 305 305 + client = get_letta_client() 312 306 313 307 # Sanitize handle for block label 314 308 clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_') ··· 367 361 Returns: 368 362 String containing the user's memory block content 369 363 """ 370 370 - import os 371 371 - import logging 372 372 - from letta_client import Letta 373 373 - 374 364 logger = logging.getLogger(__name__) 375 365 376 366 try: 377 377 - client = Letta(token=os.environ["LETTA_API_KEY"]) 367 367 + client = get_letta_client() 378 368 379 369 # Sanitize handle for block label 380 370 clean_handle = handle.lstrip('@').replace('.', '_').replace('-', '_').replace(' ', '_')

+16 -8

register_tools.py

··· 4 4 import sys 5 5 import logging 6 6 from typing import List 7 7 - from dotenv import load_dotenv 8 7 from letta_client import Letta 9 8 from rich.console import Console 10 9 from rich.table import Table 10 10 + from config_loader import get_config, get_letta_config, get_agent_config 11 11 12 12 # Import standalone functions and their schemas 13 13 from tools.search import search_bluesky_posts, SearchArgs ··· 18 18 from tools.thread import add_post_to_bluesky_reply_thread, ReplyThreadPostArgs 19 19 from tools.ignore import ignore_notification, IgnoreNotificationArgs 20 20 21 21 - load_dotenv() 21 21 + config = get_config() 22 22 + letta_config = get_letta_config() 23 23 + agent_config = get_agent_config() 22 24 logging.basicConfig(level=logging.INFO) 23 25 logger = logging.getLogger(__name__) 24 26 console = Console() ··· 101 103 ] 102 104 103 105 104 104 - def register_tools(agent_name: str = "void", tools: List[str] = None): 106 106 + def register_tools(agent_name: str = None, tools: List[str] = None): 105 107 """Register tools with a Letta agent. 106 108 107 109 Args: 108 108 - agent_name: Name of the agent to attach tools to 110 110 + agent_name: Name of the agent to attach tools to. If None, uses config default. 109 111 tools: List of tool names to register. If None, registers all tools. 110 112 """ 113 113 + # Use agent name from config if not provided 114 114 + if agent_name is None: 115 115 + agent_name = agent_config['name'] 116 116 + 111 117 try: 112 112 - # Initialize Letta client with API key 113 113 - client = Letta(token=os.environ["LETTA_API_KEY"]) 118 118 + # Initialize Letta client with API key from config 119 119 + client = Letta(token=letta_config['api_key']) 114 120 115 121 # Find the agent 116 122 agents = client.agents.list() ··· 201 207 import argparse 202 208 203 209 parser = argparse.ArgumentParser(description="Register Void tools with a Letta agent") 204 204 - parser.add_argument("agent", nargs="?", default="void", help="Agent name (default: void)") 210 210 + parser.add_argument("agent", nargs="?", default=None, help=f"Agent name (default: {agent_config['name']})") 205 211 parser.add_argument("--tools", nargs="+", help="Specific tools to register (default: all)") 206 212 parser.add_argument("--list", action="store_true", help="List available tools") 207 213 ··· 210 216 if args.list: 211 217 list_available_tools() 212 218 else: 213 213 - console.print(f"\n[bold]Registering tools for agent: {args.agent}[/bold]\n") 219 219 + # Use config default if no agent specified 220 220 + agent_name = args.agent if args.agent is not None else agent_config['name'] 221 221 + console.print(f"\n[bold]Registering tools for agent: {agent_name}[/bold]\n") 214 222 register_tools(args.agent, args.tools)

+23

requirements.txt

··· 1 1 + # Core dependencies for Void Bot 2 2 + 3 3 + # Configuration and utilities 4 4 + PyYAML>=6.0.2 5 5 + rich>=14.0.0 6 6 + python-dotenv>=1.0.0 7 7 + 8 8 + # Letta API client 9 9 + letta-client>=0.1.198 10 10 + 11 11 + # AT Protocol (Bluesky) client 12 12 + atproto>=0.0.54 13 13 + 14 14 + # HTTP client for API calls 15 15 + httpx>=0.28.1 16 16 + httpx-sse>=0.4.0 17 17 + requests>=2.31.0 18 18 + 19 19 + # Data validation 20 20 + pydantic>=2.11.7 21 21 + 22 22 + # Async support 23 23 + anyio>=4.9.0