@oneciel-ai/ciel-runtime 0.2.37 → 0.2.38

package/ciel_runtime_support/router_http.py

@@ -3,8 +3,11 @@
 from __future__ import annotations
 
 import io
+import base64
+import hashlib
 import json
 import sys
+import tempfile
 import traceback
 import urllib.error
 import urllib.parse
@@ -30,6 +33,11 @@ from ciel_runtime_support.responses_input_compatibility import (
     repair_replayed_response_items,
 )
 from ciel_runtime_support.channel_llm_context import ChannelLlmInjectionDeferred
+from ciel_runtime_support.codex_completion_gate import (
+    ResponsesCompletionObservation,
+    completion_check_body,
+    request_requires_completion_check,
+)
 from ciel_runtime_support.request_body_policy import (
     RequestBodyCapacityExceeded,
     RequestBodyTooLarge,
@@ -63,6 +71,17 @@ class UpstreamContextExceeded(Exception):
         self.payload = payload
 
 
+@dataclass(slots=True)
+class _BufferedCodexResponse:
+    status: int
+    headers: Any
+    stream: Any
+    observation: ResponsesCompletionObservation
+
+    def close(self) -> None:
+        self.stream.close()
+
+
 @dataclass(frozen=True, slots=True)
 class CodexRoutedHeaderPolicy:
     decorate: Callable[[dict[str, str]], dict[str, str]]
@@ -154,6 +173,13 @@ class RouterHttpErrors:
     try_write_json: Callable[..., Any]
 
 
+@dataclass(frozen=True, slots=True)
+class RouterHttpFileEndpoints:
+    get: Callable[[Any, str, dict[str, Any]], bool]
+    post: Callable[[Any, str, int, str, dict[str, Any]], bool]
+    delete: Callable[[Any, str, dict[str, Any]], bool]
+
+
 @dataclass(frozen=True, slots=True)
 class RouterHttpServices:
     core: RouterHttpCore
@@ -161,6 +187,7 @@ class RouterHttpServices:
     post: RouterHttpPostEndpoints
     presentation: RouterHttpPresentation
     errors: RouterHttpErrors
+    files: RouterHttpFileEndpoints | None = None
 
 
 @dataclass(frozen=True, slots=True)
@@ -216,7 +243,11 @@ class CodexBackendHttpAdapter:
     def copy_response_headers(handler: BaseHTTPRequestHandler, headers: Any) -> None:
         allowed = {
             "cache-control",
+            "content-disposition",
+            "content-length",
             "content-type",
+            "etag",
+            "last-modified",
             "openai-request-id",
             "request-id",
             "retry-after",
@@ -524,9 +555,121 @@ class CodexBackendHttpAdapter:
                     )
                     self._retry.sleep(wait)
                     continue
-                self._write_response(handler, response, preamble)
+                if mutate_responses and upstream_body.get("tools"):
+                    buffered = self._buffer_codex_response(response, preamble)
+                    chosen = buffered
+                    try:
+                        if request_requires_completion_check(
+                            upstream_body, buffered.observation
+                        ):
+                            validated = self._validate_codex_completion(
+                                provider,
+                                config,
+                                url,
+                                headers,
+                                upstream_body,
+                                buffered.observation,
+                            )
+                            if validated is not None:
+                                if validated.observation.completion_confirmed:
+                                    self._retry.log(
+                                        "INFO",
+                                        "codex_completion_gate_confirmed "
+                                        f"model={str(upstream_body.get('model') or '-')}",
+                                    )
+                                elif (
+                                    validated.observation.status == "completed"
+                                    and validated.observation.has_action
+                                ):
+                                    chosen = validated
+                                    self._retry.log(
+                                        "WARN",
+                                        "codex_completion_gate_continued "
+                                        f"model={str(upstream_body.get('model') or '-')}",
+                                    )
+                            self._write_buffered_response(handler, chosen)
+                            if validated is not None and validated is not chosen:
+                                validated.close()
+                        else:
+                            self._write_buffered_response(handler, chosen)
+                    finally:
+                        if chosen is not buffered:
+                            chosen.close()
+                        buffered.close()
+                else:
+                    self._write_response(handler, response, preamble)
                 break
 
+    def _buffer_codex_response(
+        self, response: Any, preamble: Any
+    ) -> _BufferedCodexResponse:
+        stream = tempfile.SpooledTemporaryFile(max_size=1024 * 1024)
+        observation = ResponsesCompletionObservation()
+        initial = bytes(getattr(preamble, "payload", b"") or b"")
+        if initial:
+            stream.write(initial)
+            observation.feed(initial)
+        while chunk := response.read(65_536):
+            stream.write(chunk)
+            observation.feed(chunk)
+        observation.finish()
+        stream.seek(0)
+        return _BufferedCodexResponse(
+            status=int(getattr(response, "status", 200)),
+            headers=response.headers,
+            stream=stream,
+            observation=observation,
+        )
+
+    def _validate_codex_completion(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        url: str,
+        headers: dict[str, str],
+        upstream_body: dict[str, Any],
+        observation: ResponsesCompletionObservation,
+    ) -> _BufferedCodexResponse | None:
+        validation_body = completion_check_body(upstream_body, observation)
+        validation_data = json.dumps(validation_body).encode("utf-8")
+        dump_upstream_request(url, validation_data, self._retry.log)
+        request = urllib.request.Request(
+            url, data=validation_data, headers=headers, method="POST"
+        )
+        try:
+            with self._open_with_transport_retry(
+                request,
+                provider,
+                config,
+                str(upstream_body.get("model") or ""),
+                "completion_check",
+            ) as response:
+                preamble = self._retry.read_preamble(response)
+                if preamble is not None and (
+                    preamble.capacity_error_code
+                    or getattr(preamble, "context_error_code", None)
+                ):
+                    return None
+                return self._buffer_codex_response(response, preamble)
+        except Exception as exc:  # noqa: BLE001 - preserve the original response
+            self._retry.log(
+                "WARN",
+                "codex_completion_gate_failed "
+                f"error={type(exc).__name__}: {exc}",
+            )
+            return None
+
+    def _write_buffered_response(
+        self, handler: BaseHTTPRequestHandler, response: _BufferedCodexResponse
+    ) -> None:
+        handler.send_response(response.status)
+        self.copy_response_headers(handler, response.headers)
+        handler.end_headers()
+        response.stream.seek(0)
+        while chunk := response.stream.read(65_536):
+            handler.wfile.write(chunk)
+            handler.wfile.flush()
+
     def _open_with_transport_retry(
         self,
         request: urllib.request.Request,
@@ -613,6 +756,8 @@ class EventHttpPorts:
 
 
 class EventHttpAdapter:
+    _WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
     def __init__(self, ports: EventHttpPorts) -> None:
         self._ports = ports
 
@@ -650,6 +795,8 @@ class EventHttpAdapter:
                 },
             )
             return True
