@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/advisor_request_builder.py

@@ -0,0 +1,261 @@
+"""Build and decode provider-specific Advisor requests without performing I/O."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+
+ADVISOR_REVIEW_PROMPT = (
+    "You are ciel-runtime Advisor, a stronger reviewer model. Review the current task state and provide "
+    "concise, actionable guidance for the executor model. Review now; do not say that you will review later. "
+    "Do not write code unless a small exact patch is the clearest advice. Use this exact structure: "
+    "Verdict: approve, revise, or continue. Key findings: concrete gaps or risks. Required next action: "
+    "the next action or Claude Code tool call. Validation: the check that proves the work. "
+    "If the executor is stuck after progress announcements, tell it the exact next Claude Code tool to call."
+)
+
+
+@dataclass(frozen=True, slots=True)
+class AdvisorProjectionPorts:
+    provider_kind: Callable[..., str]
+    anthropic_messages: Callable[..., tuple[list[dict[str, Any]], list[str]]]
+    openai_messages: Callable[..., list[dict[str, Any]]]
+    ollama_messages: Callable[[dict[str, Any]], list[dict[str, Any]]]
+    focus_from_body: Callable[[dict[str, Any]], str]
+    compact_text: Callable[[str], str]
+    anthropic_system: Callable[[Any, list[str]], Any]
+    anthropic_text: Callable[[Any], str]
+
+
+@dataclass(frozen=True, slots=True)
+class AdvisorBudgetPorts:
+    ollama_context: Callable[[dict[str, Any]], int]
+    provider_context: Callable[[str, dict[str, Any]], int]
+    openai_context: Callable[[str, dict[str, Any]], int]
+    reserve: Callable[[dict[str, Any], int], int]
+    compact_messages: Callable[..., list[dict[str, Any]]]
+    configured_output: Callable[..., int]
+    ollama_options: Callable[[dict[str, Any]], dict[str, Any]]
+    positive_int: Callable[[Any], int]
+    ollama_num_ctx: Callable[..., int]
+    think_enabled: Callable[[str | None, dict[str, Any]], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class AdvisorEndpointPorts:
+    join_url: Callable[[str, str], str]
+    upstream_query: Callable[[dict[str, Any], str, str], str]
+    provider_request_base: Callable[[str, dict[str, Any]], str]
+    upstream_model: Callable[[str], str]
+
+
+@dataclass(frozen=True, slots=True)
+class AdvisorAnthropicSystemPolicy:
+    review_prompt: str
+    content_to_text: Callable[[Any], str]
+
+    def project(
+        self,
+        system: Any,
+        extra_system_texts: list[str] | None = None,
+    ) -> list[dict[str, Any]]:
+        blocks: list[dict[str, Any]] = []
+        original_text = ""
+        if isinstance(system, str):
+            clean = system.strip()
+            if clean:
+                blocks.append({"type": "text", "text": clean})
+        elif isinstance(system, list) and system:
+            first = system[0]
+            if (
+                isinstance(first, dict)
+                and str(first.get("type") or "") == "text"
+                and str(first.get("text") or "").strip()
+            ):
+                blocks.append(dict(first))
+                original_text = self.content_to_text(system[1:]).strip()
+            else:
+                original_text = self.content_to_text(system).strip()
+        elif system:
+            original_text = self.content_to_text(system).strip()
+        blocks.append({"type": "text", "text": self.review_prompt})
+        if original_text:
+            blocks.append(
+                {
+                    "type": "text",
+                    "text": (
+                        "Original session system context:\n"
+                        + original_text
+                    ),
+                }
+            )
+        for text in extra_system_texts or []:
+            clean = str(text or "").strip()
+            if clean:
+                blocks.append(
+                    {
+                        "type": "text",
+                        "text": (
+                            "Additional system context from message "
+                            "history:\n" + clean
+                        ),
+                    }
+                )
+        return blocks
+
+
+class AdvisorRequestBuilder:
+    def __init__(
+        self,
+        review_prompt: str,
+        projection: AdvisorProjectionPorts,
+        budget: AdvisorBudgetPorts,
+        endpoint: AdvisorEndpointPorts,
+    ) -> None:
+        self.review_prompt = review_prompt
+        self.projection = projection
+        self.budget = budget
+        self.endpoint = endpoint
+
+    def messages(
+        self, provider: str, body: dict[str, Any], focus_override: str = ""
+    ) -> list[dict[str, Any]]:
+        kind = self.projection.provider_kind(provider)
+        if kind == "anthropic":
+            messages, _ = self.projection.anthropic_messages(body)
+        elif kind == "openai-compatible":
+            messages = self.projection.openai_messages(body)
+        else:
+            messages = self.projection.ollama_messages(body)
+        focus = focus_override or self.projection.focus_from_body(body)
+        if kind != "anthropic":
+            messages.insert(0, {"role": "system", "content": self.review_prompt})
+        if focus:
+            focus_text = f"Advisor focus:\n{self.projection.compact_text(focus)}"
+            content: Any = (
+                [{"type": "text", "text": focus_text}]
+                if kind == "anthropic"
+                else focus_text
+            )
+            messages.append({"role": "user", "content": content})
+        return messages
+
+    def input_budget(self, provider: str, config: dict[str, Any]) -> int:
+        kind = self.projection.provider_kind(provider)
+        if kind == "ollama":
+            context_limit = self.budget.ollama_context(config)
+        elif kind == "anthropic":
+            context_limit = self.budget.provider_context(provider, config) or 200000
+        else:
+            context_limit = self.budget.openai_context(provider, config)
+        return max(
+            8192,
+            context_limit - 4096 - self.budget.reserve(config, context_limit),
+        )
+
+    def model(self, provider: str, model: str) -> str:
+        return self.endpoint.upstream_model(model) if provider == "nvidia-hosted" else model
+
+    def request(
+        self,
+        provider: str,
+        model: str,
+        body: dict[str, Any],
+        config: dict[str, Any],
+        focus_override: str = "",
+    ) -> dict[str, Any]:
+        kind = self.projection.provider_kind(provider)
+        messages = self.messages(provider, body, focus_override)
+        if kind != "anthropic":
+            messages = self.budget.compact_messages(
+                messages,
+                [],
+                self.input_budget(provider, config),
+                provider=provider,
+                model=model,
+            )
+        upstream_model = self.model(provider, model)
+        if kind == "anthropic":
+            _, extra_system = self.projection.anthropic_messages(body)
+            request = {
+                "model": upstream_model,
+                "system": self.projection.anthropic_system(
+                    body.get("system"), extra_system
+                ),
+                "messages": messages,
+                "stream": False,
+                "max_tokens": min(
+                    4096, self.budget.configured_output(config, body) or 4096
+                ),
+            }
+            return self._sampling_options(request, config)
+        if kind == "openai-compatible":
+            request = {
+                "model": upstream_model,
+                "messages": messages,
+                "stream": False,
+                "max_tokens": min(
+                    4096, self.budget.configured_output(config, body) or 4096
+                ),
+            }
+            return self._sampling_options(request, config)
+        request = {
+            "model": upstream_model,
+            "messages": messages,
+            "stream": False,
+            "think": self.budget.think_enabled(upstream_model, config),
+        }
+        options = self.budget.ollama_options(config)
+        options.setdefault(
+            "num_predict",
+            min(4096, self.budget.positive_int(options.get("num_predict")) or 4096),
+        )
+        num_ctx = self.budget.ollama_num_ctx(
+            config, {"messages": messages, "tools": []}
+        )
+        if num_ctx:
+            options.setdefault("num_ctx", num_ctx)
+        if options:
+            request["options"] = options
+        return request
+
+    @staticmethod
+    def _sampling_options(
+        request: dict[str, Any], config: dict[str, Any]
+    ) -> dict[str, Any]:
+        for key in ("temperature", "top_p"):
+            if config.get(key) is not None:
+                request[key] = config[key]
+        return request
+
+    def response_text(self, provider: str, data: Any) -> str:
+        if not isinstance(data, dict):
+            return ""
+        kind = self.projection.provider_kind(provider)
+        if kind == "anthropic":
+            return self.projection.anthropic_text(data.get("content")).strip()
+        if kind == "openai-compatible":
+            choices = data.get("choices")
+            if isinstance(choices, list) and choices:
+                message = choices[0].get("message") if isinstance(choices[0], dict) else {}
+                if isinstance(message, dict):
+                    return str(message.get("content") or "").strip()
+            return ""
+        message = data.get("message")
+        return str((message or {}).get("content") or "").strip()
+
+    def endpoint_url(self, provider: str, config: dict[str, Any]) -> str:
+        base = str(config.get("base_url") or "").rstrip("/")
+        kind = self.projection.provider_kind(provider)
+        if kind == "anthropic":
+            url = self.endpoint.join_url(base, "/v1/messages")
+            query = self.endpoint.upstream_query(config, "", provider)
+            return f"{url}?{query}" if query else url
+        if kind == "openai-compatible":
+            return self.endpoint.join_url(
+                self.endpoint.provider_request_base(provider, config),
+                "/v1/chat/completions",
+            )
+        return self.endpoint.join_url(base, "/api/chat")

package/ciel_runtime_support/agy_installer.py

@@ -0,0 +1,169 @@
+"""Official manifest-backed AGY installation and update lifecycle."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import json
+import os
+import platform
+import re
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Any, Callable
+import urllib.request
+
+
+@dataclass(frozen=True, slots=True)
+class AgyInstallerPorts:
+    user_bin_dir: Callable[[], Path]
+    forced_environment: Callable[[], dict[str, str]]
+    find_executable: Callable[[str], str | None]
+    version_newer: Callable[[str, str], bool]
+    run_upgrade: Callable[..., tuple[int, str]]
+    output: Callable[..., None] = print
+
+
+@dataclass(frozen=True, slots=True)
+class AgyInstaller:
+    manifest_base_url: str
+    ports: AgyInstallerPorts
+
+    def manifest_name(self) -> str:
+        arch = "arm64" if platform.machine().lower() in ("arm64", "aarch64") else "amd64"
+        platform_name = "windows" if os.name == "nt" else ("darwin" if sys.platform == "darwin" else "linux")
+        return f"{platform_name}_{arch}.json"
+
+    def manifest_url(self) -> str:
+        override = str(os.environ.get("CIEL_RUNTIME_AGY_MANIFEST_URL") or "").strip()
+        return override or f"{self.manifest_base_url}/manifests/{self.manifest_name()}"
+
+    @staticmethod
+    def download_file(url: str, target: Path, timeout: float = 120.0) -> None:
+        with urllib.request.urlopen(url, timeout=timeout) as response, target.open("wb") as output:
+            shutil.copyfileobj(response, output)
+
+    def latest_manifest(self, timeout: float = 15.0) -> dict[str, Any] | None:
+        try:
+            with urllib.request.urlopen(self.manifest_url(), timeout=timeout) as response:
+                data = json.loads(response.read(65536).decode("utf-8", errors="replace"))
+            if isinstance(data, dict) and data.get("url") and data.get("version"):
+                return data
+        except Exception as exc:
+            self._print(f"AGY manifest check failed ({type(exc).__name__}); continuing.")
+        return None
+
+    @staticmethod
+    def current_version(executable: str) -> str:
+        try:
+            process = subprocess.run([executable, "--version"], text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=8)
+        except Exception:
+            return ""
+        if process.returncode != 0:
+            return ""
+        match = re.search(r"\d+(?:\.\d+)+(?:[-+][A-Za-z0-9_.-]+)?", process.stdout or "")
+        return match.group(0) if match else (process.stdout or "").strip()
+
+    @staticmethod
+    def verify_sha512(path: Path, expected: str) -> bool:
+        expected = str(expected or "").strip().lower()
+        if not expected:
+            return True
+        digest = hashlib.sha512()
+        with path.open("rb") as stream:
+            for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(chunk)
+        return digest.hexdigest().lower() == expected
+
+    def install_from_manifest(self, manifest: dict[str, Any]) -> str | None:
+        url = str(manifest.get("url") or "").strip()
+        version = str(manifest.get("version") or "").strip()
+        checksum = str(manifest.get("sha512") or "").strip()
+        if not url:
+            self._print("AGY install failed: manifest did not include a download URL.")
+            return None
+        install_dir = self.ports.user_bin_dir()
+        install_dir.mkdir(parents=True, exist_ok=True)
+        target = install_dir / ("agy.exe" if os.name == "nt" else "agy")
+        suffix = ".exe" if os.name == "nt" else ".tar.gz"
+        with tempfile.TemporaryDirectory(prefix="ciel-runtime-agy-") as temporary_dir:
+            download = Path(temporary_dir) / f"agy{suffix}"
+            self._print(f"Downloading AGY {version or 'latest'} from Google official manifest...")
+            self.download_file(url, download)
+            if not self.verify_sha512(download, checksum):
+                self._print("AGY install failed: sha512 verification did not match manifest.")
+                return None
+            if os.name == "nt":
+                shutil.copy2(download, target)
+            elif not self._extract_executable(download, target):
+                return None
+        try:
+            subprocess.run([str(target), "install"], input="y\n", text=True, env=self.ports.forced_environment(), timeout=120, check=False)
+        except Exception as exc:
+            self._print(f"AGY post-install setup skipped ({type(exc).__name__}); continuing.")
+        self._print(f"AGY installed: {target}")
+        return str(target)
+
+    def install_if_missing(self) -> str | None:
+        executable = self.ports.find_executable("agy")
+        if executable:
+            return executable
+        if os.environ.get("CIEL_RUNTIME_SKIP_AGY_INSTALL") == "1":
+            return None
+        manifest = self.latest_manifest()
+        if not manifest:
+            self._print("AGY executable was not found, and the official AGY manifest could not be read.")
+            return None
+        return self.install_from_manifest(manifest)
+
+    def update_check(self, executable: str, enabled: bool = True) -> str:
+        if not enabled or os.environ.get("CIEL_RUNTIME_SKIP_AGY_UPDATE") == "1":
+            return executable
+        self._print("Checking AGY update before launch...")
+        current = self.current_version(executable)
+        if current:
+            self._print(f"Current AGY version: {current}")
+        manifest = self.latest_manifest()
+        latest = str((manifest or {}).get("version") or "").strip()
+        if current and latest and not self.ports.version_newer(latest, current):
+            self._print(f"AGY is up to date ({current}).")
+            return executable
+        self._print(f"AGY update available: {current or 'unknown'} -> {latest}; upgrading automatically." if latest else "AGY update version could not be confirmed; running native updater.")
+        return_code, output = self.ports.run_upgrade([executable, "update"], timeout=300)
+        if output:
+            self._print(output)
+        if return_code != 0:
+            if manifest and latest and (not current or self.ports.version_newer(latest, current)):
+                return self.install_from_manifest(manifest) or executable
+            self._print(f"AGY update failed ({return_code}); continuing with current version.")
+            return executable
+        updated = self.ports.find_executable("agy") or executable
+        new_version = self.current_version(updated)
+        if new_version:
+            self._print(f"AGY version after update: {new_version}")
+        return updated
+
+    def _extract_executable(self, archive_path: Path, target: Path) -> bool:
+        with tarfile.open(archive_path, "r:gz") as archive:
+            member = next((item for item in archive.getmembers() if Path(item.name).name == "agy" and item.isfile()), None)
+            member = member or next((item for item in archive.getmembers() if item.isfile()), None)
+            if member is None:
+                self._print("AGY install failed: archive did not contain an executable file.")
+                return False
+            extracted = archive.extractfile(member)
+            if extracted is None:
+                self._print("AGY install failed: could not extract executable from archive.")
+                return False
+            with target.open("wb") as output:
+                shutil.copyfileobj(extracted, output)
+        target.chmod(target.stat().st_mode | 0o755)
+        return True
+
+    def _print(self, message: str) -> None:
+        self.ports.output(message, flush=True)
+
+
+__all__ = ["AgyInstaller", "AgyInstallerPorts"]

