swarms 7.9.0__py3-none-any.whl → 7.9.1__py3-none-any.whl

swarms/structs/__init__.py

@@ -83,7 +83,13 @@ from swarms.structs.swarming_architectures import (
     staircase_swarm,
     star_swarm,
 )
-from swarms.structs.interactive_groupchat import InteractiveGroupChat
+from swarms.structs.interactive_groupchat import (
+    InteractiveGroupChat,
+    round_robin_speaker,
+    random_speaker,
+    priority_speaker,
+    random_dynamic_speaker,
+)
 
 __all__ = [
     "Agent",
@@ -156,4 +162,8 @@ __all__ = [
     "find_agent_by_name",
     "run_agent",
     "InteractiveGroupChat",
+    "round_robin_speaker",
+    "random_speaker",
+    "priority_speaker",
+    "random_dynamic_speaker",
 ]

swarms/structs/agent.py

@@ -5,6 +5,7 @@ import os
 import random
 import threading
 import time
+import traceback
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
@@ -85,6 +86,7 @@ from swarms.utils.index import (
 )
 from swarms.schemas.conversation_schema import ConversationSchema
 from swarms.utils.output_types import OutputType
+from swarms.utils.retry_func import retry_function
 
 
 def stop_when_repeats(response: str) -> bool:
@@ -153,6 +155,12 @@ class AgentLLMInitializationError(AgentError):
     pass
 
 
+class AgentToolExecutionError(AgentError):
+    """Exception raised when the agent fails to execute a tool. Check the tool's configuration and availability."""
+
+    pass
+
+
 # [FEAT][AGENT]
 class Agent:
     """
@@ -425,6 +433,7 @@ class Agent:
         tool_call_summary: bool = True,
         output_raw_json_from_tool_call: bool = False,
         summarize_multiple_images: bool = False,
+        tool_retry_attempts: int = 3,
         *args,
         **kwargs,
     ):
@@ -564,6 +573,7 @@ class Agent:
             output_raw_json_from_tool_call
         )
         self.summarize_multiple_images = summarize_multiple_images
+        self.tool_retry_attempts = tool_retry_attempts
 
         # self.short_memory = self.short_memory_init()
 
@@ -791,10 +801,11 @@ class Agent:
                 or exists(self.mcp_urls)
                 or exists(self.mcp_config)
             ):
-                self.pretty_print(
-                    f"✨ [SYSTEM] Successfully integrated {len(tools)} MCP tools into agent: {self.agent_name} | Status: ONLINE | Time: {time.strftime('%H:%M:%S')} ✨",
-                    loop_count=0,
-                )
+                if self.print_on is True:
+                    self.pretty_print(
+                        f"✨ [SYSTEM] Successfully integrated {len(tools)} MCP tools into agent: {self.agent_name} | Status: ONLINE | Time: {time.strftime('%H:%M:%S')} ✨",
+                        loop_count=0,
+                    )
 
             return tools
         except AgentMCPConnectionError as e:
@@ -1015,8 +1026,8 @@ class Agent:
             # Print the request
             if print_task is True:
                 formatter.print_panel(
-                    f"\n User: {task}",
-                    f"Task Request for {self.agent_name}",
+                    content=f"\n User: {task}",
+                    title=f"Task Request for {self.agent_name}",
                 )
 
             while (
@@ -1077,6 +1088,8 @@ class Agent:
                                 **kwargs,
                             )
 
+                        # If streaming is enabled, then don't print the response
+
                         # Parse the response from the agent with the output type
                         if exists(self.tools_list_dictionary):
                             if isinstance(response, BaseModel):
@@ -1091,26 +1104,24 @@ class Agent:
                         )
 
                         # Print
-                        self.pretty_print(response, loop_count)
+                        if self.print_on is True:
+                            if isinstance(response, list):
+                                self.pretty_print(
+                                    f"Structured Output - Attempting Function Call Execution [{time.strftime('%H:%M:%S')}] \n\n {format_data_structure(response)} ",
+                                    loop_count,
+                                )
+                            elif self.streaming_on is True:
+                                pass
+                            else:
+                                self.pretty_print(
+                                    response, loop_count
+                                )
 
                         # Check and execute callable tools
                         if exists(self.tools):
-                            if (
-                                self.output_raw_json_from_tool_call
-                                is True
-                            ):
-                                response = response
-                            else:
-                                # Only execute tools if response is not None
-                                if response is not None:
-                                    self.execute_tools(
-                                        response=response,
-                                        loop_count=loop_count,
-                                    )
-                                else:
-                                    logger.warning(
-                                        f"LLM returned None response in loop {loop_count}, skipping tool execution"
-                                    )
+                            self.tool_execution_retry(
+                                response, loop_count
+                            )
 
                         # Handle MCP tools
                         if (
@@ -1141,8 +1152,12 @@ class Agent:
                             self.save()
 
                         logger.error(
-                            f"Attempt {attempt+1}: Error generating"
-                            f" response: {e}"
+                            f"Attempt {attempt+1}/{self.max_retries}: Error generating response in loop {loop_count} for agent '{self.agent_name}': {str(e)} | "
+                            f"Error type: {type(e).__name__}, Error details: {e.__dict__ if hasattr(e, '__dict__') else 'No additional details'} | "
+                            f"Current task: '{task}', Agent state: max_loops={self.max_loops}, "
+                            f"model={getattr(self.llm, 'model_name', 'unknown')}, "
+                            f"temperature={getattr(self.llm, 'temperature', 'unknown')}"
+                            f"{f' | Traceback: {e.__traceback__}' if hasattr(e, '__traceback__') else ''}"
                         )
                         attempt += 1
 
@@ -1164,13 +1179,19 @@ class Agent:
                     self.stopping_condition is not None
                     and self._check_stopping_condition(response)
                 ):
-                    logger.info("Stopping condition met.")
+                    logger.info(
+                        f"Agent '{self.agent_name}' stopping condition met. "
+                        f"Loop: {loop_count}, Response length: {len(str(response)) if response else 0}"
+                    )
                     break
                 elif (
                     self.stopping_func is not None
                     and self.stopping_func(response)
                 ):
-                    logger.info("Stopping function met.")
+                    logger.info(
+                        f"Agent '{self.agent_name}' stopping function condition met. "
+                        f"Loop: {loop_count}, Response length: {len(str(response)) if response else 0}"
+                    )
                     break
 
                 if self.interactive:
@@ -1217,14 +1238,27 @@ class Agent:
             self._handle_run_error(error)
 
     def __handle_run_error(self, error: any):
+        import traceback
+
         log_agent_data(self.to_dict())
 
         if self.autosave is True:
             self.save()
 
-        logger.info(
-            f"Error detected running your agent {self.agent_name} \n Error {error} \n Optimize your input parameters and or add an issue on the swarms github and contact our team on discord for support ;) "
+        # Get detailed error information
+        error_type = type(error).__name__
+        error_message = str(error)
+        traceback_info = traceback.format_exc()
+
+        logger.error(
+            f"Error detected running your agent {self.agent_name}\n"
+            f"Error Type: {error_type}\n"
+            f"Error Message: {error_message}\n"
+            f"Traceback:\n{traceback_info}\n"
+            f"Agent State: {self.to_dict()}\n"
+            f"Optimize your input parameters and or add an issue on the swarms github and contact our team on discord for support ;)"
         )
+
         raise error
 
     def _handle_run_error(self, error: any):
@@ -2790,19 +2824,23 @@ class Agent:
         return self.role
 
     def pretty_print(self, response: str, loop_count: int):
-        if self.print_on is False:
-            if self.streaming_on is True:
-                # Skip printing here since real streaming is handled in call_llm
-                # This avoids double printing when streaming_on=True
-                pass
-            elif self.print_on is False:
-                pass
-            else:
-                # logger.info(f"Response: {response}")
-                formatter.print_panel(
-                    f"{self.agent_name}: {response}",
-                    f"Agent Name {self.agent_name} [Max Loops: {loop_count} ]",
-                )
+        # if self.print_on is False:
+        #     if self.streaming_on is True:
+        #         # Skip printing here since real streaming is handled in call_llm
+        #         # This avoids double printing when streaming_on=True
+        #         pass
+        #     elif self.print_on is False:
+        #         pass
+        #     else:
+        #         # logger.info(f"Response: {response}")
+        #         formatter.print_panel(
+        #             response,
+        #             f"Agent Name {self.agent_name} [Max Loops: {loop_count} ]",
+        #         )
+        formatter.print_panel(
+            response,
+            f"Agent Name {self.agent_name} [Max Loops: {loop_count} ]",
+        )
 
     def parse_llm_output(self, response: Any):
         """Parse and standardize the output from the LLM.
@@ -2915,10 +2953,10 @@ class Agent:
             # execute_tool_call_simple returns a string directly, not an object with content attribute
             text_content = f"MCP Tool Response: \n\n {json.dumps(tool_response, indent=2)}"
 
-            if self.print_on is False:
+            if self.print_on is True:
                 formatter.print_panel(
-                    text_content,
-                    "MCP Tool Response: 🛠️",
+                    content=text_content,
+                    title="MCP Tool Response: 🛠️",
                     style="green",
                 )
 
@@ -2942,7 +2980,8 @@ class Agent:
                 # Fallback: provide a default summary
                 summary = "I successfully executed the MCP tool and retrieved the information above."
 
-            self.pretty_print(summary, loop_count=current_loop)
+            if self.print_on is True:
+                self.pretty_print(summary, loop_count=current_loop)
 
             # Add to the memory
             self.short_memory.add(
@@ -2974,21 +3013,30 @@ class Agent:
             )
             return
 
-        output = (
-            self.tool_struct.execute_function_calls_from_api_response(
+        try:
+            output = self.tool_struct.execute_function_calls_from_api_response(
                 response
             )
-        )
+        except Exception as e:
+            # Retry the tool call
+            output = self.tool_struct.execute_function_calls_from_api_response(
+                response
+            )
+
+            if output is None:
+                logger.error(f"Error executing tools: {e}")
+                raise e
 
         self.short_memory.add(
             role="Tool Executor",
             content=format_data_structure(output),
         )
 
-        self.pretty_print(
-            f"{format_data_structure(output)}",
-            loop_count,
-        )
+        if self.print_on is True:
+            self.pretty_print(
+                f"Tool Executed Successfully [{time.strftime('%H:%M:%S')}]",
+                loop_count,
+            )
 
         # Now run the LLM again without tools - create a temporary LLM instance
         # instead of modifying the cached one
@@ -3012,10 +3060,11 @@ class Agent:
                 content=tool_response,
             )
 
-            self.pretty_print(
-                f"{tool_response}",
-                loop_count,
-            )
+            if self.print_on is True:
+                self.pretty_print(
+                    tool_response,
+                    loop_count,
+                )
 
     def list_output_types(self):
         return OutputType
@@ -3150,3 +3199,53 @@ class Agent:
         raise Exception(
             f"Failed to find correct answer '{correct_answer}' after {max_attempts} attempts"
         )
+
+    def tool_execution_retry(self, response: any, loop_count: int):
+        """
+        Execute tools with retry logic for handling failures.
+
+        This method attempts to execute tools based on the LLM response. If the response
+        is None, it logs a warning and skips execution. If an exception occurs during
+        tool execution, it logs the error with full traceback and retries the operation
+        using the configured retry attempts.
+
+        Args:
+            response (any): The response from the LLM that may contain tool calls to execute.
+                          Can be None if the LLM failed to provide a valid response.
+            loop_count (int): The current iteration loop number for logging and debugging purposes.
+
+        Returns:
+            None
+
+        Raises:
+            Exception: Re-raises any exception that occurs during tool execution after
+                      all retry attempts have been exhausted.
+
+        Note:
+            - Uses self.tool_retry_attempts for the maximum number of retry attempts
+            - Logs detailed error information including agent name and loop count
+            - Skips execution gracefully if response is None
+        """
+        try:
+            if response is not None:
+                self.execute_tools(
+                    response=response,
+                    loop_count=loop_count,
+                )
+            else:
+                logger.warning(
+                    f"Agent '{self.agent_name}' received None response from LLM in loop {loop_count}. "
+                    f"This may indicate an issue with the model or prompt. Skipping tool execution."
+                )
+        except Exception as e:
+            logger.error(
+                f"Agent '{self.agent_name}' encountered error during tool execution in loop {loop_count}: {str(e)}. "
+                f"Full traceback: {traceback.format_exc()}. "
+                f"Attempting to retry tool execution with 3 attempts"
+            )
+            retry_function(
+                self.execute_tools,
+                response=response,
+                loop_count=loop_count,
+                max_retries=self.tool_retry_attempts,
+            )

swarms/structs/conversation.py

@@ -221,27 +221,6 @@ class Conversation(BaseStructure):
     ):
         super().__init__()
 
