multiagentos 0.4.0__py3-none-any.whl

runtime/discovery.py

@@ -0,0 +1,334 @@
+"""Provider-neutral discovery adapters for model capabilities and quota."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+from urllib.error import HTTPError, URLError
+from datetime import datetime, timezone
+from typing import Any, Callable
+
+from core.contracts.ai import AIProvider, ModelSpec
+from core.contracts.capability import CapabilityConfidence, ModelCapabilityProfile
+from core.contracts.discovery import DiscoveryError, ProviderDiscoveryResult
+from core.contracts.quota import QuotaConfidence, QuotaDimension, QuotaSnapshot
+from runtime.policy import ExecutionPolicy
+
+
+def _path(value: object, path: tuple[str, ...]) -> object:
+    current = value
+    for part in path:
+        if not isinstance(current, dict):
+            return None
+        current = current.get(part)
+    return current
+
+
+def _string_list(value: object) -> frozenset[str]:
+    if not isinstance(value, list):
+        return frozenset()
+    return frozenset(str(item) for item in value if isinstance(item, (str, int, float)))
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+class ProviderDiscoveryAdapter:
+    """Discover provider metadata using declarative provider configuration."""
+
+    def __init__(
+        self,
+        policy: ExecutionPolicy | None = None,
+        fetch: Callable[[str, dict[str, str]], dict[str, Any] | tuple[dict[str, Any], dict[str, str]]] | None = None,
+    ) -> None:
+        self.policy = policy or ExecutionPolicy()
+        self.fetch = fetch or self._fetch
+
+    def discover(
+        self,
+        provider: AIProvider,
+        *,
+        models: tuple[ModelSpec, ...] | None = None,
+    ) -> ProviderDiscoveryResult:
+        metadata = provider.metadata
+        discovery = dict(metadata.get("discovery", {}) or {})
+        self._apply_builtin_defaults(provider, discovery)
+        if not isinstance(discovery, dict):
+            return ProviderDiscoveryResult(provider.id, source="model_spec")
+
+        endpoint = discovery.get("endpoint")
+        if not isinstance(endpoint, str) or not endpoint:
+            return ProviderDiscoveryResult(provider.id, source="model_spec")
+
+        headers = self._headers(discovery)
+        self._query_env = discovery.get("query_env", {})
+        fetched = self.fetch(endpoint, headers)
+        response_headers = {}
+        if isinstance(fetched, tuple):
+            payload, response_headers = fetched
+        else:
+            payload = fetched
+        model_payload = self._extract(payload, discovery.get("models_path", ["data"]))
+        if provider.kind.lower() == "gemini" and isinstance(model_payload, list):
+            model_payload = [self._normalize_gemini_model(item) for item in model_payload]
+        quota_payload = self._extract(payload, discovery.get("quota_path", []))
+
+        configured = {model.id: model for model in (models or provider.models)}
+        profiles = self._capabilities(provider, model_payload, configured)
+        quotas = self._quotas(provider, quota_payload, configured)
+        quotas.extend(self._header_quotas(provider, response_headers, configured))
+        return ProviderDiscoveryResult(
+            provider_id=provider.id,
+            capabilities=tuple(profiles),
+            quotas=tuple(quotas),
+            source="provider_discovery",
+            metadata={"endpoint": endpoint},
+        )
+
+    def discover_safe(
+        self,
+        provider: AIProvider,
+        *,
+        models: tuple[ModelSpec, ...] | None = None,
+    ) -> tuple[ProviderDiscoveryResult | None, DiscoveryError | None]:
+        try:
+            return self.discover(provider, models=models), None
+        except (OSError, ValueError, RuntimeError) as exc:
+            return None, DiscoveryError(
+                provider_id=provider.id,
+                operation="discover",
+                message=str(exc),
+                retryable=isinstance(exc, OSError),
+            )
+
+    @staticmethod
+    def _apply_builtin_defaults(provider: AIProvider, discovery: dict[str, object]) -> None:
+        if discovery.get("endpoint"):
+            return
+        presets = {
+            "openai": ("https://api.openai.com/v1/models", "OPENAI_API_KEY", "openai"),
+            "anthropic": ("https://api.anthropic.com/v1/models", "ANTHROPIC_API_KEY", "anthropic"),
+            "gemini": ("https://generativelanguage.googleapis.com/v1beta/models", "GEMINI_API_KEY", "gemini"),
+        }
+        preset = presets.get(provider.kind.lower()) or presets.get(provider.id.lower())
+        if not preset:
+            return
+        endpoint, key_env, kind = preset
+        discovery["endpoint"] = endpoint
+        discovery["models_path"] = ["models"] if kind == "gemini" else ["data"]
+        if kind == "gemini":
+            discovery["query_env"] = {"key": key_env}
+        elif kind == "openai":
+            discovery["header_env"] = {"Authorization": key_env}
+            discovery["header_prefix"] = {"Authorization": "Bearer "}
+        else:
+            discovery["header_env"] = {"x-api-key": key_env}
+            discovery["headers"] = {"anthropic-version": "2023-06-01"}
+
+    @staticmethod
+    def _header_quotas(provider: AIProvider, headers: dict[str, str], configured: dict[str, ModelSpec]) -> list[QuotaSnapshot]:
+        mappings = {
+            "openai": (
+                ("requests", "x-ratelimit-limit-requests", "x-ratelimit-remaining-requests"),
+                ("tokens", "x-ratelimit-limit-tokens", "x-ratelimit-remaining-tokens"),
+            ),
+            "anthropic": (
+                ("requests", "anthropic-ratelimit-requests-limit", "anthropic-ratelimit-requests-remaining"),
+                ("input_tokens", "anthropic-ratelimit-input-tokens-limit", "anthropic-ratelimit-input-tokens-remaining"),
+                ("output_tokens", "anthropic-ratelimit-output-tokens-limit", "anthropic-ratelimit-output-tokens-remaining"),
+            ),
+        }
+        rows = mappings.get(provider.kind.lower(), ())
+        dimensions = []
+        for name, limit_key, remaining_key in rows:
+            limit, remaining = _as_int(headers.get(limit_key)), _as_int(headers.get(remaining_key))
+            if limit is None and remaining is None:
+                continue
+            dimensions.append(QuotaDimension(name=name, limit=limit, used=(limit - remaining) if limit is not None and remaining is not None else None,
+                remaining=remaining, confidence=QuotaConfidence.ACTUAL, source="provider_response_headers"))
+        if not dimensions:
+            return []
+        return [QuotaSnapshot(model_id=model_id, provider_id=provider.id, observed_at=_now(), dimensions=tuple(dimensions),
+            scope="provider", metadata={"source": "provider_response_headers"}) for model_id in configured]
+    
+    @staticmethod
+    def _normalize_gemini_model(item: object) -> object:
+        if not isinstance(item, dict):
+            return item
+        normalized = dict(item)
+        name = normalized.get("name")
+        if isinstance(name, str) and name.startswith("models/"):
+            normalized["id"] = name[len("models/"):]
+        methods = normalized.get("supportedGenerationMethods")
+        if isinstance(methods, list):
+            normalized["capabilities"] = ["chat" if str(method) == "generateContent" else str(method) for method in methods]
+        return normalized
+
+    def _capabilities(
+        self,
+        provider: AIProvider,
+        value: object,
+        configured: dict[str, ModelSpec],
+    ) -> list[ModelCapabilityProfile]:
+        if not isinstance(value, list):
+            return []
+        profiles: list[ModelCapabilityProfile] = []
+        for item in value:
+            if not isinstance(item, dict):
+                continue
+            model_id = str(item.get("id", ""))
+            if not model_id:
+                continue
+            base = configured.get(model_id)
+            capabilities = set(base.capabilities if base else ())
+            capabilities.update(_normalize_capabilities(item))
+            profiles.append(
+                ModelCapabilityProfile(
+                    model_id=model_id,
+                    provider_id=provider.id,
+                    capabilities=frozenset(capabilities),
+                    confidence=CapabilityConfidence.DECLARED,
+                    source="provider_discovery",
+                    metadata={"provider_metadata": item},
+                )
+            )
+        return profiles
+
+    def _quotas(
+        self,
+        provider: AIProvider,
+        value: object,
+        configured: dict[str, ModelSpec],
+    ) -> list[QuotaSnapshot]:
+        if not isinstance(value, list):
+            return []
+        snapshots: list[QuotaSnapshot] = []
+        for item in value:
+            if not isinstance(item, dict):
+                continue
+            model_id = str(item.get("model_id", item.get("model", "")))
+            if not model_id or model_id not in configured:
+                continue
+            raw_dimensions = item.get("dimensions", [])
+            dimensions: list[QuotaDimension] = []
+            if isinstance(raw_dimensions, list):
+                for raw in raw_dimensions:
+                    if not isinstance(raw, dict) or not raw.get("name"):
+                        continue
+                    dimensions.append(
+                        QuotaDimension(
+                            name=str(raw["name"]),
+                            limit=raw.get("limit"),
+                            used=raw.get("used"),
+                            remaining=raw.get("remaining"),
+                            reset_at=_parse_datetime(raw.get("reset_at")),
+                            window_seconds=_as_int(raw.get("window_seconds")),
+                            confidence=QuotaConfidence.ACTUAL,
+                            source="provider_discovery",
+                        )
+                    )
+            snapshots.append(
+                QuotaSnapshot(
+                    model_id=model_id,
+                    provider_id=provider.id,
+                    observed_at=_now(),
+                    dimensions=tuple(dimensions),
+                    scope=str(item.get("scope", "model")),
+                    metadata={"provider_metadata": item},
+                )
+            )
+        return snapshots
+
+    @staticmethod
+    def _extract(payload: dict[str, Any], value: object) -> object:
+        if value in (None, [], ""):
+            return None
+        if not isinstance(value, list):
+            return None
+        return _path(payload, tuple(str(item) for item in value))
+
+    @staticmethod
+    def _headers(discovery: dict[str, object]) -> dict[str, str]:
+        result = {str(k): str(v) for k, v in (discovery.get("headers", {}) or {}).items()}
+        prefixes = discovery.get("header_prefix", {}) or {}
+        for header, env_name in (discovery.get("header_env", {}) or {}).items():
+            if isinstance(env_name, str) and os.environ.get(env_name):
+                prefix = prefixes.get(header, "") if isinstance(prefixes, dict) else ""
+                result[str(header)] = f"{prefix}{os.environ[env_name]}"
+        return result
+
+    def _fetch(self, endpoint: str, headers: dict[str, str]) -> tuple[dict[str, Any], dict[str, str]]:
+        if not self.policy.permits("network"):
+            raise PermissionError("Network discovery is disabled by policy")
+        query_env = getattr(self, "_query_env", {})
+        if query_env:
+            from urllib.parse import urlencode, urlsplit, urlunsplit
+            parts = urlsplit(endpoint)
+            query = {key: os.environ.get(env, "") for key, env in query_env.items()}
+            endpoint = urlunsplit((parts.scheme, parts.netloc, parts.path, urlencode(query), parts.fragment))
+        request = urllib.request.Request(endpoint, headers=headers, method="GET")
+        try:
+            with urllib.request.urlopen(request, timeout=30) as response:
+                payload = json.loads(response.read().decode("utf-8"))
+                response_headers = {str(k).lower(): str(v) for k, v in response.headers.items()}
+        except HTTPError as exc:
+            raise RuntimeError(f"provider discovery failed with HTTP {exc.code}") from exc
+        except URLError as exc:
+            raise RuntimeError("provider discovery failed: network error") from exc
+        if not isinstance(payload, dict):
+            raise ValueError("provider discovery response must be a JSON object")
+        return payload, response_headers
+
+def _normalize_capabilities(item: dict[str, object]) -> frozenset[str]:
+    """Normalize provider-specific metadata to VYRELON routing vocabulary."""
+    aliases = {
+        "generatecontent": "chat",
+        "generate_content": "chat",
+        "chat": "chat",
+        "embedcontent": "embeddings",
+        "embed_content": "embeddings",
+        "embeddings": "embeddings",
+        "predictlongrunning": "predict",
+        "counttokens": "token_count",
+        "function_calling": "tools",
+        "function-calling": "tools",
+        "structured-outputs": "structured_output",
+    }
+    result: set[str] = set()
+    for field in ("capabilities", "supportedGenerationMethods"):
+        for value in _string_list(item.get(field)):
+            key = value.strip().lower().replace(" ", "_")
+            result.add(aliases.get(key, key))
+    for field in ("input_modalities", "output_modalities", "modalities"):
+        for value in _string_list(item.get(field)):
+            key = value.strip().lower()
+            result.add(aliases.get(key, key))
+    for field, capability in (
+        ("supports_tools", "tools"),
+        ("supports_reasoning", "reasoning"),
+        ("supports_vision", "vision"),
+        ("supports_audio", "audio"),
+        ("supports_image", "image"),
+        ("supports_structured_output", "structured_output"),
+    ):
+        if item.get(field) is True:
+            result.add(capability)
+    return frozenset(result)
+
+
+def _as_int(value: object) -> int | None:
+    try:
+        return int(value) if value is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _parse_datetime(value: object) -> datetime | None:
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    except ValueError:
+        return None

runtime/execution_config.py

@@ -0,0 +1,71 @@
+"""Project-scoped execution configuration for VYRELON."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class ExecutionConfig:
+    version: int
+    runtime: str
+    agent_id: str
+    model_id: str
+
+    def validate(self) -> None:
+        if self.version != 1:
+            raise ValueError(f"unsupported execution config version: {self.version}")
+        if not self.runtime.strip():
+            raise ValueError("execution runtime must not be empty")
+        if not self.agent_id.strip():
+            raise ValueError("execution agent id must not be empty")
+        if not self.model_id.strip():
+            raise ValueError("execution model id must not be empty")
+
+    def to_dict(self) -> dict[str, object]:
+        self.validate()
+        return {
+            "version": self.version,
+            "runtime": self.runtime,
+            "agent_id": self.agent_id,
+            "model_id": self.model_id,
+        }
+
+
+DEFAULT_EXECUTION_CONFIG = ExecutionConfig(
+    version=1,
+    runtime="process",
+    agent_id="cli-executor",
+    model_id="local-process",
+)
+
+
+def load_execution_config(project_root: Path) -> ExecutionConfig:
+    path = project_root / ".multiagentos" / "execution.json"
+    if not path.is_file():
+        raise FileNotFoundError(f"VYRELON execution config not found: {path}")
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError("execution config must be a JSON object")
+    config = ExecutionConfig(
+        version=int(data.get("version", 0)),
+        runtime=str(data.get("runtime", "")),
+        agent_id=str(data.get("agent_id", "")),
+        model_id=str(data.get("model_id", "")),
+    )
+    config.validate()
+    return config
+
+
+def write_default_execution_config(project_root: Path) -> Path:
+    target = project_root / ".multiagentos"
+    target.mkdir(parents=True, exist_ok=True)
+    path = target / "execution.json"
+    if not path.exists():
+        path.write_text(
+            json.dumps(DEFAULT_EXECUTION_CONFIG.to_dict(), indent=2) + "\n",
+            encoding="utf-8",
+        )
+    return path

