@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

package/ciel_runtime_support/providers/catalog.py

@@ -16,6 +16,7 @@ from ..architecture import (
     ProviderRequestPolicy,
 )
 from ..runtime_constants import DEFAULT_REQUEST_TIMEOUT_MS
+from .alibaba import ALIBABA_CODING_PLAN_MODELS
 from .base import OpenAICompatibleProviderAdapter, provider_configuration
 
 
@@ -30,8 +31,8 @@ class CompatibleProviderSpec:
     aliases: tuple[str, ...] = ()
     chat_path: str = "/v1/chat/completions"
     models_path: str = "/v1/models"
+    anthropic_url: str = ""
     authorization_header: str = "Authorization"
-    include_x_api_key: bool = False
     requires_api_key: bool = True
 
 
@@ -52,7 +53,7 @@ class CatalogOpenAIProviderAdapter(OpenAICompatibleProviderAdapter):
             configuration_defaults_value=provider_configuration(
                 default_model,
                 custom_models=spec.models,
-                native_compat=False,
+                native_compat=bool(spec.anthropic_url),
                 context_window=131072,
                 max_output_tokens=8192,
                 context_reserve_tokens=4096,
@@ -61,7 +62,7 @@ class CatalogOpenAIProviderAdapter(OpenAICompatibleProviderAdapter):
                 stream_word_chunking=False,
             ),
             authorization_header=spec.authorization_header,
-            include_x_api_key=spec.include_x_api_key,
+            include_x_api_key=False,
             require_api_key=spec.requires_api_key,
             api_key_display_name_value=spec.label,
             api_key_launch_error_value=(
@@ -97,16 +98,25 @@ class CatalogOpenAIProviderAdapter(OpenAICompatibleProviderAdapter):
         config: ProviderConfig,
         model: str | None = None,
     ) -> bool:
-        del config, model
-        return False
+        del model
+        return bool(self.spec.anthropic_url) and bool(
+            config.options.get("native_compat", True)
+        )
+
+    def anthropic_base_url(self, config: ProviderConfig) -> str:
+        del config
+        return self.spec.anthropic_url or self.default_base_url()
 
     def supported_protocols(
         self,
         config: ProviderConfig,
         model: str | None = None,
     ) -> frozenset[MessageProtocol]:
-        del config, model
-        return frozenset({"openai_chat"})
+        del model
+        protocols: set[MessageProtocol] = {"openai_chat"}
+        if self.router_native_anthropic_enabled(config):
+            protocols.add("anthropic_messages")
+        return frozenset(protocols)
 
     def select_protocol(
         self,
@@ -114,7 +124,9 @@ class CatalogOpenAIProviderAdapter(OpenAICompatibleProviderAdapter):
         config: ProviderConfig,
         model: str | None = None,
     ) -> MessageProtocol:
-        del operation, config, model
+        del model
+        if operation == "anthropic_messages" and self.router_native_anthropic_enabled(config):
+            return "anthropic_messages"
         return "openai_chat"
 
 
