Add retry logic and better timeout handling for Letta API

- Add automatic retry with exponential backoff (2 retries) for ReadTimeout
- Catch ReadTimeout specifically to distinguish from other errors
- Continue bridge processing on agent errors instead of crashing
- Show cleaner error messages with error type name
- Add retry attempt logging for debugging

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

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

src/jetstream_letta_bridge.py

···
             console.print(f"[{self.agent_name}] 📊 {self.blips_received} received | {self.messages_sent_to_agent} sent | {self.blips_published} published ({rate:.1f}/min)")
 
         except Exception as e:
-            console.print(f"[{self.agent_name}] ❌ Agent error: {e}")
+            error_name = type(e).__name__
+            console.print(f"[{self.agent_name}] ❌ {error_name}: {str(e)[:100]}")
             logger.error(f"[{self.agent_name}] Agent communication error: {e}")
+            # Continue processing - don't let one error stop the bridge
     
     def agent_stream_handler(self, chunk) -> None:
         """Handle streaming chunks from the agent."""

src/letta_integration.py

···
         
         return results
     
-    def send_message_to_agent(self, message: str, stream_handler: Optional[Callable] = None) -> Any:
+    def send_message_to_agent(self, message: str, stream_handler: Optional[Callable] = None, max_retries: int = 2) -> Any:
         """
         Send a message to the Letta agent with streaming support.
 
         Args:
             message: Message to send to the agent
             stream_handler: Optional function to handle streaming chunks
+            max_retries: Maximum number of retry attempts on timeout
 
         Returns:
             Streaming response object
         """
-        logger.debug(f"[{self.agent_name}] Sending to agent: {message[:100]}...")
+        from httpx import ReadTimeout
+        import time
 
-        try:
-            # Create streaming request
-            logger.debug(f"[{self.agent_name}] Calling create_stream API...")
-            message_stream = self.letta_client.agents.messages.create_stream(
-                agent_id=self.agent_id,
-                messages=[{"role": "user", "content": message}],
-                stream_tokens=False,  # Step streaming only
-                max_steps=self.max_steps
-            )
-            logger.debug(f"[{self.agent_name}] Stream created, processing chunks...")
+        last_error = None
+        for attempt in range(max_retries + 1):
+            try:
+                if attempt > 0:
+                    delay = min(2 ** attempt, 10)  # Exponential backoff, max 10s
+                    logger.warning(f"[{self.agent_name}] Retry attempt {attempt}/{max_retries} after {delay}s delay...")
+                    time.sleep(delay)
 
-            # Process streaming response
-            chunk_count = 0
-            for chunk in message_stream:
-                chunk_count += 1
-                if chunk_count == 1:
-                    logger.debug(f"[{self.agent_name}] Received first chunk")
+                logger.debug(f"[{self.agent_name}] Sending to agent: {message[:100]}...")
 
-                # Handle streaming chunk
-                if stream_handler:
-                    try:
-                        stream_handler(chunk)
-                    except Exception as e:
-                        logger.error(f"Error in stream handler: {e}")
-                
-                # Check for send_message tool calls
-                if hasattr(chunk, 'message_type') and chunk.message_type == 'tool_call_message':
-                    message_content = self.process_tool_call_chunk(chunk)
-                    if message_content:
-                        self.add_message_to_batch(message_content)
-                
-                # Check for direct assistant messages (not via tool)
-                elif hasattr(chunk, 'message_type') and chunk.message_type == 'assistant_message':
-                    if hasattr(chunk, 'content') and chunk.content:
-                        logger.debug(f"Direct assistant message: {chunk.content[:100]}...")
-                        self.add_message_to_batch(chunk.content)
-                
-                # Log chunk information
-                if hasattr(chunk, 'message_type'):
-                    if chunk.message_type == 'reasoning_message':
-                        logger.debug(f"Reasoning: {chunk.reasoning[:100]}...")
-                    elif chunk.message_type == 'tool_call_message':
-                        tool_name = chunk.tool_call.name
-                        logger.debug(f"Tool call: {tool_name}")
-                    elif chunk.message_type == 'tool_return_message':
-                        status = chunk.status
-                        logger.debug(f"Tool result: {chunk.name} -> {status}")
-                    elif chunk.message_type == 'assistant_message':
-                        logger.debug(f"Assistant: {chunk.content[:100]}...")
-                
-                if str(chunk) == 'done':
-                    logger.debug(f"[{self.agent_name}] Received 'done' signal")
-                    break
+                # Create streaming request
+                logger.debug(f"[{self.agent_name}] Calling create_stream API...")
+                message_stream = self.letta_client.agents.messages.create_stream(
+                    agent_id=self.agent_id,
+                    messages=[{"role": "user", "content": message}],
+                    stream_tokens=False,  # Step streaming only
+                    max_steps=self.max_steps
+                )
+                logger.debug(f"[{self.agent_name}] Stream created, processing chunks...")
 
