@oneciel-ai/ciel-runtime 0.2.37 → 0.2.38

package/ciel_runtime_support/external_event_menu.py

@@ -0,0 +1,107 @@
+"""Prelaunch menu projection for the external event receiver."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .external_event_receiver import ExternalEventReceiverService
+
+
+def panel_rows(
+    service: ExternalEventReceiverService, router_base: str
+) -> tuple[list[str], list[str]]:
+    receiver = service.receiver_configs().get("default", {})
+    public_receiver = service.public_receiver("default", receiver)
+    environment_references = public_receiver.get("environment_references", {})
+    enabled = bool(receiver.get("enabled", False))
+    transport = str(receiver.get("transport") or "webhook")
+    input_transport = str(receiver.get("input_transport") or "auto")
+    event_types = (
+        receiver.get("event_types")
+        if isinstance(receiver.get("event_types"), list)
+        else []
+    )
+    secret_status = service.vault.status("default")
+
+    def secret_source(field_name: str, stored_key: str) -> str:
+        reference = environment_references.get(field_name, {})
+        if isinstance(reference, dict) and reference.get("name"):
+            availability = "available" if reference.get("available") else "missing"
+            return f"env:{reference['name']} {availability}"
+        return "stored" if secret_status[stored_key] else "unset"
+
+    rows = [
+        f"Enabled  [{'on' if enabled else 'off'}]",
+        f"Transport  [{transport}]",
+        f"Runtime input transport  [{input_transport}]",
+        f"SSE URL  [{str(receiver.get('url') or 'unset')}]",
+        "SSE content mode  [CloudEvents 1.0 structured JSON]",
+        f"Allowed CloudEvent types  [{', '.join(str(value) for value in event_types) if event_types else 'all'}]",
+        f"Cursor JSON pointer  [{str(receiver.get('cursor_json_pointer') or 'SSE id field')}]",
+        f"Reconnect query parameter  [{str(receiver.get('cursor_query_parameter') or 'Last-Event-ID header')}]",
+        f"Webhook signing secret  [{secret_source('webhook_secret', 'stored_webhook_secret')}]",
+        f"SSE authorization  [{secret_source('authorization', 'stored_authorization')}]",
+        f"Webhook endpoint  [{router_base}/ca/events/webhooks/default]",
+        "Back",
+    ]
+    values = [
+        "enabled",
+        "transport",
+        "input_transport",
+        "url",
+        "__info__",
+        "event_types",
+        "cursor_json_pointer",
+        "cursor_query_parameter",
+        "webhook_secret",
+        "authorization",
+        "__info__",
+        "back",
+    ]
+    return rows, values
+
+
+def update_config(
+    service: ExternalEventReceiverService, key: str, value: Any
+) -> list[str]:
+    current = service.receiver_configs().get("default", {})
+    body: dict[str, Any] = {
+        "enabled": bool(current.get("enabled", False)),
+        "transport": str(current.get("transport") or "webhook"),
+        "input_transport": str(current.get("input_transport") or "auto"),
+        "url": str(current.get("url") or ""),
+        "event_types": current.get("event_types")
+        if isinstance(current.get("event_types"), list)
+        else [],
+        "cursor_json_pointer": str(current.get("cursor_json_pointer") or ""),
+        "cursor_query_parameter": str(current.get("cursor_query_parameter") or ""),
+    }
+    if key == "enabled":
+        body["enabled"] = not body["enabled"]
+    elif key == "transport":
+        body["transport"] = "sse" if body["transport"] == "webhook" else "webhook"
+    elif key == "input_transport":
+        body["input_transport"] = str(value or "auto")
+    elif key == "event_types":
+        body["event_types"] = [
+            part.strip() for part in str(value or "").split(",") if part.strip()
+        ]
+    elif key in {
+        "url",
+        "cursor_json_pointer",
+        "cursor_query_parameter",
+        "webhook_secret",
+        "authorization",
+    }:
+        body[key] = str(value or "")
+    else:
+        raise ValueError(f"unsupported external event option: {key}")
+    updated = service.save_receiver("default", body)
+    return [
+        f"External event receiver updated: enabled={updated.get('enabled')} transport={updated.get('transport')} input_transport={updated.get('input_transport')}.",
+        "The router owns receiver connections; the prelaunch configuration process does not open a duplicate stream.",
+        "External events use the private Runtime Input Gateway and are never published to Web Chat.",
+    ]
+
+
+__all__ = ["panel_rows", "update_config"]

package/ciel_runtime_support/external_event_receiver.py

@@ -418,6 +418,18 @@ class ExternalEventReceiverService:
         cursor_query_parameter = str(body.get("cursor_query_parameter") or "").strip()
         if len(cursor_query_parameter) > 80 or any(char in cursor_query_parameter for char in "&=?#/"):
             raise ValueError("cursor_query_parameter must be a single URL query parameter name")
+        input_transport = str(body.get("input_transport") or "auto").strip().lower().replace("-", "_")
+        input_transport = {
+            "socket": "session_socket",
+            "claude_socket": "session_socket",
+            "messaging_socket": "session_socket",
+            "terminal": "tty",
+            "stdin": "tty",
+            "llm": "router",
+            "context": "router",
+        }.get(input_transport, input_transport)
+        if input_transport not in {"auto", "session_socket", "tty", "router"}:
+            raise ValueError("input_transport must be auto, session_socket, tty, or router")
         cfg = self.load_config()
         root = cfg.setdefault("external_event_receivers", {})
         workspace = root.get(self.workspace_key)
@@ -433,6 +445,7 @@ class ExternalEventReceiverService:
                 "event_types": [str(value) for value in event_types if str(value)],
                 "cursor_json_pointer": cursor_json_pointer,
                 "cursor_query_parameter": cursor_query_parameter,
+                "input_transport": input_transport,
             }
         )
         workspace[receiver_id] = current
@@ -525,7 +538,8 @@ class ExternalEventReceiverService:
         return True
 
     def _admit(self, receiver_id: str, transport: str, raw_text: str, event: dict[str, str], transport_event_id: str = "") -> dict[str, Any]:
-        allowed = self.receiver_configs().get(receiver_id, {}).get("event_types", [])
+        receiver = self.receiver_configs().get(receiver_id, {})
+        allowed = receiver.get("event_types", [])
         if allowed and event["type"] not in allowed:
             raise ValueError("CloudEvent type is not admitted by this receiver")
         result = self.submit_event(
@@ -536,6 +550,10 @@ class ExternalEventReceiverService:
             event_type=event["type"],
             event_source=event["source"],
             transport_event_id=transport_event_id,
+            input_transport=(
+                "" if str(receiver.get("input_transport") or "auto") == "auto"
+                else str(receiver.get("input_transport") or "")
+            ),
         )
         self._set_status(receiver_id, state="connected", last_event_id=event["id"], last_event_at=time.time(), error="")
         return result

package/ciel_runtime_support/launch_state.py

@@ -98,6 +98,8 @@ def last_launch_runtime(repository: LaunchStateRepository, cwd_key: str) -> str:
         return "agy"
     if mode.startswith("grok"):
         return "grok"
+    if mode.startswith("muse"):
+        return "muse"
     if mode.startswith("anthropic") or mode.startswith("router:"):
         return "claude"
     return ""

package/ciel_runtime_support/managed_tool_injection.py

@@ -0,0 +1,33 @@
+"""Launch-mode policy for Ciel-owned tools, never user MCP definitions."""
+from collections.abc import Mapping
+from typing import Any
+
+
+def should_inject_tool(*, native: bool, mode: str = "always") -> bool:
+    if mode not in {"always", "native", "non_native"}:
+        raise ValueError(f"Invalid managed tool injection mode: {mode}")
+    return mode == "always" or (mode == "native") == native
+
+
+def codex_native_web_tool_overrides(*, native: bool) -> list[str]:
+    """Disable inherited replacement web MCPs for this launch, not on disk."""
+    if not native:
+        return []
+    return [
+        "-c", "mcp_servers.duckduckgo.enabled=false",
+        "-c", "mcp_servers.web_fetch.enabled=false",
+    ]
+
+
+def select_managed_tools(
+    servers: Mapping[str, Any], *, native: bool,
+) -> dict[str, Any]:
+    selected = {}
+    for name, definition in servers.items():
+        if not isinstance(definition, dict):
+            continue
+        item = dict(definition)
+        mode = item.pop("injection_mode", "always")
+        if should_inject_tool(native=native, mode=mode):
+            selected[name] = item
+    return selected

package/ciel_runtime_support/muse_runtime_context.py

@@ -0,0 +1,291 @@
+"""Native Muse Code CLI launch with subscription-safe authentication."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable
+
+
+MUSE_INSTALL_URL = "https://dev.meta.ai/install.sh"
+MUSE_SUBSCRIPTION_ENV_KEYS = ("META_API_KEY", "MODEL_API_KEY")
+
+
+def has_option(argv: list[str], *names: str) -> bool:
+    return any(
+        value in names or any(value.startswith(f"{name}=") for name in names)
+        for value in argv
+    )
+
+
+def option_value(argv: list[str], name: str) -> str:
+    for index, value in enumerate(argv):
+        if value.startswith(f"{name}="):
+            return value.split("=", 1)[1].strip()
+        if value == name and index + 1 < len(argv):
+            return str(argv[index + 1]).strip()
+    return ""
+
+
+@dataclass(frozen=True, slots=True)
+class MuseExecutable:
+    command: str
+    prefix_args: tuple[str, ...] = ()
+    platform: str = "native"
+    muse_path: str = ""
+    transcript_root: Path | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class MuseProcessPorts:
+    find_executable: Callable[[str], str | None]
+    run: Callable[..., Any]
+    call: Callable[..., int]
+    print_line: Callable[..., None]
+    environment: dict[str, str]
+    augment_path: Callable[[dict[str, str]], str]
+    platform_name: str
+
+
+@dataclass(frozen=True, slots=True)
+class MuseConfigurationPorts:
+    load: Callable[[], dict[str, Any]]
+    current_provider: Callable[[dict[str, Any]], tuple[str, dict[str, Any]]]
+
+
+@dataclass(frozen=True, slots=True)
+class MuseLifecyclePorts:
+    materialize_command: Callable[..., tuple[list[str], dict[str, str]]]
+    start_router: Callable[[], Any]
+    run_with_router: Callable[[Callable[[], int], bool], int]
+    call_with_channel_proxy: Callable[..., int]
+    channel_delivery_mode: Callable[[dict[str, Any]], str]
+    web_backend_requested: Callable[[dict[str, Any]], bool]
+    record_launch: Callable[[str, str], None]
+    set_transcript_scope: Callable[..., None]
+
+
+@dataclass(frozen=True, slots=True)
+class MuseRuntimeContext:
+    process: MuseProcessPorts
+    config: MuseConfigurationPorts
+    lifecycle: MuseLifecyclePorts
+
+    def _native_executable(self) -> MuseExecutable | None:
+        executable = self.process.find_executable("muse")
+        if executable:
+            path = Path(str(executable)).expanduser()
+            home = path.parents[2] if len(path.parents) >= 3 else Path.home()
+            return MuseExecutable(
+                str(executable),
+                muse_path=str(executable),
+                transcript_root=home / ".local" / "share" / "muse",
+            )
+        return None
+
+    def _wsl_executable(self) -> MuseExecutable | None:
+        if self.process.platform_name != "nt":
+            return None
+        wsl = self.process.find_executable("wsl.exe") or self.process.find_executable("wsl")
+        if not wsl:
+            return None
+        result = self.process.run(
+            [wsl, "-e", "sh", "-lc", "command -v muse"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode:
+            return None
+        muse_path = str(result.stdout or "").strip().splitlines()
+        if not muse_path:
+            return None
+        path = muse_path[-1].strip()
+        if not path.startswith("/"):
+            return None
+        root_result = self.process.run(
+            [wsl, "-e", "sh", "-lc", 'wslpath -w "$HOME/.local/share/muse"'],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        root_lines = str(root_result.stdout or "").strip().splitlines()
+        transcript_root = (
+            Path(root_lines[-1].strip())
+            if root_result.returncode == 0 and root_lines
+            else None
+        )
+        return MuseExecutable(
+            str(wsl),
+            (
+                "-e",
+                "env",
+                "-u",
+                "META_API_KEY",
+                "-u",
+                "MODEL_API_KEY",
+                path,
+            ),
+            "wsl",
+            path,
+            transcript_root,
+        )
+
+    def discover(self) -> MuseExecutable | None:
+        return self._native_executable() or self._wsl_executable()
+
+    def install_if_missing(self) -> MuseExecutable | None:
+        installed = self.discover()
+        if installed:
+            return installed
+        shell = self.process.find_executable("bash")
+        command = f"curl -fsSL {MUSE_INSTALL_URL} | bash"
+        if self.process.platform_name == "nt":
+            wsl = self.process.find_executable("wsl.exe") or self.process.find_executable("wsl")
+            if not wsl:
+                self.process.print_line(
+                    "Muse Code supports macOS and Linux. Install WSL2, then run: "
+                    f"wsl bash -lc '{command}'",
+                    flush=True,
+                )
+                return None
+            install_command = [wsl, "-e", "bash", "-lc", command]
+        elif shell:
+            install_command = [shell, "-lc", command]
+        else:
+            self.process.print_line(
+                f"Muse Code is missing. Install it with: {command}", flush=True
+            )
+            return None
+        self.process.print_line("Installing Muse Code from Meta's official installer...", flush=True)
+        result = self.process.run(install_command, check=False)
+        if result.returncode:
+            self.process.print_line(
+                f"Muse Code installation failed (exit {result.returncode}).", flush=True
+            )
+            return None
+        return self.discover()
+
+    @staticmethod
+    def _model(provider: str, provider_config: dict[str, Any]) -> str:
+        configured = str(provider_config.get("current_model") or "").strip()
+        if provider == "meta" and configured.startswith("muse-"):
+            return configured
+        return "muse-spark-1.3"
+
+    @staticmethod
+    def _effort(provider: str, provider_config: dict[str, Any]) -> str:
+        if provider != "meta":
+            return ""
+        configured = str(provider_config.get("effort_level") or "").strip().lower()
+        configured = {"max": "ultra"}.get(configured, configured)
+        if configured in {"none", "minimal", "low", "medium", "high", "xhigh", "ultra"}:
+            return configured
+        return ""
+
+    def launch(self, passthrough: list[str]) -> int:
+        argv = list(passthrough)
+        executable = self.install_if_missing()
+        if executable is None:
+            return 127
+        config = self.config.load()
+        provider, provider_config = self.config.current_provider(config)
+        model = self._model(provider, provider_config)
+        options: dict[str, Any] = {"prefix_args": executable.prefix_args}
+        if not has_option(argv, "--yolo"):
+            options["yolo_args"] = ("--yolo",)
+        muse_provider = option_value(argv, "--provider").lower()
+        meta_launch = not muse_provider or muse_provider == "meta"
+        if meta_launch and model and not has_option(argv, "-m", "--model"):
+            options["model"] = model
+        effort = self._effort(provider, provider_config)
+        if meta_launch and effort and not has_option(argv, "--reasoning-effort"):
+            options["reasoning_effort"] = effort
+
+        env = self.process.environment.copy()
+        env["PATH"] = self.process.augment_path(env)
+        for name in MUSE_SUBSCRIPTION_ENV_KEYS:
+            env.pop(name, None)
+        command, child_env = self.lifecycle.materialize_command(
+            "muse",
+            executable.command,
+            env,
+            provider,
+            provider_config,
+            mode="native",
+            protocol="native",
+            cwd=Path.cwd(),
+            enable_channels=True,
+            passthrough=argv,
+            options=options,
+        )
+        non_session_commands = {
+            "--help", "-h", "--version", "-V", "-v", "version", "config", "export",
+            "trace", "skills", "sandbox", "schema", "serve", "session-message",
+            "auth", "login", "logout", "init",
+        }
+        is_session = not argv or argv[0] not in non_session_commands
+        interactive_session = is_session and (not argv or argv[0] != "exec")
+        if is_session:
+            self.lifecycle.record_launch(provider, model)
+        if interactive_session:
+            self.lifecycle.set_transcript_scope(
+                "muse",
+                cwd=Path.cwd(),
+                muse_home=executable.transcript_root,
+            )
+        manage_router = bool(
+            interactive_session
+            and (
+                self.lifecycle.channel_delivery_mode(config) == "llm"
+                or self.lifecycle.web_backend_requested(config)
+            )
+            and self.lifecycle.start_router()
+        )
+
+        def run() -> int:
+            if not interactive_session:
+                return self.process.call(command, env=child_env)
+            return self.lifecycle.call_with_channel_proxy(
+                command,
+                child_env,
+                wake_for_llm_delivery=False,
+                synthetic_enter_bytes=None,
+                normalize_bare_cr_for_synthetic_enter=False,
+                # Muse's session JSONL uses a different schema from the
+                # Claude/Codex turn-confirmation reader. Keep delivery
+                # fire-and-forget while the tool-event observer tails it.
+                channel_wake_submit_retries=1,
+                channel_wake_confirm_submit=False,
+                channel_wake_bracketed_paste=True,
+            )
+
+        return self.lifecycle.run_with_router(run, manage_router)
+
+
+@dataclass(frozen=True, slots=True)
+class MuseRuntimeCompatibilityApi:
+    context: Callable[[], MuseRuntimeContext]
+
+    def discover(self) -> MuseExecutable | None:
+        return self.context().discover()
+
+    def install_if_missing(self) -> MuseExecutable | None:
+        return self.context().install_if_missing()
+
+    def launch(self, passthrough: list[str]) -> int:
+        return self.context().launch(passthrough)
+
+
+__all__ = [
+    "MUSE_INSTALL_URL",
+    "MUSE_SUBSCRIPTION_ENV_KEYS",
+    "MuseConfigurationPorts",
+    "MuseExecutable",
+    "MuseLifecyclePorts",
+    "MuseProcessPorts",
+    "MuseRuntimeCompatibilityApi",
+    "MuseRuntimeContext",
+    "has_option",
+    "option_value",
+]

package/ciel_runtime_support/ollama_thinking.py

@@ -25,22 +25,6 @@ class OllamaReasoningProfile:
     always_on: bool = False
 
 
-_GENERIC_CLOUD_LEVEL_MODELS = frozenset(
-    {
-        "gemma4:31b",
-        "glm-5.1",
-        "kimi-k2.6",
-        "kimi-k2.7-code",
-        "minimax-m2.7",
-        "minimax-m3",
-        "nemotron-3-nano:30b",
-        "nemotron-3-super",
-        "nemotron-3-ultra",
-        "qwen3.5:397b",
-    }
-)
-
-
 def _codex_level_description(level: str) -> str:
     return {
         "low": "Low reasoning effort",
@@ -107,6 +91,14 @@ def ollama_cloud_reasoning_profile(
             default_codex="high",
             always_on=True,
         )
+    if discovered == "glm_dsa_moe" or model == "glm-5.3":
+        return OllamaReasoningProfile(
+            native_levels=("low", "high", "max"),
+            codex_levels=("low", "high", "xhigh"),
+            default_native="max",
+            default_codex="xhigh",
+            always_on=True,
+        )
     if discovered == "kimi-k3" or model == "kimi-k3":
         return OllamaReasoningProfile(
             native_levels=("low", "high", "max"),
@@ -124,13 +116,6 @@ def ollama_cloud_reasoning_profile(
             default_native=native_default,
             default_codex="xhigh" if native_default == "max" else native_default,
         )
-    if model in _GENERIC_CLOUD_LEVEL_MODELS:
-        return OllamaReasoningProfile(
-            native_levels=("low", "medium", "high", "max"),
-            codex_levels=("low", "medium", "high", "xhigh"),
-            default_native="medium",
-            default_codex="medium",
-        )
     return None
 
 
@@ -185,7 +170,7 @@ def ollama_cloud_model_config_updates(
         ),
     }
     return {
-        "think": profile is not None,
+        "think": profile is not None or "thinking" in normalized_capabilities,
         "effort_level": profile.default_native if profile else "",
         "ollama_think_levels": list(profile.native_levels) if profile else [],
         "ollama_thinking_always_on": bool(profile and profile.always_on),
@@ -246,6 +231,8 @@ class OllamaThinkingPolicy:
             return "gptoss"
         if model in {"glm-5.2", "glm-5.2:cloud"}:
             return "glm5.2"
+        if model in {"glm-5.3", "glm-5.3:cloud"}:
+            return "glm_dsa_moe"
         return ""
 
     def value(
@@ -342,8 +329,7 @@ class OllamaThinkingPolicy:
         if "thinking" in capabilities:
             if thinking_disabled(request):
                 return False
-            if effort:
-                return True
+            return True
         return None
 
 

package/ciel_runtime_support/prelaunch.py

@@ -82,6 +82,7 @@ class PrelaunchLaunchPolicy:
     launch_kimi: Callable[..., Any]
     launch_grok: Callable[..., Any] = lambda *_args, **_kwargs: 0
     launch_zcode: Callable[..., Any] = lambda *_args, **_kwargs: 0
+    launch_muse: Callable[..., Any] = lambda *_args, **_kwargs: 0
 
 
 @dataclass(frozen=True, slots=True)
@@ -223,6 +224,7 @@ def run_prelaunch_menu(passthrough: list[str] | None = None,
     launch_kimi = services.launch_policy.launch_kimi
     launch_grok = services.launch_policy.launch_grok
     launch_zcode = services.launch_policy.launch_zcode
+    launch_muse = services.launch_policy.launch_muse
     llm_option_current_bool = services.options.llm_option_current_bool
     llm_option_panel_rows = services.panel_rows.llm_option_panel_rows
     llm_option_prompt_default = services.options.llm_option_prompt_default
@@ -500,6 +502,10 @@ def run_prelaunch_menu(passthrough: list[str] | None = None,
                         persist_launch_action(action)
                         launch_zcode([])
                         return PRELAUNCH_CANCEL
+                    if action == "launch-muse":
+                        persist_launch_action(action)
+                        launch_muse([])
+                        return PRELAUNCH_CANCEL
                     continue
                 if panel == "language" and value:
                     cfg["language"] = value
@@ -770,6 +776,13 @@ def run_prelaunch_menu(passthrough: list[str] | None = None,
                         continue
                     if value in {"enabled", "transport"}:
                         messages = set_external_event_config(value, "toggle")
+                    elif value == "input_transport":
+                        entered = prompt_menu_value(
+                            "Runtime input transport (auto/session_socket/tty/router)",
+                            restore_tty=restore_line_mode,
+                            raw_tty=restore_raw_mode,
+                        )
+                        messages = set_external_event_config(value, entered or "auto")
                     elif value == "url":
                         entered = prompt_menu_value(
                             "SSE URL (blank for webhook mode)",

package/ciel_runtime_support/prelaunch_launch_panel.py

@@ -28,10 +28,11 @@ def launch_panel_rows(
             f"Kimi{kimi_suffix}",
             "Grok Build",
             "ZCode",
+            "Muse Code (subscription)",
             f"Codex app server{codex_suffix}",
             "Back",
         ],
-        ["launch", "launch-codex", "launch-agy", "launch-kimi", "launch-grok", "launch-zcode", "launch-codex-app-server", "back"],
+        ["launch", "launch-codex", "launch-agy", "launch-kimi", "launch-grok", "launch-zcode", "launch-muse", "launch-codex-app-server", "back"],
     )