@@ -130,19 +142,15 @@ COMPATIBLE_PROVIDER_SPECS: tuple[CompatibleProviderSpec, ...] = (
     CompatibleProviderSpec(
         "alicode-intl", "Alibaba Coding International",
         "https://coding-intl.dashscope.aliyuncs.com/v1",
-        ("qwen3.5-plus", "kimi-k2.5", "glm-5", "qwen3-coder-next"),
+        ALIBABA_CODING_PLAN_MODELS,
         ("alibaba-coding-intl",),
+        anthropic_url="https://coding-intl.dashscope.aliyuncs.com/apps/anthropic",
     ),
     CompatibleProviderSpec(
         "alicode", "Alibaba Coding", "https://coding.dashscope.aliyuncs.com/v1",
-        ("qwen3.5-plus", "kimi-k2.5", "glm-5", "qwen3-coder-next"),
+        ALIBABA_CODING_PLAN_MODELS,
         ("alibaba-coding",),
-    ),
-    CompatibleProviderSpec(
-        "alims-intl", "Alibaba Model Studio International",
-        "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
-        ("qwen3.5-plus", "kimi-k2.5", "glm-5", "qwen3-coder-next"),
-        ("dashscope-intl",),
+        anthropic_url="https://coding.dashscope.aliyuncs.com/apps/anthropic",
     ),
     CompatibleProviderSpec(
         "blackbox", "Blackbox AI", "https://api.blackbox.ai/v1",

package/ciel_runtime_support/providers/deepseek.py

@@ -1,6 +1,7 @@
 """DeepSeek provider adapter."""
 
 from dataclasses import dataclass, field
+from typing import Any, Mapping
 
 from ..architecture import (
     ProviderCapabilities,
@@ -24,6 +25,12 @@ class DeepSeekProviderAdapter(HttpBearerProviderAdapter):
             "deepseek-v4-pro[1m]",
             custom_models=("deepseek-v4-pro[1m]", "deepseek-v4-flash"),
             native_compat=True,
+            claude_code_supported_capabilities=[
+                "effort",
+                "max_effort",
+                "thinking",
+                "interleaved_thinking",
+            ],
             context_window=1048576,
             max_output_tokens=8192,
             context_reserve_tokens=8192,
@@ -111,5 +118,71 @@ class DeepSeekProviderAdapter(HttpBearerProviderAdapter):
             not in str(model or config.model or "").split("[", 1)[0].lower()
         )
 
+    @staticmethod
+    def _normalized_effort(value: Any) -> str:
+        effort = str(value or "").strip().lower()
+        if effort in {"max", "xhigh"}:
+            return "max"
+        return "high"
+
+    def normalize_request_options(
+        self, config: ProviderConfig, request: Mapping[str, Any]
+    ) -> Mapping[str, Any]:
+        """Honor DeepSeek's native thinking contract on Anthropic requests."""
+
+        del config
+        normalized = dict(request)
+        thinking = request.get("thinking")
+        thinking_disabled = isinstance(thinking, Mapping) and str(
+            thinking.get("type") or ""
+        ).strip().lower() in {"disabled", "none", "off", "false"}
+        if not thinking_disabled:
+            for key in (
+                "temperature",
+                "top_p",
+                "top_k",
+                "presence_penalty",
+                "frequency_penalty",
+            ):
+                normalized.pop(key, None)
+        output_config = request.get("output_config")
+        if thinking_disabled:
+            normalized.pop("output_config", None)
+            output_config = None
+        elif not isinstance(output_config, Mapping) and isinstance(thinking, Mapping):
+            if thinking.get("effort") is not None:
+                output_config = {"effort": thinking.get("effort")}
+        if isinstance(output_config, Mapping) and output_config.get("effort") is not None:
+            normalized["output_config"] = {
+                **output_config,
+                "effort": self._normalized_effort(output_config.get("effort")),
+            }
+        if isinstance(thinking, Mapping) and "effort" in thinking:
+            normalized["thinking"] = {
+                key: value for key, value in thinking.items() if key != "effort"
+            }
+        return normalized
+
+    def openai_reasoning_passback_enabled(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> bool:
+        del config
+        normalized = str(model or "").split("[", 1)[0].lower()
+        return normalized.startswith(("deepseek-v4-", "deepseek-reasoner"))
+
+    def openai_reasoning_effort(
+        self, config: ProviderConfig, model: str, request: Mapping[str, Any]
+    ) -> str | None:
+        del model
+        metadata = request.get("metadata")
+        hinted = metadata.get("ciel_runtime_reasoning_effort") if isinstance(metadata, Mapping) else None
+        return self._normalized_effort(hinted or config.options.get("effort_level") or "high")
+
+    def allows_sampling_overrides(self, config: ProviderConfig) -> bool:
+        # Thinking is enabled by default. Do not inject configured sampling
+        # values that DeepSeek documents as ineffective in that mode.
+        del config
+        return False
+
 
 __all__ = ["DeepSeekProviderAdapter"]

package/ciel_runtime_support/providers/github_copilot_oauth.py

@@ -26,12 +26,32 @@ from .base import HttpBearerProviderAdapter, provider_configuration
 
 GITHUB_COPILOT_BASE_URL = "https://api.githubcopilot.com"
 GITHUB_COPILOT_MODELS = (
+    "gpt-5.6-sol",
+    "gpt-5.6-terra",
+    "gpt-5.6-luna",
+    "gpt-5.5",
     "gpt-5.4",
+    "gpt-5.4-mini",
+    "gpt-5.4-nano",
     "gpt-5.3-codex",
-    "gpt-5.2-codex",
+    "gpt-5-mini",
+    "claude-fable-5",
+    "claude-sonnet-5",
+    "claude-opus-5",
+    "claude-opus-4.8",
+    "claude-opus-4.7",
     "claude-sonnet-4.6",
     "claude-opus-4.6",
+    "claude-sonnet-4.5",
+    "claude-opus-4.5",
+    "claude-haiku-4.5",
+    "gemini-3.6-flash",
+    "gemini-3.5-flash",
     "gemini-3.1-pro-preview",
+    "kimi-k2.7-code",
+    "mai-code-1-flash",
+    "raptor-mini",
+    "grok-4.5",
 )
 
 
@@ -78,6 +98,7 @@ class GitHubCopilotOAuthProviderAdapter(HttpBearerProviderAdapter):
             kind="openai",
             fallback_models=GITHUB_COPILOT_MODELS,
             allow_configured_fallback=True,
+            authoritative_upstream_catalog=True,
         )
     )
 

package/ciel_runtime_support/providers/kimi.py

@@ -6,6 +6,7 @@ from typing import Any, Mapping
 
 from ..architecture import (
     MessageProtocol,
+    HostedToolPolicy,
     ProviderCapabilities,
     ProviderConfig,
     ProviderContextPolicy,
@@ -40,7 +41,9 @@ class KimiProviderAdapter(HttpBearerProviderAdapter):
             request_timeout_ms=600000,
             stream_enabled=True,
             stream_word_chunking=False,
-            effort_level="high",
+            effort_level="max",
+            official_tools_enabled=True,
+            official_tools=["web-search", "fetch"],
             haiku_model="kimi-for-coding",
             subagent_model="kimi-for-coding",
         )
@@ -155,10 +158,10 @@ class KimiProviderAdapter(HttpBearerProviderAdapter):
             {
                 "context_window": context,
                 "max_model_len": context,
-                "effort_level": "high",
+                "effort_level": "max",
                 "model_profile": "kimi-k3-1m",
             },
-            "Kimi K3 profile applied: 1M context and high reasoning effort. "
+            "Kimi K3 profile applied: 1M context and max reasoning effort. "
             "Start a new session after changing model, context, or reasoning effort.",
         )
 
