devsper 2.1.6__py3-none-any.whl

devsper/__init__.py

@@ -0,0 +1,14 @@
+"""
+devsper: distributed AI swarm runtime.
+
+Example:
+    from devsper import Swarm
+
+    swarm = Swarm(config="devsper.toml")
+    result = swarm.run("analyze diffusion models")
+"""
+
+from devsper.config import get_config
+from devsper.swarm.swarm import Swarm
+
+__all__ = ["Swarm", "get_config"]

devsper/agents/a2a/__init__.py

@@ -0,0 +1,27 @@
+"""
+A2A (Agent-to-Agent) integration: client, server, tool adapter.
+"""
+
+from devsper.agents.a2a.types import (
+    AgentCard,
+    AgentSkill,
+    A2ATaskRequest,
+    A2ATaskResponse,
+)
+from devsper.agents.a2a.client import A2AClient
+from devsper.agents.a2a.server import create_a2a_app, run_a2a_server
+from devsper.agents.a2a.tool_adapter import A2AAgentTool
+
+# Alias for task spec: "A2AServer" = run_a2a_server / create_a2a_app
+A2AServer = create_a2a_app
+
+__all__ = [
+    "A2AClient",
+    "A2AServer",
+    "AgentCard",
+    "A2ATaskRequest",
+    "A2ATaskResponse",
+    "A2AAgentTool",
+    "create_a2a_app",
+    "run_a2a_server",
+]

devsper/agents/a2a/client.py

@@ -0,0 +1,126 @@
+"""
+A2A client: call external A2A-compliant agents (get AgentCard, send_task, stream_task).
+"""
+
+import uuid
+from typing import AsyncIterator
+
+from devsper.agents.a2a.types import (
+    AgentCard,
+    AgentSkill,
+    A2ATaskRequest,
+    A2ATaskResponse,
+)
+
+
+def _parse_agent_card(data: dict) -> AgentCard:
+    """Build AgentCard from JSON response."""
+    skills_data = data.get("skills") or []
+    skills = [
+        AgentSkill(
+            id=s.get("id", ""),
+            name=s.get("name", ""),
+            description=s.get("description", ""),
+            input_modes=list(s.get("inputModes") or []),
+            output_modes=list(s.get("outputModes") or []),
+        )
+        for s in skills_data
+        if isinstance(s, dict)
+    ]
+    return AgentCard(
+        name=data.get("name", ""),
+        description=data.get("description", ""),
+        url=data.get("url", ""),
+        version=data.get("version", ""),
+        capabilities=list(data.get("capabilities") or []),
+        skills=skills,
+        authentication=data.get("authentication"),
+    )
+
+
+def _parse_task_response(data: dict) -> A2ATaskResponse:
+    """Build A2ATaskResponse from JSON."""
+    status = data.get("status", "failed")
+    if status not in ("submitted", "working", "completed", "failed", "canceled"):
+        status = "failed"
+    return A2ATaskResponse(
+        id=data.get("id", ""),
+        status=status,
+        result=data.get("result"),
+        artifacts=data.get("artifacts") or [],
+    )
+
+
+class A2AClient:
+    """Calls external A2A-compliant agents as if they were local tools."""
+
+    def __init__(self, timeout_seconds: float = 60.0) -> None:
+        self.timeout_seconds = timeout_seconds
+
+    def _client(self):
+        import httpx
+        return httpx.AsyncClient(timeout=self.timeout_seconds)
+
+    async def get_agent_card(self, base_url: str) -> AgentCard:
+        """GET {base_url}/.well-known/agent.json"""
+        url = base_url.rstrip("/") + "/.well-known/agent.json"
+        async with self._client() as client:
+            r = await client.get(url)
+            r.raise_for_status()
+            data = r.json()
+        return _parse_agent_card(data)
+
+    async def send_task(
+        self,
+        base_url: str,
+        request: A2ATaskRequest,
+        poll_interval: float = 0.5,
+    ) -> A2ATaskResponse:
+        """POST {base_url}/tasks/send, then poll GET /tasks/{id} until completed/failed."""
+        import asyncio
+        url = base_url.rstrip("/") + "/tasks/send"
+        body = {
+            "id": request.id,
+            "message": request.message,
+            "sessionId": request.session_id,
+        }
+        async with self._client() as client:
+            r = await client.post(url, json=body)
+            r.raise_for_status()
+            data = r.json()
+        resp = _parse_task_response(data)
+        if resp.status in ("completed", "failed", "canceled"):
+            return resp
+        task_url = base_url.rstrip("/") + f"/tasks/{resp.id}"
+        while resp.status in ("submitted", "working"):
+            await asyncio.sleep(poll_interval)
+            async with self._client() as client:
+                r = await client.get(task_url)
+                r.raise_for_status()
+                data = r.json()
+            resp = _parse_task_response(data)
+            if resp.status in ("completed", "failed", "canceled"):
+                return resp
+        return resp
+
+    async def stream_task(
+        self,
+        base_url: str,
+        request: A2ATaskRequest,
+    ) -> AsyncIterator[str]:
+        """POST {base_url}/tasks/sendSubscribe, consume SSE stream, yield text chunks."""
+        import httpx
+        url = base_url.rstrip("/") + "/tasks/sendSubscribe"
+        body = {
+            "id": request.id,
+            "message": request.message,
+            "sessionId": request.session_id,
+        }
+        async with httpx.AsyncClient(timeout=self.timeout_seconds) as client:
+            async with client.stream("POST", url, json=body) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if line.startswith("data:"):
+                        data = line[5:].strip()
+                        if data and data != "[DONE]":
+                            yield data

