molecule-ai-workspace-runtime 0.1.0__tar.gz

molecule_ai_workspace_runtime-0.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: molecule-ai-workspace-runtime
+Version: 0.1.0
+Summary: Molecule AI workspace runtime — shared infrastructure for all agent adapters
+License: BSL-1.1
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: a2a-sdk[http-server]>=0.3.25
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: starlette>=0.38.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: opentelemetry-api>=1.24.0
+Requires-Dist: opentelemetry-sdk>=1.24.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.24.0
+Requires-Dist: temporalio>=1.7.0
+
+# molecule-ai-workspace-runtime
+
+Shared Python runtime infrastructure for all Molecule AI agent adapters.
+
+This package provides the core machinery that every Molecule AI workspace container needs:
+
+- **A2A server** — Registers with the platform, heartbeats, serves A2A JSON-RPC
+- **Adapter interface** — `BaseAdapter` / `AdapterConfig` / `SetupResult`
+- **Built-in tools** — delegation, memory, approvals, sandbox, telemetry
+- **Skill loader** — loads and hot-reloads skill modules from `/configs/skills/`
+- **Plugin system** — per-workspace + shared plugin discovery and install
+- **Config / preflight** — YAML config loading with validation
+
+## Installation
+
+```bash
+pip install molecule-ai-workspace-runtime
+```
+
+## Adapter Discovery
+
+The runtime discovers adapters in two ways:
+
+1. **`ADAPTER_MODULE` env var** (standalone adapter repos):
+   ```bash
+   ADAPTER_MODULE=my_adapter molecule-runtime
+   ```
+   The module must export an `Adapter` class extending `BaseAdapter`.
+
+2. **Built-in subdirectory scan** (monorepo local dev):
+   Scans `molecule_runtime/adapters/` subdirectories for `Adapter` classes.
+
+## Writing an Adapter
+
+```python
+from molecule_runtime.adapters.base import BaseAdapter, AdapterConfig
+from a2a.server.agent_execution import AgentExecutor
+
+class Adapter(BaseAdapter):
+    @staticmethod
+    def name() -> str:
+        return "my-runtime"
+
+    @staticmethod
+    def display_name() -> str:
+        return "My Runtime"
+
+    @staticmethod
+    def description() -> str:
+        return "My custom agent runtime"
+
+    async def setup(self, config: AdapterConfig) -> None:
+        result = await self._common_setup(config)
+        # Store result attributes for create_executor
+
+    async def create_executor(self, config: AdapterConfig) -> AgentExecutor:
+        # Return an AgentExecutor instance
+        ...
+```
+
+Set `ADAPTER_MODULE=my_package.adapter` and run `molecule-runtime`.
+
+## License
+
+BSL-1.1 — see LICENSE for details.

molecule_ai_workspace_runtime-0.1.0/README.md

@@ -0,0 +1,65 @@
+# molecule-ai-workspace-runtime
+
+Shared Python runtime infrastructure for all Molecule AI agent adapters.
+
+This package provides the core machinery that every Molecule AI workspace container needs:
+
+- **A2A server** — Registers with the platform, heartbeats, serves A2A JSON-RPC
+- **Adapter interface** — `BaseAdapter` / `AdapterConfig` / `SetupResult`
+- **Built-in tools** — delegation, memory, approvals, sandbox, telemetry
+- **Skill loader** — loads and hot-reloads skill modules from `/configs/skills/`
+- **Plugin system** — per-workspace + shared plugin discovery and install
+- **Config / preflight** — YAML config loading with validation
+
+## Installation
+
+```bash
+pip install molecule-ai-workspace-runtime
+```
+
+## Adapter Discovery
+
+The runtime discovers adapters in two ways:
+
+1. **`ADAPTER_MODULE` env var** (standalone adapter repos):
+   ```bash
+   ADAPTER_MODULE=my_adapter molecule-runtime
+   ```
+   The module must export an `Adapter` class extending `BaseAdapter`.
+
+2. **Built-in subdirectory scan** (monorepo local dev):
+   Scans `molecule_runtime/adapters/` subdirectories for `Adapter` classes.
+
+## Writing an Adapter
+
+```python
+from molecule_runtime.adapters.base import BaseAdapter, AdapterConfig
+from a2a.server.agent_execution import AgentExecutor
+
+class Adapter(BaseAdapter):
+    @staticmethod
+    def name() -> str:
+        return "my-runtime"
+
+    @staticmethod
+    def display_name() -> str:
+        return "My Runtime"
+
+    @staticmethod
+    def description() -> str:
+        return "My custom agent runtime"
+
+    async def setup(self, config: AdapterConfig) -> None:
+        result = await self._common_setup(config)
+        # Store result attributes for create_executor
+
+    async def create_executor(self, config: AdapterConfig) -> AgentExecutor:
+        # Return an AgentExecutor instance
+        ...
+```
+
+Set `ADAPTER_MODULE=my_package.adapter` and run `molecule-runtime`.
+
+## License
+
+BSL-1.1 — see LICENSE for details.

