@oneciel-ai/ciel-runtime 0.2.22 → 0.2.23

package/ciel_runtime_support/event_settings_cli.py

@@ -13,6 +13,8 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from typing import Any, Callable
+import os
+import time
 import urllib.parse
 from pathlib import PurePosixPath
 
@@ -32,6 +34,39 @@ EXTERNAL_EVENT_KEYS = (
     "webhook_secret",
     "authorization",
 )
+TRANSCRIPT_EVENT_KEYS = (
+    "enabled",
+    "url",
+    "authorization",
+    "timeout_seconds",
+    "poll_interval_ms",
+    "max_batch_bytes",
+    "start_mode",
+)
+TRANSCRIPT_EVENT_LIMITS = {
+    "timeout_seconds": (1, 30),
+    "poll_interval_ms": (100, 60_000),
+    "max_batch_bytes": (1_024, 16_777_216),
+}
+USAGE_EVENT_KEYS = (
+    "endpoint_id",
+    "enabled",
+    "url",
+    "authorization",
+    "api_key",
+    "timeout_seconds",
+    "poll_interval_seconds",
+    "start_mode",
+    "audit_interval_seconds",
+    "audit_emit_on_start",
+    "jsonl_enabled",
+    "backfill_paths",
+)
+USAGE_EVENT_LIMITS = {
+    "timeout_seconds": (1, 30),
+    "poll_interval_seconds": (1, 60),
+    "audit_interval_seconds": (1, 31_536_000),
+}
 REMOTE_INSTRUCTION_URL_KEYS = (
     "claude_url",
     "codex_url",
@@ -63,7 +98,7 @@ REMOTE_MEMORY_LIMITS = {
     "max_total_bytes": (1_024, 134_217_728),
     "max_files": (1, 2_048),
 }
-_SECRET_KEYS = frozenset({"webhook_secret", "authorization"})
+_SECRET_KEYS = frozenset({"webhook_secret", "authorization", "api_key"})
 
 
 class EventSettingsCliError(ValueError):
@@ -116,6 +151,7 @@ class EventSettingsCliPorts:
     sync_instructions: Callable[[], list[str]]
     sync_memories: Callable[[], list[str]]
     output: Callable[[str], None]
+    usage_keys: Callable[[], Any] = lambda: None
 
 
 @dataclass(frozen=True, slots=True)
@@ -186,6 +222,247 @@ class EventSettingsCli:
         service.save_receiver(self.receiver_id, body)
         self._confirm("external-events", changed)
 
+    # -- transcript events ------------------------------------------------
+
+    def _transcript_event_settings(self) -> dict[str, Any]:
+        value = self.ports.load_config().get("transcript_events")
+        return value if isinstance(value, dict) else {}
+
+    def transcript_event_values(self) -> dict[str, Any]:
+        current = self._transcript_event_settings()
+        return {
+            "enabled": bool(current.get("enabled", False)),
+            "url": str(current.get("url") or ""),
+            "authorization": "stored" if current.get("authorization") else "unset",
+            "timeout_seconds": current.get("timeout_seconds") or 5,
+            "poll_interval_ms": current.get("poll_interval_ms") or 1000,
+            "max_batch_bytes": current.get("max_batch_bytes") or 1_048_576,
+            "start_mode": str(current.get("start_mode") or "tail"),
+        }
+
+    def transcript_events(self, args: Any) -> None:
+        tokens = [str(value) for value in (getattr(args, "values", None) or [])]
+        if not tokens:
+            self._report("transcript-events", self.transcript_event_values())
+            return
+        current = dict(self._transcript_event_settings())
+        updates: dict[str, Any] = {}
+        changed: list[str] = []
+        for token in tokens:
+            key, value = split_assignment(token)
+            if key not in TRANSCRIPT_EVENT_KEYS:
+                raise EventSettingsCliError(
+                    f"unsupported transcript event option: {key}; expected one of "
+                    f"{', '.join(TRANSCRIPT_EVENT_KEYS)}"
+                )
+            if key == "enabled":
+                updates[key] = parse_flag(key, value)
+            elif key == "url":
+                updates[key] = _validated_url(key, value)
+            elif key in TRANSCRIPT_EVENT_LIMITS:
+                minimum, maximum = TRANSCRIPT_EVENT_LIMITS[key]
+                try:
+                    parsed = int(value.strip())
+                except ValueError:
+                    raise EventSettingsCliError(
+                        f"{key} must be a whole number from {minimum} to {maximum}"
+                    ) from None
+                if not minimum <= parsed <= maximum:
+                    raise EventSettingsCliError(
+                        f"{key} must be a whole number from {minimum} to {maximum}"
+                    )
+                updates[key] = parsed
+            elif key == "start_mode":
+                mode = value.strip().lower()
+                if mode not in {"tail", "beginning"}:
+                    raise EventSettingsCliError(
+                        "start_mode must be tail or beginning"
+                    )
+                updates[key] = mode
+            else:
+                updates[key] = value
+            changed.append(key)
+        resulting = {**current, **updates}
+        if resulting.get("enabled") and not str(resulting.get("url") or "").strip():
+            raise EventSettingsCliError(
+                "transcript-events requires url when enabled=true"
+            )
+        config = self.ports.load_config()
+        stored = config.get("transcript_events")
+        if not isinstance(stored, dict):
+            stored = {}
+            config["transcript_events"] = stored
+        stored.update(updates)
+        self.ports.save_config(config)
+        self._confirm("transcript-events", changed)
+
+    # -- usage events -----------------------------------------------------
+
+    def _usage_settings(self) -> dict[str, Any]:
+        value = self.ports.load_config().get("usage")
+        return value if isinstance(value, dict) else {}
+
+    def _usage_endpoint(self, endpoint_id: str) -> dict[str, Any]:
+        endpoints = self._usage_settings().get("push_endpoints")
+        for endpoint in endpoints if isinstance(endpoints, list) else []:
+            if isinstance(endpoint, dict) and str(endpoint.get("id") or "") == endpoint_id:
+                return dict(endpoint)
+        return {"id": endpoint_id, "enabled": False}
+
+    def usage_event_values(self, endpoint_id: str = "default") -> dict[str, Any]:
+        current = self._usage_endpoint(endpoint_id)
+        settings = self._usage_settings()
+        return {
+            "endpoint_id": endpoint_id,
+            "enabled": bool(current.get("enabled", False)),
+            "url": str(current.get("url") or ""),
+            "authorization": "stored" if current.get("authorization") else "unset",
+            "api_key": "stored" if current.get("api_key") else "unset",
+            "timeout_seconds": current.get("timeout_seconds") or 5,
+            "poll_interval_seconds": current.get("poll_interval_seconds") or 1,
+            "start_mode": str(current.get("start_mode") or "tail"),
+            "audit_interval_seconds": current.get("audit_interval_seconds") or 86400,
+            "audit_emit_on_start": bool(current.get("audit_emit_on_start", True)),
+            "jsonl_enabled": bool(settings.get("jsonl_enabled", True)),
+            "backfill_paths": os.pathsep.join(str(path) for path in (settings.get("backfill_paths") or [])),
+        }
+
+    def usage_events(self, args: Any) -> None:
+        tokens = [str(value) for value in (getattr(args, "values", None) or [])]
+        endpoint_id = "default"
+        for token in tokens:
+            key, value = split_assignment(token)
+            if key == "endpoint_id":
+                endpoint_id = value.strip() or "default"
+        if not tokens or all(split_assignment(token)[0] == "endpoint_id" for token in tokens):
+            self._report("usage-events", self.usage_event_values(endpoint_id))
+            return
+        current = self._usage_endpoint(endpoint_id)
+        updates: dict[str, Any] = {"id": endpoint_id}
+        changed: list[str] = []
+        backfill_paths: list[str] | None = None
+        jsonl_enabled: bool | None = None
+        for token in tokens:
+            key, value = split_assignment(token)
+            if key not in USAGE_EVENT_KEYS:
+                raise EventSettingsCliError(
+                    f"unsupported usage event option: {key}; expected one of {', '.join(USAGE_EVENT_KEYS)}"
+                )
+            if key == "endpoint_id":
+                continue
+            if key in {"enabled", "audit_emit_on_start"}:
+                updates[key] = parse_flag(key, value)
+            elif key == "jsonl_enabled":
+                jsonl_enabled = parse_flag(key, value)
+            elif key == "url":
+                updates[key] = _validated_url(key, value)
+            elif key in USAGE_EVENT_LIMITS:
+                minimum, maximum = USAGE_EVENT_LIMITS[key]
+                try:
+                    parsed = int(value.strip())
+                except ValueError:
+                    raise EventSettingsCliError(
+                        f"{key} must be a whole number from {minimum} to {maximum}"
+                    ) from None
+                if not minimum <= parsed <= maximum:
+                    raise EventSettingsCliError(
+                        f"{key} must be a whole number from {minimum} to {maximum}"
+                    )
+                updates[key] = parsed
+            elif key == "start_mode":
+                mode = value.strip().lower()
+                if mode not in {"tail", "beginning"}:
+                    raise EventSettingsCliError("start_mode must be tail or beginning")
+                updates[key] = mode
+            elif key == "backfill_paths":
+                backfill_paths = [path.strip() for path in value.split(os.pathsep) if path.strip()]
+            else:
+                updates[key] = value
+            changed.append(key)
+        resulting = {**current, **updates}
+        if resulting.get("enabled") and not str(resulting.get("url") or "").strip():
+            raise EventSettingsCliError("usage-events requires url when enabled=true")
+        config = self.ports.load_config()
+        settings = config.get("usage")
+        if not isinstance(settings, dict):
+            settings = {}
+            config["usage"] = settings
+        endpoints = settings.get("push_endpoints")
+        stored_endpoints = [dict(item) for item in endpoints if isinstance(item, dict)] if isinstance(endpoints, list) else []
+        stored_endpoints = [item for item in stored_endpoints if str(item.get("id") or "") != endpoint_id]
+        stored_endpoints.append(resulting)
+        settings["push_endpoints"] = stored_endpoints
+        if backfill_paths is not None:
+            settings["backfill_paths"] = backfill_paths
+        if jsonl_enabled is not None:
+            settings["jsonl_enabled"] = jsonl_enabled
+        self.ports.save_config(config)
+        self._confirm("usage-events", changed)
+
+    def usage_api_key(self, args: Any) -> None:
+        tokens = [str(value) for value in (getattr(args, "values", None) or [])]
+        repository = self.ports.usage_keys()
+        if repository is None:
+            raise EventSettingsCliError("usage API key repository is unavailable")
+        action = "list"
+        assignments: dict[str, str] = {}
+        for index, token in enumerate(tokens):
+            key, value = split_assignment(token, bare_keys=("list", "issue", "revoke"))
+            if index == 0 and key in {"list", "issue", "revoke"}:
+                action = key
+            else:
+                assignments[key] = value
+        if action == "list":
+            rows = repository.list()
+            self.ports.output("usage-api-key:")
+            for row in rows:
+                self.ports.output(
+                    f"  {row['key_id']} name={row['name']} scopes={','.join(row['scopes'])} "
+                    f"expires_at={row['expires_at']} revoked_at={row['revoked_at']}"
+                )
+            if not rows:
+                self.ports.output("  none")
+            return
+        if action == "revoke":
+            key_id = assignments.get("key_id", "").strip()
+            if not key_id:
+                raise EventSettingsCliError("usage-api-key revoke requires key_id=<id>")
+            self.ports.output(f"usage-api-key revoked: {key_id} ok={repository.revoke(key_id)}")
+            return
+        allowed = {"name", "scopes", "ttl_seconds", "expires_at", "api_key", "key_id"}
+        unknown = sorted(set(assignments) - allowed)
+        if unknown:
+            raise EventSettingsCliError(f"unsupported usage API key option: {unknown[0]}")
+        scopes = []
+        for scope in assignments.get("scopes", "read,stream").split(","):
+            normalized = scope.strip().lower()
+            if normalized in {"read", "usage:read"}:
+                scopes.append("usage:read")
+            elif normalized in {"stream", "usage:stream"}:
+                scopes.append("usage:stream")
+            elif normalized:
+                raise EventSettingsCliError(f"unsupported usage API key scope: {scope}")
+        try:
+            ttl = int(assignments.get("ttl_seconds", "0") or 0)
+        except ValueError:
+            raise EventSettingsCliError("ttl_seconds must be a non-negative whole number") from None
+        if ttl < 0:
+            raise EventSettingsCliError("ttl_seconds must be a non-negative whole number")
+        try:
+            expires_at = float(assignments.get("expires_at", "0") or 0)
+        except ValueError:
+            raise EventSettingsCliError("expires_at must be a non-negative epoch timestamp") from None
+        if expires_at < 0:
+            raise EventSettingsCliError("expires_at must be a non-negative epoch timestamp")
+        result = repository.issue(
+            assignments.get("name", "usage-consumer"), scopes,
+            expires_at or (time.time() + ttl if ttl else 0),
+            secret=assignments.get("api_key", ""), key_id=assignments.get("key_id", ""),
+        )
+        self.ports.output(f"usage-api-key issued: key_id={result['key_id']}")
+        self.ports.output(f"  api_key={result['api_key']}")
+        self.ports.output(f"  scopes={','.join(result['scopes'])}")
+
     # -- remote instructions -----------------------------------------------
 
     def _remote_settings(self) -> dict[str, Any]:
@@ -377,11 +654,14 @@ def _guarded(handler: Callable[[Any], None]) -> Callable[[Any], None]:
 
 
 def handlers(ports: EventSettingsCliPorts) -> tuple[Callable[[Any], None], ...]:
-    """Return external-event, remote-instruction, and remote-memory handlers."""
+    """Return event, usage, instruction, and memory handlers."""
 
     controller = EventSettingsCli(ports)
     return (
         _guarded(controller.external_events),
+        _guarded(controller.transcript_events),
+        _guarded(controller.usage_events),
+        _guarded(controller.usage_api_key),
         _guarded(controller.remote_instructions),
         _guarded(controller.remote_memory),
     )
@@ -389,6 +669,8 @@ def handlers(ports: EventSettingsCliPorts) -> tuple[Callable[[Any], None], ...]:
 
 __all__ = [
     "EXTERNAL_EVENT_KEYS",
+    "TRANSCRIPT_EVENT_KEYS",
+    "USAGE_EVENT_KEYS",
     "REMOTE_MEMORY_KEYS",
     "REMOTE_INSTRUCTION_KEYS",
     "REMOTE_INSTRUCTION_URL_KEYS",

package/ciel_runtime_support/openai_chat_passthrough.py

@@ -18,6 +18,7 @@ class OpenAIChatPassthroughPorts:
     urlopen: Callable[..., Any]
     timeout_seconds: Callable[[dict[str, Any]], float]
     copy_response_headers: Callable[[Any, Any], None]
+    finalize_body: Callable[[dict[str, Any]], dict[str, Any]] = lambda body: body
 
 
 class OpenAIChatPassthrough:
@@ -40,6 +41,7 @@ class OpenAIChatPassthrough:
         upstream_body = dict(
             self._ports.normalize_request(provider, config, upstream_body)
         )
+        upstream_body = self._ports.finalize_body(upstream_body)
         url = self._ports.join_url(
             self._ports.upstream_base(provider, config),
             "/v1/chat/completions",

package/ciel_runtime_support/protocols/openai_responses.py

@@ -175,6 +175,7 @@ def openai_responses_to_anthropic_messages(body: dict[str, Any], fallback_model:
         raw_input = []
     saw_conversation_item = False
     pending_reasoning = ""
+    pending_tool_role = ""
     for item in raw_input:
         if not isinstance(item, dict):
             continue
@@ -200,30 +201,33 @@ def openai_responses_to_anthropic_messages(body: dict[str, Any], fallback_model:
                     ),
                 }
             )
-            messages.append(
-                {
-                    "role": "assistant",
-                    "content": content,
-                }
-            )
+            if pending_tool_role == "assistant" and messages:
+                messages[-1]["content"].extend(content)
+            else:
+                messages.append(
+                    {
+                        "role": "assistant",
+                        "content": content,
+                    }
+                )
+            pending_tool_role = "assistant"
             saw_conversation_item = True
             continue
         if item_type in {"function_call_output", "custom_tool_call_output"}:
             call_id = str(item.get("call_id") or item.get("id") or "call_tool")
-            messages.append(
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "tool_result",
-                            "tool_use_id": call_id,
-                            "content": _content_text(item.get("output")),
-                        }
-                    ],
-                }
-            )
+            result = {
+                "type": "tool_result",
+                "tool_use_id": call_id,
+                "content": _content_text(item.get("output")),
+            }
+            if pending_tool_role == "user" and messages:
+                messages[-1]["content"].append(result)
+            else:
+                messages.append({"role": "user", "content": [result]})
+            pending_tool_role = "user"
             saw_conversation_item = True
             continue