devsper/agents/a2a/discovery.py

@@ -0,0 +1,24 @@
+"""
+A2A discovery: fetch AgentCard from URL, register skills as A2AAgentTool.
+"""
+
+import asyncio
+
+from devsper.config.schema import A2AAgentConfig
+from devsper.agents.a2a.client import A2AClient
+from devsper.agents.a2a.tool_adapter import A2AAgentTool
+
+
+async def discover_a2a_tools_async(agent_config: A2AAgentConfig) -> int:
+    """Fetch AgentCard from agent URL, create A2AAgentTool per skill, register. Return count."""
+    client = A2AClient()
+    card = await client.get_agent_card(agent_config.url)
+    name = agent_config.name or card.name or "a2a-agent"
+    for skill in card.skills:
+        A2AAgentTool(agent_name=name, skill=skill, base_url=agent_config.url, client=client)
+    return len(card.skills)
+
+
+def register_a2a_agent(agent_config: A2AAgentConfig) -> int:
+    """Sync: discover and register A2A agent tools; return count."""
+    return asyncio.run(discover_a2a_tools_async(agent_config))

devsper/agents/a2a/server.py

@@ -0,0 +1,128 @@
+"""
+A2A server: expose devsper agents as A2A-compliant endpoints (FastAPI).
+"""
+
+from typing import Any
+
+from devsper.agents.a2a.types import AgentCard, AgentSkill, A2ATaskRequest, A2ATaskResponse
+
+
+def _build_agent_card(host: str, port: int, swarm_name: str) -> dict:
+    """Build AgentCard JSON for GET /.well-known/agent.json."""
+    from devsper.intelligence.strategy_selector import ExecutionStrategy
+    url = f"http://{host}:{port}"
+    name = swarm_name or "devsper"
+    skills = [
+        {
+            "id": s.value,
+            "name": s.value.replace("_", " ").title(),
+            "description": f"Execute task using {s.value} strategy.",
+            "inputModes": ["text"],
+            "outputModes": ["text"],
+        }
+        for s in ExecutionStrategy
+        if s != ExecutionStrategy.GENERAL
+    ]
+    return {
+        "name": name,
+        "description": "devsper swarm orchestration as A2A agent.",
+        "url": url,
+        "version": "1.10.5",
+        "capabilities": ["streaming"],
+        "skills": skills,
+    }
+
+
+def create_a2a_app(host: str = "localhost", port: int = 8080, swarm_name: str = "") -> Any:
+    """Create FastAPI app with A2A routes. Requires fastapi, uvicorn, sse-starlette."""
+    from fastapi import FastAPI
+    from fastapi.responses import StreamingResponse
+    import asyncio
+    import uuid
+
+    app = FastAPI(title="devsper A2A Server")
+
+    @app.get("/.well-known/agent.json")
+    def agent_card() -> dict:
+        return _build_agent_card(host, port, swarm_name)
+
+    @app.post("/tasks/send")
+    async def tasks_send(body: dict) -> dict:
+        """Accept A2A task, run via Swarm, return result."""
+        task_id = body.get("id") or str(uuid.uuid4())
+        message = body.get("message") or {}
+        text = message.get("text", "") if isinstance(message, dict) else ""
+        if not text:
+            return {
+                "id": task_id,
+                "status": "failed",
+                "result": "Missing message.text",
+                "artifacts": [],
+            }
+        try:
+            from devsper.config import get_config
+            from devsper.swarm.swarm import Swarm
+            cfg = get_config()
+            swarm = Swarm(config=cfg)
+            result = swarm.run(text)
+            out = "\n".join(f"{k}: {v[:2000]}" for k, v in result.items()) if result else ""
+            return {
+                "id": task_id,
+                "status": "completed",
+                "result": out,
+                "artifacts": [],
+            }
+        except Exception as e:
+            return {
+                "id": task_id,
+                "status": "failed",
+                "result": str(e),
+                "artifacts": [],
+            }
+
+    @app.post("/tasks/sendSubscribe")
+    async def tasks_send_subscribe(body: dict):
+        """SSE streaming task execution."""
+        task_id = body.get("id") or str(uuid.uuid4())
+        message = body.get("message") or {}
+        text = message.get("text", "") if isinstance(message, dict) else ""
+
+        async def stream():
+            if not text:
+                yield f"data: {__import__('json').dumps({'error': 'Missing message.text'})}\n\n"
+                return
+            try:
+                from devsper.config import get_config
+                from devsper.swarm.swarm import Swarm
+                cfg = get_config()
+                swarm = Swarm(config=cfg)
+                result = swarm.run(text)
+                out = "\n".join(f"{k}: {v[:2000]}" for k, v in result.items()) if result else ""
+                yield f"data: {__import__('json').dumps({'id': task_id, 'status': 'completed', 'result': out})}\n\n"
+            except Exception as e:
+                yield f"data: {__import__('json').dumps({'id': task_id, 'status': 'failed', 'result': str(e)})}\n\n"
+
+        return StreamingResponse(
+            stream(),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "Connection": "keep-alive"},
+        )
+
+    @app.get("/tasks/{task_id}")
+    def task_status(task_id: str) -> dict:
+        """Task status (stub: we don't persist task state for now)."""
+        return {"id": task_id, "status": "completed", "result": None, "artifacts": []}
+
+    @app.post("/tasks/{task_id}/cancel")
+    def task_cancel(task_id: str) -> dict:
+        """Cancel running task (stub)."""
+        return {"id": task_id, "status": "canceled", "result": None, "artifacts": []}
+
+    return app
+
+
+def run_a2a_server(host: str = "localhost", port: int = 8080, swarm_name: str = "") -> None:
+    """Run A2A server with uvicorn."""
+    import uvicorn
+    app = create_a2a_app(host=host, port=port, swarm_name=swarm_name)
+    uvicorn.run(app, host=host, port=port)

