@oneciel-ai/ciel-runtime 0.2.37 → 0.2.38

package/ciel_runtime_support/provider_responses_passthrough.py

@@ -12,7 +12,17 @@ from http.client import IncompleteRead
 from typing import Any, Callable, Mapping
 
 from .responses_usage_observer import ResponsesUsageObserver
+from .responses_cache_diagnostics import (
+    cache_trace,
+    request_cache_profile,
+    usage_with_cache_profile,
+)
 from .responses_input_compatibility import repair_replayed_response_items
+from .responses_custom_tool_bridge import (
+    ResponsesCustomToolStreamProjector,
+    project_response_payload,
+    tool_definitions,
+)
 from .remote_bridge import is_remote_bridge_request
 from .upstream_dump import dump_upstream_request
 from .upstream_error_policy import UpstreamStreamReadError
@@ -34,7 +44,7 @@ class ProviderResponsesPassthroughPorts:
     urlopen: Callable[..., Any]
     timeout_seconds: Callable[[dict[str, Any]], float]
     copy_response_headers: Callable[[Any, Any], None]
-    record_usage: Callable[[str, str, dict[str, int]], None] = (
+    record_usage: Callable[[str, str, dict[str, Any]], None] = (
         lambda _provider, _model, _usage: None
     )
     log: Callable[[str, str], Any] = lambda _level, _message: None
@@ -73,6 +83,44 @@ class ProviderResponsesPassthrough:
         )
         return self._ports.join_url(self._ports.upstream_base(provider, config), path)
 
+    def _request_headers(
+        self,
+        provider: str,
+        config: dict[str, Any],
+        inbound_headers: Any,
+        body: Mapping[str, Any],
+    ) -> dict[str, str]:
+        headers = self._ports.headers(provider, config, inbound_headers)
+        if not config.get("responses_session_cache_requires_previous_response_id"):
+            return headers
+        if str(body.get("previous_response_id") or "").strip():
+            return headers
+        filtered = {
+            name: value
+            for name, value in headers.items()
+            if str(name).casefold() != "x-dashscope-session-cache"
+        }
+        if len(filtered) != len(headers):
+            self._ports.log(
+                "INFO",
+                "provider_responses_session_cache_deferred "
+                f"provider={provider} reason=missing_previous_response_id",
+            )
+        return filtered
+
+    @staticmethod
+    def _response_headers(headers: Any, *, transformed: bool) -> Any:
+        if not transformed:
+            return headers
+        try:
+            return {
+                key: value
+                for key, value in headers.items()
+                if str(key).casefold() != "content-length"
+            }
+        except (AttributeError, TypeError):
+            return headers
+
     def forward_compact(
         self,
         handler: Any,
@@ -90,11 +138,16 @@ class ProviderResponsesPassthrough:
             upstream_body = self._ports.finalize_body(upstream_body)
         data = self._encode(upstream_body)
         url = self._endpoint(provider, config, "openai_responses_compact")
-        dump_upstream_request(url, data, self._ports.log)
+        request_headers = self._request_headers(
+            provider, config, handler.headers, upstream_body
+        )
+        dump_upstream_request(
+            url, data, self._ports.log, headers=request_headers
+        )
         request = urllib.request.Request(
             url,
             data=data,
-            headers=self._ports.headers(provider, config, handler.headers),
+            headers=request_headers,
             method="POST",
         )
         with self._ports.urlopen(
@@ -168,6 +221,9 @@ class ProviderResponsesPassthrough:
                 provider=provider,
                 model=str(current.get("model") or ""),
                 remote_bridge=remote_bridge,
+                stable_prefix_checkpoint_items=config.get(
+                    "responses_cache_checkpoint_items", 0
+                ),
             )
             if not remote_bridge:
                 compacted = self._ports.finalize_body(compacted)
@@ -228,6 +284,8 @@ class ProviderResponsesPassthrough:
         provider: str,
         config: dict[str, Any],
         upstream_body: dict[str, Any],
+        response_tools: Mapping[str, Mapping[str, Any]],
+        cache_profile: Mapping[str, Any],
     ) -> None:
         """Validate a native Responses stream before exposing it downstream."""
 
@@ -297,14 +355,33 @@ class ProviderResponsesPassthrough:
                     ) from failure
 
                 handler.send_response(getattr(response, "status", 200))