+        if path == "/ca/events/ws":
+            return self._handle_websocket(handler, query)
         if path != "/ca/events/stream":
             return False
         last_id = self.query_int(query, "after", 0)
@@ -659,11 +806,30 @@ class EventHttpAdapter:
         handler.send_header("connection", "close")
         handler.end_headers()
         try:
-            last_id = self._write_events(handler, self._ports.recent(limit=200, min_id=last_id), last_id)
+            level = (query.get("level") or [None])[0]
+            category = (query.get("category") or [None])[0]
+            last_id = self._write_events(
+                handler,
+                self._ports.recent(
+                    limit=200,
+                    min_id=last_id,
+                    level=level,
+                    category=category,
+                ),
+                last_id,
+            )
             while True:
-                events = self._ports.wait_after(last_id, timeout=15.0)
+                observed = self._ports.wait_after(last_id, timeout=15.0)
+                observed_last_id = self._max_event_id(observed, last_id)
+                events = self._filtered(
+                    observed,
+                    level=level,
+                    category=category,
+                )
                 if events:
                     last_id = self._write_events(handler, events, last_id)
+                if observed:
+                    last_id = max(last_id, observed_last_id)
                 else:
                     handler.wfile.write(b": keepalive\n\n")
                     handler.wfile.flush()
@@ -673,6 +839,125 @@ class EventHttpAdapter:
             self._ports.log("DEBUG", f"events stream closed: {type(exc).__name__}: {exc}")
         return True
 
