Bundle multi-agent assets into exportable agents suite

agents-suite/README.md

@@ -0,0 +1,16 @@
+# Agents Suite
+
+Consolidated bundle of all existing multi-agent, automation, and AI assets for portable export. Each item preserves its original structure so it can be lifted out independently.
+
+- `backend-ai/` (from `backend/ai`): FastAPI AI inference service with multi-engine routing and governance.
+- `_shared/` (from `platforms/_shared`): Shared kernel (engine/event bus/sandbox protocols) used by the platform packages.
+- `automation-platform/` (from `platforms/automation-platform`): Python multi-agent pipeline orchestrator and agent pool.
+- `automation/` (from `platforms/automation`): Instant execution/organizer manifests, scripts, and docs for automation pipelines.
+- `eco-superai/` (from `platforms/eco-superai`): SuperAI platform bundle (ops, infra, artifacts, and source).
+- `ng-era-platforms/` (from `platforms/ng-era-platforms`): Legacy multi-agent/runtime archive for backward compatibility.
+- `Agent_Actions.zip` (from repository root): Packaged agent action set.
+
+Migration tips:
+- Keep `_shared` alongside `automation-platform` so protocol imports (`platform_shared.*`) resolve without modification.
+- Each package includes its own README/pyproject/requirements; install or run tests from inside the copied folder as needed.
+- To export, zip or copy the entire `agents-suite/` directory.

agents-suite/_shared/conftest.py

@@ -0,0 +1,4 @@
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent / "src"))

agents-suite/_shared/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "platform-shared"
+version = "1.0.0"
+description = "Shared kernel — sandbox/container/environment framework and cross-cutting protocols for decentralized platforms."
+requires-python = ">=3.11"
+license = { text = "Proprietary" }
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8.3", "pytest-asyncio>=0.24"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/platform_shared"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

agents-suite/_shared/src/platform_shared/__init__.py

@@ -0,0 +1,3 @@
+"""Platform Shared Kernel — sandbox, container, environment framework and protocols."""
+
+__version__ = "1.0.0"

agents-suite/_shared/src/platform_shared/domain/__init__.py

@@ -0,0 +1,25 @@
+"""Shared domain primitives."""
+
+from platform_shared.domain.errors import (
+    PlatformError,
+    SandboxError,
+    ContainerError,
+    EnvironmentError as EnvError,
+    ResourceExhaustedError,
+    TimeoutExpiredError,
+    IsolationViolationError,
+)
+from platform_shared.domain.platform_id import PlatformId
+from platform_shared.domain.version import SemVer
+
+__all__ = [
+    "PlatformError",
+    "SandboxError",
+    "ContainerError",
+    "EnvError",
+    "ResourceExhaustedError",
+    "TimeoutExpiredError",
+    "IsolationViolationError",
+    "PlatformId",
+    "SemVer",
+]

agents-suite/_shared/src/platform_shared/domain/errors.py

