swarms 7.9.7__py3-none-any.whl → 7.9.8__py3-none-any.whl

swarms/structs/agent.py

@@ -575,8 +575,6 @@ class Agent:
         self.tool_retry_attempts = tool_retry_attempts
         self.speed_mode = speed_mode
 
-        # self.short_memory = self.short_memory_init()
-
         # Initialize the feedback
         self.feedback = []
 
@@ -827,12 +825,9 @@ class Agent:
         if self.preset_stopping_token is not None:
             self.stopping_token = "<DONE>"
 
-    def prepare_tools_list_dictionary(self):
-        import json
-
-        return json.loads(self.tools_list_dictionary)
-
-    def check_model_supports_utilities(self, img: str = None) -> bool:
+    def check_model_supports_utilities(
+        self, img: Optional[str] = None
+    ) -> bool:
         """
         Check if the current model supports vision capabilities.
 
@@ -842,18 +837,43 @@ class Agent:
         Returns:
             bool: True if model supports vision and image is provided, False otherwise.
         """
-        from litellm.utils import supports_vision
+        from litellm.utils import (
+            supports_vision,
+            supports_function_calling,
+            supports_parallel_function_calling,
+        )
 
         # Only check vision support if an image is provided
         if img is not None:
             out = supports_vision(self.model_name)
-            if not out:
-                raise ValueError(
-                    f"Model {self.model_name} does not support vision capabilities. Please use a vision-enabled model."
+            if out is False:
+                logger.error(
+                    f"[Agent: {self.agent_name}] Model '{self.model_name}' does not support vision capabilities. "
+                    f"Image input was provided: {img[:100]}{'...' if len(img) > 100 else ''}. "
+                    f"Please use a vision-enabled model."
+                )
+
+        if self.tools_list_dictionary is not None:
+            out = supports_function_calling(self.model_name)
+            if out is False:
+                logger.error(
+                    f"[Agent: {self.agent_name}] Model '{self.model_name}' does not support function calling capabilities. "
+                    f"tools_list_dictionary is set: {self.tools_list_dictionary}. "
+                    f"Please use a function calling-enabled model."
+                )
+
+        if self.tools is not None:
+            if len(self.tools) > 2:
+                out = supports_parallel_function_calling(
+                    self.model_name
                 )
-            return out
+                if out is False:
+                    logger.error(
+                        f"[Agent: {self.agent_name}] Model '{self.model_name}' does not support parallel function calling capabilities. "
+                        f"Please use a parallel function calling-enabled model."
+                    )
 
-        return False
+        return None
 
     def check_if_no_prompt_then_autogenerate(self, task: str = None):
         """
@@ -976,7 +996,6 @@ class Agent:
         self,
         task: Optional[Union[str, Any]] = None,
         img: Optional[str] = None,
-        print_task: Optional[bool] = False,
         *args,
         **kwargs,
     ) -> Any:
@@ -1001,8 +1020,7 @@ class Agent:
 
             self.check_if_no_prompt_then_autogenerate(task)
 
-            if img is not None:
-                self.check_model_supports_utilities(img=img)
+            self.check_model_supports_utilities(img=img)
 
             self.short_memory.add(role=self.user_name, content=task)
 
@@ -1015,22 +1033,11 @@ class Agent:
             # Clear the short memory
             response = None
 
-            # Query the long term memory first for the context
-            if self.long_term_memory is not None:
-                self.memory_query(task)
-
             # Autosave
             if self.autosave:
                 log_agent_data(self.to_dict())
                 self.save()
 
-            # Print the request
-            if print_task is True:
-                formatter.print_panel(
-                    content=f"\n User: {task}",
-                    title=f"Task Request for {self.agent_name}",
-                )
-
             while (
                 self.max_loops == "auto"
                 or loop_count < self.max_loops
@@ -1064,14 +1071,6 @@ class Agent:
                 success = False
                 while attempt < self.retry_attempts and not success:
                     try:
-                        if (
-                            self.long_term_memory is not None
-                            and self.rag_every_loop is True
-                        ):
-                            logger.info(
-                                "Querying RAG database for context..."
-                            )
-                            self.memory_query(task_prompt)
 
                         if img is not None:
                             response = self.call_llm(
@@ -1108,11 +1107,9 @@ class Agent:
                         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)} ",
+                                    f"Structured Output - Attempting Function Call Execution [{time.strftime('%H:%M:%S')}] \n\n Output: {format_data_structure(response)} ",
                                     loop_count,
                                 )
-                            elif self.streaming_on is True:
-                                pass
                             else:
                                 self.pretty_print(
                                     response, loop_count
@@ -1141,7 +1138,7 @@ class Agent:
                                     f"LLM returned None response in loop {loop_count}, skipping MCP tool handling"
                                 )
 
-                        self.sentiment_and_evaluator(response)
+                        # self.sentiment_and_evaluator(response)
 
                         success = True  # Mark as successful to exit the retry loop
 
@@ -1158,7 +1155,6 @@ class Agent:
 
                 if not success:
 
-
                     if self.autosave is True:
                         log_agent_data(self.to_dict())
                         self.save()
@@ -1219,191 +1215,6 @@ class Agent:
 
                 self.save()
 
-
-            # Output formatting based on output_type
-            return history_output_formatter(
-                self.short_memory, type=self.output_type
-            )
-
-        except Exception as error:
-            self._handle_run_error(error)
-
-        except KeyboardInterrupt as error:
-            self._handle_run_error(error)
-
-    def _run_fast(
-        self,
-        task: Optional[Union[str, Any]] = None,
-        img: Optional[str] = None,
-        print_task: Optional[bool] = False,
-        *args,
-        **kwargs,
-    ) -> Any:
-        """
-        run the agent
-
-        Args:
-            task (str): The task to be performed.
-            img (str): The image to be processed.
-            is_last (bool): Indicates if this is the last task.
-
-        Returns:
-            Any: The output of the agent.
-            (string, list, json, dict, yaml, xml)
-
-        Examples:
-            agent(task="What is the capital of France?")
-            agent(task="What is the capital of France?", img="path/to/image.jpg")
-            agent(task="What is the capital of France?", img="path/to/image.jpg", is_last=True)
-        """
-        try:
-
-            self.short_memory.add(role=self.user_name, content=task)
-
-            # Set the loop count
-            loop_count = 0
-
-            # Clear the short memory
-            response = None
-
-            # Query the long term memory first for the context
-            if self.long_term_memory is not None:
-                self.memory_query(task)
-
-            # Print the request
-            if print_task is True:
-                formatter.print_panel(
-                    content=f"\n User: {task}",
-                    title=f"Task Request for {self.agent_name}",
-                )
-
-            while (
-                self.max_loops == "auto"
-                or loop_count < self.max_loops
-            ):
-                loop_count += 1
-
-                if self.max_loops >= 2:
-                    self.short_memory.add(
-                        role=self.agent_name,
-                        content=f"Current Internal Reasoning Loop: {loop_count}/{self.max_loops}",
-                    )
-
-                # If it is the final loop, then add the final loop message
-                if loop_count >= 2 and loop_count == self.max_loops:
-                    self.short_memory.add(
-                        role=self.agent_name,
-                        content=f"🎉 Final Internal Reasoning Loop: {loop_count}/{self.max_loops} Prepare your comprehensive response.",
-                    )
-
-                # Dynamic temperature
-                if self.dynamic_temperature_enabled is True:
-                    self.dynamic_temperature()
-
-                # Task prompt
-                task_prompt = (
-                    self.short_memory.return_history_as_string()
-                )
-
-                # Parameters
-                attempt = 0
-                success = False
-                while attempt < self.retry_attempts and not success:
-                    try:
-                        if (
-                            self.long_term_memory is not None
-                            and self.rag_every_loop is True
-                        ):
-                            logger.info(
-                                "Querying RAG database for context..."
-                            )
-                            self.memory_query(task_prompt)
-
-                        if img is not None:
-                            response = self.call_llm(
-                                task=task_prompt,
-                                img=img,
-                                current_loop=loop_count,
-                                *args,
-                                **kwargs,
-                            )
-                        else:
-                            response = self.call_llm(
-                                task=task_prompt,
-                                current_loop=loop_count,
-                                *args,
-                                **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):
-                                response = response.model_dump()
-
-                        # Parse the response from the agent with the output type
-                        response = self.parse_llm_output(response)
-
-                        self.short_memory.add(
-                            role=self.agent_name,
-                            content=response,
-                        )
-
-                        # Print
-                        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,
-                                )
-                            else:
-                                self.pretty_print(
-                                    response, loop_count
-                                )
-
-                        # Check and execute callable tools
-                        if exists(self.tools):
-                            self.tool_execution_retry(
-                                response, loop_count
-                            )
-
-                        # Handle MCP tools
-                        if (
-                            exists(self.mcp_url)
-                            or exists(self.mcp_config)
-                            or exists(self.mcp_urls)
-                        ):
-                            # Only handle MCP tools if response is not None
-                            if response is not None:
-                                self.mcp_tool_handling(
-                                    response=response,
-                                    current_loop=loop_count,
-                                )
-                            else:
-                                logger.warning(
-                                    f"LLM returned None response in loop {loop_count}, skipping MCP tool handling"
-                                )
-
-                        success = True  # Mark as successful to exit the retry loop
-
-                    except Exception as e:
-
-                        logger.error(
-                            f"Attempt {attempt+1}/{self.retry_attempts}: Error generating response in loop {loop_count} for agent '{self.agent_name}': {str(e)} | "
-                        )
-                        attempt += 1
-
-                if not success:
-
-                    logger.error(
-                        "Failed to generate a valid response after"
-                        " retry attempts."
-                    )
-                    break  # Exit the loop if all retry attempts fail
-
-            # log_agent_data(self.to_dict())
-
             # Output formatting based on output_type
             return history_output_formatter(
                 self.short_memory, type=self.output_type
@@ -1439,12 +1250,9 @@ class Agent:
         raise error
 
     def _handle_run_error(self, error: any):
-        process_thread = threading.Thread(
-            target=self.__handle_run_error,
-            args=(error,),
-            daemon=True,
-        )
-        process_thread.start()
+        # Handle error directly instead of using daemon thread
+        # to ensure proper exception propagation
+        self.__handle_run_error(error)
 
     async def arun(
         self,
@@ -2118,9 +1926,9 @@ class Agent:
 
         """
         logger.info(f"Adding response filter: {filter_word}")
-        self.reponse_filters.append(filter_word)
+        self.response_filters.append(filter_word)
 
-    def apply_reponse_filters(self, response: str) -> str:
+    def apply_response_filters(self, response: str) -> str:
         """
         Apply the response filters to the response
 
@@ -2195,11 +2003,17 @@ class Agent:
             None
         """
         try:
+            # Process all documents and combine their content
+            all_data = []
             for doc in docs:
                 data = data_to_text(doc)
+                all_data.append(f"Document: {doc}\n{data}")
+
+            # Combine all document content
+            combined_data = "\n\n".join(all_data)
 
             return self.short_memory.add(
-                role=self.user_name, content=data
+                role=self.user_name, content=combined_data
             )
         except Exception as error:
             logger.info(f"Error ingesting docs: {error}", "red")
@@ -3417,3 +3231,13 @@ class Agent:
                 f"Full traceback: {traceback.format_exc()}. "
                 f"Attempting to retry tool execution with 3 attempts"
             )
