swarmly 0.9.0__py3-none-any.whl

swarmly/__init__.py

@@ -0,0 +1,42 @@
+"""
+Swarmly: coordinate coding-agent CLIs from different vendors, on different machines.
+
+The import package was ``a2a`` before the rename; the wire identifiers (``a2a/v1``,
+``a2a/2``) and the ``A2A_*`` environment variables keep their names.
+"""
+
+__version__ = "0.9.0"
+__protocol__ = "a2a/v1.0"
+
+from swarmly.models import (
+    A2AMessage,
+    SenderInfo,
+    RecipientInfo,
+    MessageIntent,
+    MessagePriority,
+    TaskClaimPayload,
+    TaskHandoffPayload,
+    PRReviewRequestPayload,
+    PRReviewVerdictPayload,
+    FalsificationPayload,
+)
+from swarmly.crypto import CryptoAuth, KeyPair
+from swarmly.bus import DurableBus
+from swarmly.client import A2AClient
+
+__all__ = [
+    "A2AMessage",
+    "SenderInfo",
+    "RecipientInfo",
+    "MessageIntent",
+    "MessagePriority",
+    "TaskClaimPayload",
+    "TaskHandoffPayload",
+    "PRReviewRequestPayload",
+    "PRReviewVerdictPayload",
+    "FalsificationPayload",
+    "CryptoAuth",
+    "KeyPair",
+    "DurableBus",
+    "A2AClient",
+]

swarmly/_aliases.py

@@ -0,0 +1,30 @@
+"""The command names from before the rename to Swarmly, kept for one release.
+
+Each prints one line to stderr naming its replacement, then runs it unchanged, so a
+launcher or scheduled task still using an old name keeps working and its log says so.
+"""
+
+import sys
+
+
+def _note(old: str, new: str) -> None:
+    print(f"{old}: renamed to {new}; this alias goes away in the next release",
+          file=sys.stderr)
+
+
+def a2a_telegram() -> None:
+    _note("a2a-telegram", "swarmly-telegram")
+    from swarmly.telegram.cli import main
+    sys.exit(main())
+
+
+def a2a() -> None:
+    _note("a2a", "swarmly")
+    from swarmly.swarm.cli import main
+    sys.exit(main())
+
+
+def a2a_keygen() -> None:
+    _note("a2a-keygen", "swarmly-keygen")
+    from swarmly.keygen import main
+    sys.exit(main())

swarmly/adapters/__init__.py

@@ -0,0 +1,17 @@
+"""
+Multi-Agent Framework Adapters for Swarmly.
+"""
+
+from swarmly.adapters.base import BaseAgentAdapter
+from swarmly.adapters.openai_swarm import OpenAISwarmAdapter
+from swarmly.adapters.deepseek import DeepSeekAdapter
+from swarmly.adapters.gemini import GeminiAdapter
+from swarmly.adapters.hermes import HermesAdapter
+
+__all__ = [
+    "BaseAgentAdapter",
+    "OpenAISwarmAdapter",
+    "DeepSeekAdapter",
+    "GeminiAdapter",
+    "HermesAdapter",
+]

swarmly/adapters/base.py