+        pending_tool_role = ""
         role = str(item.get("role") or "user").strip().lower()
         blocks = _content_blocks(item.get("content", item.get("text", "")))
         if not blocks:

package/ciel_runtime_support/provider_adapters.py

@@ -19,6 +19,7 @@ from .providers.constants import PROVIDER_DEFAULT_BASE_URLS, ZAI_MODEL_FALLBACK_
 from .providers.native import AgyProviderAdapter, CodexProviderAdapter
 from .providers.ollama import OllamaCloudProviderAdapter, OllamaProviderAdapter
 from .providers.openrouter import OpenRouterProviderAdapter
+from .providers.tabitoken import TabitokenProviderAdapter
 from .providers.lm_studio import LMStudioProviderAdapter
 from .providers.nim import SelfHostedNimProviderAdapter
 from .providers.nvidia import NvidiaHostedProviderAdapter
@@ -64,6 +65,12 @@ PROVIDER_DESCRIPTORS = ProviderDescriptorRegistry(
         ProviderDescriptor("nvidia-hosted", "Nvidia Hosted", NvidiaHostedProviderAdapter),
         ProviderDescriptor("self-hosted-nim", "Self Hosted NIM", SelfHostedNimProviderAdapter),
         ProviderDescriptor("openrouter", "OpenRouter", OpenRouterProviderAdapter),
+        ProviderDescriptor(
+            "tabitoken",
+            "TaBiAI (Tabitoken.com)",
+            TabitokenProviderAdapter,
+            aliases=("tabi", "tabiai", "tabi-token"),
+        ),
         ProviderDescriptor("xai", "xAI", XaiProviderAdapter, aliases=("grok",)),
         ProviderDescriptor("fireworks", "Fireworks.ai", FireworksProviderAdapter),
         ProviderDescriptor(

package/ciel_runtime_support/provider_policy.py

@@ -72,6 +72,7 @@ class ProviderRequestServices:
     normalize_tool_choice_for_provider: Callable[..., Any]
     provider_wire_profile: Callable[..., Any]
     sanitize_assistant_pseudo_tool_text_history: Callable[..., Any]
+    sanitize_invalid_anthropic_tool_history: Callable[..., Any]
 
 
 def normalize_provider_request(provider: str, pcfg: dict[str, Any], body: dict[str, Any],
@@ -87,10 +88,18 @@ def normalize_provider_request(provider: str, pcfg: dict[str, Any], body: dict[s
     normalize_tool_choice_for_provider = services.normalize_tool_choice_for_provider
     provider_wire_profile = services.provider_wire_profile
     sanitize_assistant_pseudo_tool_text_history = services.sanitize_assistant_pseudo_tool_text_history
+    sanitize_invalid_anthropic_tool_history = services.sanitize_invalid_anthropic_tool_history
     profile = provider_wire_profile(provider, pcfg, body)
     out = normalize_thinking_for_non_anthropic_provider(provider, pcfg, body)
-    out = apply_provider_adapter_request_policy(provider, pcfg, out)
+    selected_protocol = str(profile.get("upstream_format") or "").replace("-", "_")
+    out = apply_provider_adapter_request_policy(
+        provider,
+        pcfg,
+        out,
+        selected_protocol or None,
+    )
     out = normalize_tool_choice_for_provider(provider, pcfg, out)
+    out = sanitize_invalid_anthropic_tool_history(out)
     out = sanitize_assistant_pseudo_tool_text_history(out)
     out = normalize_anthropic_tool_turns_for_provider(provider, pcfg, out)
     if profile.get("upstream_format") == "anthropic-messages":

package/ciel_runtime_support/provider_request_builder.py

@@ -50,6 +50,9 @@ class ProviderOptionPorts:
     sampling_options: tuple[str, ...]
     anthropic_runtime_hints: Callable[[str], dict[str, Any]]
     log: Callable[[str, str], None]
+    finalize_messages: Callable[[list[dict[str, Any]]], list[dict[str, Any]]] = (
+        lambda messages: messages
+    )
 
 
 class ProviderRequestBuilder:
@@ -198,7 +201,7 @@ class ProviderRequestBuilder:
             configured,
             _token_cache=token_cache,
         )
-        return self.ollama.apply_optional(
+        request = self.ollama.apply_optional(
             request,
             provider,
             model,
@@ -206,6 +209,8 @@ class ProviderRequestBuilder:
             body,
             output_limit=num_predict,
         )
+        request["messages"] = self.options.finalize_messages(request["messages"])
+        return request
 
     def openai_chat(
         self,
@@ -255,7 +260,9 @@ class ProviderRequestBuilder:
         for key in ("temperature", "top_p"):
             if self.openai.sampling_allowed(provider, config) and config.get(key) is not None:
                 request[key] = config[key]
-        return self.openai.normalize_request(provider, config, request)
+        normalized = self.openai.normalize_request(provider, config, request)
+        normalized["messages"] = self.options.finalize_messages(normalized["messages"])
+        return normalized
 
 
 @dataclass(frozen=True, slots=True)

package/ciel_runtime_support/provider_responses_passthrough.py

@@ -44,6 +44,7 @@ class ProviderResponsesPassthroughPorts:
     compact_responses: Callable[..., dict[str, Any]] = (
         lambda body, _budget, **_kwargs: body
     )
+    finalize_body: Callable[[dict[str, Any]], dict[str, Any]] = lambda body: body
 
 
 class ProviderResponsesPassthrough:
@@ -65,6 +66,7 @@ class ProviderResponsesPassthrough:
         upstream_body["model"] = self._ports.normalize_model(
             provider, config, str(body.get("model") or "")
         )
+        upstream_body = self._ports.finalize_body(upstream_body)
         data = self._encode(upstream_body)
         url = self._ports.join_url(
             self._ports.upstream_base(provider, config),
@@ -127,6 +129,7 @@ class ProviderResponsesPassthrough:
                 provider=provider,
                 model=str(current.get("model") or ""),
             )
+            compacted = self._ports.finalize_body(compacted)
             compacted_data = self._encode(compacted)
             self._ports.log(
                 "WARN",
@@ -280,6 +283,7 @@ class ProviderResponsesPassthrough:
         upstream_body, delivery_body = self._ports.project_channel_context(
             upstream_body
         )
+        upstream_body = self._ports.finalize_body(upstream_body)
         self._ports.begin_channel_delivery(handler, delivery_body)
         url = self._ports.join_url(
             self._ports.upstream_base(provider, config),

package/ciel_runtime_support/providers/__init__.py

@@ -10,6 +10,7 @@ from .constants import PROVIDER_DEFAULT_BASE_URLS, ZAI_MODEL_FALLBACK_IDS
 from .native import AgyProviderAdapter, CodexProviderAdapter
 from .ollama import OllamaCloudProviderAdapter, OllamaProviderAdapter
 from .openrouter import OpenRouterProviderAdapter
+from .tabitoken import TabitokenProviderAdapter
 from .lm_studio import LMStudioProviderAdapter
 from .nim import SelfHostedNimProviderAdapter
 from .nvidia import NvidiaHostedProviderAdapter
@@ -56,6 +57,7 @@ __all__ = [
     "OllamaCloudProviderAdapter",
     "OllamaProviderAdapter",
     "OpenRouterProviderAdapter",
+    "TabitokenProviderAdapter",
     "LMStudioProviderAdapter",
     "NvidiaHostedProviderAdapter",
     "SelfHostedNimProviderAdapter",

package/ciel_runtime_support/providers/alibaba.py

@@ -20,13 +20,16 @@ from .base import HttpBearerProviderAdapter, provider_configuration
 
 QWEN38_MAX_MODEL = "qwen3.8-max"
 QWEN38_MAX_PREVIEW_MODEL = "qwen3.8-max-preview"
-QWEN38_CONTEXT_WINDOW = 1_048_576
+QWEN38_CONTEXT_WINDOW = 1_000_000
+QWEN38_MAX_INPUT = 991_808
+QWEN38_THINKING_MAX_INPUT = 983_616
 QWEN38_MAX_OUTPUT = 131_072
+QWEN38_MAX_REASONING = 262_144
 QWEN38_AUTO_COMPACT = 900_000
 ALIBABA_TOKEN_PLAN_RESPONSES_MAX_BYTES = 10 * 1024 * 1024
 QWEN38_CODEX_CATALOG = {
-    "context_window": 983_616,
-    "max_context_window": 983_616,
+    "context_window": QWEN38_THINKING_MAX_INPUT,
+    "max_context_window": QWEN38_THINKING_MAX_INPUT,
     "effective_context_window_percent": 95,
     "supports_parallel_tool_calls": False,
     "supports_image_detail_original": True,
@@ -58,6 +61,7 @@ ALIBABA_CODING_PLAN_MODELS = (
     "glm-4.7",
 )
 ALIBABA_MODEL_STUDIO_MODELS = (
+    QWEN38_MAX_MODEL,
     QWEN37_MAX_MODEL,
     "qwen3.7-plus",
     "qwen3.6-plus",
@@ -119,32 +123,33 @@ _EFFORTS = ("none", "minimal", "low", "medium", "high", "xhigh", "max")
 
 @dataclass(frozen=True)
 class AlibabaModelStudioProviderAdapter(HttpBearerProviderAdapter):
-    """Preserve Qwen Responses features while supporting Claude via Chat."""
+    """Expose Qwen's OpenAI and native Anthropic-compatible wire surfaces."""
 
     name: str = "alims-intl"
     base_url: str = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
     configuration_defaults_value: dict = field(
         default_factory=lambda: provider_configuration(
-            QWEN37_MAX_MODEL,
+            QWEN38_MAX_MODEL,
             custom_models=ALIBABA_MODEL_STUDIO_MODELS,
             native_compat=True,
             supports_tool_choice=True,
-            context_window=QWEN37_CONTEXT_WINDOW,
-            max_model_len=QWEN37_CONTEXT_WINDOW,
-            max_output_tokens=QWEN37_MAX_OUTPUT,
+            context_window=QWEN38_CONTEXT_WINDOW,
+            max_model_len=QWEN38_CONTEXT_WINDOW,
+            max_output_tokens=QWEN38_MAX_OUTPUT,
             context_reserve_tokens=8192,
             auto_compact_window=QWEN38_AUTO_COMPACT,
             codex_auto_compact_window=QWEN38_AUTO_COMPACT,
             request_timeout_ms=DEFAULT_REQUEST_TIMEOUT_MS,
             stream_enabled=True,
             stream_word_chunking=False,
-            effort_level="high",
+            effort_level="xhigh",
             explicit_cache=True,
             explicit_cache_markers=4,
             haiku_model="qwen3.6-flash",
-            opus_model=QWEN37_MAX_MODEL,
+            opus_model=QWEN38_MAX_MODEL,
             sonnet_model="qwen3.7-plus",
             subagent_model="qwen3.7-plus",
+            region="ap-southeast-1",
         )
     )
     authorization_header: str = "authorization"
@@ -155,6 +160,7 @@ class AlibabaModelStudioProviderAdapter(HttpBearerProviderAdapter):
         default_factory=lambda: ProviderCapabilities(
             upstream_protocol="openai_responses",
             supports_thinking=True,
+            preserves_anthropic_thinking=True,
             requires_api_key=True,
         )
     )
@@ -282,6 +288,20 @@ class AlibabaModelStudioProviderAdapter(HttpBearerProviderAdapter):
             self._normalize_chat(config, normalized, model)
         return normalized
 
+    def normalize_request_options_for_protocol(
+        self,
+        config: ProviderConfig,
+        request: Mapping[str, Any],
+        protocol: MessageProtocol | None,
+    ) -> Mapping[str, Any]:
+        if protocol == "anthropic_messages":
+            # Alibaba's /apps/anthropic endpoint accepts the Anthropic Messages
+            # body directly. In particular, max_tokens and thinking must not be
+            # rewritten as OpenAI Chat fields merely because both formats use a
+            # top-level messages array.
+            return deepcopy(request)
+        return self.normalize_request_options(config, request)
+
     def openai_reasoning_effort(
         self, config: ProviderConfig, model: str, request: Mapping[str, Any]
     ) -> str | None:
@@ -640,6 +660,9 @@ __all__ = [
     "AlibabaTokenPlanProviderAdapter",
     "QWEN38_AUTO_COMPACT",
     "QWEN38_CONTEXT_WINDOW",
+    "QWEN38_MAX_INPUT",
     "QWEN38_MAX_MODEL",
     "QWEN38_MAX_OUTPUT",
+    "QWEN38_MAX_REASONING",
+    "QWEN38_THINKING_MAX_INPUT",
 ]

package/ciel_runtime_support/providers/constants.py

@@ -19,6 +19,7 @@ PROVIDER_DEFAULT_BASE_URLS: dict[str, str] = {
     "nvidia-hosted": "https://integrate.api.nvidia.com/v1",
     "self-hosted-nim": "http://127.0.0.1:8000",
     "openrouter": "https://openrouter.ai/api/v1",
+    "tabitoken": "https://tabitoken.com",
     "fireworks": "https://api.fireworks.ai/inference",
     "meta": "https://api.meta.ai/v1",
 }