molecule_ai_workspace_runtime-0.1.0/molecule_ai_workspace_runtime.egg-info/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: molecule-ai-workspace-runtime
+Version: 0.1.0
+Summary: Molecule AI workspace runtime — shared infrastructure for all agent adapters
+License: BSL-1.1
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: a2a-sdk[http-server]>=0.3.25
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: starlette>=0.38.0
+Requires-Dist: websockets>=12.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: opentelemetry-api>=1.24.0
+Requires-Dist: opentelemetry-sdk>=1.24.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.24.0
+Requires-Dist: temporalio>=1.7.0
+
+# molecule-ai-workspace-runtime
+
+Shared Python runtime infrastructure for all Molecule AI agent adapters.
+
+This package provides the core machinery that every Molecule AI workspace container needs:
+
+- **A2A server** — Registers with the platform, heartbeats, serves A2A JSON-RPC
+- **Adapter interface** — `BaseAdapter` / `AdapterConfig` / `SetupResult`
+- **Built-in tools** — delegation, memory, approvals, sandbox, telemetry
+- **Skill loader** — loads and hot-reloads skill modules from `/configs/skills/`
+- **Plugin system** — per-workspace + shared plugin discovery and install
+- **Config / preflight** — YAML config loading with validation
+
+## Installation
+
+```bash
+pip install molecule-ai-workspace-runtime
+```
+
+## Adapter Discovery
+
+The runtime discovers adapters in two ways:
+
+1. **`ADAPTER_MODULE` env var** (standalone adapter repos):
+   ```bash
+   ADAPTER_MODULE=my_adapter molecule-runtime
+   ```
+   The module must export an `Adapter` class extending `BaseAdapter`.
+
+2. **Built-in subdirectory scan** (monorepo local dev):
+   Scans `molecule_runtime/adapters/` subdirectories for `Adapter` classes.
+
+## Writing an Adapter
+
+```python
+from molecule_runtime.adapters.base import BaseAdapter, AdapterConfig
+from a2a.server.agent_execution import AgentExecutor
+
+class Adapter(BaseAdapter):
+    @staticmethod
+    def name() -> str:
+        return "my-runtime"
+
+    @staticmethod
+    def display_name() -> str:
+        return "My Runtime"
+
+    @staticmethod
+    def description() -> str:
+        return "My custom agent runtime"
+
+    async def setup(self, config: AdapterConfig) -> None:
+        result = await self._common_setup(config)
+        # Store result attributes for create_executor
+
+    async def create_executor(self, config: AdapterConfig) -> AgentExecutor:
+        # Return an AgentExecutor instance
+        ...
+```
+
+Set `ADAPTER_MODULE=my_package.adapter` and run `molecule-runtime`.
+
+## License
+
+BSL-1.1 — see LICENSE for details.

molecule_ai_workspace_runtime-0.1.0/molecule_ai_workspace_runtime.egg-info/SOURCES.txt