@@ -0,0 +1,54 @@
+"""
+Base abstract adapter defining interface for heterogeneous agent frameworks.
+"""
+
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+from swarmly.models import A2AMessage, MessageIntent, MessagePriority
+from swarmly.client import A2AClient
+
+
+class BaseAgentAdapter(ABC):
+    """Abstract adapter connecting a specific agent framework to Swarmly."""
+
+    def __init__(self, client: A2AClient):
+        self.client = client
+        self.agent_id = client.agent_id
+
+    @abstractmethod
+    def export_tools(self) -> List[Dict[str, Any]]:
+        """Export tool definitions suitable for the framework's tool-calling API."""
+        pass
+
+    async def execute_tool_call(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Dispatch a tool call triggered by the underlying LLM."""
+        if tool_name == "a2a_send_message":
+            msg = await self.client.send_message(
+                intent=arguments.get("intent", MessageIntent.QUERY_REQUEST),
+                payload=arguments.get("payload", {}),
+                recipient_id=arguments.get("recipient_id", "*"),
+                priority=arguments.get("priority", MessagePriority.ROUTINE),
+                correlation_id=arguments.get("correlation_id"),
+            )
+            return {"status": "sent", "message_id": msg.message_id}
+
+        elif tool_name == "a2a_read_inbox":
+            messages = self.client.bus.read_inbox(verify_signatures=True)
+            return {
+                "count": len(messages),
+                "messages": [
+                    {
+                        "message_id": m.message_id,
+                        "sender": m.sender.agent_id,
+                        "intent": m.intent.value,
+                        "priority": m.priority.value,
+                        "payload": m.payload,
+                        "is_valid": valid,
+                        "status": status,
+                    }
+                    for m, valid, status in messages
+                ]
+            }
+
+        return {"error": f"Unknown tool: {tool_name}"}

swarmly/adapters/deepseek.py

@@ -0,0 +1,58 @@
+"""
+DeepSeek Adapter for Swarmly.
+Supports both programmatic integration and CLI Aider/runner workflows.
+"""
+
+from __future__ import annotations
+from typing import Any, Dict, List
+from swarmly.adapters.base import BaseAgentAdapter
+from swarmly.models import MessageIntent, MessagePriority
+
+
+class DeepSeekAdapter(BaseAgentAdapter):
+    """Adapter for DeepSeek-R1 and DeepSeek-V3 reasoning agents."""
+
+    def export_tools(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "a2a_send_falsification_report",
+                "description": "Publish a formal falsification or statistical audit to the swarm with citations.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["hypothesis", "predicted_metric", "measured_metric", "verdict"],
+                    "properties": {
+                        "hypothesis": {"type": "string"},
+                        "predicted_metric": {"type": "string"},
+                        "measured_metric": {"type": "string"},
+                        "bounds_violated": {"type": "boolean"},
+                        "verdict": {"type": "string"},
+                        "citation_scripts": {"type": "array", "items": {"type": "string"}}
+                    }
+                }
+            }
+        ]
+
+    async def publish_falsification(
+        self,
+        hypothesis: str,
+        predicted_metric: str,
+        measured_metric: str,
+        bounds_violated: bool,
+        verdict: str,
+        citation_scripts: List[str]
+    ):
+        """Helper to post a typed falsification report to all agents."""
+        payload = {
+            "hypothesis": hypothesis,
+            "predicted_metric": predicted_metric,
+            "measured_metric": measured_metric,
+            "bounds_violated": bounds_violated,
+            "verdict": verdict,
+            "citation_scripts": citation_scripts
+        }
+        return await self.client.send_message(
+            intent=MessageIntent.FALSIFICATION_REPORT,
+            payload=payload,
+            recipient_id="*",
+            priority=MessagePriority.HIGH
+        )

swarmly/adapters/gemini.py

@@ -0,0 +1,60 @@
+"""
+Google Gemini and Antigravity Adapter for Swarmly.
+"""
+
+from __future__ import annotations
+from typing import Any, Dict, List
+from swarmly.adapters.base import BaseAgentAdapter
+from swarmly.models import MessageIntent, MessagePriority
+
+
+class GeminiAdapter(BaseAgentAdapter):
+    """Adapter for Google Gemini and Antigravity agents."""
+
+    def export_tools(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "a2a_handoff_task",
+                "description": "Formally hand off an experimental task to a peer agent with pre-registered bounds.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["task_id", "git_commit_sha", "description", "pre_registered_hypothesis", "expected_bounds"],
+                    "properties": {
+                        "task_id": {"type": "string"},
+                        "git_commit_sha": {"type": "string"},
+                        "description": {"type": "string"},
+                        "pre_registered_hypothesis": {"type": "string"},
+                        "expected_bounds": {"type": "array", "items": {"type": "number"}},
+                        "verification_command": {"type": "string"},
+                        "target_output": {"type": "string"}
+                    }
+                }
+            }
+        ]
+
+    async def handoff_task(
+        self,
+        task_id: str,
+        git_commit_sha: str,
+        description: str,
+        hypothesis: str,
+        bounds: List[float],
+        cmd: str = "",
+        target: str = "",
+        recipient_id: str = "hermes"
+    ):
+        payload = {
+            "task_id": task_id,
+            "git_commit_sha": git_commit_sha,
+            "description": description,
+            "pre_registered_hypothesis": hypothesis,
+            "expected_bounds": bounds,
+            "verification_command": cmd,
+            "target_output": target
+        }
+        return await self.client.send_message(
+            intent=MessageIntent.TASK_HANDOFF,
+            payload=payload,
+            recipient_id=recipient_id,
+            priority=MessagePriority.HIGH
+        )

swarmly/adapters/hermes.py

@@ -0,0 +1,46 @@
+"""
+Hermes and Local vLLM Agent Adapter for Swarmly.
+"""
+
+from __future__ import annotations
+from typing import Any, Dict, List
+from swarmly.adapters.base import BaseAgentAdapter
+from swarmly.models import MessageIntent, MessagePriority
+
+
+class HermesAdapter(BaseAgentAdapter):
+    """Adapter for Hermes agents running on Linux/vLLM compute nodes."""
+
+    def export_tools(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "a2a_claim_task",
+                "description": "Claim a research or feature engineering task atomically.",
+                "parameters": {
+                    "type": "object",
+                    "required": ["task_id", "topic"],
+                    "properties": {
+                        "task_id": {"type": "string"},
+                        "topic": {"type": "string"},
+                        "branch": {"type": "string"},
+                        "claimed_files": {"type": "array", "items": {"type": "string"}},
+                        "rationale": {"type": "string"}
+                    }
+                }
+            }
+        ]
+
+    async def claim_task(self, task_id: str, topic: str, branch: str, files: List[str], rationale: str):
+        payload = {
+            "task_id": task_id,
+            "topic": topic,
+            "branch": branch,
+            "claimed_files": files,
+            "rationale": rationale
+        }
+        return await self.client.send_message(
+            intent=MessageIntent.TASK_CLAIM,
+            payload=payload,
+            recipient_id="*",
+            priority=MessagePriority.HIGH
+        )

swarmly/adapters/openai_swarm.py

@@ -0,0 +1,68 @@
+"""
+OpenAI Swarm and Function Calling Adapter for Swarmly.
+Exports tools conforming to standard OpenAI Chat Completion JSON schemas.
+"""
+
+from __future__ import annotations
+from typing import Any, Dict, List
+from swarmly.adapters.base import BaseAgentAdapter
+
+
+class OpenAISwarmAdapter(BaseAgentAdapter):
+    """Adapter for ChatGPT, OpenAI Swarm, AutoGen, and CrewAI."""
+
+    def export_tools(self) -> List[Dict[str, Any]]:
+        """Export tool specifications in standard OpenAI function format."""
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": "a2a_send_message",
+                    "description": "Send a verified A2A message to the swarm (Hermes, DeepSeek, Antigravity, MiniMax) via WebSocket or Git.",
+                    "parameters": {
+                        "type": "object",
+                        "required": ["intent", "payload"],
+                        "properties": {
+                            "intent": {
+                                "type": "string",
+                                "enum": [
+                                    "TASK_PROPOSE", "TASK_CLAIM", "TASK_APPROVE", "TASK_HANDOFF",
+                                    "PR_REVIEW_REQUEST", "PR_REVIEW_VERDICT", "FALSIFICATION_REPORT",
+                                    "EXPERIMENT_REGISTER", "QUERY_REQUEST", "QUERY_RESPONSE", "ESCALATE_BLOCKER"
+                                ],
+                                "description": "The operational intent of this message"
+                            },
+                            "recipient_id": {
+                                "type": "string",
+                                "description": "Target agent ID (e.g. 'antigravity', 'hermes', 'deepseek') or '*' for broadcast",
+                                "default": "*"
+                            },
+                            "priority": {
+                                "type": "string",
+                                "enum": ["ROUTINE", "HIGH", "BLOCKING"],
+                                "default": "ROUTINE"
+                            },
+                            "correlation_id": {
+                                "type": "string",
+                                "description": "Optional correlation ID linking to a task or PR"
+                            },
+                            "payload": {
+                                "type": "object",
+                                "description": "Structured message payload"
+                            }
+                        }
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "a2a_read_inbox",
+                    "description": "Read and cryptographically verify all pending incoming messages from the swarm inbox.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {}
+                    }
+                }
+            }
+        ]