-                self._ports.copy_response_headers(handler, response.headers)
+                self._ports.copy_response_headers(
+                    handler,
+                    self._response_headers(
+                        response.headers, transformed=bool(response_tools)
+                    ),
+                )
                 handler.end_headers()
                 spool.seek(0)
+                projector = (
+                    ResponsesCustomToolStreamProjector(response_tools)
+                    if response_tools
+                    else None
+                )
                 while chunk := spool.read(65_536):
-                    handler.wfile.write(chunk)
-                    handler.wfile.flush()
+                    output = projector.feed(chunk) if projector is not None else chunk
+                    if output:
+                        handler.wfile.write(output)
+                        handler.wfile.flush()
+                if projector is not None:
+                    tail = projector.finish()
+                    if tail:
+                        handler.wfile.write(tail)
+                        handler.wfile.flush()
                 if observed:
-                    self._ports.record_usage(provider, model, observed)
+                    observation = usage_with_cache_profile(observed, cache_profile)
+                    self._ports.record_usage(provider, model, observation)
+                    self._ports.log(*cache_trace(provider, model, observation))
                 return
 
     def forward(
@@ -318,6 +395,11 @@ class ProviderResponsesPassthrough:
         upstream_body = dict(
             body if remote_bridge else repair_replayed_response_items(body)
         )
+        response_tools = (
+            tool_definitions(upstream_body)
+            if config.get("responses_custom_tools_as_functions")
+            else {}
+        )
         upstream_body["model"] = self._ports.normalize_model(
             provider, config, str(body.get("model") or "")
         )
@@ -340,11 +422,17 @@ class ProviderResponsesPassthrough:
             upstream_body,
             remote_bridge=remote_bridge,
         )
-        dump_upstream_request(url, data, self._ports.log)
+        cache_profile = request_cache_profile(upstream_body, len(data))
+        request_headers = self._request_headers(
+            provider, config, handler.headers, upstream_body
+        )
+        dump_upstream_request(
+            url, data, self._ports.log, headers=request_headers
+        )
         request = urllib.request.Request(
             url,
             data=data,
-            headers=self._ports.headers(provider, config, handler.headers),
+            headers=request_headers,
             method="POST",
         )
         if not remote_bridge and self._stream_truncation_retries(config):
@@ -354,6 +442,8 @@ class ProviderResponsesPassthrough:
                 provider,
                 config,
                 upstream_body,
+                response_tools,
+                cache_profile,
             )
             return delivery_body
         with self._ports.urlopen(
@@ -365,21 +455,46 @@ class ProviderResponsesPassthrough:
             usage = ResponsesUsageObserver()
             received_bytes = 0
             handler.send_response(getattr(response, "status", 200))
-            self._ports.copy_response_headers(handler, response.headers)
+            self._ports.copy_response_headers(
+                handler,
+                self._response_headers(
+                    response.headers, transformed=bool(response_tools)
+                ),
+            )
             handler.end_headers()
+            projector = (
+                ResponsesCustomToolStreamProjector(response_tools)
+                if response_tools and bool(upstream_body.get("stream", True))
+                else None
+            )
+            response_body = bytearray()
             try:
                 while chunk := response.read(65_536):
                     received_bytes += len(chunk)
                     usage.feed(chunk)
-                    handler.wfile.write(chunk)
-                    handler.wfile.flush()
+                    if response_tools and projector is None:
+                        response_body.extend(chunk)
+                        continue
+                    output = projector.feed(chunk) if projector is not None else chunk
+                    if output:
+                        handler.wfile.write(output)
+                        handler.wfile.flush()
             except IncompleteRead as exc:
                 partial = bytes(exc.partial or b"")
                 if partial:
                     received_bytes += len(partial)
                     usage.feed(partial)
-                    handler.wfile.write(partial)
-                    handler.wfile.flush()
+                    if response_tools and projector is None:
+                        response_body.extend(partial)
+                    else:
+                        output = (
+                            projector.feed(partial)
+                            if projector is not None
+                            else partial
+                        )
+                        if output:
+                            handler.wfile.write(output)
+                            handler.wfile.flush()
                 usage.finish()
                 if usage.terminal_event is None:
                     self._ports.log(
@@ -403,6 +518,20 @@ class ProviderResponsesPassthrough:
                     f"provider={provider} model={upstream_body.get('model')} "
                     f"terminal={usage.terminal_event} bytes={received_bytes}",
                 )
+            if projector is not None:
+                tail = projector.finish()
+                if tail:
+                    handler.wfile.write(tail)
+                    handler.wfile.flush()
+            elif response_tools:
+                try:
+                    decoded = json.loads(response_body)
+                    projected_body = project_response_payload(decoded, response_tools)
+                    handler.wfile.write(self._encode(projected_body))
+                    handler.wfile.flush()
+                except (UnicodeDecodeError, ValueError, TypeError):
+                    handler.wfile.write(response_body)
+                    handler.wfile.flush()
             observed = usage.finish()
             if bool(upstream_body.get("stream", True)) and usage.terminal_event is None:
                 error = EOFError("upstream Responses stream ended without a terminal event")
@@ -422,10 +551,18 @@ class ProviderResponsesPassthrough:
                     received_bytes=received_bytes,
                 ) from error
             if observed and not remote_bridge:
+                observation = usage_with_cache_profile(observed, cache_profile)
                 self._ports.record_usage(
                     provider,
                     str(upstream_body.get("model") or ""),
-                    observed,
+                    observation,
+                )
+                self._ports.log(
+                    *cache_trace(
+                        provider,
+                        str(upstream_body.get("model") or ""),
+                        observation,
+                    )
                 )
         return delivery_body
 

package/ciel_runtime_support/providers/alibaba.py

@@ -19,6 +19,7 @@ from .base import HttpBearerProviderAdapter, provider_configuration
 
 
 QWEN38_MAX_MODEL = "qwen3.8-max"
+QWEN38_MAX_SNAPSHOT_MODEL = "qwen3.8-max-0902"
 QWEN38_MAX_PREVIEW_MODEL = "qwen3.8-max-preview"
 QWEN38_CONTEXT_WINDOW = 1_000_000
 QWEN38_MAX_INPUT = 991_808
@@ -40,10 +41,15 @@ QWEN38_CODEX_CATALOG = {
     "experimental_supported_tools": [],
     "truncation_policy": {"mode": "bytes", "limit": 10_000},
     "supported_reasoning_levels": [
+        {"effort": "none", "description": "Disable reasoning"},
+        {"effort": "minimal", "description": "Minimal reasoning for fastest responses"},
         {"effort": "low", "description": "Fast responses with lighter reasoning"},
         {"effort": "medium", "description": "Greater reasoning depth for complex problems"},
+        {"effort": "high", "description": "High reasoning depth for complex problems"},
         {"effort": "xhigh", "description": "Extra high reasoning depth for complex problems"},
+        {"effort": "max", "description": "Maximum reasoning depth"},
     ],
+    "default_reasoning_level": "xhigh",
 }
 QWEN37_MAX_MODEL = "qwen3.7-max"
 QWEN37_CONTEXT_WINDOW = 1_000_000
@@ -84,6 +90,7 @@ ALIBABA_CODING_PLAN_MODELS = (
 )
 ALIBABA_MODEL_STUDIO_MODELS = (
     QWEN38_MAX_MODEL,
+    QWEN38_MAX_SNAPSHOT_MODEL,
     QWEN37_MAX_MODEL,
     "qwen3.7-plus",
     "qwen3.6-plus",
@@ -173,6 +180,11 @@ class AlibabaModelStudioProviderAdapter(HttpBearerProviderAdapter):
             effort_level="xhigh",
             explicit_cache=True,
             explicit_cache_markers=4,
+            protocol_headers={
+                "openai_responses": {
+                    "x-dashscope-session-cache": "enable",
+                },
+            },
             haiku_model="qwen3.6-flash",
             opus_model=QWEN38_MAX_MODEL,
             sonnet_model="qwen3.7-plus",
@@ -204,6 +216,9 @@ class AlibabaModelStudioProviderAdapter(HttpBearerProviderAdapter):
             fallback_models=ALIBABA_MODEL_STUDIO_MODELS,
             allow_configured_fallback=True,
             authoritative_upstream_catalog=True,
+            supplemental_model_aliases=(
+                (QWEN38_MAX_MODEL, QWEN38_MAX_SNAPSHOT_MODEL),
+            ),
         )
     )
 
