@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

package/ciel_runtime_support/llm_preset_context.py

@@ -0,0 +1,338 @@
+"""LLM preset identity, recommendation, and presentation bounded context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+from typing import Any, Callable, Mapping
+
+from .architecture import ProviderContextPolicy
+from . import llm_presets
+from .llm_presets import PresetIdentityPolicy
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetCatalog:
+    presets: Mapping[str, tuple[str, str]]
+    preset_i18n: Mapping[str, Mapping[str, tuple[str, str]]]
+    family_i18n: Mapping[str, Mapping[str, str]]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetQueries:
+    load_config: Callable[[], dict[str, Any]]
+    context_policy: Callable[[str, dict[str, Any]], ProviderContextPolicy]
+    context_capacity: Callable[[str, dict[str, Any]], int | None]
+    context_services: Callable[[str], Any]
+    ui_text: Callable[[str, str | None], str]
+    pad_cells: Callable[[str, int], str]
+    format_context: Callable[[int | None], str]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetAlgorithms:
+    classify_family: Callable[..., str]
+    recommend: Callable[[str, int | None], str]
+    infer: Callable[..., str | None]
+    required_context: Callable[[str, ProviderContextPolicy], int | None]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetDefinitionPorts:
+    context_heavy_presets: set[str] | frozenset[str]
+    llm_presets: Mapping[str, tuple[str, str]]
+    preset_text: Callable[..., tuple[str, str]]
+    load_config: Callable[[], dict[str, Any]]
+    family_text: Callable[..., str]
+    model_family: Callable[[str, dict[str, Any]], str]
+    positive_int: Callable[[Any], int | None]
+    required_context: Callable[[str, str | None], int | None]
+    ui_text: Callable[[str, str | None], str]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetContextPolicyPorts:
+    lm_studio_guard: Callable[..., list[str]]
+    ollama_output_guard: Callable[..., list[str]]
+    recommended_timeout: Callable[..., list[str]]
+    cap_context: Callable[..., list[str]]
+    cap_output: Callable[..., list[str]]
+    ollama_context_status: Callable[..., str]
+    model_capacity: Callable[..., int | None]
+    sync_ollama_context: Callable[..., list[str]]
+    upstream_context_limit: Callable[..., int | None]
+    timeout_tokens: Callable[..., list[str]]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetMutationPorts:
+    apply_ollama_option: Callable[..., list[str]]
+    apply_provider_option: Callable[..., list[str]]
+    ollama_options: Callable[[dict[str, Any]], dict[str, Any]]
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetContext:
+    catalog: LlmPresetCatalog
+    queries: LlmPresetQueries
+    algorithms: LlmPresetAlgorithms
+    definition: LlmPresetDefinitionPorts
+    policy: LlmPresetContextPolicyPorts
+    mutation: LlmPresetMutationPorts
+
+    def model_family(self, provider: str, config: dict[str, Any]) -> str:
+        return self.algorithms.classify_family(
+            config,
+            self.queries.context_policy(provider, config),
+            self.queries.context_capacity(provider, config),
+            self.queries.context_services(provider),
+        )
+
+    def recommended(self, provider: str, config: dict[str, Any]) -> str:
+        return self.algorithms.recommend(
+            self.model_family(provider, config),
+            self.queries.context_capacity(provider, config),
+        )
+
+    def slider_ids(self) -> list[str]:
+        return list(self.catalog.presets)
+
+    @staticmethod
+    def command_name(preset_id: str) -> str:
+        normalized = re.sub(
+            r"[^a-z0-9]+", "-", str(preset_id or "").lower()
+        ).strip("-")
+        return f"llm-{normalized}"
+
+    def slash_command(self, preset_id: str) -> str:
+        label, description = self.text(preset_id, "en")
+        return f"""---
+description: Apply ciel-runtime live preset: {label}
+argument-hint: [ignored]
+---
+
+CIEL_RUNTIME_LIVE_LLM_OPTIONS
+
+Value: {preset_id}
+
+Apply the ciel-runtime live LLM preset `{preset_id}` ({description}) to this routed session. The original options are captured before the first live preset change and can be restored with `/llm-restore`.
+"""
+
+    def resolve(self, value: str) -> str | None:
+        return PresetIdentityPolicy(self.catalog.presets, self.command_name).resolve(value)
+
+    def required_context(
+        self, preset_id: str, provider: str | None = None
+    ) -> int | None:
+        selected = provider or "anthropic"
+        return self.algorithms.required_context(
+            preset_id, self.queries.context_policy(selected, {})
+        )
+
+    def available(
+        self, provider: str, config: dict[str, Any], preset_id: str
+    ) -> bool:
+        required = self.required_context(preset_id, provider)
+        if not required:
+            return True
+        capacity = self.queries.context_capacity(provider, config)
+        return not capacity or required <= capacity
+
+    def infer(self, provider: str, config: dict[str, Any]) -> str | None:
+        return self.algorithms.infer(
+            config,
+            self.queries.context_policy(provider, config),
+            self.queries.context_services(provider),
+        )
+
+    def applied(self, provider: str, config: dict[str, Any]) -> str:
+        preset_id = str(config.get("llm_preset") or "").strip()
+        if preset_id in self.catalog.presets:
+            return preset_id
+        inferred = self.infer(provider, config)
+        if inferred and self.available(provider, config, inferred):
+            return inferred
+        recommended = self.recommended(provider, config)
+        return recommended if self.available(provider, config, recommended) else "balanced"
+
+    def text(self, preset_id: str, lang: str | None = None) -> tuple[str, str]:
+        language = lang or str(self.queries.load_config().get("language") or "en")
+        return self.catalog.preset_i18n.get(language, {}).get(
+            preset_id, self.catalog.presets[preset_id]
+        )
+
+    def family_text(self, family: str, lang: str | None = None) -> str:
+        language = lang or str(self.queries.load_config().get("language") or "en")
+        return self.catalog.family_i18n.get(language, {}).get(family, family)
+
+    def panel_rows(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        lang: str | None = None,
+    ) -> tuple[list[str], list[str]]:
+        language = lang or str(self.queries.load_config().get("language") or "en")
+        recommended = self.recommended(provider, config)
+        applied = self.applied(provider, config)
+        family = self.model_family(provider, config)
+        recommended_label, _ = self.text(recommended, language)
+        rows = [
+            f"{self.queries.ui_text('model_family', language)}: "
+            f"{self.family_text(family, language)}; "
+            f"{self.queries.ui_text('recommended_preset_is', language)} "
+            f"{recommended_label}"
+        ]
+        values = ["__info__"]
+        for preset_id in self.catalog.presets:
+            label, description = self.text(preset_id, language)
+            mark = "*" if preset_id == applied else " "
+            suffix = ""
+            required = self.required_context(preset_id, provider)
+            capacity = (
+                self.queries.context_capacity(provider, config) if required else None
+            )
+            if required and capacity and required > capacity:
+                suffix = (
+                    f" (requires {self.queries.format_context(required)}; "
+                    f"server {self.queries.format_context(capacity)})"
+                )
+            rows.append(
+                f"{mark} {self.queries.pad_cells(label, 24)} {description}{suffix}"
+            )
+            values.append(preset_id)
+        rows.append(self.queries.ui_text("back", language))
+        values.append("back")
+        return rows, values
+
+    def apply(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        preset_id: str,
+        lang: str | None = None,
+        *,
+        sync_ollama_context: bool = True,
+        load_lm_studio: bool = False,
+    ) -> list[str]:
+        return llm_presets.apply_preset_to_provider(
+            provider,
+            config,
+            preset_id,
+            lang,
+            sync_ollama_context=sync_ollama_context,
+            load_lm_studio=load_lm_studio,
+            services=llm_presets.PresetServices(
+                definition=llm_presets.PresetDefinition(
+                    CONTEXT_HEAVY_PRESETS=self.definition.context_heavy_presets,
+                    LLM_PRESETS=self.definition.llm_presets,
+                    llm_preset_text=self.definition.preset_text,
+                    load_config=self.definition.load_config,
+                    model_family_text=self.definition.family_text,
+                    model_option_family=self.definition.model_family,
+                    positive_int=self.definition.positive_int,
+                    required_context_for_preset=self.definition.required_context,
+                    ui_text=self.definition.ui_text,
+                ),
+                context_policy=llm_presets.PresetContextPolicy(
+                    apply_lm_studio_loaded_context_guard=self.policy.lm_studio_guard,
+                    apply_ollama_runtime_output_guard=self.policy.ollama_output_guard,
+                    apply_recommended_timeout_for_model_context=self.policy.recommended_timeout,
+                    cap_context_settings_to_model_capacity=self.policy.cap_context,
+                    cap_output_settings_to_context_ratio=self.policy.cap_output,
+                    ollama_num_ctx_status=self.policy.ollama_context_status,
+                    provider_model_context_capacity=self.policy.model_capacity,
+                    sync_ollama_library_context_limit=self.policy.sync_ollama_context,
+                    upstream_model_context_limit=self.policy.upstream_context_limit,
+                    with_preset_timeout_tokens=self.policy.timeout_tokens,
+                ),
+                provider_mutation=llm_presets.PresetProviderMutation(
+                    apply_ollama_option=self.mutation.apply_ollama_option,
+                    apply_provider_option=self.mutation.apply_provider_option,
+                    ollama_extra_options=self.mutation.ollama_options,
+                ),
+            ),
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class LlmPresetCompatibilityApi:
+    context: Callable[[], LlmPresetContext]
+
+    def model_family(self, provider: str, config: dict[str, Any]) -> str:
+        return self.context().model_family(provider, config)
+
+    def recommended(self, provider: str, config: dict[str, Any]) -> str:
+        return self.context().recommended(provider, config)
+
+    def slider_ids(self) -> list[str]:
+        return self.context().slider_ids()
+
+    def command_name(self, preset_id: str) -> str:
+        return self.context().command_name(preset_id)
+
+    def slash_command(self, preset_id: str) -> str:
+        return self.context().slash_command(preset_id)
+
+    def resolve(self, value: str) -> str | None:
+        return self.context().resolve(value)
+
+    def required_context(
+        self, preset_id: str, provider: str | None = None
+    ) -> int | None:
+        return self.context().required_context(preset_id, provider)
+
+    def available(
+        self, provider: str, config: dict[str, Any], preset_id: str
+    ) -> bool:
+        return self.context().available(provider, config, preset_id)
+
+    def applied(self, provider: str, config: dict[str, Any]) -> str:
+        return self.context().applied(provider, config)
+
+    def infer(self, provider: str, config: dict[str, Any]) -> str | None:
+        return self.context().infer(provider, config)
+
+    def text(self, preset_id: str, lang: str | None = None) -> tuple[str, str]:
+        return self.context().text(preset_id, lang)
+
+    def family_text(self, family: str, lang: str | None = None) -> str:
+        return self.context().family_text(family, lang)
+
+    def panel_rows(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        lang: str | None = None,
+    ) -> tuple[list[str], list[str]]:
+        return self.context().panel_rows(provider, config, lang)
+
+    def apply(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        preset_id: str,
+        lang: str | None = None,
+        *,
+        sync_ollama_context: bool = True,
+        load_lm_studio: bool = False,
+    ) -> list[str]:
+        return self.context().apply(
+            provider,
+            config,
+            preset_id,
+            lang,
+            sync_ollama_context=sync_ollama_context,
+            load_lm_studio=load_lm_studio,
+        )
+
+
+__all__ = [
+    "LlmPresetAlgorithms",
+    "LlmPresetCatalog",
+    "LlmPresetCompatibilityApi",
+    "LlmPresetContext",
+    "LlmPresetContextPolicyPorts",
+    "LlmPresetDefinitionPorts",
+    "LlmPresetMutationPorts",
+    "LlmPresetQueries",
+]

package/ciel_runtime_support/managed_mcp_config.py

@@ -119,19 +119,23 @@ class ManagedMcpConfigService:
         return self.paths.channel
 
     def _fetch_command(self, web: dict[str, Any]) -> tuple[str | None, list[Any]]:
-        arguments: list[Any] = [web.get("fetch_package") or "mcp-server-fetch"]
+        package = str(web.get("fetch_package") or "mcp-server-fetch")
+        arguments: list[Any] = [package]
         if web.get("fetch_user_agent"):
             arguments.extend(["--user-agent", str(web["fetch_user_agent"])])
         if web.get("fetch_ignore_robots_txt", False):
             arguments.append("--ignore-robots-txt")
+        dependency_args = ["--with", "mcp<2"] if package == "mcp-server-fetch" else []
         command = self.ports.find_executable("uvx")
         if command:
-            return command, arguments
+            return command, [*dependency_args, *arguments]
         uv = self.ports.find_executable("uv")
         if uv:
-            return uv, ["tool", "run", *arguments]
+            return uv, ["tool", "run", *dependency_args, *arguments]
         if importlib.util.find_spec("uv") is not None:
-            return sys.executable, ["-m", "uv", "tool", "run", *arguments]
+            return sys.executable, [
+                "-m", "uv", "tool", "run", *dependency_args, *arguments
+            ]
         pipx = self.ports.find_executable("pipx")
         return (pipx, ["run", *arguments]) if pipx else (None, arguments)
 

package/ciel_runtime_support/mcp_configuration_context.py

@@ -0,0 +1,291 @@
+"""MCP configuration discovery and native-config projection context."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Protocol
+
+from .mcp_config_reader import ClaudeMcpConfigPathPolicy
+from .managed_mcp_discovery import (
+    ManagedMcpDiscoveryPaths,
+    ManagedMcpDiscoveryPorts,
+    ManagedMcpDiscoveryService,
+    NativeMcpConfigWriter,
+    NativeMcpConfigWriterPorts,
+)
+
+
+class JsonArtifactRepository(Protocol):
+    def save(self, data: Any, operation: str) -> None: ...
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationFilePorts:
+    read_items: Callable[..., list[Any]]
+    names_from_mapping: Callable[..., Any]
+    servers_from_mapping: Callable[..., Any]
+    log: Callable[[str, str], None]
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationPaths:
+    home: Path
+    web_tools: Path
+    proxy: Path
+    native_config: Path
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationRuntimePorts:
+    resolve_executable: Callable[[str], str]
+    parse_bool: Callable[..., bool]
+    artifact_repository: Callable[[Path], JsonArtifactRepository]
+    discover_channel_specs: Callable[..., list[str]]
+    is_channel_tagged: Callable[[str], bool]
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationContext:
+    files: McpConfigurationFilePorts
+    paths: McpConfigurationPaths
+    runtime: McpConfigurationRuntimePorts
+    native_channel_names: frozenset[str]
+
+    def read_server_names(self, path: Path, cwd: Path) -> list[str]:
+        return self.files.read_items(
+            path,
+            cwd,
+            self.files.names_from_mapping,
+            str,
+            self.files.log,
+        )
+
+    def read_servers(
+        self, path: Path, cwd: Path
+    ) -> list[tuple[str, dict[str, Any]]]:
+        return self.files.read_items(
+            path,
+            cwd,
+            self.files.servers_from_mapping,
+            lambda item: item[0],
+            self.files.log,
+        )
+
+    def server_is_stdio(self, server: dict[str, Any]) -> bool:
+        if not isinstance(server, dict):
+            return False
+        server_type = str(server.get("type") or "").strip().lower()
+        if server_type and server_type not in ("stdio", "command"):
+            return False
+        command = self.runtime.resolve_executable(
+            str(server.get("command") or "").strip()
+        )
+        if not command:
+            return False
+        raw_args = server.get("args", [])
+        args = (
+            [str(item) for item in raw_args if item is not None]
+            if isinstance(raw_args, list)
+            else []
+        )
+        return "mcp-proxy" not in args
+
+    @staticmethod
+    def server_is_streamable_http(server: dict[str, Any]) -> bool:
+        if not isinstance(server, dict):
+            return False
+        server_type = str(
+            server.get("type") or server.get("transport") or ""
+        ).strip().lower()
+        if server_type not in {"http", "streamable-http"}:
+            return False
+        url = str(server.get("url") or server.get("endpoint") or "").strip()
+        return url.startswith(("http://", "https://"))
+
+    def server_force_proxy(self, server: dict[str, Any]) -> bool:
+        if not isinstance(server, dict):
+            return False
+        return self.runtime.parse_bool(
+            server.get(
+                "ciel_runtime_mcp_proxy",
+                server.get(
+                    "ciel_runtime_force_mcp_proxy",
+                    server.get("force_mcp_proxy", False),
+                ),
+            ),
+            False,
+        )
+
+    def server_disables_proxy_notifications(self, server: dict[str, Any]) -> bool:
+        if not isinstance(server, dict):
+            return False
+        return self.runtime.parse_bool(
+            server.get(
+                "ciel_runtime_disable_notification_stream",
+                server.get("ciel_runtime_disable_mcp_notifications", False),
+            ),
+            False,
+        )
+
+    @staticmethod
+    def safe_proxy_name(name: str) -> str:
+        safe = re.sub(r"[^A-Za-z0-9_.-]+", "_", name.strip())
+        return safe[:80] or "server"
+
+    def config_paths(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> list[Path]:
+        return ClaudeMcpConfigPathPolicy.paths(
+            passthrough or [], cwd or Path.cwd(), home or self.paths.home
+        )
+
+    def existing_config_paths(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> list[Path]:
+        return ClaudeMcpConfigPathPolicy.existing_paths(
+            passthrough or [], cwd or Path.cwd(), home or self.paths.home
+        )
+
+    def discover_user_servers(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> dict[str, dict[str, Any]]:
+        working_directory = cwd or Path.cwd()
+        servers: dict[str, dict[str, Any]] = {}
+        for path in self.existing_config_paths(
+            passthrough, working_directory, home
+        ):
+            for name, server in self.read_servers(path, working_directory):
+                servers.setdefault(name, server)
+        return servers
+
+    def read_generated_servers(
+        self, path: Path, cwd: Path
+    ) -> dict[str, dict[str, Any]]:
+        if not path.exists() or not path.is_file():
+            return {}
+        servers: dict[str, dict[str, Any]] = {}
+        for name, server in self.read_servers(path, cwd):
+            if name.strip().lower() in self.native_channel_names:
+                continue
+            servers.setdefault(name, server)
+        return servers
+
+    def discover_managed_servers(
+        self, cwd: Path | None = None
+    ) -> dict[str, dict[str, Any]]:
+        service = ManagedMcpDiscoveryService(
+            paths=ManagedMcpDiscoveryPaths(
+                web_tools=self.paths.web_tools,
+                proxy=self.paths.proxy,
+            ),
+            ports=ManagedMcpDiscoveryPorts(
+                read_generated=self.read_generated_servers,
+                load_json=lambda path: json.loads(path.read_text(encoding="utf-8")),
+                log=self.files.log,
+            ),
+            native_channel_names=frozenset(
+                name.casefold() for name in self.native_channel_names
+            ),
+        )
+        return service.discover(cwd or Path.cwd())
+
+    def write_native_config(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> Path | None:
+        writer = NativeMcpConfigWriter(
+            self.paths.native_config,
+            NativeMcpConfigWriterPorts(
+                self.discover_user_servers,
+                self.discover_managed_servers,
+                lambda path, data, operation: self.runtime.artifact_repository(
+                    path
+                ).save(data, operation),
+                self.files.log,
+            ),
+        )
+        return writer.write(passthrough, cwd, home)
+
+    def auto_discovered_channel_specs(
+        self,
+        passthrough: list[str] | None = None,
+        cwd: Path | None = None,
+        home: Path | None = None,
+    ) -> list[str]:
+        working_directory = cwd or Path.cwd()
+        return self.runtime.discover_channel_specs(
+            self.config_paths(passthrough, working_directory, home),
+            working_directory,
+            self.read_server_names,
+            self.runtime.is_channel_tagged,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class McpConfigurationCompatibilityApi:
+    context: Callable[[], McpConfigurationContext]
+
+    def read_server_names(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().read_server_names(*args, **kwargs)
+
+    def read_servers(self, *args: Any, **kwargs: Any) -> list[Any]:
+        return self.context().read_servers(*args, **kwargs)
+
+    def server_is_stdio(self, server: dict[str, Any]) -> bool:
+        return self.context().server_is_stdio(server)
+
+    def server_is_streamable_http(self, server: dict[str, Any]) -> bool:
+        return self.context().server_is_streamable_http(server)
+
+    def server_force_proxy(self, server: dict[str, Any]) -> bool:
+        return self.context().server_force_proxy(server)
+
+    def server_disables_proxy_notifications(self, server: dict[str, Any]) -> bool:
+        return self.context().server_disables_proxy_notifications(server)
+
+    def safe_proxy_name(self, name: str) -> str:
+        return self.context().safe_proxy_name(name)
+
+    def config_paths(self, *args: Any, **kwargs: Any) -> list[Path]:
+        return self.context().config_paths(*args, **kwargs)
+
+    def existing_config_paths(self, *args: Any, **kwargs: Any) -> list[Path]:
+        return self.context().existing_config_paths(*args, **kwargs)
+
+    def discover_user_servers(self, *args: Any, **kwargs: Any) -> dict[str, dict[str, Any]]:
+        return self.context().discover_user_servers(*args, **kwargs)
+
+    def read_generated_servers(self, *args: Any, **kwargs: Any) -> dict[str, dict[str, Any]]:
+        return self.context().read_generated_servers(*args, **kwargs)
+
+    def discover_managed_servers(self, *args: Any, **kwargs: Any) -> dict[str, dict[str, Any]]:
+        return self.context().discover_managed_servers(*args, **kwargs)
+
+    def write_native_config(self, *args: Any, **kwargs: Any) -> Path | None:
+        return self.context().write_native_config(*args, **kwargs)
+
+    def auto_discovered_channel_specs(self, *args: Any, **kwargs: Any) -> list[str]:
+        return self.context().auto_discovered_channel_specs(*args, **kwargs)
+
+
+__all__ = [
+    "McpConfigurationCompatibilityApi",
+    "McpConfigurationContext",
+    "McpConfigurationFilePorts",
+    "McpConfigurationPaths",
+    "McpConfigurationRuntimePorts",
+]