+
+    def add_tool_schema(self, tool_schema: dict):
+        self.tools_list_dictionary = [tool_schema]
+
+        self.output_type = "dict-all-except-first"
+
+    def add_multiple_tool_schemas(self, tool_schemas: list[dict]):
+        self.tools_list_dictionary = tool_schemas
+
+        self.output_type = "dict-all-except-first"

swarms/structs/conversation.py

@@ -6,7 +6,6 @@ import threading
 import uuid
 from typing import (
     TYPE_CHECKING,
-    Callable,
     Dict,
     List,
     Optional,
@@ -190,18 +189,16 @@ class Conversation(BaseStructure):
         save_enabled: bool = False,  # New parameter to control if saving is enabled
         save_filepath: str = None,
         load_filepath: str = None,  # New parameter to specify which file to load from
-        tokenizer: Callable = None,
         context_length: int = 8192,
         rules: str = None,
         custom_rules_prompt: str = None,
-        user: str = "User:",
+        user: str = "User",
         save_as_yaml: bool = False,
         save_as_json_bool: bool = False,
-        token_count: bool = True,
+        token_count: bool = False,
         message_id_on: bool = False,
         provider: providers = "in-memory",
         backend: Optional[str] = None,
-        # Backend-specific parameters
         supabase_url: Optional[str] = None,
         supabase_key: Optional[str] = None,
         redis_host: str = "localhost",
@@ -210,7 +207,6 @@ class Conversation(BaseStructure):
         redis_password: Optional[str] = None,
         db_path: Optional[str] = None,
         table_name: str = "conversations",
-        # Additional backend parameters
         use_embedded_redis: bool = True,
         persist_redis: bool = True,
         auto_persist: bool = True,
@@ -230,20 +226,7 @@ class Conversation(BaseStructure):
         self.save_enabled = save_enabled
         self.conversations_dir = conversations_dir
         self.message_id_on = message_id_on
-
-        # Handle save filepath
-        if save_enabled and save_filepath:
-            self.save_filepath = save_filepath
-        elif save_enabled and conversations_dir:
-            self.save_filepath = os.path.join(
-                conversations_dir, f"{self.id}.json"
-            )
-        else:
-            self.save_filepath = None
-
         self.load_filepath = load_filepath
-        self.conversation_history = []
-        self.tokenizer = tokenizer
         self.context_length = context_length
         self.rules = rules
         self.custom_rules_prompt = custom_rules_prompt
@@ -253,9 +236,40 @@ class Conversation(BaseStructure):
         self.token_count = token_count
         self.provider = provider  # Keep for backwards compatibility
         self.conversations_dir = conversations_dir
+        self.backend = backend
+        self.supabase_url = supabase_url
+        self.supabase_key = supabase_key
+        self.redis_host = redis_host
+        self.redis_port = redis_port
+        self.redis_db = redis_db
+        self.redis_password = redis_password
+        self.db_path = db_path
+        self.table_name = table_name
+        self.use_embedded_redis = use_embedded_redis
+        self.persist_redis = persist_redis
+        self.auto_persist = auto_persist
+        self.redis_data_dir = redis_data_dir
+
+        self.conversation_history = []
+
+        # Handle save filepath
+        if save_enabled and save_filepath:
+            self.save_filepath = save_filepath
+        elif save_enabled and conversations_dir:
+            self.save_filepath = os.path.join(
+                conversations_dir, f"{self.id}.json"
+            )
+        else:
+            self.save_filepath = None
 
         #  Support both 'provider' and 'backend' parameters for backwards compatibility
         # 'backend' takes precedence if both are provided
+
+        self.backend_setup(backend, provider)
+
+    def backend_setup(
+        self, backend: str = None, provider: str = None
+    ):
         self.backend = backend or provider
         self.backend_instance = None
 
@@ -285,19 +299,18 @@ class Conversation(BaseStructure):
         ]:
             try:
                 self._initialize_backend(
-                    supabase_url=supabase_url,
-                    supabase_key=supabase_key,
-                    redis_host=redis_host,
-                    redis_port=redis_port,
-                    redis_db=redis_db,
-                    redis_password=redis_password,
-                    db_path=db_path,
-                    table_name=table_name,
-                    use_embedded_redis=use_embedded_redis,
-                    persist_redis=persist_redis,
-                    auto_persist=auto_persist,
-                    redis_data_dir=redis_data_dir,
-                    **kwargs,
+                    supabase_url=self.supabase_url,
+                    supabase_key=self.supabase_key,
+                    redis_host=self.redis_host,
+                    redis_port=self.redis_port,
+                    redis_db=self.redis_db,
+                    redis_password=self.redis_password,
+                    db_path=self.db_path,
+                    table_name=self.table_name,
+                    use_embedded_redis=self.use_embedded_redis,
+                    persist_redis=self.persist_redis,
+                    auto_persist=self.auto_persist,
+                    redis_data_dir=self.redis_data_dir,
                 )
             except Exception as e:
                 logger.warning(
@@ -324,7 +337,6 @@ class Conversation(BaseStructure):
             "time_enabled": self.time_enabled,
             "autosave": self.autosave,
             "save_filepath": self.save_filepath,
-            "tokenizer": self.tokenizer,
             "context_length": self.context_length,
             "rules": self.rules,
             "custom_rules_prompt": self.custom_rules_prompt,
@@ -449,8 +461,8 @@ class Conversation(BaseStructure):
         if self.custom_rules_prompt is not None:
             self.add(self.user or "User", self.custom_rules_prompt)
 
-        if self.tokenizer is not None:
-            self.truncate_memory_with_tokenizer()
+        # if self.tokenizer is not None:
+        #     self.truncate_memory_with_tokenizer()
 
     def _autosave(self):
         """Automatically save the conversation if autosave is enabled."""
@@ -1051,9 +1063,7 @@ class Conversation(BaseStructure):
         for message in self.conversation_history:
             role = message.get("role")
             content = message.get("content")
-            tokens = self.tokenizer.count_tokens(
-                text=content
-            )  # Count the number of tokens
+            tokens = count_tokens(content)
             count = tokens  # Assign the token count
             total_tokens += count