@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/providers/nvidia.py

@@ -0,0 +1,158 @@
+"""NVIDIA hosted provider adapter."""
+
+from dataclasses import dataclass, field, replace
+from typing import Any, Mapping
+from urllib.parse import urlparse
+
+from ..architecture import (
+    ProviderCapabilities,
+    ProviderConfigurationPolicy,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderOptionPresentationPolicy,
+    ProviderRequestPolicy,
+    ProviderStatusPolicy,
+)
+from .base import (
+    OpenAICompatibleProviderAdapter,
+    configuration_policy,
+    provider_configuration,
+)
+from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
+
+
+def hosted_context_default(model_id: str) -> int:
+    model = str(model_id or "").casefold()
+    if "kimi-k2.6" in model or "kimi_k2.6" in model:
+        return 262144
+    if "deepseek" in model:
+        return 131072
+    return 65536
+
+
+@dataclass(frozen=True)
+class NvidiaHostedProviderAdapter(OpenAICompatibleProviderAdapter):
+    name: str = "nvidia-hosted"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["nvidia-hosted"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            "qwen/qwen3-coder-480b-a35b-instruct",
+            api_key="not-used",
+            native_compat=False,
+            rate_limit_rpm=0,
+            rate_limit_status=False,
+            context_window=65536,
+            max_output_tokens=4096,
+            temperature=0.7,
+            top_p=0.8,
+            request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
+            stream_enabled=True,
+            stream_word_chunking=False,
+        )
+    )
+    api_key_display_name_value: str = "NVIDIA"
+    api_key_launch_error_value: str = (
+        "Launch blocked: NVIDIA hosted requires an NVIDIA API key."
+    )
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=lambda: ProviderCapabilities(
+            upstream_protocol="openai_chat", requires_api_key=True
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(kind="nvidia")
+    )
+    request_policy_value: ProviderRequestPolicy = field(
+        default_factory=lambda: ProviderRequestPolicy(
+            chat_path="/v1/chat/completions",
+            models_path="/v1/models",
+            model_alias_strategy="ncp",
+            stream_required=True,
+            managed_service="nvidia_proxy",
+        )
+    )
+
+    def normalize_base_url(self, value: str) -> str:
+        text = str(value or "").strip()
+        parsed = urlparse(text)
+        if (
+            not text
+            or text.startswith("nv" + "api-")
+            or not text.startswith(("http://", "https://"))
+            or (parsed.hostname or "") in {"127.0.0.1", "localhost"}
+        ):
+            return PROVIDER_DEFAULT_BASE_URLS["nvidia-hosted"].rstrip("/")
+        return text.rstrip("/")
+
+    def selection_config_updates(self, config: ProviderConfig) -> Mapping[str, Any]:
+        normalized = self.normalize_base_url(config.base_url)
+        if normalized == str(config.base_url or "").strip().rstrip("/"):
+            return {}
+        return {"base_url": normalized}
+
+    def selection_update_status_lines(
+        self, config: ProviderConfig, updates: Mapping[str, Any]
+    ) -> tuple[str, ...]:
+        del config
+        if "base_url" not in updates:
+            return ()
+        return (f"Base URL set to {updates['base_url']} for NVIDIA hosted.",)
+
+    def configuration_policy(
+        self, config: ProviderConfig
+    ) -> ProviderConfigurationPolicy:
+        del config
+        return configuration_policy(
+            native_compat_error=(
+                "nvidia-hosted does not expose Anthropic /v1/messages; use router mode. "
+                "Use self-hosted-nim or vLLM for native /v1/messages."
+            ),
+            status_fields=(
+                "context_window",
+                "max_output_tokens",
+                "request_timeout_ms",
+                "stream_idle_timeout_ms",
+            ),
+        )
+
+    def status_policy(self, config: ProviderConfig) -> ProviderStatusPolicy:
+        del config
+        return ProviderStatusPolicy(kind="nvidia", label="NVIDIA hosted")
+
+    def preserves_claude_model_alias(self, model_id: str) -> bool:
+        return str(model_id).startswith("claude-")
+
+    def display_model_name(self, model_id: str, provider_label: str) -> str:
+        if str(model_id).startswith("claude-nvidia-"):
+            cleaned = str(model_id)[len("claude-") :]
+            return cleaned.replace("/", " ").replace("-", " ").replace("_", " ").title()
+        return super().display_model_name(model_id, provider_label)
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="nvidia",
+            settings_strategy="standard",
+            hosted_timeout=True,
+            preset_context_profile="nvidia",
+            status_capacity_strategy="openai_budget",
+        )
+
+    def router_native_anthropic_enabled(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> bool:
+        del config, model
+        return False
+
+    def option_presentation_policy(
+        self, config: ProviderConfig
+    ) -> ProviderOptionPresentationPolicy:
+        return replace(
+            super().option_presentation_policy(config),
+            show_rate_limit=True,
+            show_native=False,
+        )
+
+
+__all__ = ["NvidiaHostedProviderAdapter", "hosted_context_default"]

package/ciel_runtime_support/providers/nvidia_runtime.py

@@ -0,0 +1,285 @@
+"""NVIDIA hosted provider runtime and nvd-claude-proxy lifecycle."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib
+import importlib.util
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+from typing import Any, Callable, Protocol
+
+
+@dataclass(frozen=True, slots=True)
+class NvidiaProxyRuntimeConfig:
+    env_path: Path
+    log_path: Path
+    package_name: str
+    upstream_base_url: str = "https://integrate.api.nvidia.com/v1"
+
+
+@dataclass(frozen=True, slots=True)
+class NvidiaProxyRuntimePorts:
+    load_config: Callable[..., dict[str, Any]]
+    read_env_file: Callable[[Path], dict[str, str]]
+    is_url_up: Callable[[str], bool]
+    find_executable: Callable[[str], str | None]
+    positive_int: Callable[[Any], int | None]
+    http_json: Callable[..., Any]
+    join_url: Callable[[str, str], str]
+
+
+@dataclass(frozen=True, slots=True)
+class NvidiaProxyRuntime:
+    config: NvidiaProxyRuntimeConfig
+    ports: NvidiaProxyRuntimePorts
+
+    def upstream_base_url(self) -> str:
+        return self.config.upstream_base_url
+
+    def proxy_base_url(self) -> str:
+        environment = self.ports.read_env_file(self.config.env_path)
+        host = environment.get("PROXY_HOST") or "127.0.0.1"
+        port = environment.get("PROXY_PORT") or "8788"
+        return f"http://{host}:{port}"
+
+    def api_key(self) -> str:
+        return (
+            self.ports.read_env_file(self.config.env_path).get("NVIDIA_API_KEY")
+            or os.environ.get("NVIDIA_API_KEY")
+            or os.environ.get("NV_API_KEY")
+            or ""
+        ).strip()
+
+    def install_proxy(self) -> str | None:
+        if os.environ.get("CIEL_RUNTIME_AUTO_INSTALL_NCP", "1").lower() in ("0", "false", "no"):
+            return None
+        self.config.log_path.parent.mkdir(parents=True, exist_ok=True)
+        with self.config.log_path.open("ab", buffering=0) as log:
+            log.write(b"\n[ciel-runtime] installing nvd-claude-proxy with pip\n")
+            process = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--user", "--upgrade", self.config.package_name],
+                stdout=log,
+                stderr=log,
+                timeout=240,
+            )
+        if process.returncode != 0:
+            return None
+        importlib.invalidate_caches()
+        return self.ports.find_executable("ncp")
+
+    @staticmethod
+    def module_available() -> bool:
+        return importlib.util.find_spec("nvd_claude_proxy") is not None
+
+    def proxy_executable(self) -> str | None:
+        return self.ports.find_executable("nvd-claude-proxy") or self.ports.find_executable("ncp")
+
+    def ensure(self) -> None:
+        provider = self.ports.load_config()["providers"]["nvidia-hosted"]
+        upstream = provider.get("base_url") or self.upstream_base_url()
+        environment = os.environ.copy()
+        environment.update(self.ports.read_env_file(self.config.env_path))
+        environment["NVIDIA_BASE_URL"] = upstream.rstrip("/")
+        environment.setdefault("PROXY_HOST", "127.0.0.1")
+        environment.setdefault("PROXY_PORT", "8788")
+        environment.setdefault("STORAGE_ENGINE", "sqlite")
+        timeout_ms = self.ports.positive_int(provider.get("request_timeout_ms"))
+        if timeout_ms:
+            environment["REQUEST_TIMEOUT_SECONDS"] = str(max(1, timeout_ms / 1000))
+        base_url = f"http://{environment['PROXY_HOST']}:{environment['PROXY_PORT']}"
+        if self.ports.is_url_up(f"{base_url}/v1/models"):
+            return
+        self.config.log_path.parent.mkdir(parents=True, exist_ok=True)
+        executable = self.proxy_executable()
+        if not (executable or self.module_available()):
+            self.install_proxy()
+            executable = self.proxy_executable()
+        if not (executable or self.module_available()):
+            raise RuntimeError(
+                "nvd-claude-proxy was not found. Install it with: "
+                "python -m pip install --user nvd-claude-proxy"
+            )
+        creation_flags = getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0
+        with self.config.log_path.open("ab", buffering=0) as log:
+            if executable:
+                command = [executable]
+                log.write(f"\n[ciel-runtime] starting nvd-claude-proxy executable: {executable}\n".encode())
+            else:
+                command = [sys.executable, "-m", "nvd_claude_proxy.main"]
+                log.write(b"\n[ciel-runtime] starting nvd-claude-proxy module\n")
+            subprocess.Popen(
+                command,
+                stdout=log,
+                stderr=log,
+                env=environment,
+                cwd=str(self.config.env_path.parent),
+                creationflags=creation_flags,
+            )
+        deadline = time.time() + 45
+        while time.time() < deadline:
+            if self.ports.is_url_up(f"{base_url}/v1/models"):
+                return
+            time.sleep(0.5)
+        raise RuntimeError("nvd-claude-proxy did not become ready")
+
+    def model_id(self, model_id: str) -> str:
+        if model_id.startswith("claude-") and not model_id.startswith("ciel-runtime-"):
+            return model_id
+        try:
+            data = self.ports.http_json(
+                self.ports.join_url(self.proxy_base_url(), "/v1/models"),
+                timeout=3.0,
+            )
+        except Exception:
+            return model_id
+        items = data.get("data") if isinstance(data, dict) else None
+        if not isinstance(items, list):
+            return model_id
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            proxy_id = str(item.get("id") or "").strip()
+            upstream_id = str(item.get("nvidia_id") or "").strip()
+            if proxy_id == model_id:
+                return proxy_id
+            if upstream_id and upstream_id == model_id and proxy_id:
+                return proxy_id
+        return model_id
+
+
+class NvidiaPortTerminator(Protocol):
+    def __call__(self, port: int, label: str, quiet: bool = False) -> bool: ...
+
+
+class MatchingProcessTerminator(Protocol):
+    def __call__(
+        self,
+        needles: list[str],
+        label: str,
+        quiet: bool = False,
+    ) -> bool: ...
+
+
+class ProcessRunner(Protocol):
+    def __call__(self, command: list[str], **kwargs: Any) -> Any: ...
+
+
+@dataclass(frozen=True, slots=True)
+class NvidiaProxyStopPorts:
+    read_env_file: Callable[[Path], dict[str, str]]
+    positive_int: Callable[[Any], int | None]
+    terminate_windows_port: NvidiaPortTerminator
+    find_executable: Callable[[str], str | None]
+    terminate_matching_processes: MatchingProcessTerminator
+    run: ProcessRunner
+    log: Callable[[str, str], None]
+    output: Callable[[str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class NvidiaProxyStopper:
+    env_path: Path
+    ports: NvidiaProxyStopPorts
+
+    def stop(self, quiet: bool = False, *, platform_name: str = os.name) -> bool:
+        label = "Nvidia NCP proxy"
+        if platform_name == "nt":
+            port = (
+                self.ports.positive_int(
+                    self.ports.read_env_file(self.env_path).get("PROXY_PORT")
+                )
+                or 8788
+            )
+            stopped = self.ports.terminate_windows_port(port, label, quiet=True)
+            if stopped and not quiet:
+                self.ports.output(
+                    "Stopped existing Nvidia NCP proxy session if one was running."
+                )
+            return stopped
+
+        executable = self.ports.find_executable("ncp")
+        if not executable:
+            return self.ports.terminate_matching_processes(
+                ["nvd_claude_proxy"],
+                label,
+                quiet=quiet,
+            )
+
+        stopped = False
+        try:
+            self.ports.run(
+                [executable, "kill"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=10,
+            )
+            stopped = True
+        except (OSError, subprocess.SubprocessError) as exc:
+            self.ports.log(
+                "WARN",
+                f"ncp_proxy_kill_failed executable={executable} "
+                f"error={type(exc).__name__}: {exc}",
+            )
+        for needles in (
+            ["nvd-claude-proxy"],
+            ["ncp", "proxy"],
+            ["nvd_claude_proxy"],
+        ):
+            stopped = (
+                self.ports.terminate_matching_processes(
+                    needles,
+                    label,
+                    quiet=True,
+                )
+                or stopped
+            )
+        if stopped and not quiet:
+            self.ports.output(
+                "Stopped existing Nvidia NCP proxy session if one was running."
+            )
+        return stopped
+
+
+@dataclass(frozen=True, slots=True)
+class NvidiaRuntimeApi:
+    """Explicit compatibility API for late-bound NVIDIA proxy runtimes."""
+
+    runtime_factory: Callable[[], NvidiaProxyRuntime]
+
+    def upstream_base_url(self) -> str:
+        return self.runtime_factory().upstream_base_url()
+
+    def proxy_base_url(self) -> str:
+        return self.runtime_factory().proxy_base_url()
+
+    def api_key(self) -> str:
+        return self.runtime_factory().api_key()
+
+    def install_proxy(self) -> str | None:
+        return self.runtime_factory().install_proxy()
+
+    def module_available(self) -> bool:
+        return self.runtime_factory().module_available()
+
+    def proxy_executable(self) -> str | None:
+        return self.runtime_factory().proxy_executable()
+
+    def ensure(self) -> None:
+        self.runtime_factory().ensure()
+
+    def model_id(self, model_id: str) -> str:
+        return self.runtime_factory().model_id(model_id)
+
+
+__all__ = [
+    "NvidiaProxyRuntime",
+    "NvidiaProxyRuntimeConfig",
+    "NvidiaProxyRuntimePorts",
+    "NvidiaProxyStopper",
+    "NvidiaProxyStopPorts",
+    "NvidiaRuntimeApi",
+]

package/ciel_runtime_support/providers/ollama.py

@@ -0,0 +1,181 @@
+"""Ollama local and cloud provider adapters."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+
+from ..architecture import (
+    ProviderCapabilities,
+    ProviderConfigurationPolicy,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderOptionPresentationPolicy,
+    ProviderRequestPolicy,
+    ProviderStatusPolicy,
+)
+from .base import HttpBearerProviderAdapter, provider_configuration
+from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
+
+
+@dataclass(frozen=True)
+class OllamaProviderAdapter(HttpBearerProviderAdapter):
+    name: str = "ollama"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["ollama"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            "qwen3-coder",
+            api_key="ollama",
+            custom_models=("qwen3-coder",),
+            native_compat=True,
+            rate_limit_rpm=0,
+            rate_limit_status=False,
+            num_ctx="auto",
+            num_ctx_min=32768,
+            num_ctx_max=131072,
+            keep_alive="5m",
+            think=False,
+            request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
+            stream_enabled=True,
+            stream_word_chunking=False,
+            ollama_options={
+                "temperature": 0.7,
+                "top_p": 0.8,
+                "top_k": 40,
+                "num_predict": 4096,
+            },
+        )
+    )
+    send_placeholder_key: bool = True
+    api_key_display_name_value: str = "Ollama"
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=lambda: ProviderCapabilities(
+            upstream_protocol="ollama_chat",
+            supports_thinking=True,
+            local=True,
+        )
+    )
+    request_policy_value: ProviderRequestPolicy = field(
+        default_factory=lambda: ProviderRequestPolicy(
+            chat_path="/api/chat",
+            models_path="/api/tags",
+            model_info_path="/api/show",
+            default_timeout_seconds=300.0,
+            probe_strategy="ollama",
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(kind="ollama")
+    )
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="ollama",
+            settings_strategy="ollama",
+            uses_catalog_timeout=True,
+            preset_context_profile="ollama",
+            status_capacity_strategy="ollama_budget",
+        )
+
+    def launch_model_strategy(self, config: ProviderConfig) -> str:
+        del config
+        return "ollama_unslug"
+
+    def option_presentation_policy(
+        self, config: ProviderConfig
+    ) -> ProviderOptionPresentationPolicy:
+        del config
+        return ProviderOptionPresentationPolicy(
+            show_rate_limit=True,
+            show_tool_choice=True,
+            show_stream=True,
+            show_rate_limit_controls=True,
+            show_sampling_controls=True,
+            show_ip_family_control=True,
+        )
+
+    def model_paths(self, config: ProviderConfig) -> tuple[str, ...]:
+        del config
+        return ("/api/tags", "/v1/models")
+
+    def configuration_policy(
+        self, config: ProviderConfig
+    ) -> ProviderConfigurationPolicy:
+        del config
+        return ProviderConfigurationPolicy(
+            mutation_strategy="ollama", uses_ollama_status=True
+        )
+
+    def status_policy(self, config: ProviderConfig) -> ProviderStatusPolicy:
+        return replace(
+            super().status_policy(config),
+            unreachable_hint="Start Ollama or set a reachable Base URL before launching Claude Code.",
+        )
+
+
+@dataclass(frozen=True)
+class OllamaCloudProviderAdapter(OllamaProviderAdapter):
+    name: str = "ollama-cloud"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["ollama-cloud"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            "glm-5.1",
+            custom_models=("glm-5.1",),
+            rate_limit_rpm=0,
+            rate_limit_status=False,
+            num_ctx="auto",
+            num_ctx_min=32768,
+            num_ctx_max=131072,
+            keep_alive="5m",
+            think=True,
+            request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
+            stream_enabled=True,
+            stream_word_chunking=False,
+            ollama_options={
+                "temperature": 0.7,
+                "top_p": 0.8,
+                "top_k": 40,
+                "num_predict": 4096,
+            },
+        )
+    )
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=lambda: ProviderCapabilities(
+            upstream_protocol="ollama_chat",
+            supports_thinking=True,
+            requires_api_key=True,
+        )
+    )
+    api_key_display_name_value: str = "Ollama Cloud"
+    api_key_launch_error_value: str = (
+        "Launch blocked: Ollama Cloud requires an API key."
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(
+            kind="ollama", use_bundled_catalog_fallback=True
+        )
+    )
+
+    def normalize_model_id(self, model_id: str) -> str:
+        normalized = super().normalize_model_id(model_id)
+        return normalized[:-6] if normalized.endswith(":cloud") else normalized
+
+    def launch_model_strategy(self, config: ProviderConfig) -> str:
+        del config
+        return "alias"
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="ollama",
+            settings_strategy="ollama",
+            hosted_timeout=True,
+            timeout_weight=1.2,
+            uses_catalog_timeout=True,
+            preset_context_profile="ollama",
+            status_capacity_strategy="ollama_budget",
+        )
+
+
+__all__ = ["OllamaCloudProviderAdapter", "OllamaProviderAdapter"]