alysis-code 0.13.0__py3-none-any.whl

alysis_code/agent_runtimes/__init__.py

@@ -0,0 +1,51 @@
+from .base import (
+    AgentRuntimeAdapter,
+    AuthMethod,
+    RuntimeAccountStatus,
+    RuntimeCapabilities,
+    RuntimeProbeStatus,
+    RuntimeTurnRequest,
+    RuntimeTurnResult,
+)
+from .registry import (
+    AgentRuntimeRegistry,
+    DuplicateRuntimeError,
+    RuntimeRegistryError,
+    UnknownRuntimeError,
+)
+from .service import (
+    RuntimeConnectionError,
+    RuntimeConnectionSnapshot,
+    activate_native_runtime,
+    activate_runtime,
+    ensure_runtime_settings,
+    login_runtime,
+    logout_runtime,
+    resolve_runtime_id,
+    run_runtime_turn,
+    runtime_connection_snapshot,
+)
+
+__all__ = [
+    "AgentRuntimeAdapter",
+    "AgentRuntimeRegistry",
+    "AuthMethod",
+    "DuplicateRuntimeError",
+    "RuntimeAccountStatus",
+    "RuntimeCapabilities",
+    "RuntimeConnectionError",
+    "RuntimeConnectionSnapshot",
+    "RuntimeProbeStatus",
+    "RuntimeTurnRequest",
+    "RuntimeTurnResult",
+    "RuntimeRegistryError",
+    "UnknownRuntimeError",
+    "activate_native_runtime",
+    "activate_runtime",
+    "ensure_runtime_settings",
+    "login_runtime",
+    "logout_runtime",
+    "resolve_runtime_id",
+    "run_runtime_turn",
+    "runtime_connection_snapshot",
+]

alysis_code/agent_runtimes/base.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from ..config import AgentRuntimeSettings
+
+
+@dataclass(frozen=True, slots=True)
+class AuthMethod:
+    """One authentication method exposed by a provider-managed runtime."""
+
+    id: str
+    label: str
+    provider_managed: bool = True
+    interactive: bool = True
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeCapabilities:
+    """Stable capability flags used before a delegated runtime is selected."""
+
+    streaming: bool = False
+    session_resume: bool = False
+    image_inputs: bool = False
+    structured_output: bool = False
+    read_only: bool = True
+    workspace_write: bool = True
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeProbeStatus:
+    """Result of checking whether a runtime is installed and usable."""
+
+    available: bool
+    executable: str | None = None
+    version: str | None = None
+    detail: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAccountStatus:
+    """Provider-owned account state without exposing provider credentials."""
+
+    authenticated: bool
+    verified: bool = True
+    auth_method_id: str | None = None
+    account_label: str | None = None
+    detail: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeTurnRequest:
+    """Provider-neutral input for one delegated agent turn."""
+
+    prompt: str
+    cwd: Path
+    mode: Literal["readonly", "review", "auto", "fullaccess"] = "review"
+    session_id: str | None = None
+    images: tuple[Path, ...] = ()
+    no_log: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeTurnResult:
+    """In-memory result of a delegated turn; provider credentials are never included."""
+
+    runtime_id: str
+    command: tuple[str, ...]
+    exit_code: int
+    final_message: str = ""
+    session_id: str | None = None
+    stdout: str = ""
+    stderr: str = ""
+    events: tuple[Mapping[str, object], ...] = ()
+    usage: Mapping[str, object] | None = None
+    timed_out: bool = False
+    error: str | None = None
+    warnings: tuple[str, ...] = ()
+
+    @property
+    def ok(self) -> bool:
+        return self.exit_code == 0 and not self.timed_out and self.error is None
+
+
+@runtime_checkable
+class AgentRuntimeAdapter(Protocol):
+    """Discovery contract implemented by each delegated runtime adapter."""
+
+    runtime_id: str
+    display_name: str
+    capabilities: RuntimeCapabilities
+    auth_methods: tuple[AuthMethod, ...]
+
+    def probe(self, settings: AgentRuntimeSettings) -> RuntimeProbeStatus: ...
+
+    def account_status(self, settings: AgentRuntimeSettings) -> RuntimeAccountStatus: ...
+
+    def login(
+        self,
+        settings: AgentRuntimeSettings,
+        method_id: str,
+    ) -> RuntimeAccountStatus: ...
+
+    def logout(self, settings: AgentRuntimeSettings) -> RuntimeAccountStatus: ...
+
+    def run_turn(
+        self,
+        settings: AgentRuntimeSettings,
+        request: RuntimeTurnRequest,
+    ) -> RuntimeTurnResult: ...