@@ -218,7 +221,15 @@ class KimiProviderAdapter(HttpBearerProviderAdapter):
         config: ProviderConfig,
         model: str | None = None,
     ) -> MessageProtocol:
-        del config, model
+        normalized_model = self.normalize_model_id(
+            str(model or config.model or "")
+        )
+        if (
+            operation == "anthropic_messages"
+            and normalized_model in {"k3", "k3[1m]"}
+            and self.hosted_tool_policy(config).formulas
+        ):
+            return "openai_chat"
         return (
             "openai_chat"
             if operation in {"openai_chat", "openai_responses"}
@@ -266,20 +277,69 @@ class KimiProviderAdapter(HttpBearerProviderAdapter):
             requested = config.options.get("effort_level")
         return self._reasoning_effort(requested)
 
+    def openai_reasoning_passback_enabled(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> bool:
+        del config
+        normalized = self.normalize_model_id(str(model or ""))
+        return normalized in {
+            "k3",
+            "k3[1m]",
+            "kimi-for-coding",
+            "kimi-for-coding-highspeed",
+        }
+
+    def hosted_tool_policy(self, config: ProviderConfig) -> HostedToolPolicy:
+        if config.options.get("official_tools_enabled", True) is False:
+            return HostedToolPolicy()
+        configured = config.options.get("official_tools", ("web-search", "fetch"))
+        if configured is False or configured is None:
+            return HostedToolPolicy()
+        if isinstance(configured, str):
+            names = tuple(part.strip() for part in configured.split(",") if part.strip())
+        elif isinstance(configured, (list, tuple)):
+            names = tuple(str(part).strip() for part in configured if str(part).strip())
+        else:
+            names = ("web-search", "fetch") if configured is True else ()
+        formulas = tuple(
+            name if "/" in name else f"moonshot/{name}:latest" for name in names
+        )
+        base_url = str(
+            config.options.get("official_tools_base_url")
+            or "https://api.moonshot.ai/v1"
+        ).rstrip("/")
+        return HostedToolPolicy(base_url=base_url, formulas=formulas)
+
+    def should_omit_openai_tool_choice(
+        self,
+        config: ProviderConfig,
+        model: str | None,
+        request: Mapping[str, Any],
+    ) -> bool:
+        if not self.openai_reasoning_passback_enabled(config, model):
+            return False
+        choice = request.get("tool_choice")
+        return bool(
+            isinstance(choice, Mapping)
+            and str(choice.get("type") or "").strip().lower() == "tool"
+        )
+
     def allows_sampling_overrides(self, config: ProviderConfig) -> bool:
         del config
         return False
 
     @staticmethod
     def _reasoning_effort(value: Any) -> str:
-        effort = str(value or "high").strip().lower()
-        if effort == "ultra":
+        effort = str(value or "max").strip().lower()
+        if effort in {"xhigh", "ultra", "max"}:
             return "max"
         if effort in {"minimum", "light"}:
             return "low"
-        if effort in {"low", "medium", "high", "xhigh", "max"}:
+        if effort == "medium":
+            return "high"
+        if effort in {"low", "high"}:
             return effort
-        return "high"
+        return "max"
 
     def normalize_tool_choice(
         self, config: ProviderConfig, model: str, tool_choice: Any
@@ -289,7 +349,7 @@ class KimiProviderAdapter(HttpBearerProviderAdapter):
             tool_choice, Mapping
         ):
             return tool_choice
-        if str(tool_choice.get("type") or "").strip().lower() in {"any", "tool"}:
+        if str(tool_choice.get("type") or "").strip().lower() == "tool":
             return {"type": "auto"}
         return tool_choice
 

package/ciel_runtime_support/providers/ollama.py

@@ -84,6 +84,14 @@ class OllamaProviderAdapter(HttpBearerProviderAdapter):
     ) -> bool | str | None:
         return OllamaThinkingPolicy().value(config.options, model, request)
 
+    def reasoning_passback_enabled(
+        self, config: ProviderConfig, model: str | None = None
+    ) -> bool:
+        """Keep native Ollama thinking blocks so multi-turn tool history remains valid."""
+
+        del config, model
+        return True
+
     def option_presentation_policy(
         self, config: ProviderConfig
     ) -> ProviderOptionPresentationPolicy:

package/ciel_runtime_support/providers/ollama_context.py

@@ -179,10 +179,29 @@ class OllamaRequestContextPolicy:
         )
         options = dict(self.extra_options(retry_config))
         configured_num_predict = self.positive_int(options.get("num_predict"))