package/ciel_runtime_support/agy_mcp_restore.py

@@ -0,0 +1,182 @@
+"""Restore missing managed MCP servers into AGY's native JSON configuration."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .mcp_inventory import McpInventoryService
+
+
+@dataclass(frozen=True, slots=True)
+class AgyMcpRestorePorts:
+    discover_managed: Callable[[Path], dict[str, dict[str, Any]]]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class AgyMcpRestoreService:
+    ports: AgyMcpRestorePorts
+
+    def restore(
+        self,
+        env: Mapping[str, str] | None = None,
+        cwd: Path | None = None,
+    ) -> list[str]:
+        environment = os.environ if env is None else env
+        working_directory = (cwd or Path.cwd()).resolve()
+        home = self._home(environment)
+        global_path = home / ".gemini" / "antigravity-cli" / "mcp_config.json"
+        workspace_path = working_directory / ".agents" / "mcp_config.json"
+        try:
+            before = self._signature(global_path)
+            global_data = self._load(global_path)
+            workspace_data = self._load(workspace_path)
+        except (OSError, UnicodeError, json.JSONDecodeError, TypeError, ValueError) as exc:
+            self.ports.log(
+                "WARN",
+                "agy_mcp_restore_config_read_failed "
+                f"error={type(exc).__name__}: {exc}",
+            )
+            return []
+
+        global_servers = self._servers(global_data)
+        reserved = set(self._servers(workspace_data))
+        projected: dict[str, dict[str, Any]] = {}
+        for name, server in self.ports.discover_managed(working_directory).items():
+            normalized = self._project_server(server)
+            if normalized is None:
+                self.ports.log(
+                    "WARN", f"agy_mcp_restore_skipped_unsupported server={name}"
+                )
+                continue
+            projected[name] = normalized
+        merged = McpInventoryService.merge(
+            global_servers, projected, reserved=reserved
+        )
+        if not merged.added:
+            return []
+        restored = dict(global_data)
+        restored["mcpServers"] = merged.servers
+        try:
+            self._atomic_replace(global_path, restored, before)
+        except (OSError, UnicodeError, TypeError, ValueError, RuntimeError) as exc:
+            self.ports.log(
+                "WARN",
+                "agy_mcp_restore_write_failed "
+                f"path={global_path} error={type(exc).__name__}: {exc}",
+            )
+            return []
+        names = list(merged.added)
+        self.ports.log(
+            "INFO",
+            "agy_mcp_config_restored "
+            f"path={global_path} servers={','.join(sorted(names))}",
+        )
+        return names
+
+    @staticmethod
+    def _home(env: Mapping[str, str]) -> Path:
+        configured = str(env.get("HOME") or env.get("USERPROFILE") or "").strip()
+        return Path(configured).expanduser() if configured else Path.home()
+
+    @staticmethod
+    def _signature(path: Path) -> tuple[int, int, int] | None:
+        try:
+            stat = path.stat()
+        except FileNotFoundError:
+            return None
+        return stat.st_mtime_ns, stat.st_size, getattr(stat, "st_ino", 0)
+
+    @staticmethod
+    def _load(path: Path) -> dict[str, Any]:
+        if not path.is_file():
+            return {}
+        value = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(value, dict):
+            raise ValueError(f"AGY MCP config must be a JSON object: {path}")
+        servers = value.get("mcpServers", {})
+        if not isinstance(servers, dict):
+            raise ValueError(f"AGY mcpServers must be a JSON object: {path}")
+        return value
+
+    @staticmethod
+    def _servers(data: dict[str, Any]) -> dict[str, dict[str, Any]]:
+        value = data.get("mcpServers", {})
+        return {
+            str(name): dict(server)
+            for name, server in value.items()
+            if str(name).strip() and isinstance(server, dict)
+        }
+
+    @staticmethod
+    def _project_server(server: dict[str, Any]) -> dict[str, Any] | None:
+        command = str(server.get("command") or "").strip()
+        url = str(
+            server.get("serverUrl")
+            or server.get("serverURL")
+            or server.get("url")
+            or server.get("endpoint")
+            or ""
+        ).strip()
+        args = server.get("args")
+        arguments = [str(item) for item in args] if isinstance(args, list) else []
+        if "mcp-proxy" in arguments and "--server-config" in arguments:
+            return None
+        if command:
+            projected: dict[str, Any] = {"command": command}
+        elif url.startswith(("http://", "https://")):
+            projected = {"serverUrl": url}
+        else:
+            return None
+        aliases = {
+            "http_headers": "headers",
+            "env_http_headers": "headers",
+            "type": "transport",
+        }
+        supported = (
+            "args", "env", "headers", "transport", "authProviderType",
+        )
+        normalized = dict(server)
+        for source, target in aliases.items():
+            if target not in normalized and source in normalized:
+                normalized[target] = normalized[source]
+        for key in supported:
+            value = normalized.get(key)
+            if isinstance(value, (str, bool, int, float, list, dict)):
+                projected[key] = value
+        return projected
+
+    @classmethod
+    def _atomic_replace(
+        cls,
+        path: Path,
+        value: dict[str, Any],
+        expected: tuple[int, int, int] | None,
+    ) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        if cls._signature(path) != expected:
+            raise RuntimeError("AGY config changed while MCP restoration was running")
+        temporary = path.with_name(f"{path.name}.{os.getpid()}.{time.time_ns()}.tmp")
+        try:
+            temporary.write_text(
+                json.dumps(value, indent=2, ensure_ascii=False) + "\n",
+                encoding="utf-8",
+            )
+            os.chmod(temporary, 0o600)
+            if cls._signature(path) != expected:
+                raise RuntimeError("AGY config changed while MCP restoration was running")
+            temporary.replace(path)
+        finally:
+            try:
+                temporary.unlink()
+            except FileNotFoundError:
+                pass
+
+
+__all__ = ["AgyMcpRestorePorts", "AgyMcpRestoreService"]