alysis_code/agent_runtimes/builtins.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib.metadata import entry_points
+from typing import Any
+
+from ..branding import env_get
+from .base import AgentRuntimeAdapter
+from .codex_cli import CodexCliRuntimeAdapter
+from .registry import AgentRuntimeRegistry, DuplicateRuntimeError
+
+RUNTIME_ENTRY_POINT_GROUP = "alysis.agent_runtimes"
+RUNTIME_PLUGIN_OPT_IN_ENV = "ALYSIS_ENABLE_AGENT_RUNTIME_PLUGINS"
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeSetupOption:
+    """Provider-neutral metadata rendered by setup and configuration UIs."""
+
+    id: str
+    label: str
+    description: str
+    adapter: str
+    default_executable: str
+    auth_hint: str
+
+
+_BUILTIN_OPTIONS: tuple[RuntimeSetupOption, ...] = (
+    RuntimeSetupOption(
+        id="openai-codex",
+        label="OpenAI Codex account",
+        description="Delegate work to Codex using its official ChatGPT sign-in.",
+        adapter="codex-cli",
+        default_executable="codex",
+        auth_hint="Browser or device-code sign-in is managed by Codex; Alysis Code never reads its tokens.",
+    ),
+)
+
+
+def runtime_setup_options() -> tuple[RuntimeSetupOption, ...]:
+    """Return runtimes supported by this installation.
+
+    Setup/config code depends only on this metadata contract. Additional adapters
+    can extend discovery later without introducing provider conditionals there.
+    """
+
+    options = list(_BUILTIN_OPTIONS)
+    known = {option.id for option in options}
+    for adapter in _plugin_runtime_adapters():
+        runtime_id = str(adapter.runtime_id or "").strip()
+        if not runtime_id or runtime_id in known:
+            continue
+        options.append(_option_from_adapter(adapter))
+        known.add(runtime_id)
+    return tuple(options)
+
+
+def runtime_setup_option(runtime_id: str) -> RuntimeSetupOption | None:
+    normalized = str(runtime_id or "").strip()
+    return next((option for option in runtime_setup_options() if option.id == normalized), None)
+
+
+def create_builtin_runtime_registry() -> AgentRuntimeRegistry:
+    """Build a fresh registry so tests and callers never share mutable state."""
+
+    return AgentRuntimeRegistry((CodexCliRuntimeAdapter(),))
+
+
+def create_runtime_registry() -> AgentRuntimeRegistry:
+    """Build the installed registry, including trusted Python entry points."""
+
+    registry = create_builtin_runtime_registry()
+    for adapter in _plugin_runtime_adapters():
+        try:
+            registry.register(adapter)
+        except DuplicateRuntimeError:
+            continue
+    return registry
+
+
+def _plugin_runtime_adapters() -> tuple[AgentRuntimeAdapter, ...]:
+    enabled = str(env_get(RUNTIME_PLUGIN_OPT_IN_ENV) or "").strip().lower()
+    if enabled not in {"1", "true", "yes", "on"}:
+        return ()
+    try:
+        selected = entry_points().select(group=RUNTIME_ENTRY_POINT_GROUP)
+    except Exception:  # noqa: BLE001 - broken package metadata must not break setup
+        return ()
+    adapters: list[AgentRuntimeAdapter] = []
+    for entry_point in selected:
+        try:
+            loaded: Any = entry_point.load()
+            candidate = loaded() if isinstance(loaded, type) else loaded
+            if callable(candidate) and not hasattr(candidate, "runtime_id"):
+                candidate = candidate()
+            if isinstance(candidate, AgentRuntimeAdapter):
+                adapters.append(candidate)
+        except Exception:  # noqa: BLE001 - one optional plugin cannot block built-ins
+            continue
+    return tuple(adapters)
+
+
+def _option_from_adapter(adapter: AgentRuntimeAdapter) -> RuntimeSetupOption:
+    runtime_id = str(adapter.runtime_id).strip()
+    return RuntimeSetupOption(
+        id=runtime_id,
+        label=str(adapter.display_name or runtime_id),
+        description=str(getattr(adapter, "description", "Provider-managed agent runtime.")),
+        adapter=str(getattr(adapter, "adapter_id", runtime_id)),
+        default_executable=str(getattr(adapter, "default_executable", runtime_id)),
+        auth_hint=str(
+            getattr(
+                adapter,
+                "auth_hint",
+                "Authentication is managed by the provider runtime; Alysis Code does not copy tokens.",
+            )
+        ),
+    )
+
+
+__all__ = [
+    "RuntimeSetupOption",
+    "RUNTIME_ENTRY_POINT_GROUP",
+    "RUNTIME_PLUGIN_OPT_IN_ENV",
+    "create_builtin_runtime_registry",
+    "create_runtime_registry",
+    "runtime_setup_option",
+    "runtime_setup_options",
+]