swarmai 1.0.0__tar.gz

swarmai-1.0.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: swarmai
+Version: 1.0.0
+Summary: A highly flexible multi-agent ReAct framework powered by Google Gemini
+Author-email: ProgVM <progvminc@gmail.com>
+Project-URL: Homepage, https://github.com/ProgVM
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: google-genai
+Requires-Dist: duckduckgo-search
+
+# 🐝 Swarm
+
+**Swarm** is an advanced, open-source multi-agent intelligence framework designed for autonomous collaboration. Powered by Google's **Gemini 3.1 Flash Lite**, Swarm allows multiple agents to interact, use tools, execute code, and perform web searches in a shared environment.
+
+## 🚀 Key Features
+
+- **N-Agent Collaboration**: Run any number of agents in a single session.
+- **Autonomous Tool Usage**: Agents can perform Google searches and execute Shell commands.
+- **Agent Sandboxing**: Per-agent blacklists for terminal commands and file paths.
+- **Turn Management**: Agents can autonomously pass turns to specific peers using `pass_turn`.
+- **ReAct Loop**: High-level reasoning before acting, supporting multi-step tool execution.
+- **Files API Support**: Agents can upload and analyze PDF, images, and logs via Google Files API.
+- **Persistent Sessions**: Save and load full agent histories and environment states.
+
+## 🛠 Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/ProgVM/swarm
+cd swarm
+
+# Install dependencies
+pip install .
+```
+
+Or:
+```bash
+pip install swarmai
+```
+
+## 💻 CLI Usage
+
+Start a basic conversation with two agents:
+```bash
+swarm --keys YOUR_API_KEY --agents_count 2
+```
+
+Start an autonomous coding session:
+```bash
+swarm --first_msg "Write a web scraper in Python and test it" \
+      --sys1 "You are an Expert Coder" \
+      --sys2 "You are a Security Auditor" \
+      --cmd_timeout 600
+```
+
+### Advanced Configuration
+Swarm supports individual parameters for every agent using `aiN_` prefixes:
+- `--ai1_name "Architect"`
+- `--ai1_model "gemini-2.0-flash"`
+- `--ai2_name "Tester"`
+- `--ai2_temp 0.2`
+
+## ⚙️ Configuration File
+You can use a JSON config to manage complex Swarms:
+```json
+{
+  "agents_count": 3,
+  "model": "gemini-3.1-flash-lite",
+  "cmd_blacklist": ["rm -rf", "format"],
+  "no_pause": true
+}
+```
+Run with: `swarm --config my_swarm.json`
+
+## ⌨️ Command Center (Interactive Menu)
+Press `Ctrl+C` at any time to:
+- Rotate API Keys.
+- Toggle reading pauses.
+- Save the current state.
+- Change logging levels (DEBUG, INFO, WARNING).
+- Inject manual directives into agents' minds.
+
+## 🤝 Contributing
+Developed by **ProgVM**. 
+- Email: progvminc@gmail.com
+- GitHub: [https://github.com/ProgVM](https://github.com/ProgVM)
+
+License: MIT

swarmai-1.0.0/README.md

@@ -0,0 +1,78 @@
+# 🐝 Swarm
+
+**Swarm** is an advanced, open-source multi-agent intelligence framework designed for autonomous collaboration. Powered by Google's **Gemini 3.1 Flash Lite**, Swarm allows multiple agents to interact, use tools, execute code, and perform web searches in a shared environment.
+
+## 🚀 Key Features
+
+- **N-Agent Collaboration**: Run any number of agents in a single session.
+- **Autonomous Tool Usage**: Agents can perform Google searches and execute Shell commands.
+- **Agent Sandboxing**: Per-agent blacklists for terminal commands and file paths.
+- **Turn Management**: Agents can autonomously pass turns to specific peers using `pass_turn`.
+- **ReAct Loop**: High-level reasoning before acting, supporting multi-step tool execution.
+- **Files API Support**: Agents can upload and analyze PDF, images, and logs via Google Files API.
+- **Persistent Sessions**: Save and load full agent histories and environment states.
+
+## 🛠 Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/ProgVM/swarm
+cd swarm
+
+# Install dependencies
+pip install .
+```
+
+Or:
+```bash
+pip install swarmai
+```
+
+## 💻 CLI Usage
+
+Start a basic conversation with two agents:
+```bash
+swarm --keys YOUR_API_KEY --agents_count 2
+```
+
+Start an autonomous coding session:
+```bash
+swarm --first_msg "Write a web scraper in Python and test it" \
+      --sys1 "You are an Expert Coder" \
+      --sys2 "You are a Security Auditor" \
+      --cmd_timeout 600
+```
+
+### Advanced Configuration
+Swarm supports individual parameters for every agent using `aiN_` prefixes:
+- `--ai1_name "Architect"`
+- `--ai1_model "gemini-2.0-flash"`
+- `--ai2_name "Tester"`
+- `--ai2_temp 0.2`
+
+## ⚙️ Configuration File
+You can use a JSON config to manage complex Swarms:
+```json
+{
+  "agents_count": 3,
+  "model": "gemini-3.1-flash-lite",
+  "cmd_blacklist": ["rm -rf", "format"],
+  "no_pause": true
+}
+```
+Run with: `swarm --config my_swarm.json`
+
+## ⌨️ Command Center (Interactive Menu)
+Press `Ctrl+C` at any time to:
+- Rotate API Keys.
+- Toggle reading pauses.
+- Save the current state.
+- Change logging levels (DEBUG, INFO, WARNING).
+- Inject manual directives into agents' minds.
+
+## 🤝 Contributing
+Developed by **ProgVM**. 
+- Email: progvminc@gmail.com
+- GitHub: [https://github.com/ProgVM](https://github.com/ProgVM)
+
+License: MIT

swarmai-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "swarmai"
+version = "1.0.0"
+authors = [
+  { name="ProgVM", email="progvminc@gmail.com" },
+]
+description = "A highly flexible multi-agent ReAct framework powered by Google Gemini"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "google-genai",
+    "duckduckgo-search",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/ProgVM"
+
+[project.scripts]
+swarm = "swarm.cli:run"

swarmai-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

swarmai-1.0.0/swarm/__init__.py

@@ -0,0 +1,6 @@
+from .core import SwarmSession, Agent
+from .tools import ToolRegistry
+from .utils import Serializer, setup_logger
+
+__version__ = "1.0.0"
+__author__ = "ProgVM"

swarmai-1.0.0/swarm/cli.py

@@ -0,0 +1,119 @@
+import argparse
+import os
+import json
+import logging
+from .utils import Colors, setup_logger, smart_sleep, Serializer
+from .core import SwarmSession
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Swarm Framework")
+    parser.add_argument("--agents_count", type=int, default=2)
+    parser.add_argument("--model", default="gemini-3.1-flash-lite")
+    parser.add_argument("--first_msg", default="Initialize Swarm and greet the user.")
+    parser.add_argument("--keys", nargs="+")
+    parser.add_argument("--config", help="Path to config JSON")
+    parser.add_argument("--load", help="Load session JSON")
+    parser.add_argument("--log_level", default="INFO")
+    parser.add_argument("--no_pause", action="store_true")
+    parser.add_argument("--save_file", default="swarm_session.json")
+    
+    # Global tool settings
+    parser.add_argument("--max_results", type=int, default=5)
+    parser.add_argument("--cmd_timeout", type=int, default=300)
+    parser.add_argument("--cmd_blacklist", nargs="*", default=[])
+    parser.add_argument("--file_blacklist", nargs="*", default=[])
+    
+    # Defaults
+    parser.add_argument("--sys1", default="You are Agent 1.")
+    parser.add_argument("--sys2", default="You are Agent 2.")
+    parser.add_argument("--temp", type=float, default=0.7)
+
+    return parser.parse_known_args()
+
+def run():
+    args, unknown = parse_args()
+    logger = setup_logger(args.log_level)
+    
+    # 1. Load config if exists (Overrides defaults)
+    if args.config and os.path.exists(args.config):
+        with open(args.config, 'r') as f:
+            cdata = json.load(f)
+            for k, v in cdata.items(): setattr(args, k, v)
+
+    # 2. Collect API Keys
+    keys = args.keys or [os.getenv("GOOGLE_API_KEY")]
+    if not keys or not keys[0]:
+        print(f"{Colors.ERR}Error: API Keys not found. Set GOOGLE_API_KEY environment variable or use --keys.{Colors.RESET}")
+        return
+
+    session = SwarmSession(args, keys)
+
+    # 3. Handle loading (Arguments take priority after load)
+    if args.load and os.path.exists(args.load):
+        with open(args.load, 'r') as f:
+            sd = json.load(f)
+            session.current_agent_idx = sd.get("current_agent", 0)
+            session.last_interaction = sd.get("last_interaction", args.first_msg)
+            for i, ah in enumerate(sd.get("histories", [])):
+                if i < len(session.agents):
+                    session.agents[i].history = Serializer.deserialize_history(ah)
+            print(f"{Colors.SYS}Session loaded. Overriding with current CLI parameters...{Colors.RESET}")
+
+    print(f"{Colors.SYS}{Colors.BOLD}>>> SWARM STARTING. CTRL+C FOR COMMAND CENTER.{Colors.RESET}")
+
+    while True:
+        try:
+            agent = session.agents[session.current_agent_idx]
+            color = Colors.AI_COLORS[session.current_agent_idx % len(Colors.AI_COLORS)]
+
+            # 1-Agent User Input Mode
+            if args.agents_count == 1 and len(agent.history) > 0:
+                user_msg = input(f"{Colors.BOLD}User: {Colors.RESET}")
+                session.last_interaction = user_msg
+
+            # Agent Thinking
+            response, reports = session.execute_react_step()
+            
+            # Print and Share Reports
+            for rep in reports:
+                print(f"{Colors.REPORT}{rep}{Colors.RESET}")
+                for i, other in enumerate(session.agents):
+                    if i != session.current_agent_idx:
+                        other.history.append(types.Content(role="user", parts=[types.Part(text=rep)]))
+
+            # Final Output
+            print(f"{color}{Colors.BOLD}{agent.name}:{Colors.RESET} {response}")
+
+            # Turn Management
+            if not session.turn_passed_manually and args.agents_count > 1:
+                session.current_agent_idx = (session.current_agent_idx + 1) % args.agents_count
+
+            # Timing
+            wait = (len(response) / 10) * 1.5
+            smart_sleep(max(3, min(wait, 30)), enabled=session.enable_pauses)
+
+        except KeyboardInterrupt:
+            print(f"\n{Colors.MENU}{Colors.BOLD}=== SWARM COMMAND CENTER ==={Colors.RESET}")
+            print("1. Change Keys\n2. Toggle Pauses\n3. Save State\n4. Change Log Level\n5. Exit Swarm")
+            choice = input("Choice: ")
+            
+            if choice == '1':
+                nk = input("Enter keys (space separated): ").split()
+                if nk: session.keys = nk; session.key_idx = 0
+            elif choice == '2':
+                session.enable_pauses = not session.enable_pauses
+                print(f"Pauses enabled: {session.enable_pauses}")
+            elif choice == '3':
+                path = input(f"Save filename [{args.save_file}]: ") or args.save_file
+                save_data = {
+                    "current_agent": session.current_agent_idx,
+                    "last_interaction": session.last_interaction,
+                    "histories": [Serializer.serialize_history(a.history) for a in session.agents]
+                }
+                with open(path, 'w') as f: json.dump(save_data, f, indent=2)
+                print(f"State saved to {path}")
+            elif choice == '4':
+                lv = input("Enter Level (DEBUG, INFO, WARNING): ").upper()
+                logger.setLevel(getattr(logging, lv, logging.INFO))
+            elif choice == '5':
+                break

swarmai-1.0.0/swarm/core.py

@@ -0,0 +1,167 @@
+import logging
+from google import genai
+from google.genai import types
+from .utils import Colors, Serializer
+from .tools import ToolRegistry
+
+logger = logging.getLogger("Swarm.Core")
+
+class Agent:
+    """Individual Agent state and configuration."""
+    def __init__(self, agent_id, name, description, config):
+        self.id = agent_id
+        self.name = name
+        self.description = description
+        self.model = config.get('model', 'gemini-3.1-flash-lite')
+        self.sys_prompt = config.get('sys_prompt', 'You are a helpful agent.')
+        self.temperature = config.get('temp', 0.7)
+        self.history = []
+        
+        # Tool specifics for this agent
+        self.tools_enabled = config.get('tools', ["web_search", "shell_exec", "upload_file", "pass_turn"])
+        self.max_search = config.get('max_search', 5)
+        self.cmd_timeout = config.get('cmd_timeout', 300)
+        self.cmd_blacklist = config.get('cmd_blacklist', [])
+        self.file_blacklist = config.get('file_blacklist', [])
+
+class SwarmSession:
+    """Manager of the multi-agent ReAct loop."""
+    def __init__(self, args, keys):
+        self.args = args
+        self.keys = keys
+        self.key_idx = 0
+        self.client = genai.Client(api_key=self.keys[self.key_idx])
+        self.agents = []
+        self.current_agent_idx = 0
+        self.last_interaction = args.first_msg
+        self.enable_pauses = not args.no_pause
+        self.turn_passed_manually = False
+        self._init_agents(args)
+
+    def _init_agents(self, args):
+        for i in range(args.agents_count):
+            p = f"ai{i+1}_"
+            # Get values with fallbacks to global args
+            config = {
+                'model': getattr(args, f"{p}model", args.model),
+                'sys_prompt': getattr(args, f"{p}sys", args.sys1 if i == 0 else args.sys2),
+                'temp': getattr(args, f"{p}temp", args.temp),
+                'tools': getattr(args, f"{p}tools", ["web_search", "shell_exec", "upload_file", "pass_turn"]),
+                'max_search': getattr(args, f"{p}max_search", args.max_results),
+                'cmd_timeout': getattr(args, f"{p}cmd_timeout", args.cmd_timeout),
+                'cmd_blacklist': getattr(args, f"{p}cmd_blacklist", args.cmd_blacklist),
+                'file_blacklist': getattr(args, f"{p}file_blacklist", args.file_blacklist),
+            }
+            name = getattr(args, f"{p}name", f"Agent_{i+1}")
+            desc = getattr(args, f"{p}desc", "A Swarm Agent.")
+            self.agents.append(Agent(i+1, name, desc, config))
+
+    def rotate_key(self):
+        if len(self.keys) > 1:
+            self.key_idx = (self.key_idx + 1) % len(self.keys)
+            self.client = genai.Client(api_key=self.keys[self.key_idx])
+            logger.info(f"API key rotated to index {self.key_idx}")
+            return True
+        return False
+
+    def build_system_instruction(self, agent):
+        """Constructs the root prompt for the agent."""
+        swarm_map = "\n".join([f"- {a.name} (ID: {a.id}): {a.description}" for a in self.agents])
+        root = (
+            f"{agent.sys_prompt}\n\n"
+            f"FRAMEWORK: SWARM\n"
+            f"YOUR IDENTITY: {agent.name}\n"
+            f"ALL AGENTS IN SWARM:\n{swarm_map}\n\n"
+            f"GUIDELINES:\n"
+            f"1. You are autonomous. Use tools as needed.\n"
+        )
+        if len(self.agents) > 1:
+            root += "2. You can use 'pass_turn' to give control to another agent by their name.\n"
+        else:
+            root += "2. You are talking directly to the User.\n"
+        return root
+
+    def get_tool_definitions(self, agent):
+        decls = []
+        if "web_search" in agent.tools_enabled:
+            decls.append({"name": "web_search", "description": "Search the web.", "parameters": {"type": "OBJECT", "properties": {"query": {"type": "STRING"}}, "required": ["query"]}})
+        if "shell_exec" in agent.tools_enabled:
+            decls.append({"name": "shell_exec", "description": "Execute terminal commands.", "parameters": {"type": "OBJECT", "properties": {"command": {"type": "STRING"}}, "required": ["command"]}})
+        if "upload_file" in agent.tools_enabled:
+            decls.append({"name": "upload_file", "description": "Upload a local file for analysis.", "parameters": {"type": "OBJECT", "properties": {"path": {"type": "STRING"}}, "required": ["path"]}})
+        if "pass_turn" in agent.tools_enabled and len(self.agents) > 1:
+            decls.append({"name": "pass_turn", "description": "Transfer turn to another agent.", "parameters": {"type": "OBJECT", "properties": {"agent_name": {"type": "STRING"}}, "required": ["agent_name"]}})
+        return [{"function_declarations": decls}] if decls else None
+
+    def execute_react_step(self):
+        """Runs the ReAct loop for the current agent."""
+        agent = self.agents[self.current_agent_idx]
+        agent.history.append(types.Content(role="user", parts=[types.Part(text=self.last_interaction)]))
+        
+        full_text_output = ""
+        reports = []
+        self.turn_passed_manually = False
+
+        while True:
+            try:
+                config = types.GenerateContentConfig(
+                    system_instruction=self.build_system_instruction(agent),
+                    tools=self.get_tool_definitions(agent),
+                    temperature=agent.temperature,
+                    safety_settings=[types.SafetySetting(category=c, threshold="BLOCK_NONE") for c in [
+                        "HARM_CATEGORY_HARASSMENT", "HARM_CATEGORY_HATE_SPEECH", 
+                        "HARM_CATEGORY_SEXUALLY_EXPLICIT", "HARM_CATEGORY_DANGEROUS_CONTENT"]]
+                )
+
+                response = self.client.models.generate_content(model=agent.model, config=config, contents=agent.history)
+                
+                if not response.candidates:
+                    return "[Blocked by Safety Filters]", []
+
+                candidate = response.candidates[0]
+                chunk_text = "".join([p.text for p in candidate.content.parts if p.text])
+                full_text_output += chunk_text
+
+                calls = [p.function_call for p in candidate.content.parts if p.function_call]
+                
+                if not calls:
+                    agent.history.append(candidate.content)
+                    self.last_interaction = full_text_output
+                    return full_text_output, reports
+
+                agent.history.append(candidate.content)
+                res_parts = []
+                
+                for call in calls:
+                    fn, args = call.name, call.args
+                    logger.info(f"Agent {agent.name} calls tool: {fn}")
+                    
+                    if fn == "pass_turn":
+                        target = args.get("agent_name")
+                        for i, a in enumerate(self.agents):
+                            if a.name == target:
+                                self.current_agent_idx = i
+                                self.turn_passed_manually = True
+                                res = f"Turn successfully passed to {target}."
+                                break
+                        else: res = f"Error: Agent '{target}' not found in Swarm."
+                    elif fn == "web_search":
+                        res = ToolRegistry.web_search(args.get("query"), max_results=agent.max_search)
+                    elif fn == "shell_exec":
+                        res = ToolRegistry.shell_exec(args.get("command"), timeout=agent.cmd_timeout, blacklist=agent.cmd_blacklist)
+                    elif fn == "upload_file":
+                        up = ToolRegistry.upload_file(self.client, args.get("path"), blacklist=agent.file_blacklist)
+                        if "uri" in up:
+                            res = f"File {args.get('path')} uploaded to {up['uri']}"
+                            agent.history.append(types.Content(role="user", parts=[types.Part(file_data=types.FileData(file_uri=up['uri'], mime_type=up['mime']))]))
+                        else: res = f"File Upload Error: {up.get('error')}"
+                    
+                    res_parts.append(types.Part.from_function_response(name=fn, response={"result": res}))
+                    reports.append(f"Tool Report: {agent.name} -> {fn}. Result: {str(res)[:150]}...")
+
+                agent.history.append(types.Content(role="tool", parts=res_parts))
+
+            except Exception as e:
+                if "429" in str(e) and self.rotate_key(): continue
+                logger.error(f"Cycle Exception: {e}")
+                return f"Error during agent cycle: {e}", []

swarmai-1.0.0/swarm/tools.py

@@ -0,0 +1,76 @@
+import subprocess
+import json
+import re
+import time
+import logging
+from ddgs import DDGS
+
+logger = logging.getLogger("Swarm.Tools")
+
+class ToolRegistry:
+    """Static container for all tool logic with built-in security and limits."""
+
+    @staticmethod
+    def web_search(query, max_results=5):
+        """Standard web search tool."""
+        logger.debug(f"Searching for: {query} (limit: {max_results})")
+        try:
+            with DDGS() as ddgs:
+                results = [r for r in ddgs.text(query, max_results=max_results)]
+            if not results:
+                return "No search results found."
+            return json.dumps(results, ensure_ascii=False, indent=2)
+        except Exception as e:
+            logger.error(f"DDGS Error: {e}")
+            return f"Search failed: {str(e)}"
+
+    @staticmethod
+    def shell_exec(command, timeout=300, blacklist=None):
+        """Secure shell execution tool."""
+        logger.debug(f"Executing: {command} (timeout: {timeout})")
+        if blacklist:
+            for pattern in blacklist:
+                if re.search(pattern, command, re.IGNORECASE):
+                    logger.warning(f"Blocked command: {command} (matches {pattern})")
+                    return f"Security Exception: Command matches blacklist pattern '{pattern}'."
+        
+        try:
+            res = subprocess.run(
+                command, shell=True, capture_output=True, text=True, timeout=timeout
+            )
+            output = f"STDOUT:\n{res.stdout}\nSTDERR:\n{res.stderr}"
+            return output if output.strip() else "Executed successfully with no output."
+        except subprocess.TimeoutExpired:
+            return f"Timeout Error: Command exceeded {timeout} seconds."
+        except Exception as e:
+            return f"Execution failed: {str(e)}"
+
+    @staticmethod
+    def upload_file(client, path, blacklist=None):
+        """Google Files API wrapper."""
+        if not os.path.exists(path):
+            return {"error": f"Path '{path}' does not exist."}
+        
+        if blacklist:
+            for pattern in blacklist:
+                if re.search(pattern, path, re.IGNORECASE):
+                    return {"error": f"Access to '{path}' is denied by security policy."}
+
+        logger.info(f"Uploading file: {path}")
+        try:
+            file_obj = client.files.upload(path=path)
+            while file_obj.state.name == "PROCESSING":
+                time.sleep(2)
+                file_obj = client.files.get(name=file_obj.name)
+            
+            if file_obj.state.name == "FAILED":
+                return {"error": "Server-side file processing failed."}
+                
+            return {
+                "uri": file_obj.uri, 
+                "mime": file_obj.mime_type, 
+                "name": file_obj.name
+            }
+        except Exception as e:
+            logger.error(f"Upload error: {e}")
+            return {"error": str(e)}

swarmai-1.0.0/swarm/utils.py

@@ -0,0 +1,82 @@
+import os
+import sys
+import json
+import time
+import select
+import logging
+from google.genai import types
+
+class Colors:
+    """ANSI Escape sequences for professional terminal output."""
+    AI_COLORS = ['\033[94m', '\033[92m', '\033[96m', '\033[95m', '\033[91m', '\033[33m']
+    SYS = '\033[93m'
+    ERR = '\033[91m'
+    TOOL = '\033[36m'
+    REPORT = '\033[90m'
+    MENU = '\033[95m'
+    BOLD = '\033[1m'
+    RESET = '\033[0m'
+
+def setup_logger(level_name="INFO"):
+    """Initializes the logging system with configurable levels."""
+    level = getattr(logging, level_name.upper(), logging.INFO)
+    logging.basicConfig(
+        level=level,
+        format='%(asctime)s [%(levelname)s] %(name)s: %(message)s',
+        handlers=[logging.StreamHandler(sys.stdout)]
+    )
+    return logging.getLogger("Swarm")
+
+def smart_sleep(timeout, enabled=True):
+    """Provides a toggleable pause that can be skipped with the Enter key."""
+    if not enabled or timeout <= 0:
+        return
+    print(f"{Colors.REPORT}[Pause: {timeout:.1f}s | Press Enter to skip]{Colors.RESET}", end="", flush=True)
+    # Use select for non-blocking stdin check
+    ready, _, _ = select.select([sys.stdin], [], [], timeout)
+    if ready:
+        sys.stdin.readline()
+        print(f"\r{Colors.SYS}[User Skipped Pause]{' ' * 30}{Colors.RESET}")
+    else:
+        # Clear the line after pause expires
+        print(f"\r{' ' * 50}\r", end="", flush=True)
+
+class Serializer:
+    """Serializes and deserializes Google GenAI objects for persistent storage."""
+    @staticmethod
+    def serialize_history(history):
+        data = []
+        for content in history:
+            parts_list = []
+            for p in content.parts:
+                if p.text:
+                    parts_list.append({"text": p.text})
+                elif p.function_call:
+                    parts_list.append({"function_call": {"name": p.function_call.name, "args": p.function_call.args}})
+                elif p.function_response:
+                    parts_list.append({"function_response": {"name": p.function_response.name, "response": p.function_response.response}})
+                elif p.file_data:
+                    parts_list.append({"file_data": {"file_uri": p.file_data.file_uri, "mime_type": p.file_data.mime_type}})
+            data.append({"role": content.role, "parts": parts_list})
+        return data
+
+    @staticmethod
+    def deserialize_history(data):
+        history = []
+        for item in data:
+            parts = []
+            for p in item.get('parts', []):
+                if "text" in p:
+                    parts.append(types.Part(text=p["text"]))
+                elif "function_call" in p:
+                    fc = p["function_call"]
+                    parts.append(types.Part(function_call=types.FunctionCall(name=fc["name"], args=fc["args"])))
+                elif "function_response" in p:
+                    fr = p["function_response"]
+                    parts.append(types.Part.from_function_response(name=fr["name"], response=fr["response"]))
+                elif "file_data" in p:
+                    fd = p["file_data"]
+                    parts.append(types.Part(file_data=types.FileData(file_uri=fd["file_uri"], mime_type=fd["mime_type"])))
+            if parts:
+                history.append(types.Content(role=item["role"], parts=parts))
+        return history

swarmai-1.0.0/swarmai.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: swarmai
+Version: 1.0.0
+Summary: A highly flexible multi-agent ReAct framework powered by Google Gemini
+Author-email: ProgVM <progvminc@gmail.com>
+Project-URL: Homepage, https://github.com/ProgVM
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: google-genai
+Requires-Dist: duckduckgo-search
+
+# 🐝 Swarm
+
+**Swarm** is an advanced, open-source multi-agent intelligence framework designed for autonomous collaboration. Powered by Google's **Gemini 3.1 Flash Lite**, Swarm allows multiple agents to interact, use tools, execute code, and perform web searches in a shared environment.
+
+## 🚀 Key Features
+
+- **N-Agent Collaboration**: Run any number of agents in a single session.
+- **Autonomous Tool Usage**: Agents can perform Google searches and execute Shell commands.
+- **Agent Sandboxing**: Per-agent blacklists for terminal commands and file paths.
+- **Turn Management**: Agents can autonomously pass turns to specific peers using `pass_turn`.
+- **ReAct Loop**: High-level reasoning before acting, supporting multi-step tool execution.
+- **Files API Support**: Agents can upload and analyze PDF, images, and logs via Google Files API.
+- **Persistent Sessions**: Save and load full agent histories and environment states.
+
+## 🛠 Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/ProgVM/swarm
+cd swarm
+
+# Install dependencies
+pip install .
+```
+
+Or:
+```bash
+pip install swarmai
+```
+
+## 💻 CLI Usage
+
+Start a basic conversation with two agents:
+```bash
+swarm --keys YOUR_API_KEY --agents_count 2
+```
+
+Start an autonomous coding session:
+```bash
+swarm --first_msg "Write a web scraper in Python and test it" \
+      --sys1 "You are an Expert Coder" \
+      --sys2 "You are a Security Auditor" \
+      --cmd_timeout 600
+```
+
+### Advanced Configuration
+Swarm supports individual parameters for every agent using `aiN_` prefixes:
+- `--ai1_name "Architect"`
+- `--ai1_model "gemini-2.0-flash"`
+- `--ai2_name "Tester"`
+- `--ai2_temp 0.2`
+
+## ⚙️ Configuration File
+You can use a JSON config to manage complex Swarms:
+```json
+{
+  "agents_count": 3,
+  "model": "gemini-3.1-flash-lite",
+  "cmd_blacklist": ["rm -rf", "format"],
+  "no_pause": true
+}
+```
+Run with: `swarm --config my_swarm.json`
+
+## ⌨️ Command Center (Interactive Menu)
+Press `Ctrl+C` at any time to:
+- Rotate API Keys.
+- Toggle reading pauses.
+- Save the current state.
+- Change logging levels (DEBUG, INFO, WARNING).
+- Inject manual directives into agents' minds.
+
+## 🤝 Contributing
+Developed by **ProgVM**. 
+- Email: progvminc@gmail.com
+- GitHub: [https://github.com/ProgVM](https://github.com/ProgVM)
+
+License: MIT

swarmai-1.0.0/swarmai.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+swarm/__init__.py
+swarm/cli.py
+swarm/core.py
+swarm/tools.py
+swarm/utils.py
+swarmai.egg-info/PKG-INFO
+swarmai.egg-info/SOURCES.txt
+swarmai.egg-info/dependency_links.txt
+swarmai.egg-info/entry_points.txt
+swarmai.egg-info/requires.txt
+swarmai.egg-info/top_level.txt

swarmai-1.0.0/swarmai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

swarmai-1.0.0/swarmai.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+swarm = swarm.cli:run

swarmai-1.0.0/swarmai.egg-info/requires.txt

@@ -0,0 +1,2 @@
+google-genai
+duckduckgo-search

swarmai-1.0.0/swarmai.egg-info/top_level.txt

@@ -0,0 +1 @@
+swarm