@@ -0,0 +1,68 @@
+"""Base error hierarchy for the platform ecosystem."""
+
+from __future__ import annotations
+
+
+class PlatformError(Exception):
+    """Root of all platform errors."""
+
+    def __init__(self, message: str, *, code: str = "PLATFORM_ERROR", context: dict | None = None):
+        super().__init__(message)
+        self.code = code
+        self.context = context or {}
+
+
+class SandboxError(PlatformError):
+    """Sandbox lifecycle or execution failure."""
+
+    def __init__(self, message: str, *, sandbox_id: str = "", **kw):
+        super().__init__(message, code="SANDBOX_ERROR", **kw)
+        self.sandbox_id = sandbox_id
+
+
+class ContainerError(PlatformError):
+    """Container runtime failure."""
+
+    def __init__(self, message: str, *, container_id: str = "", **kw):
+        super().__init__(message, code="CONTAINER_ERROR", **kw)
+        self.container_id = container_id
+
+
+class EnvironmentError(PlatformError):  # noqa: A001 — intentional shadow
+    """Environment management failure."""
+
+    def __init__(self, message: str, *, env_id: str = "", **kw):
+        super().__init__(message, code="ENVIRONMENT_ERROR", **kw)
+        self.env_id = env_id
+
+
+class ResourceExhaustedError(SandboxError):
+    """CPU, memory, or fd limit exceeded inside a sandbox."""
+
+    def __init__(self, resource: str, limit: float, actual: float, **kw):
+        super().__init__(
+            f"{resource} exhausted: limit={limit}, actual={actual}", code="RESOURCE_EXHAUSTED", **kw
+        )
+        self.resource = resource
+        self.limit = limit
+        self.actual = actual
+
+
+class TimeoutExpiredError(SandboxError):
+    """Execution exceeded its time budget."""
+
+    def __init__(self, timeout_seconds: float, **kw):
+        super().__init__(
+            f"Execution timed out after {timeout_seconds}s", code="TIMEOUT_EXPIRED", **kw
+        )
+        self.timeout_seconds = timeout_seconds
+
+
+class IsolationViolationError(SandboxError):
+    """An operation attempted to escape its isolation boundary."""
+
+    def __init__(self, violation: str, **kw):
+        super().__init__(
+            f"Isolation violation: {violation}", code="ISOLATION_VIOLATION", **kw
+        )
+        self.violation = violation

agents-suite/_shared/src/platform_shared/domain/platform_id.py

@@ -0,0 +1,33 @@
+"""PlatformId — strongly-typed identifier for every platform in the ecosystem."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+_SLUG_RE = re.compile(r"^[a-z][a-z0-9-]{1,62}[a-z0-9]$")
+
+
+@dataclass(frozen=True, slots=True)
+class PlatformId:
+    """Immutable, validated platform identifier.
+
+    Format: lowercase alphanumeric slug with hyphens, 3-64 chars.
+    Examples: ``automation-platform``, ``governance-platform``
+    """
+
+    value: str
+
+    def __post_init__(self) -> None:
+        if not _SLUG_RE.match(self.value):
+            raise ValueError(
+                f"Invalid PlatformId '{self.value}': must be lowercase slug, 3-64 chars"
+            )
+
+    def __str__(self) -> str:
+        return self.value
+
+    @property
+    def package_name(self) -> str:
+        """Python package name (hyphens → underscores)."""
+        return self.value.replace("-", "_")

agents-suite/_shared/src/platform_shared/domain/version.py

@@ -0,0 +1,43 @@
+"""SemVer — semantic versioning value object."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from functools import total_ordering
+
+_SEMVER_RE = re.compile(r"^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.]+))?$")
+
+
+@total_ordering
+@dataclass(frozen=True, slots=True)
+class SemVer:
+    major: int
+    minor: int
+    patch: int
+    pre: str = ""
+
+    @classmethod
+    def parse(cls, text: str) -> SemVer:
+        m = _SEMVER_RE.match(text)
+        if not m:
+            raise ValueError(f"Invalid semver: {text}")
+        return cls(int(m[1]), int(m[2]), int(m[3]), m[4] or "")
+
+    def __str__(self) -> str:
+        base = f"{self.major}.{self.minor}.{self.patch}"
+        return f"{base}-{self.pre}" if self.pre else base
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, SemVer):
+            return NotImplemented
+        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
+
+    def bump_patch(self) -> SemVer:
+        return SemVer(self.major, self.minor, self.patch + 1)
+
+    def bump_minor(self) -> SemVer:
+        return SemVer(self.major, self.minor + 1, 0)
+
+    def bump_major(self) -> SemVer:
+        return SemVer(self.major + 1, 0, 0)

agents-suite/_shared/src/platform_shared/protocols/__init__.py

