Add list support to bluesky_reply tool with threading (max 4 messages)

Major changes:
- Updated ReplyArgs schema to accept List[str] messages instead of single message
- Added validation for max 4 messages, each max 300 characters
- Updated bluesky_reply function to handle message lists
- Created reply_with_thread_to_notification function in bsky_utils.py
- Added system failure message posting when thread messages fail
- Updated bot processing logic in bsky.py to handle both single and multi-message replies
- Maintained backward compatibility with old message format
- Updated register_tools.py description

Threading behavior:
- Single message: Works exactly like before
- Multiple messages: Creates a linear thread where each reply is a response to the previous one
- Failure handling: Posts "[SYSTEM FAILURE: COULD NOT POST MESSAGE, PLEASE TRY AGAIN]" if a message in the thread fails

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

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

bsky.py

···
                 if message.tool_call.name == 'bluesky_reply':
                     try:
                         args = json.loads(message.tool_call.arguments)
-                        reply_text = args.get('message', '')
+                        # Handle both old format (message) and new format (messages)
+                        reply_messages = args.get('messages', [])
+                        if not reply_messages:
+                            # Fallback to old format for backward compatibility
+                            old_message = args.get('message', '')
+                            if old_message:
+                                reply_messages = [old_message]
+                        
                         reply_lang = args.get('lang', 'en-US')
-                        if reply_text:  # Only add if there's actual content
-                            reply_candidates.append((reply_text, reply_lang))
-                            logger.info(f"Found bluesky_reply candidate: {reply_text[:50]}... (lang: {reply_lang})")
+                        if reply_messages:  # Only add if there's actual content
+                            reply_candidates.append((reply_messages, reply_lang))
+                            if len(reply_messages) == 1:
+                                logger.info(f"Found bluesky_reply candidate: {reply_messages[0][:50]}... (lang: {reply_lang})")
+                            else:
+                                logger.info(f"Found bluesky_reply thread candidate with {len(reply_messages)} messages (lang: {reply_lang})")
                     except json.JSONDecodeError as e:
                         logger.error(f"Failed to parse tool call arguments: {e}")
 
         if reply_candidates:
             logger.info(f"Found {len(reply_candidates)} bluesky_reply candidates, trying each until one succeeds...")
             
-            for i, (reply_text, reply_lang) in enumerate(reply_candidates, 1):
+            for i, (reply_messages, reply_lang) in enumerate(reply_candidates, 1):
                 # Print the generated reply for testing
                 print(f"\n=== GENERATED REPLY {i}/{len(reply_candidates)} ===")
                 print(f"To: @{author_handle}")
-                print(f"Reply: {reply_text}")
+                if len(reply_messages) == 1:
+                    print(f"Reply: {reply_messages[0]}")
+                else:
+                    print(f"Reply thread ({len(reply_messages)} messages):")
+                    for j, msg in enumerate(reply_messages, 1):
+                        print(f"  {j}. {msg}")
                 print(f"Language: {reply_lang}")
                 print(f"======================\n")
 
-                # Send the reply with language
-                logger.info(f"Trying reply {i}/{len(reply_candidates)}: {reply_text[:50]}... (lang: {reply_lang})")
-                response = bsky_utils.reply_to_notification(
-                    client=atproto_client,
-                    notification=notification_data,
-                    reply_text=reply_text,
-                    lang=reply_lang
-                )
+                # Send the reply(s) with language
+                if len(reply_messages) == 1:
+                    # Single reply - use existing function
+                    logger.info(f"Trying single reply {i}/{len(reply_candidates)}: {reply_messages[0][:50]}... (lang: {reply_lang})")
+                    response = bsky_utils.reply_to_notification(
+                        client=atproto_client,
+                        notification=notification_data,
+                        reply_text=reply_messages[0],
+                        lang=reply_lang
+                    )
+                else:
+                    # Multiple replies - use new threaded function
+                    logger.info(f"Trying threaded reply {i}/{len(reply_candidates)} with {len(reply_messages)} messages (lang: {reply_lang})")
+                    response = bsky_utils.reply_with_thread_to_notification(
+                        client=atproto_client,
+                        notification=notification_data,
+                        reply_messages=reply_messages,
+                        lang=reply_lang
+                    )
 
                 if response:
                     logger.info(f"Successfully replied to @{author_handle} with candidate {i}")