-        if configured_num_predict:
+        output_is_explicit = bool(config.get("output_tokens_explicit")) or (
+            "num_predict"
+            in {
+                str(item)
+                for item in config.get("ollama_explicit_options") or []
+            }
+        )
+        if configured_num_predict and output_is_explicit:
             options["num_predict"] = min(configured_num_predict, output_cap)
+        else:
+            options.pop("num_predict", None)
         retry_config["ollama_options"] = options
-        retry_config["ollama_transient_options"] = ["num_predict"]
+        transient = {
+            str(item)
+            for item in retry_config.get("ollama_transient_options") or []
+            if str(item) != "num_predict"
+        }
+        if output_is_explicit:
+            transient.add("num_predict")
+        if transient:
+            retry_config["ollama_transient_options"] = sorted(transient)
+        else:
+            retry_config.pop("ollama_transient_options", None)
         return retry_config
 
     def context_limit_for_budget(self, config: dict[str, Any]) -> int:

package/ciel_runtime_support/providers/vllm.py

@@ -1,6 +1,7 @@
 """vLLM provider adapter."""
 
 from dataclasses import dataclass, field, replace
+from typing import Literal
 
 from ..architecture import (
     ProviderCapabilities,
@@ -39,11 +40,16 @@ class VllmProviderAdapter(OpenAICompatibleProviderAdapter):
             upstream_protocol="openai_chat", supports_tool_choice=False, local=True
         )
     )
-
     def requires_catalog_model_selection(self, config: ProviderConfig) -> bool:
         del config
         return True
 
+    def anthropic_system_role_strategy(
+        self, config: ProviderConfig
+    ) -> Literal["hoist_top_level"]:
+        del config
+        return "hoist_top_level"
+
     def placeholder_model_ids(self) -> frozenset[str]:
         return super().placeholder_model_ids() | {"my-model"}
 

package/ciel_runtime_support/response_collection.py

@@ -15,6 +15,10 @@ class ChatCollectionStrategy:
     request_timeout_seconds: Callable[..., float]
     normalize_upstream_model: Callable[..., str]
     skip_rate_limit_during_compatibility_test: bool = False
+    # When set, the upstream is read as a stream and assembled here instead of
+    # being fetched with one blocking POST. Same result, except a runaway can be
+    # cut off while it is still being generated rather than after.
+    stream_collect: Callable[..., dict[str, Any]] | None = None
 
 
 @dataclass(frozen=True, slots=True)
@@ -48,6 +52,7 @@ class ResponseCollectionServices:
     rate_limit: ResponseCollectionRateLimit
     projection: ResponseCollectionProjection
     post_json_with_retry: Callable[..., Any]
+    hosted_tools: Any
 
 
 @dataclass(frozen=True, slots=True)
@@ -112,25 +117,60 @@ def collect_chat_message_for_responses(
     model = strategy.normalize_upstream_model(provider, pcfg, model)
     original_body = body
     upstream_body = request.body_with_advisor_tool(body, pcfg) if request.advisor_provider_supported(provider) else body
-    req_body = strategy.build_request(provider, model, upstream_body, pcfg, stream=False)
+    streaming = strategy.stream_collect is not None
+    req_body = strategy.build_request(provider, model, upstream_body, pcfg, stream=streaming)
     url = request.provider_endpoint(provider, pcfg, strategy.operation)
+    timeout = strategy.request_timeout_seconds(pcfg)
+    headers = request.provider_headers(provider, pcfg, handler.headers, strategy.operation)
+    req_body, hosted_state = services.hosted_tools.prepare(
+        provider, pcfg, req_body, headers, timeout
+    )
     compatibility_test = str(handler.headers.get(services.compatibility_test_header) or "").strip().lower() in ("1", "true", "yes", "on")
     if compatibility_test and strategy.skip_rate_limit_during_compatibility_test:
         waited, rpm_used, rpm_limit = 0.0, 0, rate_limit.effective_rpm(provider, pcfg, model)
     else:
         waited, rpm_used, rpm_limit = rate_limit.apply(provider, pcfg, model)
-    data = services.post_json_with_retry(
-        url,
-        req_body,
-        request.provider_headers(
-            provider, pcfg, handler.headers, strategy.operation
+    if streaming:
+        data = strategy.stream_collect(
+            url,
+            req_body,
+            headers,
+            timeout,
+            provider,
+            pcfg,
+            model,
+            retry_rate_limits=not compatibility_test,
+        )
+    else:
+        data = services.post_json_with_retry(
+            url,
+            req_body,
+            headers,
+            timeout,
+            provider,
+            pcfg,
+            model,
+            None,
+            retry_rate_limits=not compatibility_test,
+        )
+    # Hosted-tool follow-ups are plain request/response, so they keep using the
+    # blocking POST regardless of how the first turn was read.
+    data = services.hosted_tools.resolve(
+        hosted_state,
+        {**req_body, "stream": False} if streaming else req_body,
+        data,
+        lambda next_body: services.post_json_with_retry(
+            url,
+            next_body,
+            headers,
+            timeout,
+            provider,
+            pcfg,
+            model,
+            None,
+            retry_rate_limits=not compatibility_test,
         ),
-        strategy.request_timeout_seconds(pcfg),
-        provider,
-        pcfg,
-        model,
-        None,
-        retry_rate_limits=not compatibility_test,
+        timeout,
     )
     message = strategy.decode_response(data, model, source_body=original_body)
     message = projection.refine_with_advisor(provider, pcfg, original_body, message, model)
@@ -146,14 +186,20 @@ def collect_anthropic_message_for_responses(
     body: dict[str, Any],
     *,
     services: AnthropicCollectionServices,
+    stream_collect: Callable[..., dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
-    """Collect one native Anthropic message for a Responses API projection."""
+    """Collect one native Anthropic message for a Responses API projection.
+
+    ``stream_collect`` reads the upstream as SSE and assembles the same message
+    object, which lets the repetition guard cut a loop off mid-generation
+    instead of paying for all of it and trimming afterwards.
+    """
 
     request = services.request
     transport = services.transport
     projection = services.projection
     body = request.normalize_thinking(provider, pcfg, body)
-    body = request.normalize_system_roles(body)
+    body = request.normalize_system_roles(provider, pcfg, body)
     body = request.cap_body(provider, pcfg, body)
     body = request.apply_options(provider, pcfg, body)
     body = request.rehydrate_thinking(provider, pcfg, body)
@@ -162,7 +208,8 @@ def collect_anthropic_message_for_responses(
     body["model"] = upstream_model
     body = request.resolve_tool_models(provider, pcfg, body)
     body = request.normalize_model_options(provider, pcfg, body, upstream_model)
-    upstream_body = request.strip_internal_metadata({**body, "stream": False})
+    streaming = stream_collect is not None
+    upstream_body = request.strip_internal_metadata({**body, "stream": streaming})
     if transport.native_compat_enabled(provider, pcfg):
         base = transport.native_base_url(provider, pcfg)
     else:
@@ -186,11 +233,14 @@ def collect_anthropic_message_for_responses(
         provider,
         pcfg,
         upstream_model,
-        stream=False,
+        stream=streaming,
     )
     try:
-        raw_response = upstream_response.read()
-        payload = json.loads(raw_response.decode("utf-8", errors="replace"))
+        if streaming:
+            payload = stream_collect(upstream_response, provider, upstream_model)
+        else:
+            raw_response = upstream_response.read()
+            payload = json.loads(raw_response.decode("utf-8", errors="replace"))
         if not isinstance(payload, dict):
             raise RuntimeError("upstream returned non-object JSON")
         payload = projection.normalize_response_thinking(provider, pcfg, payload, upstream_model)