runtime/execution_registry.py

@@ -0,0 +1,50 @@
+"""Built-in execution contracts used by the VYRELON CLI."""
+
+from __future__ import annotations
+
+from core.contracts import AgentContract, AIProvider, ModelSpec
+from core.registry import AgentRegistry, AIRegistry
+
+
+def default_execution_registries() -> tuple[AgentRegistry, AIRegistry]:
+    agents = AgentRegistry()
+    agents.register(
+        AgentContract(
+            id="cli-executor",
+            role="executor",
+            capabilities=frozenset({"process"}),
+            tools=frozenset({"process"}),
+            kind="runtime",
+        )
+    )
+
+    models = AIRegistry()
+    models.register(
+        AIProvider(
+            id="local",
+            kind="runtime",
+            models=(
+                ModelSpec(
+                    id="local-process",
+                    provider_id="local",
+                    capabilities=frozenset({"process"}),
+                    metadata={"runtime": "process"},
+                ),
+            ),
+        )
+    )
+    return agents, models
+
+
+def resolve_execution_contracts(
+    agent_id: str,
+    model_id: str,
+) -> tuple[AgentContract, ModelSpec]:
+    agents, models = default_execution_registries()
+    agent = agents.get(agent_id)
+    model = models.model(model_id)
+    if not agent.capabilities.issubset(model.capabilities):
+        raise ValueError(
+            f"execution model {model.id!r} is incompatible with agent {agent.id!r}"
+        )
+    return agent, model

runtime/git.py

@@ -0,0 +1,84 @@
+"""Policy-controlled Git runtime for VYRELON."""
+
+from __future__ import annotations
+
+from runtime.process import ProcessRuntime
+from runtime.policy import ExecutionPolicy
+
+
+class GitRuntime:
+    def __init__(self, process: ProcessRuntime | None = None, policy: ExecutionPolicy | None = None):
+        self.policy = policy or ExecutionPolicy()
+        self.process = process or ProcessRuntime(self.policy)
+
+    def status(self, cwd: str):
+        return self.process.run(["git", "status", "--short", "--branch"], cwd)
+
+    def diff(self, cwd: str, *, staged: bool = False, path: str | None = None):
+        command = ["git", "diff"]
+        if staged:
+            command.append("--staged")
+        if path:
+            command.extend(["--", path])
+        else:
+            command.append("--")
+        return self.process.run(command, cwd)
+
+    def log(self, cwd: str, count: int = 10):
+        return self.process.run(["git", "log", "--oneline", "-n", str(count)], cwd)
+
+    def add(self, cwd: str, paths: list[str] | None = None):
+        self._require_git_write()
+        command = ["git", "add"]
+        command.extend(paths if paths else ["-A"])
+        return self.process.run(command, cwd)
+
+    def checkout_branch(self, cwd: str, branch: str):
+        self._require_git_write()
+        return self.process.run(["git", "switch", branch], cwd)
+
+    def restore(self, cwd: str, paths: list[str], source: str = "HEAD"):
+        self._require_git_write()
+        return self.process.run(["git", "restore", "--source", source, "--", *paths], cwd)
+
+    def stash(self, cwd: str, action: str = "list", message: str | None = None):
+        command = ["git", "stash"]
+        if action == "list":
+            command.append("list")
+        else:
+            self._require_git_write()
+            command.append(action)
+            if action == "push" and message:
+                command.extend(["-m", message])
+        return self.process.run(command, cwd)
+
+    def commit(self, cwd: str, message: str, approved: bool = False):
+        self._require_git_write()
+        self._require_approval("git.commit", approved)
+        added = self.process.run(["git", "add", "-A"], cwd)
+        if added.returncode != 0:
+            return added
+        return self.process.run(["git", "commit", "-m", message], cwd)
+
+    def push(self, cwd: str, remote: str = "origin", branch: str | None = None, approved: bool = False):
+        self._require_git_write()
+        self._require_approval("git.push", approved)
+        command = ["git", "push", remote]
+        if branch:
+            command.append(branch)
+        return self.process.run(command, cwd)
+
+    def pull(self, cwd: str, remote: str = "origin", branch: str | None = None):
+        self._require_git_write()
+        command = ["git", "pull", remote]
+        if branch:
+            command.append(branch)
+        return self.process.run(command, cwd)
+
+    def _require_git_write(self):
+        if not self.policy.permits("git.write"):
+            raise PermissionError("Git write operations are disabled by policy")
+
+    def _require_approval(self, action: str, approved: bool):
+        if self.policy.requires_approval(action) and not approved:
+            raise PermissionError(f"Explicit approval required for: {action}")