bsky_utils.py

···
         return None
 
 
+def reply_with_thread_to_notification(client: Client, notification: Any, reply_messages: List[str], lang: str = "en-US") -> Optional[List[Dict[str, Any]]]:
+    """
+    Reply to a notification with a threaded chain of messages (max 4).
+
+    Args:
+        client: Authenticated Bluesky client
+        notification: The notification object from list_notifications
+        reply_messages: List of reply texts (max 4 messages, each max 300 chars)
+        lang: Language code for the posts (defaults to "en-US")
+
+    Returns:
+        List of responses from sending the replies or None if failed
+    """
+    try:
+        from typing import List
+        
+        # Validate input
+        if not reply_messages or len(reply_messages) == 0:
+            logger.error("Reply messages list cannot be empty")
+            return None
+        if len(reply_messages) > 4:
+            logger.error(f"Cannot send more than 4 reply messages (got {len(reply_messages)})")
+            return None
+        
+        # Get the post URI and CID from the notification (handle both dict and object)
+        if isinstance(notification, dict):
+            post_uri = notification.get('uri')
+            post_cid = notification.get('cid')
+        elif hasattr(notification, 'uri') and hasattr(notification, 'cid'):
+            post_uri = notification.uri
+            post_cid = notification.cid
+        else:
+            post_uri = None
+            post_cid = None
+
+        if not post_uri or not post_cid:
+            logger.error("Notification doesn't have required uri/cid fields")
+            return None
+
+        # Get the thread to find the root post
+        thread_data = get_post_thread(client, post_uri)
+        
+        root_uri = post_uri
+        root_cid = post_cid
+
+        if thread_data and hasattr(thread_data, 'thread'):
+            thread = thread_data.thread
+            # If this has a parent, find the root
+            if hasattr(thread, 'parent') and thread.parent:
+                # Keep going up until we find the root
+                current = thread
+                while hasattr(current, 'parent') and current.parent:
+                    current = current.parent
+                    if hasattr(current, 'post') and hasattr(current.post, 'uri') and hasattr(current.post, 'cid'):
+                        root_uri = current.post.uri
+                        root_cid = current.post.cid
+
+        # Send replies in sequence, creating a thread
+        responses = []
+        current_parent_uri = post_uri
+        current_parent_cid = post_cid
+        
+        for i, message in enumerate(reply_messages):
+            logger.info(f"Sending reply {i+1}/{len(reply_messages)}: {message[:50]}...")
+            
+            # Send this reply
+            response = reply_to_post(
+                client=client,
+                text=message,
+                reply_to_uri=current_parent_uri,
+                reply_to_cid=current_parent_cid,
+                root_uri=root_uri,
+                root_cid=root_cid,
+                lang=lang
+            )
+            
+            if not response:
+                logger.error(f"Failed to send reply {i+1}, posting system failure message")
+                # Try to post a system failure message
+                failure_response = reply_to_post(
+                    client=client,
+                    text="[SYSTEM FAILURE: COULD NOT POST MESSAGE, PLEASE TRY AGAIN]",
+                    reply_to_uri=current_parent_uri,
+                    reply_to_cid=current_parent_cid,
+                    root_uri=root_uri,
+                    root_cid=root_cid,
+                    lang=lang
+                )
+                if failure_response:
+                    responses.append(failure_response)
+                    current_parent_uri = failure_response.uri
+                    current_parent_cid = failure_response.cid
+                else:
+                    logger.error("Could not even send system failure message, stopping thread")
+                    return responses if responses else None
+            else:
+                responses.append(response)
+                # Update parent references for next reply (if any)
+                if i < len(reply_messages) - 1:  # Not the last message
+                    current_parent_uri = response.uri
+                    current_parent_cid = response.cid
+                
+        logger.info(f"Successfully sent {len(responses)} threaded replies")
+        return responses
+
+    except Exception as e:
+        logger.error(f"Error sending threaded reply to notification: {e}")
+        return None
+
+
 if __name__ == "__main__":
     client = default_login()
     # do something with the client

