@oneciel-ai/ciel-runtime 0.1.1 → 0.2.0

package/ciel_runtime_support/configuration_cli.py

@@ -0,0 +1,374 @@
+"""Application controller for interactive configuration CLI commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+
+RuntimeConfig = dict[str, Any]
+ProviderConfig = dict[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigurationCliConfigPorts:
+    load: Callable[[], RuntimeConfig]
+    save: Callable[[RuntimeConfig], None]
+    current_provider: Callable[
+        [RuntimeConfig],
+        tuple[str, ProviderConfig],
+    ]
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigurationCliProviderPorts:
+    normalize_choice: Callable[[str], str | None]
+    normalize_provider: Callable[[str], str]
+    panel_rows: Callable[[RuntimeConfig], tuple[list[str], list[str]]]
+    menu_label: Callable[[str, ProviderConfig], str]
+    set_choice: Callable[[str], list[str]]
+    set_provider: Callable[[str], list[str]]
+    set_base_url: Callable[[str, str], list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigurationCliModelPorts:
+    cached_ids: Callable[[str, ProviderConfig], list[str]]
+    alias_for: Callable[[str, str], str]
+    read_cache: Callable[[str, ProviderConfig], list[str] | None]
+    set_model: Callable[[str], list[str]]
+    upstream_ids: Callable[[str, ProviderConfig], list[str]]
+    set_advisor: Callable[[str], list[str]]
+    advisor_uses_builtin: Callable[[str, ProviderConfig], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigurationCliDisplayPorts:
+    log_level_names: Mapping[int, str]
+    log_level_status: Callable[[], str]
+    log_level_name: Callable[[], str]
+    set_log_level: Callable[[str], list[str]]
+    languages: Mapping[str, str]
+    web_tools_config_path: Path
+    language_panel_rows: Callable[
+        [RuntimeConfig],
+        tuple[list[str], list[str]],
+    ]
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigurationCliIO:
+    output: Callable[[str], None]
+    select: Callable[[str, list[str], int], int | None]
+
+
+@dataclass(frozen=True, slots=True)
+class ConfigurationCliController:
+    config: ConfigurationCliConfigPorts
+    provider: ConfigurationCliProviderPorts
+    model: ConfigurationCliModelPorts
+    display: ConfigurationCliDisplayPorts
+    io: ConfigurationCliIO
+
+    def provider_command(self, name: str | None) -> None:
+        config = self.config.load()
+        if not name:
+            current = str(config["current_provider"])
+            providers = config["providers"]
+            current_config = (
+                providers.get(current, {})
+                if isinstance(providers, dict)
+                else {}
+            )
+            rows, _values = self.provider.panel_rows(config)
+            self.io.output(
+                "Available providers (current: %s)"
+                % self.provider.menu_label(current, current_config)
+            )
+            for index, row in enumerate(rows, 1):
+                self.io.output(f" {index:>2}. {row}")
+            self.io.output("\nUse: /provider <name>")
+            self.io.output(
+                "Examples: /provider codex, /provider codex-routed, "
+                "/provider ollama"
+            )
+            self.io.output(
+                "Then run /model to choose a model for the selected provider."
+            )
+            return
+        choice = self.provider.normalize_choice(name)
+        lines = (
+            self.provider.set_choice(choice)
+            if choice
+            else self.provider.set_provider(
+                self.provider.normalize_provider(name)
+            )
+        )
+        self._output_lines(lines)
+        self.io.output(
+            "Gateway model cache cleared. Run /model to refresh "
+            "the model picker."
+        )
+
+    def base_url_command(self, provider: str, url: str) -> None:
+        normalized = self.provider.normalize_provider(provider)
+        self._output_lines(self.provider.set_base_url(normalized, url))
+
+    def model_command(self, values: list[str] | None) -> None:
+        config = self.config.load()
+        provider, provider_config = self.config.current_provider(config)
+        if not values:
+            self.io.output(
+                f"Model menu for {provider} "
+                f"(current: {provider_config.get('current_model')})"
+            )
+            models = self.model.cached_ids(provider, provider_config)
+            for index, model_id in enumerate(models[:100], 1):
+                mark = (
+                    "*"
+                    if model_id == provider_config.get("current_model")
+                    else " "
+                )
+                self.io.output(
+                    f" {mark} {index:>3}. "
+                    f"{self.model.alias_for(provider, model_id)}    "
+                    f"[{model_id}]"
+                )
+            if len(models) > 100:
+                self.io.output(f" ... {len(models) - 100} more")
+            if self.model.read_cache(provider, provider_config) is None:
+                self.io.output(
+                    "\nProvider model list is not cached yet. Use the menu "
+                    "refresh row or run: ciel-runtimectl models"
+                )
+            self.io.output(
+                "\nSet direct/custom model with: /set-model MODEL_ID"
+            )
+            self.io.output(
+                "Or from terminal: ciel-runtimectl model MODEL_ID"
+            )
+            return
+        value = " ".join(values).strip()
+        if value.startswith("add "):
+            value = value[4:].strip()
+        if not value:
+            raise SystemExit("Missing model id")
+        self._output_lines(self.model.set_model(value))
+        self.io.output(
+            "Gateway model cache cleared. Run /model to refresh if needed."
+        )
+
+    def advisor_model_command(self, values: list[str] | None) -> None:
+        if not values:
+            config = self.config.load()
+            provider, provider_config = self.config.current_provider(config)
+            if self.model.advisor_uses_builtin(provider, provider_config):
+                self.io.output(
+                    "Anthropic modes use Claude Code's built-in /advisor; "
+                    "run /advisor in the session to pick its model."
+                )
+                return
+            current = provider_config.get("advisor_model") or "off"
+            self.io.output(f"Advisor Model for {provider}: {current}")
+            self.io.output(
+                "Set with: ciel-runtimectl advisor-model deepseek-v4-pro"
+            )
+            self.io.output(
+                "Disable with: ciel-runtimectl advisor-model off"
+            )
+            return
+        value = " ".join(values).strip()
+        if value.lower() in {
+            "off",
+            "unset",
+            "disable",
+            "disabled",
+            "none",
+            "null",
+        }:
+            value = ""
+        self._output_lines(self.model.set_advisor(value))
+
+    def models_command(self, provider_override: str | None) -> None:
+        config = self.config.load()
+        provider, provider_config = self.config.current_provider(config)
+        if provider_override:
+            provider = self.provider.normalize_provider(provider_override)
+            provider_config = config["providers"][provider]
+        models = self.model.upstream_ids(provider, provider_config)
+        self.io.output(f"{provider}: {len(models)} models")
+        for model_id in models:
+            self.io.output(
+                f"{self.model.alias_for(provider, model_id)}\t{model_id}"
+            )
+
+    def log_level_command(self, value: str | None) -> None:
+        if not value:
+            self.io.output(f"log_level: {self.display.log_level_status()}")
+            for numeric in sorted(self.display.log_level_names):
+                name = self.display.log_level_names[numeric]
+                mark = (
+                    "*"
+                    if name == self.display.log_level_name()
+                    else " "
+                )
+                self.io.output(f" {mark} {name:<6} {numeric}")
+            self.io.output("   DEFAULT reset to environment/default")
+            return
+        self._output_lines(self.display.set_log_level(str(value)))
+
+    def language_command(self, value: str | None) -> None:
+        config = self.config.load()
+        if not value:
+            current = str(config.get("language", "en"))
+            label = self.display.languages.get(current, current)
+            self.io.output(f"language: {current} ({label})")
+            for code, language_label in self.display.languages.items():
+                mark = "*" if code == current else " "
+                self.io.output(f" {mark} {code:<2} {language_label}")
+            return
+        normalized = self._language_alias(value)
+        if normalized not in self.display.languages:
+            raise SystemExit(
+                f"Unknown language: {value}\n"
+                f"Known: {', '.join(self.display.languages)}"
+            )
+        config["language"] = normalized
+        self.config.save(config)
+        self.io.output(
+            f"Language set to {normalized} "
+            f"({self.display.languages[normalized]})."
+        )
+
+    def portable_provider_menu(self) -> int:
+        config = self.config.load()
+        rows, values = self.provider.panel_rows(config)
+        selected = self.io.select(
+            "Select ciel-runtime provider",
+            rows,
+            values.index(
+                str(config.get("current_provider", "nvidia-hosted"))
+            ),
+        )
+        if selected is None:
+            self.io.output("Cancelled.")
+            return 1
+        self._output_lines(self.provider.set_provider(values[selected]))
+        return 0
+
+    def portable_language_menu(self) -> int:
+        config = self.config.load()
+        rows, values = self.display.language_panel_rows(config)
+        selected = self.io.select(
+            "Select display language",
+            rows,
+            values.index(str(config.get("language", "en"))),
+        )
+        if selected is None:
+            self.io.output("Cancelled.")
+            return 1
+        language = values[selected]
+        config["language"] = language
+        self.config.save(config)
+        self.io.output(
+            f"Language set to {language} "
+            f"({self.display.languages[language]})."
+        )
+        return 0
+
+    def web_search_command(self, value: str | None) -> None:
+        config = self.config.load()
+        web = config.setdefault("web_search", {})
+        if value:
+            web["auto_for_non_native"] = self._toggle(
+                value,
+                "Use: ciel-runtime web-search on|off|status",
+            )
+            self.config.save(config)
+        state = "on" if web.get("auto_for_non_native", True) else "off"
+        package = web.get("package", "ddg-mcp-search")
+        self.io.output(f"web_search: {state}")
+        self.io.output(
+            f"search_provider: {web.get('provider', 'duckduckgo')}"
+        )
+        self.io.output(f"search_package: {package}")
+        self.io.output(
+            f"web_fetch: {'on' if web.get('fetch_enabled', True) else 'off'}"
+        )
+        self.io.output(
+            f"fetch_package: "
+            f"{web.get('fetch_package', 'mcp-server-fetch')}"
+        )
+        self.io.output(f"mcp_config: {self.display.web_tools_config_path}")
+
+    def web_fetch_command(self, value: str | None) -> None:
+        config = self.config.load()
+        web = config.setdefault("web_search", {})
+        if value:
+            normalized = value.lower()
+            if normalized == "ignore-robots-on":
+                web["fetch_ignore_robots_txt"] = True
+            elif normalized == "ignore-robots-off":
+                web["fetch_ignore_robots_txt"] = False
+            else:
+                web["fetch_enabled"] = self._toggle(
+                    normalized,
+                    "Use: ciel-runtime web-fetch "
+                    "on|off|ignore-robots-on|ignore-robots-off",
+                )
+            self.config.save(config)
+        self.io.output(
+            f"web_fetch: {'on' if web.get('fetch_enabled', True) else 'off'}"
+        )
+        self.io.output(
+            f"fetch_package: "
+            f"{web.get('fetch_package', 'mcp-server-fetch')}"
+        )
+        self.io.output(
+            "ignore_robots_txt: "
+            f"{bool(web.get('fetch_ignore_robots_txt', False))}"
+        )
+        self.io.output(
+            f"user_agent: {web.get('fetch_user_agent') or 'default'}"
+        )
+        self.io.output(f"mcp_config: {self.display.web_tools_config_path}")
+
+    def _output_lines(self, lines: list[str]) -> None:
+        for line in lines:
+            self.io.output(line)
+
+    @staticmethod
+    def _toggle(value: str, usage: str) -> bool:
+        normalized = value.lower()
+        if normalized in {"on", "enable", "enabled", "true", "1"}:
+            return True
+        if normalized in {"off", "disable", "disabled", "false", "0"}:
+            return False
+        raise SystemExit(usage)
+
+    @staticmethod
+    def _language_alias(value: str) -> str:
+        normalized = value.strip().lower()
+        aliases = {
+            "english": "en",
+            "korean": "ko",
+            "한국어": "ko",
+            "japanese": "ja",
+            "日本語": "ja",
+            "chinese": "zh",
+            "中文": "zh",
+            "zh-cn": "zh",
+            "cn": "zh",
+        }
+        return aliases.get(normalized, normalized)
+
+
+__all__ = [
+    "ConfigurationCliConfigPorts",
+    "ConfigurationCliController",
+    "ConfigurationCliDisplayPorts",
+    "ConfigurationCliIO",
+    "ConfigurationCliModelPorts",
+    "ConfigurationCliProviderPorts",
+]

package/ciel_runtime_support/context_compaction.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class ContextCompactionTransport:
+    summary_output_tokens: Callable[[dict[str, Any], int], int]
+    request_timeout: Callable[[dict[str, Any]], float]
+    endpoint: Callable[[str, dict[str, Any], str], str]
+    post_json: Callable[..., Any]
+    headers: Callable[[str, dict[str, Any]], dict[str, str]]
+    extract_text: Callable[[Any, str], str]
+    native_compat_enabled: Callable[[str, dict[str, Any]], bool]
+    native_anthropic_base: Callable[[str, dict[str, Any]], str]
+    upstream_base: Callable[[str, dict[str, Any]], str]
+    join_url: Callable[[str, str], str]
+
+
+@dataclass(frozen=True)
+class ContextCompactionWorkflow:
+    parse_bool: Callable[..., bool]
+    compaction_available: Callable[[str, dict[str, Any]], bool]
+    instruction_index: Callable[[list[dict[str, Any]]], int | None]
+    content_to_text: Callable[[Any], str]
+    chunk_target_tokens: Callable[[dict[str, Any], int], int]
+    split_messages: Callable[..., list[tuple[int, list[dict[str, Any]]]]]
+    parallel_sessions: Callable[[dict[str, Any], int], int]
+    write_activity: Callable[..., Any]
+    estimate_tokens: Callable[[Any], int]
+    request_summary: Callable[..., str]
+
+
+@dataclass(frozen=True)
+class ContextCompactionProjection:
+    build_chunk_prompt: Callable[..., str]
+    build_fallback_summary: Callable[..., str]
+    build_reduce_prompt: Callable[..., str]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True)
+class ContextCompactionServices:
+    transport: ContextCompactionTransport
+    workflow: ContextCompactionWorkflow
+    projection: ContextCompactionProjection
+    map_system_prompt: str
+
+
+def request_context_summary(
+    provider: str,
+    model: str,
+    provider_config: dict[str, Any],
+    prompt: str,
+    services: ContextCompactionServices,
+    *,
+    wire: str,
+    budget_tokens: int,
+) -> str:
+    transport = services.transport
+    max_tokens = transport.summary_output_tokens(provider_config, budget_tokens)
+    timeout = transport.request_timeout(provider_config)
+    if wire == "ollama":
+        request: dict[str, Any] = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": services.map_system_prompt},
+                {"role": "user", "content": prompt},
+            ],
+            "stream": False,
+            "think": False,
+            "options": {"num_predict": max_tokens},
+        }
+        if provider_config.get("keep_alive"):
+            request["keep_alive"] = str(provider_config["keep_alive"])
+        operation = "ollama_chat"
+    elif wire == "openai":
+        request = {
+            "model": model,
+            "messages": [
+                {"role": "system", "content": services.map_system_prompt},
+                {"role": "user", "content": prompt},
+            ],
+            "stream": False,
+            "max_tokens": max_tokens,
+        }
+        operation = "openai_chat"
+    else:
+        request = {
+            "model": model,
+            "system": services.map_system_prompt,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": max_tokens,
+            "stream": False,
+        }
+        base = (
+            transport.native_anthropic_base(provider, provider_config)
+            if transport.native_compat_enabled(provider, provider_config)
+            else transport.upstream_base(provider, provider_config)
+        )
+        url = transport.join_url(base, "/v1/messages")
+        return _post_summary(
+            provider, model, provider_config, request, url, "anthropic", timeout, services
+        )
+    url = transport.endpoint(provider, provider_config, operation)
+    return _post_summary(
+        provider, model, provider_config, request, url, wire, timeout, services
+    )
+
+
+def _post_summary(
+    provider: str,
+    model: str,
+    provider_config: dict[str, Any],
+    request: dict[str, Any],
+    url: str,
+    wire: str,
+    timeout: float,
+    services: ContextCompactionServices,
+) -> str:
+    transport = services.transport
+    data = transport.post_json(
+        url,
+        request,
+        transport.headers(provider, provider_config),
+        timeout,
+        provider,
+        provider_config,
+        model,
+        # Summarization is a non-idempotent generation request.  A retry can
+        # consume quota even when the provider completed the first attempt but
+        # the response was lost, so never multiply it implicitly.
+        retry_rate_limits=False,
+    )
+    return transport.extract_text(data, wire)
+
+
+def build_llm_compacted_messages(
+    provider: str,
+    model: str,
+    provider_config: dict[str, Any] | None,
+    messages: list[dict[str, Any]],
+    budget_tokens: int,
+    services: ContextCompactionServices,
+    *,
+    wire: str,
+) -> list[dict[str, Any]] | None:
+    if not provider_config or not messages:
+        return None
+    workflow = services.workflow
+    projection = services.projection
+    # Claude Code already performs the final compact generation.  The former
+    # default ran one extra generation per segment before forwarding that
+    # request (N map calls + one reduce call), which multiplied provider quota.
+    # Keep segmented LLM compaction as an explicit compatibility opt-in only.
+    if workflow.parse_bool(provider_config.get("context_compact_llm"), default=False) is False:
+        return None
+    if not workflow.compaction_available(provider, provider_config):
+        return None
+    instruction_index = workflow.instruction_index(messages)
+    if instruction_index is None:
+        return None
+    compact_instruction = workflow.content_to_text(messages[instruction_index].get("content"))
+    history = [
+        message
+        for index, message in enumerate(messages)
+        if index != instruction_index and str(message.get("role") or "") != "system"
+    ]
+    system_messages = [message for message in messages if str(message.get("role") or "") == "system"]
+    if not history:
+        return None
+    target_tokens = workflow.chunk_target_tokens(provider_config, budget_tokens)
+    chunks = workflow.split_messages(history, target_tokens)
+    if not chunks:
+        return None
+    parallel_sessions = workflow.parallel_sessions(provider_config, len(chunks))
+    initial_tokens = workflow.estimate_tokens({"messages": messages})
+    _write_activity(
+        provider,
+        model,
+        len(chunks),
+        parallel_sessions,
+        initial_tokens,
+        0,
+        budget_tokens,
+        "map",
+        0,
+        workflow,
+    )
+    summaries: list[str] = []
+    for chunk_number, (start, chunk) in enumerate(chunks, start=1):
+        prompt = projection.build_chunk_prompt(chunk, start, chunk_number, len(chunks))
+        try:
+            summary = workflow.request_summary(
+                provider,
+                model,
+                provider_config,
+                prompt,
+                wire=wire,
+                budget_tokens=budget_tokens,
+            )
+        except Exception as exc:
+            projection.log(
+                "WARN",
+                f"context_compact_chunk_failed provider={provider} model={model} "
+                f"chunk={chunk_number}/{len(chunks)} error={type(exc).__name__}: {exc}",
+            )
+            summary = projection.build_fallback_summary(
+                chunk, target_tokens, start_index=start
+            )
+        if not summary.strip():
+            summary = projection.build_fallback_summary(
+                chunk, target_tokens, start_index=start
+            )
+        summaries.append(summary.strip())
+        _write_activity(
+            provider,
+            model,
+            len(chunks),
+            parallel_sessions,
+            initial_tokens,
+            sum(workflow.estimate_tokens(item) for item in summaries),
+            budget_tokens,
+            "map",
+            chunk_number,
+            workflow,
+        )
+    reduce_prompt = projection.build_reduce_prompt(
+        summaries,
+        compact_instruction,
+        budget_tokens=budget_tokens,
+        source_message_count=len(history),
+    )
+    output = [*system_messages, {"role": "user", "content": reduce_prompt}]
+    final_tokens = workflow.estimate_tokens({"messages": output})
+    projection.log(
+        "WARN",
+        f"context_compact_map_reduce provider={provider} model={model} chunks={len(chunks)} "
+        f"messages {len(messages)}->{len(output)} tokens {initial_tokens}->{final_tokens} "
+        f"budget={budget_tokens}",
+    )
+    workflow.write_activity(
+        provider or "provider",
+        model,
+        chunks=len(chunks),
+        parallel_sessions=parallel_sessions,
+        tokens=initial_tokens,
+        final_tokens=final_tokens,
+        budget=budget_tokens,
+        phase="reduce",
+        completed_chunks=len(chunks),
+        retained_messages=len(output),
+    )
+    return output
+
+
+def _write_activity(
+    provider: str,
+    model: str,
+    chunks: int,
+    parallel_sessions: int,
+    tokens: int,
+    final_tokens: int,
+    budget: int,
+    phase: str,
+    completed_chunks: int,
+    workflow: ContextCompactionWorkflow,
+) -> None:
+    workflow.write_activity(
+        provider or "provider",
+        model,
+        chunks=chunks,
+        parallel_sessions=parallel_sessions,
+        tokens=tokens,
+        final_tokens=final_tokens,
+        budget=budget,
+        phase=phase,
+        completed_chunks=completed_chunks,
+    )