@@ -0,0 +1,19 @@
+"""Cross-cutting protocols — every platform engine must satisfy these."""
+
+from platform_shared.protocols.engine import Engine, EngineStatus
+from platform_shared.protocols.event_bus import EventBus, Event, EventHandler
+from platform_shared.protocols.health import HealthCheck, HealthStatus, HealthReport
+from platform_shared.protocols.lifecycle import Lifecycle, LifecycleState
+
+__all__ = [
+    "Engine",
+    "EngineStatus",
+    "EventBus",
+    "Event",
+    "EventHandler",
+    "HealthCheck",
+    "HealthStatus",
+    "HealthReport",
+    "Lifecycle",
+    "LifecycleState",
+]

agents-suite/_shared/src/platform_shared/protocols/engine.py

@@ -0,0 +1,32 @@
+"""Engine protocol — the universal contract for all platform engines."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Protocol, runtime_checkable
+
+
+class EngineStatus(str, Enum):
+    IDLE = "idle"
+    STARTING = "starting"
+    RUNNING = "running"
+    STOPPING = "stopping"
+    STOPPED = "stopped"
+    ERROR = "error"
+
+
+@runtime_checkable
+class Engine(Protocol):
+    """Every platform engine implements this interface."""
+
+    @property
+    def name(self) -> str: ...
+
+    @property
+    def status(self) -> EngineStatus: ...
+
+    async def start(self) -> None: ...
+
+    async def stop(self) -> None: ...
+
+    async def execute(self, payload: dict[str, Any]) -> dict[str, Any]: ...

agents-suite/_shared/src/platform_shared/protocols/event_bus.py

@@ -0,0 +1,52 @@
+"""Event bus protocol — decentralized, async event communication between platforms."""
+
+from __future__ import annotations
+
+import time
+import uuid
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Protocol, runtime_checkable
+
+
+@dataclass(frozen=True, slots=True)
+class Event:
+    topic: str
+    payload: dict[str, Any]
+    event_id: str = field(default_factory=lambda: uuid.uuid4().hex[:16])
+    source: str = ""
+    timestamp: float = field(default_factory=time.time)
+
+EventHandler = Callable[[Event], Awaitable[None]]
+
+
+@runtime_checkable
+class EventBus(Protocol):
+    async def publish(self, event: Event) -> None: ...
+    def subscribe(self, topic: str, handler: EventHandler) -> None: ...
+    def unsubscribe(self, topic: str, handler: EventHandler) -> None: ...
+
+
+class LocalEventBus:
+    """In-process event bus (single-node, for dev/test)."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[str, list[EventHandler]] = defaultdict(list)
+        self._history: list[Event] = []
+
+    async def publish(self, event: Event) -> None:
+        self._history.append(event)
+        for handler in self._handlers.get(event.topic, []):
+            await handler(event)
+
+    def subscribe(self, topic: str, handler: EventHandler) -> None:
+        self._handlers[topic].append(handler)
+
+    def unsubscribe(self, topic: str, handler: EventHandler) -> None:
+        handlers = self._handlers.get(topic, [])
+        if handler in handlers:
+            handlers.remove(handler)
+
+    @property
+    def history(self) -> list[Event]:
+        return list(self._history)

agents-suite/_shared/src/platform_shared/protocols/health.py

@@ -0,0 +1,36 @@
+"""Health check protocol — liveness / readiness for every component."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Protocol, runtime_checkable
+
+
+class HealthStatus(str, Enum):
+    HEALTHY = "healthy"
+    DEGRADED = "degraded"
+    UNHEALTHY = "unhealthy"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True, slots=True)
+class HealthReport:
+    component: str
+    status: HealthStatus
+    message: str = ""
+    details: dict[str, Any] = field(default_factory=dict)
+    checked_at: float = field(default_factory=time.time)
+    latency_ms: float = 0.0
+
+    @property
+    def is_healthy(self) -> bool:
+        return self.status in (HealthStatus.HEALTHY, HealthStatus.DEGRADED)
+
+
+@runtime_checkable
+class HealthCheck(Protocol):
+    async def check_health(self) -> HealthReport: ...
+    async def check_readiness(self) -> bool: ...
+    async def check_liveness(self) -> bool: ...