@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/output_budget.py

@@ -0,0 +1,89 @@
+"""Provider request output-token budgeting policy."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class OpenAIContextBudgetPolicy:
+    """Resolve context capacity for providers using OpenAI-compatible payloads."""
+
+    positive_int: Callable[[Any], int | None]
+    runtime_capacity: Callable[[str, dict[str, Any]], int]
+    nvidia_default: Callable[[str], int]
+
+    def context_limit(self, provider: str, config: dict[str, Any]) -> int:
+        configured = self.positive_int(config.get("context_window")) or self.positive_int(
+            config.get("max_model_len")
+        )
+        if provider in ("vllm", "self-hosted-nim"):
+            runtime = self.runtime_capacity(provider, config)
+            if configured and str(config.get("llm_preset") or "").strip():
+                return min(configured, runtime) if runtime else configured
+            if runtime:
+                return runtime
+        if configured:
+            return configured
+        if provider == "nvidia-hosted":
+            return self.nvidia_default(str(config.get("current_model") or ""))
+        return 65536
+
+
+@dataclass(frozen=True, slots=True)
+class OutputBudgetPolicy:
+    positive_int: Callable[[Any], int | None]
+    estimate_tokens: Callable[[Any, dict[int, int] | None], int]
+    provider_options: Callable[[dict[str, Any]], dict[str, Any]]
+
+    def configured_tokens(
+        self,
+        config: dict[str, Any],
+        body: dict[str, Any],
+        option_key: str | None = None,
+    ) -> int | None:
+        configured = self.positive_int(config.get("max_output_tokens"))
+        if option_key:
+            configured = (
+                self.positive_int(self.provider_options(config).get(option_key))
+                or configured
+            )
+        requested = self.positive_int(body.get("max_tokens"))
+        if configured and requested:
+            return min(configured, requested)
+        return configured or requested
+
+    def reserve_tokens(
+        self, config: dict[str, Any], context_limit: int | None
+    ) -> int:
+        configured = self.positive_int(config.get("context_reserve_tokens"))
+        if configured:
+            return configured
+        if not context_limit:
+            return 1024
+        return max(1024, min(32768, int(context_limit) // 32))
+
+    def cap_tokens_for_context(
+        self,
+        config: dict[str, Any],
+        body: dict[str, Any],
+        payload: Any,
+        context_limit: int | None,
+        configured: int | None,
+        _token_cache: dict[int, int] | None = None,
+    ) -> int | None:
+        del body
+        if not configured:
+            return None
+        if not context_limit:
+            return configured
+        reserve = self.reserve_tokens(config, context_limit)
+        available = context_limit - self.estimate_tokens(payload, _token_cache) - reserve
+        if available <= 0:
+            return min(configured, 256)
+        return max(1, min(configured, available))
+
+
+__all__ = ["OpenAIContextBudgetPolicy", "OutputBudgetPolicy"]

package/ciel_runtime_support/package_lifecycle.py

@@ -0,0 +1,217 @@
+"""Reusable npm-backed runtime package installation and update lifecycle."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from pathlib import Path
+import subprocess
+from typing import Callable
+
+
+@dataclass(frozen=True, slots=True)
+class NpmPackageLifecyclePorts:
+    find_executable: Callable[[str], str | None]
+    install_prefix: Callable[[], Path | None]
+    install_command: Callable[[str, str, Path | None], list[str]]
+    run_upgrade: Callable[..., tuple[int, str]]
+    add_prefix_bin: Callable[[Path | None], None]
+    latest_version: Callable[[str, str], str]
+    version_newer: Callable[[str, str], bool]
+    output: Callable[..., None] = print
+
+
+class NpmPackageLifecycle:
+    def __init__(self, ports: NpmPackageLifecyclePorts) -> None:
+        self._ports = ports
+
+    def install_if_missing(
+        self,
+        *,
+        executable_name: str,
+        label: str,
+        package_spec: str,
+        skip_env: str,
+    ) -> str | None:
+        executable = self._ports.find_executable(executable_name)
+        if executable:
+            return executable
+        if os.environ.get(skip_env) == "1":
+            return None
+        npm = self._ports.find_executable("npm")
+        if not npm:
+            self._print(
+                f"{label} executable was not found, and npm is not available to install {package_spec}."
+            )
+            return None
+        prefix = self._ports.install_prefix()
+        command = self._ports.install_command(npm, package_spec, prefix)
+        self._print(f"{label} executable was not found; installing {package_spec}...")
+        if prefix is not None:
+            self._print(f"Installing {label} into active npm prefix: {prefix}")
+        return_code, output = self._ports.run_upgrade(command, timeout=300)
+        if output:
+            self._print(output)
+        if return_code != 0:
+            self._print(f"{label} install failed ({return_code}).")
+            if prefix is not None:
+                self._print(
+                    f"Install targeted the active install prefix ({prefix}). "
+                    "If this prefix is not writable, install with the permissions used for that prefix."
+                )
+            return None
+        self._ports.add_prefix_bin(prefix)
+        executable = self._ports.find_executable(executable_name)
+        if executable:
+            self._print(f"{label} installed: {executable}")
+        else:
+            self._print(
+                f"{label} install completed, but the {executable_name} executable is still not visible in PATH."
+            )
+        return executable
+
+    def update_check(
+        self,
+        executable: str,
+        *,
+        executable_name: str,
+        label: str,
+        package_spec: str,
+        skip_env: str,
+        current_version: Callable[[str], str],
+        enabled: bool = True,
+    ) -> str:
+        if not enabled or os.environ.get(skip_env) == "1":
+            return executable
+        self._print(f"Checking {label} update before launch...")
+        current = current_version(executable)
+        if current:
+            self._print(f"Current {label} version: {current}")
+        npm = self._ports.find_executable("npm")
+        if not npm:
+            self._print(f"{label} update check skipped: npm was not found.")
+            return executable
+        latest = self._ports.latest_version(npm, package_spec)
+        if not latest:
+            self._print(f"{label} update check could not read the latest npm version; continuing.")
+            return executable
+        if current and not self._ports.version_newer(latest, current):
+            self._print(f"{label} is up to date ({current}).")
+            return executable
+        self._print(f"{label} update available: {current or 'unknown'} -> {latest}; upgrading automatically.")
+        prefix = self._ports.install_prefix()
+        if prefix is not None:
+            self._print(f"Updating {label} in active npm prefix: {prefix}")
+        return_code, output = self._ports.run_upgrade(
+            self._ports.install_command(npm, package_spec, prefix),
+            timeout=300,
+        )
+        if output:
+            self._print(output)
+        if return_code != 0:
+            self._print(f"{label} update failed ({return_code}); continuing with current version.")
+            return executable
+        self._ports.add_prefix_bin(prefix)
+        updated = self._ports.find_executable(executable_name) or executable
+        new_version = current_version(updated)
+        if new_version:
+            self._print(f"{label} version after update: {new_version}")
+        return updated
+
+    def _print(self, message: str) -> None:
+        self._ports.output(message, flush=True)
+
+
+@dataclass(frozen=True, slots=True)
+class SelfUpdatePorts:
+    running_from_package: Callable[[], bool]
+    find_executable: Callable[[str], str | None]
+    latest_version: Callable[[str, str], str]
+    version_newer: Callable[[str, str], bool]
+    package_root: Callable[[], Path | None]
+    prefix_from_root: Callable[[Path], Path | None]
+    install_command: Callable[[str, str, Path | None], list[str]]
+    forced_environment: Callable[[], dict[str, str]]
+    restart: Callable[..., None]
+    output: Callable[..., None] = print
+
+
+class SelfUpdateLifecycle:
+    PACKAGE_SPEC = "@oneciel-ai/ciel-runtime@latest"
+
+    def __init__(self, current_version: str, ports: SelfUpdatePorts) -> None:
+        self._current_version = current_version
+        self._ports = ports
+
+    def run(self, enabled: bool = True) -> bool:
+        if not enabled or os.environ.get("CIEL_RUNTIME_SKIP_SELF_UPDATE") == "1":
+            return False
+        raw_check = os.environ.get("CIEL_RUNTIME_SELF_UPDATE_CHECK")
+        if raw_check is not None and raw_check.strip().lower() in {"0", "false", "no", "off"}:
+            return False
+        if not self._ports.running_from_package():
+            return False
+        npm = self._ports.find_executable("npm")
+        if not npm:
+            return False
+        latest = self._ports.latest_version(npm, self.PACKAGE_SPEC)
+        if not latest or not self._ports.version_newer(latest, self._current_version):
+            return False
+        self._print(
+            f"Ciel Runtime update available: {self._current_version} -> {latest}; upgrading automatically."
+        )
+        package_root = self._ports.package_root()
+        prefix = self._ports.prefix_from_root(package_root) if package_root else None
+        command = self._ports.install_command(npm, self.PACKAGE_SPEC, prefix)
+        if prefix is not None:
+            self._print(f"Updating current Ciel Runtime install prefix: {prefix}")
+        try:
+            update = subprocess.run(
+                command,
+                text=True,
+                input="y\n",
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                env=self._ports.forced_environment(),
+                timeout=300,
+            )
+        except subprocess.TimeoutExpired:
+            self._print("Ciel Runtime update timed out; continuing with current version.")
+            return False
+        except (OSError, subprocess.SubprocessError) as exc:
+            self._print(f"Ciel Runtime update failed ({type(exc).__name__}); continuing.")
+            return False
+        output = (update.stdout or "").strip()
+        if output:
+            self._print(output)
+        if update.returncode != 0:
+            self._print(
+                f"Ciel Runtime update exited with {update.returncode}; continuing with current version."
+            )
+            if prefix is not None:
+                self._print(
+                    f"Update targeted the active install prefix ({prefix}). "
+                    "If this prefix is not writable, reinstall or update with the permissions used for that prefix."
+                )
+            return False
+        self._print("Ciel Runtime updated. Restarting with the new version...")
+        try:
+            self._ports.restart(npm, package_root=package_root)
+        except SystemExit:
+            raise
+        except (OSError, subprocess.SubprocessError) as exc:
+            self._print(
+                f"Restart failed ({type(exc).__name__}); continuing with the current process."
+            )
+        return True
+
+    def _print(self, message: str) -> None:
+        self._ports.output(message, flush=True)
+
+
+__all__ = [
+    "NpmPackageLifecycle",
+    "NpmPackageLifecyclePorts",
+    "SelfUpdateLifecycle",
+    "SelfUpdatePorts",
+]