@@ -402,7 +417,7 @@ class AlibabaModelStudioProviderAdapter(HttpBearerProviderAdapter):
             projected = dict(reasoning)
             effort = str(projected.get("effort") or "xhigh").strip().lower()
             projected["effort"] = (
-                cls._normalize_qwen38_effort(effort)
+                cls._normalize_qwen38_responses_effort(effort)
                 if cls._is_qwen38(model)
                 else effort if effort in _EFFORTS else "xhigh"
             )
@@ -505,6 +520,11 @@ class AlibabaModelStudioProviderAdapter(HttpBearerProviderAdapter):
             return "none"
         return "xhigh"
 
+    @staticmethod
+    def _normalize_qwen38_responses_effort(value: Any) -> str:
+        effort = str(value or "xhigh").strip().lower()
+        return effort if effort in _EFFORTS else "xhigh"
+
     @classmethod
     def _apply_explicit_cache_markers(
         cls, messages: list[Any], configured_limit: Any
@@ -687,11 +707,23 @@ class AlibabaTokenPlanProviderAdapter(AlibabaModelStudioProviderAdapter):
             codex_auto_compact_window=QWEN38_AUTO_COMPACT,
             request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
             responses_stream_truncation_retries=1,
+            # Alibaba documents this header together with a response-id-linked
+            # session. Stateless Codex replay uses the model's implicit prefix
+            # cache until Ciel has a validated previous_response_id chain.
+            responses_session_cache_requires_previous_response_id=True,
+            # Keep the summarized Responses prefix byte-stable across several
+            # appended Codex tool turns so Alibaba can reuse its session cache.
+            responses_cache_checkpoint_items=24,
             stream_enabled=True,
             stream_word_chunking=False,
             effort_level="xhigh",
             explicit_cache=True,
             explicit_cache_markers=4,
+            protocol_headers={
+                "openai_responses": {
+                    "x-dashscope-session-cache": "enable",
+                },
+            },
             haiku_model="qwen3.6-flash",
             opus_model=QWEN38_MAX_MODEL,
             sonnet_model="qwen3.7-plus",
@@ -765,6 +797,7 @@ __all__ = [
     "QWEN38_CONTEXT_WINDOW",
     "QWEN38_MAX_INPUT",
     "QWEN38_MAX_MODEL",
+    "QWEN38_MAX_SNAPSHOT_MODEL",
     "QWEN38_MAX_OUTPUT",
     "QWEN38_MAX_REASONING",
     "QWEN38_THINKING_MAX_INPUT",

package/ciel_runtime_support/providers/anthropic.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+import re
 from typing import Any, Mapping
 
 from ..architecture import (
@@ -17,6 +18,7 @@ from ..architecture import (
 )
 from .base import NoAuthProviderAdapter, provider_configuration
 from .constants import PROVIDER_DEFAULT_BASE_URLS
+from ..runtime_constants import ANTHROPIC_ONE_MILLION_MODEL_IDS
 
 
 @dataclass(frozen=True)
@@ -25,7 +27,9 @@ class AnthropicProviderAdapter(NoAuthProviderAdapter):
     base_url: str = PROVIDER_DEFAULT_BASE_URLS["anthropic"]
     configuration_defaults_value: dict = field(
         default_factory=lambda: provider_configuration(
-            "claude-sonnet-4-6", route_through_router=False
+            "claude-opus-5[1m]",
+            custom_models=ANTHROPIC_ONE_MILLION_MODEL_IDS,
+            route_through_router=False,
         )
     )
     capabilities_value: ProviderCapabilities = field(
@@ -50,6 +54,19 @@ class AnthropicProviderAdapter(NoAuthProviderAdapter):
         default_factory=lambda: ProviderModelCatalogPolicy(kind="anthropic")
     )
 
+    def normalize_model_id(self, model_id: str) -> str:
+        text = str(model_id or "").strip()
+        base = re.sub(r"\[1m\]\s*$", "", text, flags=re.IGNORECASE).strip()
+        return f"{base}[1m]" if base and re.search(r"\[1m\]\s*$", text, re.IGNORECASE) else base
+
+    def upstream_api_model_id(self, model_id: str) -> str:
+        return re.sub(
+            r"\[1m\]\s*$", "", str(model_id or "").strip(), flags=re.IGNORECASE
+        ).strip()
+
+    def preserves_claude_context_suffix_in_alias(self) -> bool:
+        return True
+
     def advisor_panel_notice(
         self, config: ProviderConfig
     ) -> tuple[tuple[str, ...], tuple[str, ...]]: