@oneciel-ai/ciel-runtime 0.2.37 → 0.2.38

package/ciel_runtime_support/providers/meta.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import json
+from copy import deepcopy
 from dataclasses import dataclass, field
 from typing import Any, Mapping
 
@@ -19,9 +21,34 @@ from .base import HttpBearerProviderAdapter, provider_configuration
 from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
 
 
-MUSE_SPARK_MODEL = "muse-spark-1.1"
+MUSE_SPARK_MODEL = "muse-spark-1.3"
+MUSE_SPARK_MODELS = (
+    MUSE_SPARK_MODEL,
+    "muse-spark-1.3-contributor",
+    "muse-spark-1.2",
+    "muse-spark-1.2-contributor",
+    "muse-spark-1.1",
+)
 MUSE_SPARK_CONTEXT_WINDOW = 1_048_576
 MUSE_SPARK_AUTO_COMPACT_LIMIT = 900_000
+MUSE_SPARK_CODEX_CATALOG = {
+    "context_window": MUSE_SPARK_CONTEXT_WINDOW,
+    "max_context_window": MUSE_SPARK_CONTEXT_WINDOW,
+    "input_modalities": ["text", "image"],
+    "support_verbosity": False,
+    "supports_reasoning_summaries": True,
+    "supported_reasoning_levels": [
+        {"effort": "minimal", "description": "Shortest reasoning pass"},
+        {"effort": "low", "description": "Light reasoning"},
+        {"effort": "medium", "description": "Moderate reasoning depth"},
+        {"effort": "high", "description": "Deep reasoning"},
+        {
+            "effort": "xhigh",
+            "description": "Accepted alias; currently the same strength as high",
+        },
+    ],
+    "default_reasoning_level": "high",
+}
 
 
 @dataclass(frozen=True)
