swarms 7.8.4__py3-none-any.whl → 7.8.7__py3-none-any.whl

swarms/structs/swarm_router.py

@@ -20,11 +20,13 @@ from swarms.structs.rearrange import AgentRearrange
 from swarms.structs.sequential_workflow import SequentialWorkflow
 from swarms.structs.spreadsheet_swarm import SpreadSheetSwarm
 from swarms.structs.swarm_matcher import swarm_matcher
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 from swarms.utils.loguru_logger import initialize_logger
 from swarms.structs.malt import MALT
 from swarms.structs.deep_research_swarm import DeepResearchSwarm
 from swarms.structs.council_judge import CouncilAsAJudge
+from swarms.structs.interactive_groupchat import InteractiveGroupChat
+
 
 logger = initialize_logger(log_folder="swarm_router")
 
@@ -43,6 +45,7 @@ SwarmType = Literal[
     "MALT",
     "DeepResearchSwarm",
     "CouncilAsAJudge",
+    "InteractiveGroupChat",
 ]
 
 
@@ -187,7 +190,7 @@ class SwarmRouter:
         shared_memory_system: Any = None,
         rules: str = None,
         documents: List[str] = [],  # A list of docs file paths
-        output_type: OutputType = "dict",
+        output_type: OutputType = "dict-all-except-first",
         no_cluster_ops: bool = False,
         speaker_fn: callable = None,
         load_agents_from_csv: bool = False,
@@ -332,19 +335,7 @@ class SwarmRouter:
         )
         logger.info("🚀 [SYSTEM] Swarm is ready for deployment")
 
-    def _create_swarm(
-        self, task: str = None, *args, **kwargs
-    ) -> Union[
-        AgentRearrange,
-        MixtureOfAgents,
-        SpreadSheetSwarm,
-        SequentialWorkflow,
-        ConcurrentWorkflow,
-        GroupChat,
-        MultiAgentRouter,
-        MajorityVoting,
-        HierarchicalSwarm,
-    ]:
+    def _create_swarm(self, task: str = None, *args, **kwargs):
         """
         Dynamically create and return the specified swarm type or automatically match the best swarm type for a given task.
 
@@ -397,6 +388,15 @@ class SwarmRouter:
                 base_agent=self.agents[0] if self.agents else None,
             )
 
+        elif self.swarm_type == "InteractiveGroupChat":
+            return InteractiveGroupChat(
+                name=self.name,
+                description=self.description,
+                agents=self.agents,
+                max_loops=self.max_loops,
+                output_type=self.output_type,
+            )
+
         elif self.swarm_type == "DeepResearchSwarm":
             return DeepResearchSwarm(
                 name=self.name,
@@ -778,85 +778,3 @@ class SwarmRouter:
                     results.append(None)
 
         return results
-
-
-def swarm_router(
-    name: str = "swarm-router",
-    description: str = "Routes your task to the desired swarm",
-    max_loops: int = 1,
-    agents: List[Union[Agent, Callable]] = [],
-    swarm_type: SwarmType = "SequentialWorkflow",  # "SpreadSheetSwarm" # "auto"
-    autosave: bool = False,
-    flow: str = None,
-    return_json: bool = True,
-    auto_generate_prompts: bool = False,
-    task: str = None,
-    rules: str = None,
-    *args,
-    **kwargs,
-) -> SwarmRouter:
-    """
-    Create and run a SwarmRouter instance with the given configuration.
-
-    Args:
-        name (str, optional): Name of the swarm router. Defaults to "swarm-router".
-        description (str, optional): Description of the router. Defaults to "Routes your task to the desired swarm".
-        max_loops (int, optional): Maximum number of execution loops. Defaults to 1.
-        agents (List[Union[Agent, Callable]], optional): List of agents or callables. Defaults to [].
-        swarm_type (SwarmType, optional): Type of swarm to use. Defaults to "SequentialWorkflow".
-        autosave (bool, optional): Whether to autosave results. Defaults to False.
-        flow (str, optional): Flow configuration. Defaults to None.
-        return_json (bool, optional): Whether to return results as JSON. Defaults to True.
-        auto_generate_prompts (bool, optional): Whether to auto-generate prompts. Defaults to False.
-        task (str, optional): Task to execute. Defaults to None.
-        *args: Additional positional arguments passed to SwarmRouter.run()
-        **kwargs: Additional keyword arguments passed to SwarmRouter.run()
-
-    Returns:
-        Any: Result from executing the swarm router
-
-    Raises:
-        ValueError: If invalid arguments are provided
-        Exception: If an error occurs during router creation or task execution
-    """
-    try:
-        logger.info(
-            f"Creating SwarmRouter with name: {name}, swarm_type: {swarm_type}"
-        )
-
-        if not agents:
-            logger.warning(
-                "No agents provided, router may have limited functionality"
-            )
-
-        if task is None:
-            logger.warning("No task provided")
-
-        swarm_router = SwarmRouter(
-            name=name,
-            description=description,
-            max_loops=max_loops,
-            agents=agents,
-            swarm_type=swarm_type,
-            autosave=autosave,
-            flow=flow,
-            return_json=return_json,
-            auto_generate_prompts=auto_generate_prompts,
-            rules=rules,
-        )
-
-        logger.info(f"Executing task with SwarmRouter: {task}")
-        result = swarm_router.run(task, *args, **kwargs)
-        logger.info(
-            f"Task execution completed successfully: {result}"
-        )
-        return result
-
-    except ValueError as e:
-        logger.error(
-            f"Invalid arguments provided to swarm_router: {str(e)}"
-        )
-        raise
-    except Exception as e:
-        logger.error(f"Error in swarm_router execution: {str(e)}")
-        raise

swarms/structs/swarming_architectures.py

@@ -9,7 +9,7 @@ from swarms.structs.conversation import Conversation
 from swarms.utils.history_output_formatter import (
     history_output_formatter,
 )
-from swarms.structs.output_types import OutputType
+from swarms.utils.output_types import OutputType
 
 logger = initialize_logger(log_folder="swarming_architectures")
 

swarms/tools/mcp_client_call.py

@@ -494,6 +494,9 @@ async def execute_tool_call_simple(
     *args,
     **kwargs,
 ) -> List[Dict[str, Any]]:
+    if isinstance(response, str):
+        response = json.loads(response)
+
     return await _execute_tool_call_simple(
         response=response,
         server_path=server_path,

swarms/utils/__init__.py

@@ -11,12 +11,18 @@ from swarms.utils.file_processing import (
     create_file_in_folder,
     zip_folders,
 )
-from swarms.utils.markdown_message import display_markdown_message
 from swarms.utils.parse_code import extract_code_from_markdown
 from swarms.utils.pdf_to_text import pdf_to_text
 from swarms.utils.try_except_wrapper import try_except_wrapper
 from swarms.utils.calculate_func_metrics import profile_func
 from swarms.utils.litellm_tokenizer import count_tokens
+from swarms.utils.output_types import HistoryOutputType
+from swarms.utils.history_output_formatter import (
+    history_output_formatter,
+)
+from swarms.utils.check_all_model_max_tokens import (
+    check_all_model_max_tokens,
+)
 
 
 __all__ = [
@@ -29,10 +35,12 @@ __all__ = [
     "zip_workspace",
     "create_file_in_folder",
     "zip_folders",
-    "display_markdown_message",
     "extract_code_from_markdown",
     "pdf_to_text",
     "try_except_wrapper",
     "profile_func",
     "count_tokens",
+    "HistoryOutputType",
+    "history_output_formatter",
+    "check_all_model_max_tokens",
 ]

swarms/utils/check_all_model_max_tokens.py

@@ -0,0 +1,43 @@
+from litellm import model_list, get_max_tokens
+from swarms.utils.formatter import formatter
+
+# Add model overrides here
+MODEL_MAX_TOKEN_OVERRIDES = {
+    "llama-2-70b-chat:2796ee9483c3fd7aa2e171d38f4ca12251a30609463dcfd4cd76703f22e96cdf": 4096,  # Example override
+}
+
+
+def check_all_model_max_tokens():
+    """
+    Check and display the maximum token limits for all available models.
+
+    This function iterates through all models in the litellm model list and attempts
+    to retrieve their maximum token limits. For models that are not properly mapped
+    in litellm, it checks for custom overrides in MODEL_MAX_TOKEN_OVERRIDES.
+
+    Returns:
+        None: Prints the results to console using formatter.print_panel()
+
+    Note:
+        Models that are not mapped in litellm and have no override set will be
+        marked with a [WARNING] in the output.
+    """
+    text = ""
+    for model in model_list:
+        # skip model names
+        try:
+            max_tokens = get_max_tokens(model)
+        except Exception:
+            max_tokens = MODEL_MAX_TOKEN_OVERRIDES.get(
+                model, "[NOT MAPPED]"
+            )
+            if max_tokens == "[NOT MAPPED]":
+                text += f"[WARNING] {model}: not mapped in litellm and no override set.\n"
+        text += f"{model}: {max_tokens}\n"
+        text += "─" * 80 + "\n"  # Add borderline for each model
+    formatter.print_panel(text, "All Model Max Tokens")
+    return text
+
+
+# if __name__ == "__main__":
+#     print(check_all_model_max_tokens())

swarms/utils/generate_keys.py

@@ -1,6 +1,5 @@
 import secrets
 import string
-import re
 
 
 def generate_api_key(prefix: str = "sk-", length: int = 32) -> str:
@@ -36,29 +35,3 @@ def generate_api_key(prefix: str = "sk-", length: int = 32) -> str:
     api_key = f"{prefix}{random_part}"
 
     return api_key
-
-
-def validate_api_key(api_key: str, prefix: str = "sk-") -> bool:
-    """
-    Validate if an API key matches the expected format.
-
-    Args:
-        api_key (str): The API key to validate
-        prefix (str): The expected prefix (default: "sk-")
-
-    Returns:
-        bool: True if the API key is valid, False otherwise
-    """
-    if not isinstance(api_key, str):
-        return False
-
-    # Check if key starts with prefix
-    if not api_key.startswith(prefix):
-        return False
-
-    # Check if the rest of the key contains only alphanumeric characters
-    random_part = api_key[len(prefix) :]
-    if not re.match(r"^[a-zA-Z0-9]+$", random_part):
-        return False
-
-    return True

swarms/utils/history_output_formatter.py

@@ -1,28 +1,11 @@
 import yaml
-from swarms.structs.conversation import Conversation
-from typing import Literal, Union, List, Dict, Any
+from typing import Union, List, Dict, Any
 from swarms.utils.xml_utils import to_xml_string
-
-HistoryOutputType = Literal[
-    "list",
-    "dict",
-    "dictionary",
-    "string",
-    "str",
-    "final",
-    "last",
-    "json",
-    "all",
-    "yaml",
-    "xml",
-    # "dict-final",
-    "dict-all-except-first",
-    "str-all-except-first",
-]
+from swarms.utils.output_types import HistoryOutputType
 
 
 def history_output_formatter(
-    conversation: Conversation, type: HistoryOutputType = "list"
+    conversation: callable, type: HistoryOutputType = "list"
 ) -> Union[List[Dict[str, Any]], Dict[str, Any], str]:
     if type == "list":
         return conversation.return_messages_as_list()
@@ -42,6 +25,8 @@ def history_output_formatter(
         return conversation.return_all_except_first()
     elif type == "str-all-except-first":
         return conversation.return_all_except_first_string()
+    elif type == "dict-final":
+        return conversation.return_dict_final()
     elif type == "xml":
         data = conversation.to_dict()
         return to_xml_string(data, root_tag="conversation")