-        # Support both 'provider' and 'backend' parameters for backwards compatibility
-        # 'backend' takes precedence if both are provided
-        self.backend = backend or provider
-        self.backend_instance = None
-
-        # Validate backend
-        valid_backends = [
-            "in-memory",
-            "mem0",
-            "supabase",
-            "redis",
-            "sqlite",
-            "duckdb",
-            "pulsar",
-        ]
-        if self.backend not in valid_backends:
-            raise ValueError(
-                f"Invalid backend: '{self.backend}'. "
-                f"Valid backends are: {', '.join(valid_backends)}"
-            )
-
         # Initialize all attributes first
         self.id = id
         self.name = name or id
@@ -275,6 +254,27 @@ class Conversation(BaseStructure):
         self.provider = provider  # Keep for backwards compatibility
         self.conversations_dir = conversations_dir
 
+        #  Support both 'provider' and 'backend' parameters for backwards compatibility
+        # 'backend' takes precedence if both are provided
+        self.backend = backend or provider
+        self.backend_instance = None
+
+        # Validate backend
+        valid_backends = [
+            "in-memory",
+            "mem0",
+            "supabase",
+            "redis",
+            "sqlite",
+            "duckdb",
+            "pulsar",
+        ]
+        if self.backend not in valid_backends:
+            raise ValueError(
+                f"Invalid backend: '{self.backend}'. "
+                f"Valid backends are: {', '.join(valid_backends)}"
+            )
+
         # Initialize backend if using persistent storage
         if self.backend in [
             "supabase",
@@ -484,8 +484,7 @@ class Conversation(BaseStructure):
         self,
         role: str,
         content: Union[str, dict, list, Any],
-        *args,
-        **kwargs,
+        category: Optional[str] = None,
     ):
         """Add a message to the conversation history.
 
@@ -505,6 +504,9 @@ class Conversation(BaseStructure):
         if self.message_id_on:
             message["message_id"] = str(uuid.uuid4())
 
+        if category:
+            message["category"] = category
+
         # Add message to conversation history
         self.conversation_history.append(message)
 
@@ -520,6 +522,79 @@ class Conversation(BaseStructure):
                     f"Failed to autosave conversation: {str(e)}"
                 )
 
+    def export_and_count_categories(
+        self, tokenizer_model_name: Optional[str] = "gpt-4.1-mini"
+    ) -> Dict[str, int]:
+        """Export all messages with category 'input' and 'output' and count their tokens.
+
+        This method searches through the conversation history and:
+        1. Extracts all messages marked with category 'input' or 'output'
+        2. Concatenates the content of each category
+        3. Counts tokens for each category using the specified tokenizer model
+
+        Args:
+            tokenizer_model_name (str): Name of the model to use for tokenization
+
+        Returns:
+            Dict[str, int]: A dictionary containing:
+                - input_tokens: Number of tokens in input messages
+                - output_tokens: Number of tokens in output messages
+                - total_tokens: Total tokens across both categories
+        """
+        try:
+            # Extract input and output messages
+            input_messages = []
+            output_messages = []
+
+            for message in self.conversation_history:
+                # Get message content and ensure it's a string
+                content = message.get("content", "")
+                if not isinstance(content, str):
+                    content = str(content)
+
+                # Sort messages by category
+                category = message.get("category", "")
+                if category == "input":
+                    input_messages.append(content)
+                elif category == "output":
+                    output_messages.append(content)
+
+            # Join messages with spaces
+            all_input_text = " ".join(input_messages)
+            all_output_text = " ".join(output_messages)
+
+            print(all_input_text)
+            print(all_output_text)
+
+            # Count tokens only if there is text
+            input_tokens = (
+                count_tokens(all_input_text, tokenizer_model_name)
+                if all_input_text.strip()
+                else 0
+            )
+            output_tokens = (
+                count_tokens(all_output_text, tokenizer_model_name)
+                if all_output_text.strip()
+                else 0
+            )
+            total_tokens = input_tokens + output_tokens
+
+            return {
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "total_tokens": total_tokens,
+            }
+
+        except Exception as e:
+            logger.error(
+                f"Error in export_and_count_categories: {str(e)}"
+            )
+            return {
+                "input_tokens": 0,
+                "output_tokens": 0,
+                "total_tokens": 0,
+            }
+
     def add_mem0(
         self,
         role: str,
@@ -546,8 +621,9 @@ class Conversation(BaseStructure):
     def add(
         self,
         role: str,
-        content: Union[str, dict, list],
+        content: Union[str, dict, list, Any],
         metadata: Optional[dict] = None,
+        category: Optional[str] = None,
     ):
         """Add a message to the conversation history."""
         # If using a persistent backend, delegate to it
@@ -562,7 +638,9 @@ class Conversation(BaseStructure):
                 )
                 return self.add_in_memory(role, content)
         elif self.provider == "in-memory":
-            return self.add_in_memory(role, content)
+            return self.add_in_memory(
+                role=role, content=content, category=category
+            )
         elif self.provider == "mem0":
             return self.add_mem0(
                 role=role, content=content, metadata=metadata