Add language support for Bluesky replies

- Updated bluesky_reply tool to accept optional lang parameter (defaults to en-US)
- Modified bsky.py to extract language from tool call and pass to reply function
- Updated bsky_utils.py reply functions to accept and use langs parameter
- Posts are now tagged with the specified language code for better filtering

This allows Void to post in different languages by specifying codes like
'es', 'ja', 'th', etc. when using the bluesky_reply tool.

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

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

bsky.py

···
         logger.debug("Successfully received response from Letta API")
         logger.debug(f"Number of messages in response: {len(message_response.messages) if hasattr(message_response, 'messages') else 'N/A'}")
 
-        # Extract the reply text from the agent's response
+        # Extract the reply text and language from the agent's response
         reply_text = ""
+        reply_lang = "en-US"  # Default language
         logger.debug(f"Processing {len(message_response.messages)} response messages...")
         
         for i, message in enumerate(message_response.messages, 1):
···
             # Check if this is a ToolCallMessage with bluesky_reply tool
             if hasattr(message, 'tool_call') and message.tool_call:
                 if message.tool_call.name == 'bluesky_reply':
-                    # Parse the JSON arguments to get the message
+                    # Parse the JSON arguments to get the message and language
                     try:
                         args = json.loads(message.tool_call.arguments)
                         reply_text = args.get('message', '')
-                        logger.info(f"Extracted reply from tool call: {reply_text[:50]}...")
+                        reply_lang = args.get('lang', 'en-US')  # Extract language or use default
+                        logger.info(f"Extracted reply from tool call: {reply_text[:50]}... (lang: {reply_lang})")
                         break
                     except json.JSONDecodeError as e:
                         logger.error(f"Failed to parse tool call arguments: {e}")
···
             print(f"\n=== GENERATED REPLY ===")
             print(f"To: @{author_handle}")
             print(f"Reply: {reply_text}")
+            print(f"Language: {reply_lang}")
             print(f"======================\n")
 
-            # Send the reply
-            logger.info(f"Sending reply: {reply_text[:50]}...")
+            # Send the reply with language
+            logger.info(f"Sending reply: {reply_text[:50]}... (lang: {reply_lang})")
             response = bsky_utils.reply_to_notification(
                 client=atproto_client,
                 notification=notification_data,
-                reply_text=reply_text
+                reply_text=reply_text,
+                lang=reply_lang
             )
 
             if response:

bsky_utils.py

···
 
     return init_client(username, password)
 
-def reply_to_post(client: Client, text: str, reply_to_uri: str, reply_to_cid: str, root_uri: Optional[str] = None, root_cid: Optional[str] = None) -> Dict[str, Any]:
+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]:
     """
     Reply to a post on Bluesky with rich text support.
 
···
         reply_to_cid: The CID of the post being replied to (parent)
         root_uri: The URI of the root post (if replying to a reply). If None, uses reply_to_uri
         root_cid: The CID of the root post (if replying to a reply). If None, uses reply_to_cid
+        lang: Language code for the post (e.g., 'en-US', 'es', 'ja')
 
     Returns:
         The response from sending the post
···
         response = client.send_post(
             text=text,
             reply_to=models.AppBskyFeedPost.ReplyRef(parent=parent_ref, root=root_ref),
-            facets=facets
+            facets=facets,
+            langs=[lang] if lang else None
         )
     else:
         response = client.send_post(
             text=text,
-            reply_to=models.AppBskyFeedPost.ReplyRef(parent=parent_ref, root=root_ref)
+            reply_to=models.AppBskyFeedPost.ReplyRef(parent=parent_ref, root=root_ref),
+            langs=[lang] if lang else None
         )
 
     logger.info(f"Reply sent successfully: {response.uri}")
···
         return None
 
 
-def reply_to_notification(client: Client, notification: Any, reply_text: str) -> Optional[Dict[str, Any]]:
+def reply_to_notification(client: Client, notification: Any, reply_text: str, lang: str = "en-US") -> Optional[Dict[str, Any]]:
     """
     Reply to a notification (mention or reply).
 
···
         client: Authenticated Bluesky client
         notification: The notification object from list_notifications
         reply_text: The text to reply with
+        lang: Language code for the post (defaults to "en-US")
 
     Returns:
         The response from sending the reply or None if failed
···
                 reply_to_uri=post_uri,
                 reply_to_cid=post_cid,
                 root_uri=root_uri,
-                root_cid=root_cid
+                root_cid=root_cid,
+                lang=lang
             )
         else:
             # If we can't get thread data, just reply directly
···
                 client=client,
                 text=reply_text,
                 reply_to_uri=post_uri,
-                reply_to_cid=post_cid
+                reply_to_cid=post_cid,
+                lang=lang
             )
 
     except Exception as e:

tools/reply.py

···
 """Reply tool for Bluesky - a simple tool for the Letta agent to indicate a reply."""
+from typing import Optional
 from pydantic import BaseModel, Field, validator
 
 
···
         ..., 
         description="The reply message text (max 300 characters)"
     )
+    lang: Optional[str] = Field(
+        default="en-US",
+        description="Language code for the post (e.g., 'en-US', 'es', 'ja', 'th'). Defaults to 'en-US'"
+    )
     
     @validator('message')
     def validate_message_length(cls, v):
···
         return v
 
 
-def bluesky_reply(message: str) -> str:
+def bluesky_reply(message: str, lang: str = "en-US") -> str:
     """
     This is a simple function that returns a string. MUST be less than 300 characters.
     
     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'
         
     Returns:
-        Confirmation message
+        Confirmation message with language info
         
     Raises:
         Exception: If message exceeds 300 characters
···
     if len(message) > 300:
         raise Exception(f"Message cannot be longer than 300 characters (current: {len(message)} characters)")
     
-    return 'Reply sent'
+    return f'Reply sent (language: {lang})'