+    def _handle_websocket(
+        self,
+        handler: BaseHTTPRequestHandler,
+        query: dict[str, list[str]],
+    ) -> bool:
+        upgrade = str(handler.headers.get("upgrade") or "").strip().lower()
+        key = str(handler.headers.get("sec-websocket-key") or "").strip()
+        version = str(handler.headers.get("sec-websocket-version") or "13").strip()
+        if upgrade != "websocket" or not key or version != "13":
+            self._ports.write_json(
+                handler,
+                {
+                    "ok": False,
+                    "error": "websocket_upgrade_required",
+                    "required_version": "13",
+                },
+                400,
+            )
+            return True
+        accept = base64.b64encode(
+            hashlib.sha1((key + self._WEBSOCKET_GUID).encode("ascii")).digest()
+        ).decode("ascii")
+        handler.protocol_version = "HTTP/1.1"
+        handler.send_response(101)
+        handler.send_header("upgrade", "websocket")
+        handler.send_header("connection", "Upgrade")
+        handler.send_header("sec-websocket-accept", accept)
+        handler.end_headers()
+        handler.close_connection = True
+        last_id = self.query_int(query, "after", 0)
+        level = (query.get("level") or [None])[0]
+        category = (query.get("category") or [None])[0]
+        try:
+            last_id = self._write_ws_events(
+                handler,
+                self._ports.recent(
+                    limit=200,
+                    min_id=last_id,
+                    level=level,
+                    category=category,
+                ),
+                last_id,
+            )
+            while True:
+                observed = self._ports.wait_after(last_id, timeout=15.0)
+                observed_last_id = self._max_event_id(observed, last_id)
+                events = self._filtered(
+                    observed,
+                    level=level,
+                    category=category,
+                )
+                if events:
+                    last_id = self._write_ws_events(handler, events, last_id)
+                if observed:
+                    last_id = max(last_id, observed_last_id)
+                else:
+                    handler.wfile.write(self._websocket_frame(b"", opcode=0x9))
+                    handler.wfile.flush()
+        except (BrokenPipeError, ConnectionResetError):
+            return True
+        except Exception as exc:
+            self._ports.log("DEBUG", f"events websocket closed: {type(exc).__name__}: {exc}")
+        return True
+
+    @staticmethod
+    def _max_event_id(events: list[dict[str, Any]], default: int) -> int:
+        return max(
+            (int(event.get("id") or 0) for event in events),
+            default=default,
+        )
+
+    @staticmethod
+    def _filtered(
+        events: list[dict[str, Any]],
+        *,
+        level: str | None,
+        category: str | None,
+    ) -> list[dict[str, Any]]:
+        if level:
+            ranks = {"trace": 10, "debug": 20, "info": 30, "warn": 40, "error": 50, "fatal": 60}
+            threshold = ranks.get(str(level).lower(), 30)
+            events = [
+                event
+                for event in events
+                if ranks.get(str(event.get("level") or "info").lower(), 30) >= threshold
+            ]
+        if category:
+            events = [
+                event
+                for event in events
+                if str(event.get("category") or "").startswith(category)
+            ]
+        return events
+
+    @staticmethod
+    def _websocket_frame(payload: bytes, *, opcode: int = 0x1) -> bytes:
+        size = len(payload)
+        head = bytes([0x80 | (opcode & 0x0F)])
+        if size < 126:
+            return head + bytes([size]) + payload
+        if size <= 0xFFFF:
+            return head + bytes([126]) + size.to_bytes(2, "big") + payload
+        return head + bytes([127]) + size.to_bytes(8, "big") + payload
+
+    def _write_ws_events(
+        self,
+        handler: BaseHTTPRequestHandler,
+        events: list[dict[str, Any]],
+        last_id: int,
+    ) -> int:
+        for event in events:
+            last_id = max(last_id, int(event.get("id") or 0))
+            payload = json.dumps(event, ensure_ascii=False, separators=(",", ":")).encode(
+                "utf-8"
+            )
+            handler.wfile.write(self._websocket_frame(payload))
+        handler.wfile.flush()
+        return last_id
+
     @staticmethod
     def _write_events(
         handler: BaseHTTPRequestHandler,
@@ -747,6 +1032,8 @@ class RouterHttpHandler(BaseHTTPRequestHandler):
             return
         if services.core.reject_external(self, cfg):
             return
+        if services.files is not None and services.files.get(self, path, cfg):
+            return
         endpoints = services.get
         if endpoints.tui(self, path, query):
             return
@@ -1068,11 +1355,19 @@ class RouterHttpHandler(BaseHTTPRequestHandler):
             length = self._validated_content_length(path, services)
             if length is None:
                 return
+            content_type = str(
+                self.headers.get("content-type") or "application/json"
+            )
+            if (
+                services.files is not None
+                and services.files.post(self, path, length, content_type, cfg)
+            ):
+                return
             try:
                 admission = services.core.request_body_policy.admit(
                     path,
                     length,
-                    str(self.headers.get("content-type") or "application/json"),
+                    content_type,
                 )
                 with admission:
                     raw = self._read_request_body(path, services, length)
@@ -1292,6 +1587,8 @@ class RouterHttpHandler(BaseHTTPRequestHandler):
         cfg = services.core.load_config()
         if services.core.reject_external(self, cfg):
             return
+        if services.files is not None and services.files.delete(self, path, cfg):
+            return
         services.presentation.write_json(
             self,
             {"type": "error", "error": {"type": "not_found_error", "message": path}},

package/ciel_runtime_support/router_observability_context.py

@@ -71,6 +71,7 @@ class SseObservabilityPorts:
     current_log_level: Callable[[], int]
     truncate: Callable[[str, int], str]
     log: Callable[[str, str], None]
+    event_publish: Callable[..., Any]
 
 
 @dataclass(frozen=True, slots=True)
@@ -185,6 +186,31 @@ class RouterObservabilityContext:
 
     def append_tool_call(self, *args: Any, **kwargs: Any) -> None:
         self.sse_repository().append_tool_call(*args, **kwargs)
+        event = str(args[0] if args else kwargs.get("event") or "tool_call")
+        payload = args[1] if len(args) > 1 else kwargs.get("payload")
+        payload = payload if isinstance(payload, dict) else {}
+        provider = event.removesuffix("_stream_tool_call").replace("_", "-")
+        name = str(payload.get("matched_name") or payload.get("raw_name") or "tool").strip()
+        config = self.preview.load_config()
+        tool_event_config = config.get("tool_call_events")
+        tool_event_config = tool_event_config if isinstance(tool_event_config, dict) else {}
+        data = {
+            "call_id": str(payload.get("tool_id") or ""),
+            "name": name,
+            "call_type": event,
+            "sse_index": payload.get("sse_index"),
+        }
+        if bool(tool_event_config.get("include_arguments", True)):
+            data["arguments"] = payload.get("emitted_input")
+        self.sse.event_publish(
+            level="info",
+            category="tool.call",
+            message=f"{provider} tool call: {name}",
+            source="router-stream",
+            provider=provider,
+            model=str(payload.get("model") or ""),
+            data=data,
+        )
 
 
 @dataclass(frozen=True, slots=True)

package/ciel_runtime_support/router_server_context.py

@@ -65,6 +65,7 @@ class RouterServerContext:
             "chat": "/ca/chat/health",
             "plan": "/ca/plan/artifacts",
             "events": "/ca/events",
+            "events_websocket": "/ca/events/ws",
             "external_event_receivers": "/ca/events/receivers",
             "otlp_logs": "/v1/logs",
             "telemetry_logs_tool": "POST /ca/mcp tools/call telemetry_logs",

package/ciel_runtime_support/runtime_adapters.py

@@ -116,12 +116,42 @@ class ZcodeRuntimeAdapter(CliRuntimeAdapter):
         return RuntimeCommand(argv=tuple(argv), env=dict(self.environment), cwd=spec.cwd)
 
 
+class MuseRuntimeAdapter(CliRuntimeAdapter):
+    """Official Muse Code CLI with optional WSL command prefix."""
+
+    def build_command(self, spec: LaunchSpec) -> RuntimeCommand:
+        options = spec.runtime.options
+        argv = [str(spec.runtime.executable or self.executable)]
+        argv.extend(str(value) for value in options.get("prefix_args", ()))
+        passthrough = list(spec.passthrough)
+        subcommand = passthrough[0] if passthrough else ""
+        utility_commands = {
+            "config", "export", "trace", "skills", "sandbox", "schema", "serve",
+            "session-message", "auth", "login", "logout", "init", "help", "version",
+        }
+        if subcommand in utility_commands or subcommand in {"--help", "-h", "--version", "-V", "-v"}:
+            argv.extend(passthrough)
+            return RuntimeCommand(argv=tuple(argv), env=dict(self.environment), cwd=spec.cwd)
+        if subcommand in {"exec", "resume"}:
+            argv.append(passthrough.pop(0))
+        argv.extend(str(value) for value in options.get("yolo_args", ()))
+        model = str(options.get("model") or "").strip()
+        if model:
+            argv.extend(("--model", model))
+        effort = str(options.get("reasoning_effort") or "").strip()
+        if effort:
+            argv.extend(("--reasoning-effort", effort))
+        argv.extend(passthrough)
+        return RuntimeCommand(argv=tuple(argv), env=dict(self.environment), cwd=spec.cwd)
+
+
 RUNTIME_ADAPTERS: AdapterRegistry[RuntimeAdapter] = AdapterRegistry()
 RUNTIME_ADAPTERS.register("claude", lambda **kwargs: ClaudeRuntimeAdapter(name="claude", **kwargs))
 RUNTIME_ADAPTERS.register("codex", lambda **kwargs: CodexRuntimeAdapter(name="codex", **kwargs))
 RUNTIME_ADAPTERS.register("agy", lambda **kwargs: AgyRuntimeAdapter(name="agy", **kwargs))
 RUNTIME_ADAPTERS.register("grok", lambda **kwargs: GrokRuntimeAdapter(name="grok", **kwargs))
 RUNTIME_ADAPTERS.register("zcode", lambda **kwargs: ZcodeRuntimeAdapter(name="zcode", **kwargs))
+RUNTIME_ADAPTERS.register("muse", lambda **kwargs: MuseRuntimeAdapter(name="muse", **kwargs))
 
 
 __all__ = [
@@ -131,5 +161,6 @@ __all__ = [
     "CliRuntimeAdapter",
     "CodexRuntimeAdapter",
     "GrokRuntimeAdapter",
+    "MuseRuntimeAdapter",
     "ZcodeRuntimeAdapter",
 ]

package/ciel_runtime_support/runtime_constants.py

@@ -12,7 +12,17 @@ ANTHROPIC_MODEL_DOCS_URLS = (
     ANTHROPIC_MODEL_DOCS_URL,
     "https://platform.claude.com/docs/en/about-claude/models/overview",
 )
+ANTHROPIC_ONE_MILLION_MODEL_IDS: tuple[str, ...] = (
+    "claude-fable-5-1[1m]",
+    "claude-fable-5[1m]",
+    "claude-opus-5[1m]",
+    "claude-opus-4-8[1m]",
+    "claude-sonnet-5[1m]",
+    "claude-sonnet-4-6[1m]",
+)
 ANTHROPIC_PUBLIC_MODEL_FALLBACK_IDS: tuple[str, ...] = (
+    *ANTHROPIC_ONE_MILLION_MODEL_IDS,
+    "claude-fable-5-1",
     "claude-fable-5",
     "claude-opus-5",
     "claude-opus-4-8",
@@ -87,7 +97,7 @@ OPENCODE_ENDPOINT_ALIASES = {
 }
 
 APP_NAME = "Ciel Runtime"
-VERSION = "0.2.37"
+VERSION = "0.2.38"
 CREDITS = "Credits: One Ciel LLC"
 PRELAUNCH_CANCEL = 10
 PRELAUNCH_LAUNCH_CODEX = 11
@@ -175,12 +185,24 @@ ROUTED_CODEX_COMPAT_PROMPT = (
     "You are running inside Codex CLI through the ciel-runtime router. Do not stop after announcing what you plan to do. "
     "When the user asks you to inspect, create, edit, or run code, call the tools available in this turn and report the concrete result. "
     "Never end a turn with only a statement of intent such as saying you will now start; perform the work in the same turn. "
+    "If you identify a concrete next action in a progress report, call the next tool before returning a final answer. "
+    "For a persistent monitoring goal, unchanged external state is a verified wait, not a blocker: do not mark the goal blocked merely because the next market, job, or service event has not occurred. "
+    "Poll a confirmed-live handle or use the available recurring monitor or wait mechanism, and leave the goal active while safe in-scope monitoring work remains. "
     "If the task has several reasonable in-scope parts, do all of them; do not ask which part to start unless the user explicitly asked for a choice. "
     "If you decide not to use tools, give the complete answer in the same turn. "
     "Use exactly the tool schema provided and do not invent extra fields, and never write pseudo tool calls or partial JSON where a real tool call is required."
 )
 LANGUAGES = {"en": "English", "ko": "한국어", "ja": "日本語", "zh": "中文"}
 MODEL_PRESETS: dict[str, dict[str, Any]] = {
+    # Muse Spark reasoning tokens consume the output budget.  A live
+    # contributor probe exhausted 128 tokens before it could emit tool_use;
+    # 4096 completed the same request and is also the documented minimum used
+    # by Meta's long-media examples.
+    "muse-spark-1.3": {"compat_max_tokens": 4096, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1048576},
+    "muse-spark-1.3-contributor": {"compat_max_tokens": 4096, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1048576},
+    "muse-spark-1.2": {"compat_max_tokens": 4096, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1048576},
+    "muse-spark-1.2-contributor": {"compat_max_tokens": 4096, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1048576},
+    "muse-spark-1.1": {"compat_max_tokens": 4096, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1048576},
     "glm-5.3": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1000000},
     "glm-5.3:cloud": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1000000},
     "deepseek-v4-flash:0731": {"compat_max_tokens": 64, "thinking": True, "num_ctx_min": 32768, "num_ctx_max": 1000000},