@@ -0,0 +1,60 @@
+README.md
+pyproject.toml
+molecule_ai_workspace_runtime.egg-info/PKG-INFO
+molecule_ai_workspace_runtime.egg-info/SOURCES.txt
+molecule_ai_workspace_runtime.egg-info/dependency_links.txt
+molecule_ai_workspace_runtime.egg-info/entry_points.txt
+molecule_ai_workspace_runtime.egg-info/requires.txt
+molecule_ai_workspace_runtime.egg-info/top_level.txt
+molecule_runtime/__init__.py
+molecule_runtime/a2a_cli.py
+molecule_runtime/a2a_client.py
+molecule_runtime/a2a_executor.py
+molecule_runtime/a2a_mcp_server.py
+molecule_runtime/a2a_tools.py
+molecule_runtime/agent.py
+molecule_runtime/claude_sdk_executor.py
+molecule_runtime/cli_executor.py
+molecule_runtime/config.py
+molecule_runtime/consolidation.py
+molecule_runtime/coordinator.py
+molecule_runtime/events.py
+molecule_runtime/executor_helpers.py
+molecule_runtime/heartbeat.py
+molecule_runtime/initial_prompt.py
+molecule_runtime/main.py
+molecule_runtime/molecule_ai_status.py
+molecule_runtime/platform_auth.py
+molecule_runtime/plugins.py
+molecule_runtime/preflight.py
+molecule_runtime/prompt.py
+molecule_runtime/transcript_auth.py
+molecule_runtime/watcher.py
+molecule_runtime/adapters/__init__.py
+molecule_runtime/adapters/base.py
+molecule_runtime/adapters/shared_runtime.py
+molecule_runtime/builtin_tools/__init__.py
+molecule_runtime/builtin_tools/a2a_tools.py
+molecule_runtime/builtin_tools/approval.py
+molecule_runtime/builtin_tools/audit.py
+molecule_runtime/builtin_tools/awareness_client.py
+molecule_runtime/builtin_tools/compliance.py
+molecule_runtime/builtin_tools/delegation.py
+molecule_runtime/builtin_tools/governance.py
+molecule_runtime/builtin_tools/hitl.py
+molecule_runtime/builtin_tools/medo.py
+molecule_runtime/builtin_tools/memory.py
+molecule_runtime/builtin_tools/sandbox.py
+molecule_runtime/builtin_tools/security_scan.py
+molecule_runtime/builtin_tools/telemetry.py
+molecule_runtime/builtin_tools/temporal_workflow.py
+molecule_runtime/plugins_registry/__init__.py
+molecule_runtime/plugins_registry/builtins.py
+molecule_runtime/plugins_registry/protocol.py
+molecule_runtime/plugins_registry/raw_drop.py
+molecule_runtime/policies/__init__.py
+molecule_runtime/policies/namespaces.py
+molecule_runtime/policies/routing.py
+molecule_runtime/skill_loader/__init__.py
+molecule_runtime/skill_loader/loader.py
+molecule_runtime/skill_loader/watcher.py

molecule_ai_workspace_runtime-0.1.0/molecule_ai_workspace_runtime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

molecule_ai_workspace_runtime-0.1.0/molecule_ai_workspace_runtime.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+molecule-runtime = molecule_runtime.main:main_sync

molecule_ai_workspace_runtime-0.1.0/molecule_ai_workspace_runtime.egg-info/requires.txt

@@ -0,0 +1,11 @@
+a2a-sdk[http-server]>=0.3.25
+httpx>=0.27.0
+uvicorn>=0.30.0
+starlette>=0.38.0
+websockets>=12.0
+pyyaml>=6.0
+langchain-core>=0.3.0
+opentelemetry-api>=1.24.0
+opentelemetry-sdk>=1.24.0
+opentelemetry-exporter-otlp-proto-http>=1.24.0
+temporalio>=1.7.0

molecule_ai_workspace_runtime-0.1.0/molecule_ai_workspace_runtime.egg-info/top_level.txt

@@ -0,0 +1 @@
+molecule_runtime

molecule_ai_workspace_runtime-0.1.0/molecule_runtime/__init__.py

@@ -0,0 +1,6 @@
+"""Molecule AI workspace runtime — shared infrastructure for all agent adapters."""
+
+from molecule_runtime.adapters.base import BaseAdapter, AdapterConfig, SetupResult
+
+__version__ = "0.1.0"
+__all__ = ["BaseAdapter", "AdapterConfig", "SetupResult"]