register_tools.py

···
     {
         "func": bluesky_reply,
         "args_schema": ReplyArgs,
-        "description": "Simple reply indicator for the Letta agent (max 300 chars)",
+        "description": "Reply indicator for the Letta agent (1-4 messages, each max 300 chars). Creates threaded replies.",
         "tags": ["bluesky", "reply", "response"]
     },
 ]

tools/reply.py

···
 """Reply tool for Bluesky - a simple tool for the Letta agent to indicate a reply."""
-from typing import Optional
+from typing import List, Optional
 from pydantic import BaseModel, Field, validator
 
 
 class ReplyArgs(BaseModel):
-    message: str = Field(
+    messages: List[str] = Field(
         ..., 
-        description="The reply message text (max 300 characters)"
+        description="List of reply messages (each max 300 characters, max 4 messages total). Single item creates one reply, multiple items create a threaded reply chain."
     )
     lang: Optional[str] = Field(
         default="en-US",
-        description="Language code for the post (e.g., 'en-US', 'es', 'ja', 'th'). Defaults to 'en-US'"
+        description="Language code for the posts (e.g., 'en-US', 'es', 'ja', 'th'). Defaults to 'en-US'"
     )
     
-    @validator('message')
-    def validate_message_length(cls, v):
-        if len(v) > 300:
-            raise ValueError(f"Message cannot be longer than 300 characters (current: {len(v)} characters)")
+    @validator('messages')
+    def validate_messages(cls, v):
+        if not v or len(v) == 0:
+            raise ValueError("Messages list cannot be empty")
+        if len(v) > 4:
+            raise ValueError(f"Cannot send more than 4 reply messages (current: {len(v)} messages)")
+        for i, message in enumerate(v):
+            if len(message) > 300:
+                raise ValueError(f"Message {i+1} cannot be longer than 300 characters (current: {len(message)} characters)")
         return v
 
 
-def bluesky_reply(message: str, lang: str = "en-US") -> str:
+def bluesky_reply(messages: List[str], lang: str = "en-US") -> str:
     """
-    This is a simple function that returns a string. MUST be less than 300 characters.
+    This is a simple function that returns a string indicating reply thread will be sent.
     
     Args:
-        message: The reply text (max 300 characters)
-        lang: Language code for the post (e.g., 'en-US', 'es', 'ja', 'th'). Defaults to 'en-US'
+        messages: List of reply texts (each max 300 characters, max 4 messages total)
+        lang: Language code for the posts (e.g., 'en-US', 'es', 'ja', 'th'). Defaults to 'en-US'
         
     Returns:
-        Confirmation message with language info
+        Confirmation message with language info and message count
         
     Raises:
-        Exception: If message exceeds 300 characters
+        Exception: If messages list is invalid or messages exceed limits
     """
-    if len(message) > 300:
-        raise Exception(f"Message cannot be longer than 300 characters (current: {len(message)} characters)")
+    if not messages or len(messages) == 0:
+        raise Exception("Messages list cannot be empty")
+    if len(messages) > 4:
+        raise Exception(f"Cannot send more than 4 reply messages (current: {len(messages)} messages)")
     
-    return f'Reply sent (language: {lang})'
+    for i, message in enumerate(messages):
+        if len(message) > 300:
+            raise Exception(f"Message {i+1} cannot be longer than 300 characters (current: {len(message)} characters)")
+    
+    if len(messages) == 1:
+        return f'Reply sent (language: {lang})'
+    else:
+        return f'Reply thread with {len(messages)} messages sent (language: {lang})'