@oneciel-ai/ciel-runtime 0.2.22 → 0.2.23

package/ciel_runtime_support/providers/opencode.py

@@ -22,6 +22,10 @@ from .base import (
 from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
 
 
+OPENCODE_ZEN_OX_ALPHA_FREE_MODEL = "x-preview-f-free"
+OPENCODE_GO_OX_ALPHA_FREE_MODEL = "ox-alpha-free"
+
+
 @dataclass(frozen=True)
 class OpenCodeProviderAdapter(HttpBearerProviderAdapter):
     name: str = "opencode"
@@ -29,7 +33,10 @@ class OpenCodeProviderAdapter(HttpBearerProviderAdapter):
     configuration_defaults_value: dict = field(
         default_factory=lambda: provider_configuration(
             "claude-sonnet-4-6",
-            custom_models=("claude-sonnet-4-6", "qwen3.6-plus-free"),
+            custom_models=(
+                "claude-sonnet-4-6",
+                OPENCODE_ZEN_OX_ALPHA_FREE_MODEL,
+            ),
             native_compat=True,
             context_window=200000,
             max_output_tokens=8192,
@@ -40,7 +47,7 @@ class OpenCodeProviderAdapter(HttpBearerProviderAdapter):
             ip_family="ipv6-preferred",
             haiku_model="claude-haiku-4-5",
             subagent_model="claude-sonnet-4-6",
-            model_endpoints={},
+            model_endpoints={OPENCODE_ZEN_OX_ALPHA_FREE_MODEL: "openai-chat"},
         )
     )
     send_placeholder_key: bool = True
@@ -132,21 +139,30 @@ class OpenCodeProviderAdapter(HttpBearerProviderAdapter):
                 normalized = normalized[len(prefix) :]
                 break
         if self.name == "opencode-go":
+            if normalized.startswith(("gpt-", "grok-", "muse-spark-")):
+                return "openai_responses"
+            if normalized == OPENCODE_GO_OX_ALPHA_FREE_MODEL:
+                return "openai_chat"
+            if normalized == "hy3":
+                return "openai_chat"
             if normalized.startswith(("glm-", "kimi-", "deepseek-", "mimo-", "hy3-")):
                 return "openai_chat"
             return "anthropic_messages"
-        if normalized.startswith("gpt-"):
+        if normalized.startswith(("gpt-", "grok-", "muse-spark-")):
             return "openai_responses"
         if normalized.startswith("gemini-"):
             return "google_generative"
+        if normalized == OPENCODE_ZEN_OX_ALPHA_FREE_MODEL:
+            return "openai_chat"
         if normalized.startswith(
             (
                 "minimax-",
                 "glm-",
                 "kimi-",
-                "grok-",
                 "big-pickle",
                 "deepseek-",
+                "hy3-",
+                "laguna-",
                 "mimo-",
                 "nemotron-",
                 "north-",
@@ -217,4 +233,8 @@ class OpenCodeProviderAdapter(HttpBearerProviderAdapter):
         return configuration_policy(supports_model_endpoint_overrides=True)
 
 
-__all__ = ["OpenCodeProviderAdapter"]
+__all__ = [
+    "OPENCODE_GO_OX_ALPHA_FREE_MODEL",
+    "OPENCODE_ZEN_OX_ALPHA_FREE_MODEL",
+    "OpenCodeProviderAdapter",
+]

package/ciel_runtime_support/providers/opencode_go.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field
 
 from .base import provider_configuration
 from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
-from .opencode import OpenCodeProviderAdapter
+from .opencode import OPENCODE_GO_OX_ALPHA_FREE_MODEL, OpenCodeProviderAdapter
 
 
 @dataclass(frozen=True)
@@ -14,7 +14,7 @@ class OpenCodeGoProviderAdapter(OpenCodeProviderAdapter):
     configuration_defaults_value: dict = field(
         default_factory=lambda: provider_configuration(
             "qwen3.6-plus",
-            custom_models=("qwen3.6-plus",),
+            custom_models=("qwen3.6-plus", OPENCODE_GO_OX_ALPHA_FREE_MODEL),
             native_compat=True,
             context_window=1048576,
             max_output_tokens=8192,
@@ -25,7 +25,7 @@ class OpenCodeGoProviderAdapter(OpenCodeProviderAdapter):
             ip_family="ipv6-preferred",
             haiku_model="qwen3.5-plus",
             subagent_model="qwen3.6-plus",
-            model_endpoints={},
+            model_endpoints={OPENCODE_GO_OX_ALPHA_FREE_MODEL: "openai-chat"},
         )
     )
     api_key_display_name_value: str = "OpenCode Go"

package/ciel_runtime_support/providers/openrouter.py

@@ -1,12 +1,23 @@
 """OpenRouter provider adapter."""
 
 from dataclasses import dataclass, field
+from typing import Any, Mapping
 
-from ..architecture import ProviderCapabilities, ProviderConfig, ProviderContextPolicy
+from ..architecture import (
+    MessageProtocol,
+    ProviderCapabilities,
+    ProviderConfig,
+    ProviderContextPolicy,
+)
 from .base import OpenAICompatibleProviderAdapter, provider_configuration
 from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
 
 
+OPENROUTER_OX_ALPHA_MODEL = "stealth/ox-alpha"
+OPENROUTER_OX_ALPHA_CONTEXT_WINDOW = 1_048_576
+OPENROUTER_OX_ALPHA_MAX_OUTPUT_TOKENS = 131_072
+
+
 @dataclass(frozen=True)
 class OpenRouterProviderAdapter(OpenAICompatibleProviderAdapter):
     name: str = "OpenRouter"
@@ -14,6 +25,7 @@ class OpenRouterProviderAdapter(OpenAICompatibleProviderAdapter):
     configuration_defaults_value: dict = field(
         default_factory=lambda: provider_configuration(
             "nvidia/nemotron-3-ultra-550b-a55b:free",
+            custom_models=(OPENROUTER_OX_ALPHA_MODEL,),
             native_compat=False,
             rate_limit_rpm=0,
             rate_limit_status=False,
@@ -50,8 +62,69 @@ class OpenRouterProviderAdapter(OpenAICompatibleProviderAdapter):
     def router_native_anthropic_enabled(
         self, config: ProviderConfig, model: str | None = None
     ) -> bool:
+        return self.select_protocol("anthropic_messages", config, model) == "anthropic_messages"
+
+    def supported_protocols(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> frozenset[MessageProtocol]:
+        protocols: set[MessageProtocol] = {"openai_chat"}
+        selected = self.normalize_model_id(str(model or config.model or ""))
+        native = config.options.get("native_compat")
+        if selected == OPENROUTER_OX_ALPHA_MODEL or native is True or str(
+            native
+        ).strip().lower() in {"1", "true", "yes", "on"}:
+            protocols.add("anthropic_messages")
+        return frozenset(protocols)
+
+    def select_protocol(
+        self,
+        operation: MessageProtocol,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> MessageProtocol:
+        if operation == "anthropic_messages" and "anthropic_messages" in self.supported_protocols(
+            config, model
+        ):
+            return "anthropic_messages"
+        return "openai_chat"
+
+    def model_configuration_profile(
+        self, config: ProviderConfig
+    ) -> tuple[Mapping[str, Any], str | None]:
+        if self.normalize_model_id(config.model) != OPENROUTER_OX_ALPHA_MODEL:
+            return {}, None
+        return (
+            {
+                "context_window": OPENROUTER_OX_ALPHA_CONTEXT_WINDOW,
+                "max_model_len": OPENROUTER_OX_ALPHA_CONTEXT_WINDOW,
+                "max_output_tokens": OPENROUTER_OX_ALPHA_MAX_OUTPUT_TOKENS,
+                "model_profile": "openrouter-ox-alpha-1m",
+                "supports_tool_choice": True,
+                "supports_vision": True,
+            },
+            "OpenRouter Ox Alpha profile applied: 1,048,576-token context and 131,072-token maximum output.",
+        )
+
+    def openai_reasoning_effort(
+        self,
+        config: ProviderConfig,
+        model: str,
+        request: Mapping[str, Any],
+    ) -> str | None:
         del config, model
-        return False
+        metadata = request.get("metadata")
+        hinted = (
+            metadata.get("ciel_runtime_reasoning_effort")
+            if isinstance(metadata, Mapping)
+            else None
+        )
+        value = str(request.get("reasoning_effort") or hinted or "").strip().casefold()
+        return value or None
 
 
-__all__ = ["OpenRouterProviderAdapter"]
+__all__ = [
+    "OPENROUTER_OX_ALPHA_CONTEXT_WINDOW",
+    "OPENROUTER_OX_ALPHA_MAX_OUTPUT_TOKENS",
+    "OPENROUTER_OX_ALPHA_MODEL",
+    "OpenRouterProviderAdapter",
+]

package/ciel_runtime_support/providers/tabitoken.py

@@ -0,0 +1,130 @@
+"""TaBiAI (tabitoken.com) provider adapter."""
+
+from dataclasses import dataclass, field
+from typing import Any, Mapping
+
+from ..architecture import (
+    MessageProtocol,
+    ProviderCapabilities,
+    ProviderConfig,
+    ProviderContextPolicy,
+    ProviderModelCatalogPolicy,
+    ProviderRequestPolicy,
+)
+from .base import OpenAICompatibleProviderAdapter, provider_configuration
+from .constants import DEFAULT_REQUEST_TIMEOUT_MS, PROVIDER_DEFAULT_BASE_URLS
+
+
+TABITOKEN_MODELS: tuple[str, ...] = (
+    "claude-opus-4-8",
+    "claude-opus-4-8-thinking",
+    "claude-opus-5",
+    "claude-opus-5-thinking",
+)
+TABITOKEN_THINKING_MODELS = frozenset(
+    model for model in TABITOKEN_MODELS if model.endswith("-thinking")
+)
+
+
+@dataclass(frozen=True)
+class TabitokenProviderAdapter(OpenAICompatibleProviderAdapter):
+    """Dual OpenAI Chat and Anthropic Messages transport for TaBiAI."""
+
+    name: str = "tabitoken"
+    base_url: str = PROVIDER_DEFAULT_BASE_URLS["tabitoken"]
+    configuration_defaults_value: dict = field(
+        default_factory=lambda: provider_configuration(
+            TABITOKEN_MODELS[0],
+            custom_models=TABITOKEN_MODELS,
+            native_compat=True,
+            context_window=1_000_000,
+            max_output_tokens=8192,
+            context_reserve_tokens=8192,
+            request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
+            stream_enabled=True,
+            stream_word_chunking=False,
+        )
+    )
+    authorization_header: str = "Authorization"
+    include_x_api_key: bool = False
+    require_api_key: bool = True
+    api_key_display_name_value: str = "TaBiAI (Tabitoken.com)"
+    api_key_launch_error_value: str = (
+        "Launch blocked: TaBiAI (Tabitoken.com) requires an API key."
+    )
+    capabilities_value: ProviderCapabilities = field(
+        default_factory=lambda: ProviderCapabilities(
+            upstream_protocol="openai_chat",
+            requires_api_key=True,
+            supports_thinking=True,
+            preserves_anthropic_thinking=True,
+        )
+    )
+    request_policy_value: ProviderRequestPolicy = field(
+        default_factory=lambda: ProviderRequestPolicy(
+            chat_path="/v1/chat/completions",
+            models_path="/v1/models",
+        )
+    )
+    model_catalog_policy_value: ProviderModelCatalogPolicy = field(
+        default_factory=lambda: ProviderModelCatalogPolicy(
+            kind="openai",
+            fallback_models=TABITOKEN_MODELS,
+            allow_configured_fallback=True,
+        )
+    )
+
+    def context_policy(self, config: ProviderConfig) -> ProviderContextPolicy:
+        del config
+        return ProviderContextPolicy(
+            capacity_strategy="configured_first",
+            settings_strategy="standard",
+            hosted_timeout=True,
+        )
+
+    def anthropic_base_url(self, config: ProviderConfig) -> str:
+        return str(config.base_url or self.default_base_url()).rstrip("/")
+
+    def supported_protocols(
+        self,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> frozenset[MessageProtocol]:
+        del config, model
+        return frozenset({"anthropic_messages", "openai_chat"})
+
+    def select_protocol(
+        self,
+        operation: MessageProtocol,
+        config: ProviderConfig,
+        model: str | None = None,
+    ) -> MessageProtocol:
+        del config, model
+        if operation == "anthropic_messages":
+            return "anthropic_messages"
+        return "openai_chat"
+
+    def openai_reasoning_effort(
+        self,
+        config: ProviderConfig,
+        model: str,
+        request: Mapping[str, Any],
+    ) -> str | None:
+        del config
+        if self.normalize_model_id(model) not in TABITOKEN_THINKING_MODELS:
+            return None
+        metadata = request.get("metadata")
+        hinted = (
+            metadata.get("ciel_runtime_reasoning_effort")
+            if isinstance(metadata, Mapping)
+            else None
+        )
+        value = str(request.get("reasoning_effort") or hinted or "").strip().casefold()
+        return value or None
+
+
+__all__ = [
+    "TABITOKEN_MODELS",
+    "TABITOKEN_THINKING_MODELS",
+    "TabitokenProviderAdapter",
+]

package/ciel_runtime_support/remote_instructions.py

@@ -65,6 +65,13 @@ def target_file(workspace: Path, runtime: str) -> Path:
     return workspace.resolve() / filename
 
 
+def normalized_instruction_sha256(value: str) -> str:
+    """Hash managed instruction text independently of platform line endings."""
+
+    normalized = value.replace("\r\n", "\n").replace("\r", "\n").strip()
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
+
+
 @dataclass(frozen=True, slots=True)
 class RemoteInstructionResult:
     runtime: str
@@ -104,10 +111,14 @@ class RemoteInstructionSynchronizer:
             return self._failed(runtime, url, f"missing authorization environment variable: {', '.join(sorted(set(missing)))}")
         if authorization.strip():
             headers["Authorization"] = authorization.strip()
-        if state.get("etag"):
-            headers["If-None-Match"] = str(state["etag"])
-        if state.get("last_modified"):
-            headers["If-Modified-Since"] = str(state["last_modified"])
+        # States written before normalized content verification cannot safely
+        # authorize pointer projection after platform newline conversion.
+        # Refresh them without validators once so the next state is verifiable.
+        if state.get("normalized_sha256"):
+            if state.get("etag"):
+                headers["If-None-Match"] = str(state["etag"])
+            if state.get("last_modified"):
+                headers["If-Modified-Since"] = str(state["last_modified"])
         request = urllib.request.Request(url, headers=headers, method="GET")
         try:
             with self.urlopen(request, timeout=timeout) as response:
@@ -126,6 +137,7 @@ class RemoteInstructionSynchronizer:
                     "url": url,
                     "target": path.name,
                     "sha256": digest,
+                    "normalized_sha256": normalized_instruction_sha256(text),
                     "etag": str(response.headers.get("etag") or ""),
                     "last_modified": str(response.headers.get("last-modified") or ""),
                     "updated_at": self.now(),
@@ -162,14 +174,15 @@ class RemoteInstructionSynchronizer:
 
     @staticmethod
     def _write_if_changed(path: Path, text: str) -> bool:
+        raw = text.encode("utf-8")
         try:
-            if path.read_text(encoding="utf-8") == text:
+            if path.read_bytes() == raw:
                 return False
         except FileNotFoundError:
             pass
         path.parent.mkdir(parents=True, exist_ok=True)
         temporary = path.with_name(path.name + ".ciel-runtime.tmp")
-        temporary.write_text(text, encoding="utf-8")
+        temporary.write_bytes(raw)
         os.replace(temporary, path)
         return True
 
@@ -237,6 +250,7 @@ __all__ = [
     "SynchronizedLaunch",
     "configured_url",
     "expand_environment_references",
+    "normalized_instruction_sha256",
     "panel_rows",
     "settings",
     "target_file",