molecule_ai_workspace_runtime-0.1.0/molecule_runtime/a2a_cli.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""A2A CLI — command-line tools for inter-workspace communication.
+
+Supports both synchronous and asynchronous delegation:
+  a2a delegate <id> <task>        — Send task, wait for response (sync)
+  a2a delegate --async <id> <task> — Send task, return task ID immediately
+  a2a status <task_id>            — Check task status / get result
+  a2a peers                       — List available peers
+  a2a info                        — Show this workspace's info
+
+Environment variables:
+  WORKSPACE_ID  — this workspace's ID
+  PLATFORM_URL  — platform API base URL
+"""
+
+import asyncio
+import json
+import os
+import sys
+import uuid
+
+import httpx
+
+WORKSPACE_ID = os.environ.get("WORKSPACE_ID", "")
+PLATFORM_URL = os.environ.get("PLATFORM_URL", "http://platform:8080")
+
+
+async def discover(target_id: str) -> dict | None:
+    """Discover a peer workspace's URL."""
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp = await client.get(
+            f"{PLATFORM_URL}/registry/discover/{target_id}",
+            headers={"X-Workspace-ID": WORKSPACE_ID},
+        )
+        if resp.status_code == 200:
+            return resp.json()
+        return None
+
+
+async def delegate(target_id: str, task: str, async_mode: bool = False):
+    """Delegate a task to another workspace."""
+    peer = await discover(target_id)
+    if not peer:
+        print(f"Error: cannot reach workspace {target_id} (access denied or offline)", file=sys.stderr)
+        sys.exit(1)
+
+    target_url = peer.get("url", "")
+    if not target_url:
+        print(f"Error: workspace {target_id} has no URL", file=sys.stderr)
+        sys.exit(1)
+
+    task_id = str(uuid.uuid4())
+
+    if async_mode:
+        # Async: send and return immediately, don't wait for response
+        # Use a background task that fires and forgets
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            try:
+                # Send with a short timeout — just confirm receipt
+                resp = await client.post(
+                    target_url,
+                    json={
+                        "jsonrpc": "2.0",
+                        "id": task_id,
+                        "method": "message/send",
+                        "params": {
+                            "message": {
+                                "role": "user",
+                                "messageId": str(uuid.uuid4()),
+                                "parts": [{"kind": "text", "text": task}],
+                            }
+                        },
+                    },
+                )
+                # Even if we timeout, the task is queued on the target
+                print(json.dumps({
+                    "task_id": task_id,
+                    "target": target_id,
+                    "status": "submitted",
+                    "target_url": target_url,
+                }))
+            except httpx.TimeoutException:
+                # Request was sent but we didn't get confirmation — task may or may not have been received
+                print(json.dumps({
+                    "task_id": task_id,
+                    "target": target_id,
+                    "status": "uncertain",
+                    "note": "Request sent but response timed out — delivery unconfirmed. Use 'a2a status' to check.",
+                }), file=sys.stderr)
+        return
+
+    # Sync: wait for full response with retry on rate limit
+    max_retries = 3
+    for attempt in range(max_retries):
+        async with httpx.AsyncClient(timeout=300.0) as client:
+            try:
+                resp = await client.post(
+                    target_url,
+                    json={
+                        "jsonrpc": "2.0",
+                        "id": task_id,
+                        "method": "message/send",
+                        "params": {
+                            "message": {
+                                "role": "user",
+                                "messageId": str(uuid.uuid4()),
+                                "parts": [{"kind": "text", "text": task}],
+                            }
+                        },
+                    },
+                )
+                try:
+                    data = resp.json()
+                except Exception:
+                    print(f"Error: invalid JSON response (status {resp.status_code})", file=sys.stderr)
+                    sys.exit(1)
+                if "result" in data:
+                    parts = data["result"].get("parts", [])
+                    text = parts[0].get("text", "") if parts else ""
+                    if text and text != "(no response generated)":
+                        print(text)
+                        return
+                    # Empty or no-response — might be rate limited, retry
+                    if attempt < max_retries - 1:
+                        delay = 5 * (2 ** attempt)
+                        print(f"(empty response, retrying in {delay}s...)", file=sys.stderr)
+                        await asyncio.sleep(delay)
+                        continue
+                    print(text or "(no response after retries)")
+                elif "error" in data:
+                    error_msg = data['error'].get('message', 'unknown')
+                    if ("rate" in error_msg.lower() or "overloaded" in error_msg.lower()) and attempt < max_retries - 1:
+                        delay = 5 * (2 ** attempt)
+                        print(f"(rate limited, retrying in {delay}s...)", file=sys.stderr)
+                        await asyncio.sleep(delay)
+                        continue
+                    print(f"Error: {error_msg}", file=sys.stderr)
+                    sys.exit(1)
+                return
+            except httpx.TimeoutException:
+                if attempt < max_retries - 1:
+                    delay = 5 * (2 ** attempt)
+                    print(f"(timeout, retrying in {delay}s...)", file=sys.stderr)
+                    await asyncio.sleep(delay)
+                    continue
+                print("Error: request timed out after retries", file=sys.stderr)
+                sys.exit(1)
+
+
+async def check_status(target_id: str, task_id: str):
+    """Check the status of an async task."""
+    peer = await discover(target_id)
+    if not peer:
+        print(f"Error: cannot reach workspace {target_id}", file=sys.stderr)
+        sys.exit(1)
+
+    target_url = peer.get("url", "")
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp = await client.post(
+            target_url,
+            json={
+                "jsonrpc": "2.0",
+                "id": str(uuid.uuid4()),
+                "method": "tasks/get",
+                "params": {"id": task_id},
+            },
+        )
+        data = resp.json()
+        if "result" in data:
+            task = data["result"]
+            status = task.get("status", {}).get("state", "unknown")
+            print(f"Status: {status}")
+            if status == "completed":
+                artifacts = task.get("artifacts", [])
+                for a in artifacts:
+                    for p in a.get("parts", []):
+                        if p.get("text"):
+                            print(p["text"])
+        elif "error" in data:
+            print(f"Error: {data['error'].get('message', 'unknown')}")
+
+
+async def peers():
+    """List available peers."""
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        resp = await client.get(f"{PLATFORM_URL}/registry/{WORKSPACE_ID}/peers")
+        if resp.status_code != 200:
+            print("Error: could not fetch peers", file=sys.stderr)
+            sys.exit(1)
+        for p in resp.json():
+            status = p.get("status", "?")
+            role = p.get("role", "")
+            print(f"{p['id']}  {p['name']:30s}  {status:10s}  {role}")
+
+
+async def info():
+    """Get this workspace's info."""
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        resp = await client.get(f"{PLATFORM_URL}/workspaces/{WORKSPACE_ID}")
+        if resp.status_code == 200:
+            d = resp.json()
+            print(f"ID:     {d['id']}")
+            print(f"Name:   {d['name']}")
+            print(f"Role:   {d.get('role', '')}")
+            print(f"Tier:   {d['tier']}")
+            print(f"Status: {d['status']}")
+            print(f"Parent: {d.get('parent_id', '(root)')}")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: a2a <command> [args]")
+        print("Commands:")
+        print("  delegate <workspace_id> <task>        — Send task, wait for response")
+        print("  delegate --async <workspace_id> <task> — Send task, return immediately")
+        print("  status <workspace_id> <task_id>       — Check async task status")
+        print("  peers                                 — List available peers")
+        print("  info                                  — Show workspace info")
+        sys.exit(1)
+
+    cmd = sys.argv[1]
+
+    if cmd == "delegate":
+        async_mode = "--async" in sys.argv
+        args = [a for a in sys.argv[2:] if a != "--async"]
+        if len(args) < 2:
+            print("Usage: a2a delegate [--async] <workspace_id> <task>", file=sys.stderr)
+            sys.exit(1)
+        asyncio.run(delegate(args[0], " ".join(args[1:]), async_mode))
+    elif cmd == "status":
+        if len(sys.argv) < 4:
+            print("Usage: a2a status <workspace_id> <task_id>", file=sys.stderr)
+            sys.exit(1)
+        asyncio.run(check_status(sys.argv[2], sys.argv[3]))
+    elif cmd == "peers":
+        asyncio.run(peers())
+    elif cmd == "info":
+        asyncio.run(info())
+    else:
+        print(f"Unknown command: {cmd}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

molecule_ai_workspace_runtime-0.1.0/molecule_runtime/a2a_client.py

@@ -0,0 +1,111 @@
+"""A2A protocol client — peer discovery, messaging, and workspace info.
+
+Shared constants (WORKSPACE_ID, PLATFORM_URL) live here so that
+a2a_tools and a2a_mcp_server can import them from a single place.
+"""
+
+import logging
+import os
+import uuid
+
+import httpx
+
+from platform_auth import auth_headers
+
+logger = logging.getLogger(__name__)
+
+WORKSPACE_ID = os.environ.get("WORKSPACE_ID", "")
+PLATFORM_URL = os.environ.get("PLATFORM_URL", "http://platform:8080")
+
+# Cache workspace ID → name mappings (populated by list_peers calls)
+_peer_names: dict[str, str] = {}
+
+# Sentinel prefix for errors originating from send_a2a_message / child agents.
+# Used by delegate_task to distinguish real errors from normal response text.
+_A2A_ERROR_PREFIX = "[A2A_ERROR] "
+
+
+async def discover_peer(target_id: str) -> dict | None:
+    """Discover a peer workspace's URL via the platform registry."""
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        try:
+            resp = await client.get(
+                f"{PLATFORM_URL}/registry/discover/{target_id}",
+                headers={"X-Workspace-ID": WORKSPACE_ID, **auth_headers()},
+            )
+            if resp.status_code == 200:
+                return resp.json()
+            return None
+        except Exception as e:
+            logger.error(f"Discovery failed for {target_id}: {e}")
+            return None
+
+
+async def send_a2a_message(target_url: str, message: str) -> str:
+    """Send an A2A message/send to a target workspace."""
+    # Fix F (Cycle 5 / H2 — flagged 5 consecutive audits): timeout=None allowed
+    # a hung upstream to block the agent indefinitely. Use a generous but bounded
+    # timeout: 30s connect + 300s read (long enough for slow LLM responses).
+    async with httpx.AsyncClient(
+        timeout=httpx.Timeout(connect=30.0, read=300.0, write=30.0, pool=30.0)
+    ) as client:
+        try:
+            resp = await client.post(
+                target_url,
+                headers=auth_headers(),
+                json={
+                    "jsonrpc": "2.0",
+                    "id": str(uuid.uuid4()),
+                    "method": "message/send",
+                    "params": {
+                        "message": {
+                            "role": "user",
+                            "messageId": str(uuid.uuid4()),
+                            "parts": [{"kind": "text", "text": message}],
+                        }
+                    },
+                },
+            )
+            data = resp.json()
+            if "result" in data:
+                parts = data["result"].get("parts", [])
+                text = parts[0].get("text", "") if parts else "(no response)"
+                # Tag child-reported errors so the caller can detect them reliably
+                if text.startswith("Agent error:"):
+                    return f"{_A2A_ERROR_PREFIX}{text}"
+                return text
+            elif "error" in data:
+                return f"{_A2A_ERROR_PREFIX}{data['error'].get('message', 'unknown')}"
+            return str(data)
+        except Exception as e:
+            return f"{_A2A_ERROR_PREFIX}{e}"
+
+
+async def get_peers() -> list[dict]:
+    """Get this workspace's peers from the platform registry."""
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        try:
+            resp = await client.get(
+                f"{PLATFORM_URL}/registry/{WORKSPACE_ID}/peers",
+                headers={"X-Workspace-ID": WORKSPACE_ID, **auth_headers()},
+            )
+            if resp.status_code == 200:
+                return resp.json()
+            return []
+        except Exception:
+            return []
+
+
+async def get_workspace_info() -> dict:
+    """Get this workspace's info from the platform."""
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        try:
+            resp = await client.get(
+                f"{PLATFORM_URL}/workspaces/{WORKSPACE_ID}",
+                headers=auth_headers(),
+            )
+            if resp.status_code == 200:
+                return resp.json()
+            return {"error": "not found"}
+        except Exception as e:
+            return {"error": str(e)}