-            logger.debug(f"[{self.agent_name}] Processed {chunk_count} chunks")
+                # Process streaming response
+                chunk_count = 0
+                for chunk in message_stream:
+                    chunk_count += 1
+                    if chunk_count == 1:
+                        logger.debug(f"[{self.agent_name}] Received first chunk")
+
+                    # Handle streaming chunk
+                    if stream_handler:
+                        try:
+                            stream_handler(chunk)
+                        except Exception as e:
+                            logger.error(f"Error in stream handler: {e}")
+
+                    # Check for send_message tool calls
+                    if hasattr(chunk, 'message_type') and chunk.message_type == 'tool_call_message':
+                        message_content = self.process_tool_call_chunk(chunk)
+                        if message_content:
+                            self.add_message_to_batch(message_content)
+
+                    # Check for direct assistant messages (not via tool)
+                    elif hasattr(chunk, 'message_type') and chunk.message_type == 'assistant_message':
+                        if hasattr(chunk, 'content') and chunk.content:
+                            logger.debug(f"Direct assistant message: {chunk.content[:100]}...")
+                            self.add_message_to_batch(chunk.content)
+
+                    # Log chunk information
+                    if hasattr(chunk, 'message_type'):
+                        if chunk.message_type == 'reasoning_message':
+                            logger.debug(f"Reasoning: {chunk.reasoning[:100]}...")
+                        elif chunk.message_type == 'tool_call_message':
+                            tool_name = chunk.tool_call.name
+                            logger.debug(f"Tool call: {tool_name}")
+                        elif chunk.message_type == 'tool_return_message':
+                            status = chunk.status
+                            logger.debug(f"Tool result: {chunk.name} -> {status}")
+                        elif chunk.message_type == 'assistant_message':
+                            logger.debug(f"Assistant: {chunk.content[:100]}...")
 
-            # Flush any remaining messages in batch
-            self.flush_batch()
+                    if str(chunk) == 'done':
+                        logger.debug(f"[{self.agent_name}] Received 'done' signal")
+                        break
 
-            logger.debug(f"[{self.agent_name}] Agent processing completed")
-            return message_stream
+                logger.debug(f"[{self.agent_name}] Processed {chunk_count} chunks")
+
+                # Flush any remaining messages in batch
+                self.flush_batch()
 
-        except Exception as e:
-            logger.error(f"[{self.agent_name}] Error sending message to agent: {e}", exc_info=True)
-            raise
+                logger.debug(f"[{self.agent_name}] Agent processing completed")
+                return message_stream
+
+            except ReadTimeout as e:
+                last_error = e
+                logger.warning(f"[{self.agent_name}] Read timeout on attempt {attempt + 1}/{max_retries + 1}")
+                if attempt >= max_retries:
+                    logger.error(f"[{self.agent_name}] Max retries exceeded, giving up")
+                    raise
+                # Continue to next retry
+                continue
+
+            except Exception as e:
+                logger.error(f"[{self.agent_name}] Error sending message to agent: {e}", exc_info=True)
+                raise
+
+        # Should not reach here, but just in case
+        if last_error:
+            raise last_error
     
     def get_agent_info(self) -> Optional[Dict[str, Any]]:
         """