package/ciel_runtime_support/plan_artifact_controller.py

@@ -0,0 +1,104 @@
+"""HTTP controller and repository adapter for shared plan artifacts."""
+
+from __future__ import annotations
+
+import time
+import urllib.parse
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler
+from pathlib import Path
+from typing import Any, Callable
+
+
+@dataclass(frozen=True, slots=True)
+class PlanArtifactServices:
+    directory: Path
+    router_base: str
+    safe_segment: Callable[[str, str], str]
+    write_json: Callable[..., None]
+    write_text: Callable[..., None]
+    announce: Callable[[dict[str, Any]], dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class PlanArtifactController:
+    services: PlanArtifactServices
+
+    def get(self, handler: BaseHTTPRequestHandler, path: str) -> bool:
+        if path == "/ca/plan/artifacts":
+            self.services.directory.mkdir(parents=True, exist_ok=True)
+            items = [
+                {
+                    "name": item.name,
+                    "bytes": item.stat().st_size,
+                    "url": f"{self.services.router_base}/ca/plan/artifacts/{urllib.parse.quote(item.name)}",
+                }
+                for item in sorted(self.services.directory.glob("*"))
+                if item.is_file()
+            ]
+            self.services.write_json(handler, {"ok": True, "artifacts": items})
+            return True
+        if not path.startswith("/ca/plan/artifacts/"):
+            return False
+        name = self.services.safe_segment(
+            urllib.parse.unquote(path[len("/ca/plan/artifacts/") :]), "plan.md"
+        )
+        target = self.services.directory / name
+        if not target.exists() or not target.is_file():
+            self.services.write_json(handler, {"ok": False, "error": "not_found"}, 404)
+            return True
+        content_type = (
+            "text/markdown; charset=utf-8"
+            if target.suffix.lower() in (".md", ".markdown")
+            else "text/plain; charset=utf-8"
+        )
+        self.services.write_text(
+            handler,
+            target.read_text(encoding="utf-8", errors="replace"),
+            content_type=content_type,
+        )
+        return True
+
+    def post(
+        self,
+        handler: BaseHTTPRequestHandler,
+        path: str,
+        body: dict[str, Any],
+    ) -> bool:
+        if path != "/ca/plan/artifacts":
+            return False
+        self.services.directory.mkdir(parents=True, exist_ok=True)
+        title = str(body.get("title") or "plan")
+        content = str(body.get("content") or body.get("message") or "")
+        name = self.services.safe_segment(
+            str(body.get("name") or f"{int(time.time())}-{title}.md"), "plan.md"
+        )
+        if "." not in name:
+            name += ".md"
+        target = self.services.directory / name
+        target.write_text(content, encoding="utf-8")
+        latest = self.services.directory / "latest.md"
+        if target.name != latest.name:
+            latest.write_text(content, encoding="utf-8")
+        url = f"{self.services.router_base}/ca/plan/artifacts/{urllib.parse.quote(name)}"
+        if body.get("announce", True):
+            self.services.announce(
+                {
+                    "channel": body.get("channel", "plan"),
+                    "sender_id": body.get("sender_id", "plan"),
+                    "recipients": body.get("recipients", "all"),
+                    "kind": "plan",
+                    "message": url,
+                    "meta": {"title": title, "url": url, "name": name},
+                }
+            )
+        self.services.write_json(
+            handler,
+            {
+                "ok": True,
+                "name": name,
+                "url": url,
+                "latest_url": f"{self.services.router_base}/ca/plan/artifacts/latest.md",
+            },
+        )
+        return True