runtime/github.py

@@ -0,0 +1,56 @@
+"""Policy-controlled GitHub runtime for VYRELON."""
+
+from __future__ import annotations
+
+from core.contracts.github import GitHubGateway
+from runtime.policy import ExecutionPolicy
+
+
+class GitHubRuntime:
+    def __init__(self, gateway: GitHubGateway, policy: ExecutionPolicy | None = None) -> None:
+        self.gateway = gateway
+        self.policy = policy or ExecutionPolicy()
+
+    def _require_write(self) -> None:
+        if not self.policy.permits("github.write"):
+            raise PermissionError("GitHub write operations are disabled by policy")
+
+    def create_branch(self, repository: str, branch: str, base: str):
+        self._require_write()
+        return self.gateway.create_branch(repository, branch, base)
+
+    def create_file(self, repository: str, path: str, content: str, branch: str, message: str):
+        self._require_write()
+        return self.gateway.create_file(repository, path, content, branch, message)
+
+    def update_file(self, repository: str, path: str, content: str, sha: str, branch: str, message: str):
+        self._require_write()
+        return self.gateway.update_file(repository, path, content, sha, branch, message)
+
+    def create_issue(self, repository: str, title: str, body: str = ""):
+        self._require_write()
+        return self.gateway.create_issue(repository, title, body)
+
+    def create_pull_request(
+        self, repository: str, title: str, body: str, head: str, base: str,
+        draft: bool = False, approved: bool = False,
+    ):
+        self._require_write()
+        self._require_approval("github.pr", approved)
+        return self.gateway.create_pull_request(repository, title, body, head, base, draft)
+
+    def review_pull_request(self, repository: str, number: int, action: str, body: str = ""):
+        self._require_write()
+        return self.gateway.review_pull_request(repository, number, action, body)
+
+    def merge_pull_request(
+        self, repository: str, number: int, method: str = "squash",
+        approved: bool = False,
+    ):
+        self._require_write()
+        self._require_approval("github.merge", approved)
+        return self.gateway.merge_pull_request(repository, number, method)
+
+    def _require_approval(self, action: str, approved: bool) -> None:
+        if self.policy.requires_approval(action) and not approved:
+            raise PermissionError(f"Explicit approval required for: {action}")