@@ -33,21 +60,29 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
     configuration_defaults_value: dict = field(
         default_factory=lambda: provider_configuration(
             MUSE_SPARK_MODEL,
-            custom_models=(MUSE_SPARK_MODEL,),
+            custom_models=MUSE_SPARK_MODELS,
             native_compat=True,
             preserve_anthropic_thinking=True,
             normalize_anthropic_tool_use=True,
             supports_tool_choice=True,
-            claude_code_supported_capabilities=["effort", "thinking"],
+            claude_code_supported_capabilities=[
+                "effort",
+                "xhigh_effort",
+                "thinking",
+                "adaptive_thinking",
+            ],
             context_window=MUSE_SPARK_CONTEXT_WINDOW,
             max_model_len=MUSE_SPARK_CONTEXT_WINDOW,
             auto_compact_window=MUSE_SPARK_AUTO_COMPACT_LIMIT,
             codex_auto_compact_window=MUSE_SPARK_AUTO_COMPACT_LIMIT,
+            codex_model_catalog=deepcopy(MUSE_SPARK_CODEX_CATALOG),
             request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
             stream_enabled=True,
             stream_word_chunking=False,
             effort_level="high",
             enable_tool_search=True,
+            responses_custom_tools_as_functions=True,
+            prompt_cache_retention="24h",
             haiku_model=MUSE_SPARK_MODEL,
             opus_model=MUSE_SPARK_MODEL,
             sonnet_model=MUSE_SPARK_MODEL,
@@ -78,7 +113,7 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
     model_catalog_policy_value: ProviderModelCatalogPolicy = field(
         default_factory=lambda: ProviderModelCatalogPolicy(
             kind="openai",
-            fallback_models=(MUSE_SPARK_MODEL,),
+            fallback_models=MUSE_SPARK_MODELS,
             allow_configured_fallback=True,
         )
     )
@@ -97,11 +132,17 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
         del model
         return bool(config.options.get("native_compat", True))
 
+    def supports_server_web_tools(self, config: ProviderConfig) -> bool:
+        del config
+        return True
+
     def supported_protocols(
         self, config: ProviderConfig, model: str | None = None
     ) -> frozenset[MessageProtocol]:
         del config, model
-        return frozenset({"anthropic_messages", "openai_responses"})
+        return frozenset(
+            {"anthropic_messages", "openai_chat", "openai_responses"}
+        )
 
     def select_protocol(
         self,
@@ -109,29 +150,33 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
         config: ProviderConfig,
         model: str | None = None,
     ) -> MessageProtocol:
-        del config, model
-        return (
-            "openai_responses"
-            if operation == "openai_responses"
-            else "anthropic_messages"
-        )
+        if operation in self.supported_protocols(config, model):
+            return operation
+        return "anthropic_messages"
 
     def model_configuration_profile(
         self, config: ProviderConfig
     ) -> tuple[Mapping[str, Any], str | None]:
-        if self.normalize_model_id(config.model) != MUSE_SPARK_MODEL:
+        model = self.normalize_model_id(config.model)
+        if model not in MUSE_SPARK_MODELS:
             return {}, None
+        contributor_notice = (
+            " Contributor tier permits Meta to train on prompts and completions."
+            if model.endswith("-contributor")
+            else ""
+        )
         return (
             {
                 "context_window": MUSE_SPARK_CONTEXT_WINDOW,
                 "max_model_len": MUSE_SPARK_CONTEXT_WINDOW,
                 "auto_compact_window": MUSE_SPARK_AUTO_COMPACT_LIMIT,
                 "effort_level": "high",
-                "model_profile": "muse-spark-1.1-1m",
+                "codex_model_catalog": deepcopy(MUSE_SPARK_CODEX_CATALOG),
+                "model_profile": f"{model}-1m",
             },
-            "Muse Spark 1.1 profile applied: 1M context, high reasoning effort, "
+            f"{model} profile applied: 1M context, high reasoning effort, "
             "and 900K automatic compaction. Start a new session after changing "
-            "model, context, or reasoning effort.",
+            f"model, context, or reasoning effort.{contributor_notice}",
         )
 
     def model_selection_config_updates(
@@ -169,10 +214,28 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
     def normalize_request_options(
         self, config: ProviderConfig, request: Mapping[str, Any]
     ) -> Mapping[str, Any]:
-        del config
         normalized = dict(request)
         if "input" in normalized and "messages" not in normalized:
-            self._normalize_responses_request(normalized)
+            self._normalize_responses_request(normalized, config)
+        else:
+            self._normalize_messages_request(normalized)
+        return normalized
+
+    def normalize_request_options_for_protocol(
+        self,
+        config: ProviderConfig,
+        request: Mapping[str, Any],
+        protocol: MessageProtocol | None,
+    ) -> Mapping[str, Any]:
+        normalized = dict(request)
+        if protocol == "openai_responses":
+            self._normalize_responses_request(normalized, config)
+        elif protocol == "openai_chat":
+            self._normalize_chat_request(normalized)
+        elif protocol == "anthropic_messages":
+            self._normalize_messages_request(normalized)
+        elif "input" in normalized and "messages" not in normalized:
+            self._normalize_responses_request(normalized, config)
         else:
             self._normalize_messages_request(normalized)
         return normalized
@@ -192,7 +255,15 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
         return False
 
     @classmethod
-    def _normalize_responses_request(cls, request: dict[str, Any]) -> None:
+    def _normalize_responses_request(
+        cls, request: dict[str, Any], config: ProviderConfig
+    ) -> None:
+        if "prompt_cache_retention" not in request and request.get("prompt_cache_key"):
+            retention = str(
+                config.options.get("prompt_cache_retention") or ""
+            ).strip()
+            if retention in {"in_memory", "24h"}:
+                request["prompt_cache_retention"] = retention
         include = request.get("include")
         if request.get("previous_response_id"):
             if isinstance(include, list):
@@ -216,8 +287,150 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
         reasoning = request.get("reasoning")
         if isinstance(reasoning, Mapping):
             projected = dict(reasoning)
-            projected["effort"] = cls._effort(projected.get("effort"))
+            projected["effort"] = cls._responses_effort(projected.get("effort"))
+            # Match the official OpenCode Meta path: keep a concise visible
+            # reasoning summary while encrypted_content carries replay state.
+            projected.setdefault("summary", "auto")
             request["reasoning"] = projected
+        tools = request.get("tools")
+        if isinstance(tools, list):
+            request["tools"] = [cls._normalize_responses_tool(tool) for tool in tools]
+        raw_input = request.get("input")
+        if isinstance(raw_input, list):
+            request["input"] = [cls._normalize_responses_input(item) for item in raw_input]
+
+    @classmethod
+    def _normalize_responses_tool(cls, tool: Any) -> Any:
+        """Project tool parameters to Meta's strict Responses schema contract."""
+
+        if not isinstance(tool, Mapping):
+            return deepcopy(tool)
+        projected = deepcopy(dict(tool))
+        if str(projected.get("type") or "") == "custom":
+            description = str(projected.get("description") or "").strip()
+            format_value = projected.get("format")
+            if isinstance(format_value, Mapping):
+                definition = str(format_value.get("definition") or "").strip()
+                if definition:
+                    description = "\n\n".join(
+                        part
+                        for part in (
+                            description,
+                            "Raw input must satisfy this grammar:\n" + definition,
+                        )
+                        if part
+                    )
+            projected = {
+                "type": "function",
+                "name": str(projected.get("name") or ""),
+                "description": description,
+                "parameters": {
+                    "type": "object",
+                    "properties": {"input": {"type": "string"}},
+                    "required": ["input"],
+                    "additionalProperties": False,
+                },
+                "strict": True,
+            }
+        parameters = projected.get("parameters")
+        if isinstance(parameters, Mapping):
+            projected["parameters"] = cls._strict_responses_schema(parameters)
+        if (
+            str(tool.get("type") or "") == "function"
+            and isinstance(parameters, Mapping)
+        ):
+            projected["strict"] = True
+        return projected
+
+    @staticmethod
+    def _normalize_responses_input(item: Any) -> Any:
+        if not isinstance(item, Mapping):
+            return deepcopy(item)
+        projected = deepcopy(dict(item))
+        item_type = str(projected.get("type") or "")
+        if item_type == "custom_tool_call":
+            projected["type"] = "function_call"
+            projected["arguments"] = json.dumps(
+                {"input": str(projected.pop("input", ""))},
+                ensure_ascii=False,
+                separators=(",", ":"),
+            )
+        elif item_type == "custom_tool_call_output":
+            projected["type"] = "function_call_output"
+        return projected
+
+    @classmethod
+    def _strict_responses_schema(cls, schema: Mapping[str, Any]) -> dict[str, Any]:
+        """Require every object property while keeping former optionals nullable."""
+
+        projected = deepcopy(dict(schema))
+        properties = projected.get("properties")
+        if isinstance(properties, Mapping):
+            originally_required = {
+                str(name)
+                for name in projected.get("required") or []
+                if isinstance(name, str)
+            }
+            strict_properties: dict[str, Any] = {}
+            for raw_name, raw_property in properties.items():
+                name = str(raw_name)
+                if isinstance(raw_property, Mapping):
+                    normalized_property = cls._strict_responses_schema(raw_property)
+                    if name not in originally_required:
+                        normalized_property = cls._nullable_schema(normalized_property)
+                    strict_properties[name] = normalized_property
+                else:
+                    strict_properties[name] = deepcopy(raw_property)
+            projected["properties"] = strict_properties
+            projected["required"] = list(strict_properties)
+            projected["additionalProperties"] = False
+
+        items = projected.get("items")
+        if isinstance(items, Mapping):
+            projected["items"] = cls._strict_responses_schema(items)
+        for keyword in ("anyOf", "oneOf", "allOf"):
+            variants = projected.get(keyword)
+            if isinstance(variants, list):
+                projected[keyword] = [
+                    cls._strict_responses_schema(item)
+                    if isinstance(item, Mapping)
+                    else deepcopy(item)
+                    for item in variants
+                ]
+        definitions = projected.get("$defs")
+        if isinstance(definitions, Mapping):
+            projected["$defs"] = {
+                str(name): cls._strict_responses_schema(value)
+                if isinstance(value, Mapping)
+                else deepcopy(value)
+                for name, value in definitions.items()
+            }
+        return projected
+
+    @staticmethod
+    def _nullable_schema(schema: Mapping[str, Any]) -> dict[str, Any]:
+        projected = deepcopy(dict(schema))
+        raw_type = projected.get("type")
+        if isinstance(raw_type, str):
+            if raw_type != "null":
+                projected["type"] = [raw_type, "null"]
+        elif isinstance(raw_type, list):
+            if "null" not in raw_type:
+                projected["type"] = [*raw_type, "null"]
+        elif isinstance(projected.get("anyOf"), list):
+            variants = list(projected["anyOf"])
+            if not any(
+                isinstance(item, Mapping) and item.get("type") == "null"
+                for item in variants
+            ):
+                variants.append({"type": "null"})
+            projected["anyOf"] = variants
+        else:
+            projected = {"anyOf": [projected, {"type": "null"}]}
+        enum = projected.get("enum")
+        if isinstance(enum, list) and None not in enum:
+            projected["enum"] = [*enum, None]
+        return projected
 
     @classmethod
     def _normalize_messages_request(cls, request: dict[str, Any]) -> None:
@@ -234,11 +447,22 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
         output_config = request.get("output_config")
         if isinstance(output_config, Mapping) and output_config.get("effort") is not None:
             projected_output = dict(output_config)
-            projected_output["effort"] = cls._effort(projected_output.get("effort"))
+            projected_output["effort"] = cls._messages_effort(
+                projected_output.get("effort")
+            )
             request["output_config"] = projected_output
 
     @staticmethod
-    def _effort(value: Any) -> str:
+    def _normalize_chat_request(request: dict[str, Any]) -> None:
+        # Meta Chat Completions documents only the automatic tool-selection
+        # mode. OpenAI clients can send a named function choice object; retain
+        # the tools but project that unsupported selector to Meta's auto mode.
+        tool_choice = request.get("tool_choice")
+        if isinstance(tool_choice, Mapping):
+            request["tool_choice"] = "auto"
+
+    @staticmethod
+    def _responses_effort(value: Any) -> str:
         effort = str(value or "high").strip().lower()
         if effort in {"none", "minimal"}:
             return "minimal"
@@ -248,10 +472,17 @@ class MetaModelProviderAdapter(HttpBearerProviderAdapter):
             return "xhigh"
         return "high"
 
+    @classmethod
+    def _messages_effort(cls, value: Any) -> str:
+        effort = cls._responses_effort(value)
+        return "low" if effort == "minimal" else effort
+
 
 __all__ = [
     "MUSE_SPARK_AUTO_COMPACT_LIMIT",
+    "MUSE_SPARK_CODEX_CATALOG",
     "MUSE_SPARK_CONTEXT_WINDOW",
     "MUSE_SPARK_MODEL",
+    "MUSE_SPARK_MODELS",
     "MetaModelProviderAdapter",
 ]

package/ciel_runtime_support/pseudo_tool_parser.py

@@ -18,7 +18,23 @@ PSEUDO_CALL_END = "<|tool_call_end|>"
 
 def normalize_tool_arguments(tool_name: str, arguments: Any) -> dict[str, Any]:
     if isinstance(arguments, dict):
-        return arguments
+        normalized = dict(arguments)
+        # Kimi occasionally abbreviates Codex's ``exec_command`` tool to
+        # ``exec`` and emits the shell payload under a generic ``input`` (or
+        # OpenAI-style ``command``/``script``) key.  Name canonicalization has
+        # already resolved the tool before this function runs, so repair only
+        # non-empty string aliases whose semantics are still a shell command.
+        # A ``js`` field is deliberately not repaired: JavaScript intended for
+        # a Node REPL is not a valid PowerShell command.
+        if str(tool_name or "").casefold() == "exec_command":
+            cmd = normalized.get("cmd")
+            if not isinstance(cmd, str) or not cmd.strip():
+                for alias in ("command", "script", "input"):
+                    value = normalized.get(alias)
+                    if isinstance(value, str) and value.strip():
+                        normalized["cmd"] = value
+                        break
+        return normalized
     if isinstance(arguments, str):
         text = arguments.strip()
         if not text:

package/ciel_runtime_support/remote_bridge.py

@@ -20,6 +20,7 @@ REMOTE_LLM_PATHS = frozenset(
 REMOTE_GENERATION_PATHS = frozenset(
     {"/v1/chat/completions", "/v1/messages", "/v1/responses"}
 )
+REMOTE_FILES_PATH = "/v1/files"
 
 PROVIDER_HEADER = "x-ciel-runtime-provider"
 MODEL_HEADER = "x-ciel-runtime-model"
@@ -200,6 +201,8 @@ def remote_bridge_path_allowed(path: str) -> bool:
         normalized in REMOTE_LLM_PATHS
         or normalized in {"/ca/bridge", "/v1/models"}
         or normalized.startswith("/v1/models/")
+        or normalized == REMOTE_FILES_PATH
+        or normalized.startswith(REMOTE_FILES_PATH + "/")
     )
 
 
@@ -218,6 +221,7 @@ __all__ = [
     "REQUEST_API_KEY_MARKER",
     "REMOTE_BRIDGE_INCOMPATIBLE_PROVIDERS",
     "REMOTE_GENERATION_PATHS",
+    "REMOTE_FILES_PATH",
     "REMOTE_LLM_PATHS",
     "ROUTER_MANAGED_CREDENTIAL_PROVIDERS",
     "RemoteBridgeRoute",

package/ciel_runtime_support/remote_instructions.py

@@ -25,6 +25,8 @@ RUNTIME_FILES = {
     "grok": "AGENTS.md",
     # ZCode discovers workspace instructions from AGENTS.md.
     "zcode": "AGENTS.md",
+    # Muse Code loads AGENTS.md before other project instruction files.
+    "muse": "AGENTS.md",
 }
 URL_KEYS = {
     "claude": "claude_url",
@@ -33,6 +35,7 @@ URL_KEYS = {
     "agy": "agy_url",
     "kimi": "kimi_url",
     "grok": "grok_url",
+    "muse": "muse_url",
 }
 
 _ENV_REFERENCE = re.compile(r"%([A-Za-z_][A-Za-z0-9_]*)%|\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\{([A-Za-z_][A-Za-z0-9_]*)\}")
@@ -229,6 +232,7 @@ def panel_rows(config: dict[str, Any]) -> tuple[list[str], list[str]]:
             f"AGY URL → GEMINI.md  [{compact(current.get('agy_url') or 'unset')}]",
             f"Kimi URL → AGENTS.md  [{compact(current.get('kimi_url') or 'unset')}]",
             f"Grok URL → AGENTS.md  [{compact(current.get('grok_url') or 'unset')}]",
+            f"Muse URL → AGENTS.md  [{compact(current.get('muse_url') or 'unset')}]",
             f"Authorization header  [{'configured' if current.get('authorization') else 'unset'}]",
             f"HTTP timeout seconds  [{current.get('timeout_seconds') or 5}]",
             "Sync configured instruction files now",
@@ -241,6 +245,7 @@ def panel_rows(config: dict[str, Any]) -> tuple[list[str], list[str]]:
             "agy_url",
             "kimi_url",
             "grok_url",
+            "muse_url",
             "authorization",
             "timeout_seconds",
             "sync",

package/ciel_runtime_support/remote_memory.py

@@ -993,7 +993,7 @@ def sync_all_memory_pointers(
     """Download once and project the verified pointer for every runtime."""
 
     result = synchronizer.sync("codex", reason="manual")
-    for runtime in ("codex-app-server", "claude", "agy", "kimi", "grok"):
+    for runtime in ("codex-app-server", "claude", "agy", "kimi", "grok", "muse"):
         try:
             synchronizer.project_current_pointer(runtime)
         except (OSError, UnicodeError, ValueError) as exc:

package/ciel_runtime_support/responses_cache_diagnostics.py

@@ -0,0 +1,82 @@
+"""Privacy-safe request fingerprints for native Responses cache diagnosis."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any, Mapping
+
+
+def _fingerprint(value: Any) -> str:
+    encoded = json.dumps(
+        value,
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()[:16]
+
+
+def request_cache_profile(
+    body: Mapping[str, Any], request_bytes: int
+) -> dict[str, Any]:
+    raw_input = body.get("input")
+    input_items = raw_input if isinstance(raw_input, list) else [raw_input]
+    input_head = input_items[:8]
+    cache_key = str(body.get("prompt_cache_key") or "")
+    return {
+        "cache_hit_percent": 0.0,
+        "prompt_cache_key_fingerprint": (
+            hashlib.sha256(cache_key.encode("utf-8")).hexdigest()[:16]
+            if cache_key
+            else ""
+        ),
+        "prompt_cache_retention": str(body.get("prompt_cache_retention") or ""),
+        "request_instructions_fingerprint": _fingerprint(body.get("instructions")),
+        "request_tools_fingerprint": _fingerprint(body.get("tools")),
+        "request_input_head_fingerprint": _fingerprint(input_head),
+        "request_input_items": len(input_items) if raw_input is not None else 0,
+        "request_tools": len(body.get("tools") or []),
+        "request_bytes": max(0, int(request_bytes)),
+        "request_uses_previous_response_id": bool(body.get("previous_response_id")),
+    }
+
+
+def usage_with_cache_profile(
+    usage: Mapping[str, Any], profile: Mapping[str, Any]
+) -> dict[str, Any]:
+    observed = dict(usage)
+    input_tokens = max(0, int(observed.get("input_tokens") or 0))
+    cache_read = max(0, int(observed.get("cache_read_tokens") or 0))
+    observed.update(profile)
+    observed["cache_hit_percent"] = (
+        round(cache_read * 100.0 / input_tokens, 2) if input_tokens else 0.0
+    )
+    return observed
+
+
+def cache_trace(
+    provider: str, model: str, observation: Mapping[str, Any]
+) -> tuple[str, str]:
+    hit = float(observation.get("cache_hit_percent") or 0.0)
+    level = "WARN" if int(observation.get("input_tokens") or 0) and hit < 90.0 else "INFO"
+    fields = (
+        "input_tokens",
+        "cache_read_tokens",
+        "uncached_input_tokens",
+        "cache_hit_percent",
+        "prompt_cache_key_fingerprint",
+        "prompt_cache_retention",
+        "request_instructions_fingerprint",
+        "request_tools_fingerprint",
+        "request_input_head_fingerprint",
+        "request_input_items",
+        "request_tools",
+        "request_bytes",
+        "request_uses_previous_response_id",
+    )
+    detail = " ".join(f"{name}={observation.get(name)}" for name in fields)
+    return level, f"provider_responses_cache provider={provider} model={model} {detail}"
+
+
+__all__ = ["cache_trace", "request_cache_profile", "usage_with_cache_profile"]