devsper/agents/a2a/tool_adapter.py

@@ -0,0 +1,68 @@
+"""
+A2AAgentTool: wrap an external A2A agent skill as a devsper Tool.
+"""
+
+import asyncio
+import uuid
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+from devsper.agents.a2a.types import AgentCard, AgentSkill, A2ATaskRequest, A2ATaskResponse
+from devsper.agents.a2a.client import A2AClient
+
+
+class A2AAgentTool(Tool):
+    """
+    Wraps an external A2A agent skill as a devsper tool.
+    Discovery: fetch AgentCard, create one tool per skill.
+    """
+
+    def __init__(
+        self,
+        agent_name: str,
+        skill: AgentSkill,
+        base_url: str,
+        client: A2AClient | None = None,
+    ) -> None:
+        self.name = f"{agent_name}.{skill.id}"
+        self.description = skill.description or f"A2A skill: {skill.name}"
+        self.category = "a2a"
+        self.input_schema = {
+            "type": "object",
+            "properties": {"task": {"type": "string", "description": "Task or prompt for the agent"}},
+            "required": ["task"],
+        }
+        self._base_url = base_url.rstrip("/")
+        self._client = client or A2AClient()
+        self._skill_id = skill.id
+        register(self)
+
+    def run(self, task: str = "", **kwargs) -> str:
+        """Send task to external A2A agent via send_task."""
+        text = task or kwargs.get("task", "")
+        if not text:
+            return "Error: missing 'task' argument"
+        request = A2ATaskRequest(
+            id=str(uuid.uuid4()),
+            message={"text": text},
+            session_id=None,
+        )
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        if loop.is_running():
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+                future = pool.submit(
+                    asyncio.run,
+                    self._client.send_task(self._base_url, request),
+                )
+                resp = future.result()
+        else:
+            resp = loop.run_until_complete(self._client.send_task(self._base_url, request))
+        if resp.status == "completed" and resp.result is not None:
+            return resp.result
+        return f"Error: status={resp.status}, result={resp.result}"

devsper/agents/a2a/types.py

@@ -0,0 +1,49 @@
+"""
+A2A (Agent-to-Agent) protocol types — AgentCard, TaskRequest/Response, etc.
+"""
+
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass
+class AgentSkill:
+    """One skill exposed by an A2A agent."""
+    id: str
+    name: str
+    description: str
+    input_modes: list[str]  # e.g. ["text", "file"]
+    output_modes: list[str]
+
+
+@dataclass
+class AgentCard:
+    """A2A agent descriptor — follows A2A spec."""
+    name: str
+    description: str
+    url: str  # this agent's A2A endpoint
+    version: str
+    capabilities: list[str]  # e.g. ["streaming", "pushNotifications"]
+    skills: list[AgentSkill]
+    authentication: dict | None = None
+
+
+@dataclass
+class A2ATaskRequest:
+    """A2A task send request."""
+    id: str  # uuid4
+    message: dict  # A2A Message object
+    session_id: str | None = None
+
+
+@dataclass
+class A2ATaskResponse:
+    """A2A task response."""
+    id: str
+    status: Literal["submitted", "working", "completed", "failed", "canceled"]
+    result: str | None = None
+    artifacts: list[dict] | None = None
+
+    def __post_init__(self) -> None:
+        if self.artifacts is None:
+            self.artifacts = []