runtime/github_probe.py

@@ -0,0 +1,23 @@
+"""Probe VYRELON's local GitHub access."""
+
+from integrations.github.gateway import GitHubGatewayClient
+
+
+def probe(repository: str) -> dict:
+    client = GitHubGatewayClient()
+    repo = client.get_repository(repository)
+    branch = client.get_branch(repository, repo.default_branch)
+    return {
+        "repository": repo.full_name,
+        "private": repo.private,
+        "default_branch": repo.default_branch,
+        "default_branch_sha": branch.sha,
+    }
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("repository")
+    args = parser.parse_args()
+    print(probe(args.repository))

runtime/health.py

@@ -0,0 +1,14 @@
+"""Runtime health registry facade."""
+from core.contracts.health import (
+    HealthStatus,
+    ModelHealth,
+    ModelHealthRegistry,
+    ModelHealthStore,
+)
+
+__all__ = [
+    "HealthStatus",
+    "ModelHealth",
+    "ModelHealthRegistry",
+    "ModelHealthStore",
+]

runtime/ide/__init__.py

@@ -0,0 +1,6 @@
+"""IDE adapter runtime."""
+
+from runtime.ide.registry import IDEAdapterRegistry
+from runtime.ide.runtime import IDERuntime
+
+__all__ = ["IDEAdapterRegistry", "IDERuntime"]