@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

package/ciel_runtime_support/protocols/chat_projection.py

@@ -47,6 +47,73 @@ class OpenAiHistoryServices:
     log: Callable[[str, str], None]
 
 
+def openai_multimodal_content(content: Any, text: ChatProjectionText) -> Any:
+    if not isinstance(content, list):
+        return text.compact_text(text.content_to_text(content))
+    projected: list[dict[str, Any]] = []
+    fallback: list[Any] = []
+    for block in content:
+        if isinstance(block, dict) and block.get("type") == "text":
+            value = text.compact_text(str(block.get("text") or ""))
+            if value:
+                projected.append({"type": "text", "text": value})
+            continue
+        if isinstance(block, dict) and block.get("type") == "image":
+            source = block.get("source") if isinstance(block.get("source"), dict) else {}
+            if source.get("type") == "base64" and source.get("data"):
+                media_type = str(source.get("media_type") or "image/png")
+                projected.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:{media_type};base64,{source['data']}"},
+                    }
+                )
+                continue
+            if source.get("type") == "url" and source.get("url"):
+                projected.append(
+                    {"type": "image_url", "image_url": {"url": str(source["url"])}}
+                )
+                continue
+        fallback.append(block)
+    fallback_text = text.compact_text(text.content_to_text(fallback))
+    if fallback_text:
+        projected.append({"type": "text", "text": fallback_text})
+    return projected if any(item.get("type") == "image_url" for item in projected) else text.compact_text(text.content_to_text(content))
+
+
+def closing_system_message_indexes(
+    body: dict[str, Any], text: ChatProjectionText
+) -> set[int]:
+    """Indexes of the system messages a conversation ends on.
+
+    Anthropic lets a client hand over input that arrived while a turn was still
+    running as a system message placed after the last turn; Claude Code delivers
+    what the user typed mid-task that way. A chat wire has no such envelope, and
+    the difference is not cosmetic: replaying a captured Claude Code request
+    against ollama-cloud/deepseek-v4-flash, the same text was acted on 0/10
+    times as the closing system message and 9/10 as a user message, while moving
+    it earlier or removing the surrounding router text changed nothing.
+
+    Only the closing run counts. A system message with further conversation
+    after it is background the model has already had a turn to act on.
+    """
+
+    messages = body.get("messages", []) or []
+    kept = [
+        index
+        for index, message in enumerate(messages)
+        if isinstance(message, dict)
+        and not text.attachment_only(message)
+        and not text.skip_message(message)
+    ]
+    closing: set[int] = set()
+    for index in reversed(kept):
+        if messages[index].get("role") != "system":
+            break
+        closing.add(index)
+    return closing
+
+
 def anthropic_messages_to_ollama(body: dict[str, Any], *, services: ChatProjectionServices) -> list[dict[str, Any]]:
     text = services.text
     tools = services.tools
@@ -57,10 +124,13 @@ def anthropic_messages_to_ollama(body: dict[str, Any], *, services: ChatProjecti
     in_plan_mode = tools.plan_mode_active(body)
     tool_names_by_id: dict[str, str] = {}
     tool_inputs_by_id: dict[str, Any] = {}
-    for message in body.get("messages", []) or []:
+    closing_system = closing_system_message_indexes(body, text)
+    for index, message in enumerate(body.get("messages", []) or []):
         if not isinstance(message, dict) or text.attachment_only(message) or text.skip_message(message):
             continue
         role = message.get("role", "user")
+        if role == "system" and index in closing_system:
+            role = "user"
         content = message.get("content", "")
         if role == "user" and isinstance(content, list):
             text_blocks: list[Any] = []
@@ -111,7 +181,13 @@ def anthropic_messages_to_ollama(body: dict[str, Any], *, services: ChatProjecti
         out: dict[str, Any] = {"role": role, "content": text.compact_text(message_text)}
         if role == "assistant" and isinstance(content, list):
             calls = []
+            thinking_parts: list[str] = []
             for block in content:
+                if isinstance(block, dict) and block.get("type") == "thinking":
+                    thinking = str(block.get("thinking") or "")
+                    if thinking:
+                        thinking_parts.append(thinking)
+                    continue
                 if isinstance(block, dict) and block.get("type") == "tool_use":
                     name = str(block.get("name") or "tool")
                     tool_id = str(block.get("id") or "")
@@ -121,6 +197,8 @@ def anthropic_messages_to_ollama(body: dict[str, Any], *, services: ChatProjecti
                     calls.append({"function": {"name": name, "arguments": block.get("input") or {}}})
             if calls:
                 out["tool_calls"] = calls
+            if thinking_parts:
+                out["thinking"] = "\n".join(thinking_parts)
         messages.append(out)
     return messages
 
@@ -169,11 +247,13 @@ def anthropic_messages_to_openai(
                     })
                 else:
                     text_blocks.append(block)
-            out: dict[str, Any] = {"role": "assistant", "content": text.compact_text(text.content_to_text(text_blocks))}
+            out: dict[str, Any] = {"role": "assistant", "content": openai_multimodal_content(text_blocks, text)}
             if reasoning_seen or reasoning_passback:
                 out["reasoning_content"] = "\n".join(reasoning_parts)
             if tool_calls:
                 out["tool_calls"] = tool_calls
+            if message.get("partial") is True:
+                out["partial"] = True
             messages.append(out)
             continue
         if role == "user" and isinstance(content, list):
@@ -207,9 +287,9 @@ def anthropic_messages_to_openai(
                     messages.append({"role": "tool", "tool_call_id": tool_id, "id": tool_id, "content": tool_text})
                 else:
                     text_blocks.append(block)
-            user_text = text.content_to_text(text_blocks)
-            if user_text:
-                messages.append({"role": "user", "content": text.compact_text(user_text)})
+            user_content = openai_multimodal_content(text_blocks, text)
+            if user_content:
+                messages.append({"role": "user", "content": user_content})
             continue
         out = {"role": role, "content": text.compact_text(text.content_to_text(content))}
         if role == "assistant" and reasoning_passback:

package/ciel_runtime_support/protocols/conversation_turn_policy.py

@@ -782,6 +782,42 @@ class ConversationTurnPolicy:
             self.latest_user_looks_like_work_request(body) and len(normalized) <= 1200
         )
 
+    def should_retry_preamble_only_turn(
+        self, body: dict[str, Any], response_text: str, tool_calls: list[dict[str, Any]]
+    ) -> bool:
+        """Detect a turn that only announces work, for clients without TaskList.
+
+        The Anthropic path recovers this by synthesizing a TaskList call, which
+        needs a tool the Codex client does not expose. Here the caller replays the
+        request with an explicit continue turn instead, so this only has to decide
+        whether the reply is an announcement rather than an answer.
+        """
+
+        if tool_calls:
+            return False
+        text = (response_text or "").strip()
+        if not text:
+            # No text and no tool call is an empty turn, handled elsewhere.
+            return False
+        if self.latest_user_is_claude_code_suggestion_mode(body):
+            return False
+        if self.plan_mode_active(body):
+            return False
+        if self.latest_tool_result_indicates_completed_work(body):
+            return False
+        # Mid-work is the signal that matters: the client already ran tools this
+        # turn. Do not test the result tool names -- WORK_CONTINUATION_RESULT_TOOLS
+        # lists Claude Code tools, and a Codex client calls exec_command/apply_patch.
+        if self.latest_user_tool_result_names(body):
+            return self.non_actionable_short_response(text)
+        if not self.latest_user_looks_like_work_request(body):
+            return False
+        if self.non_actionable_short_response(text):
+            return True
+        # Structural only: a brief reply to an explicit work request is an
+        # announcement, never a finished result. Never inspect wording or domain.
+        return len(re.sub(r"\s+", " ", text)) <= 400
+
     def should_recover_empty_end_turn_with_tasklist(
         self, body: dict[str, Any], response_text: str, tool_calls: list[dict[str, Any]]
     ) -> bool:
@@ -977,6 +1013,13 @@ class ConversationTurnCompatibilityApi:
     def should_synthesize_tasklist_for_provider(self, provider: str) -> bool:
         return self.policy_factory().should_synthesize_tasklist_for_provider(provider)
 
+    def should_retry_preamble_only_turn(
+        self, body: dict[str, Any], response_text: str, tool_calls: list[dict[str, Any]]
+    ) -> bool:
+        return self.policy_factory().should_retry_preamble_only_turn(
+            body, response_text, tool_calls
+        )
+
     def should_keep_work_alive_with_tasklist(
         self, body: dict[str, Any], response_text: str, tool_calls: list[dict[str, Any]]
     ) -> bool:

package/ciel_runtime_support/protocols/ollama_chat.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import hashlib
 from dataclasses import dataclass
 from typing import Any
 
@@ -13,6 +14,7 @@ class DecodedOllamaChatResponse:
     """Provider-neutral values decoded from one Ollama `/api/chat` response."""
 
     text: str
+    thinking: str
     tool_calls: tuple[dict[str, Any], ...]
     done_reason: str
     input_tokens: int
@@ -26,6 +28,7 @@ def decode_ollama_chat_response(data: dict[str, Any]) -> DecodedOllamaChatRespon
     calls = message.get("tool_calls") if isinstance(message, dict) else None
     return DecodedOllamaChatResponse(
         text=str(message.get("content") or ""),
+        thinking=str(message.get("thinking") or ""),
         tool_calls=tuple(call for call in (calls or []) if isinstance(call, dict)),
         done_reason=str(data.get("done_reason") or ""),
         input_tokens=max(0, int(data.get("prompt_eval_count") or 0)),
@@ -33,6 +36,32 @@ def decode_ollama_chat_response(data: dict[str, Any]) -> DecodedOllamaChatRespon
     )
 
 
+def ollama_thinking_to_anthropic_block(thinking_content: Any) -> dict[str, Any] | None:
+    """Project Ollama's native reasoning field without exposing it as visible text."""
+
+    thinking = str(thinking_content or "")
+    if not thinking:
+        return None
+    digest = hashlib.sha256(thinking.encode("utf-8", errors="replace")).hexdigest()[:24]
+    return {
+        "type": "thinking",
+        "thinking": thinking,
+        "signature": f"ciel-runtime-ollama-thinking-{digest}",
+    }
+
+
+def ollama_reasoning_only_notice(done_reason: str) -> str:
+    if done_reason == "length":
+        return (
+            "[ciel-runtime] Upstream model exhausted its output budget during reasoning "
+            "before producing text or a tool call. Retry or lower reasoning effort."
+        )
+    return (
+        "[ciel-runtime] Upstream model returned reasoning without a final answer or tool call. "
+        "Please retry or ask me to continue."
+    )
+
+
 def encode_anthropic_message(
     *,
     message_id: str,
@@ -108,4 +137,6 @@ __all__ = [
     "decode_ollama_chat_response",
     "encode_anthropic_message",
     "ollama_claude_code_reminder",
+    "ollama_reasoning_only_notice",
+    "ollama_thinking_to_anthropic_block",
 ]

package/ciel_runtime_support/protocols/ollama_response.py

@@ -9,6 +9,8 @@ from typing import Any, Callable
 @dataclass(frozen=True, slots=True)
 class OllamaResponseText:
     decode: Callable[[dict[str, Any]], Any]
+    thinking_to_block: Callable[[Any], dict[str, Any] | None]
+    reasoning_only_notice: Callable[[str], str]
     strip_thinking: Callable[[str], str]
     parse_pseudo_tools: Callable[..., tuple[str, list[dict[str, Any]]]]
     log: Callable[[str, str], Any]
@@ -22,6 +24,7 @@ class OllamaResponseTools:
     plan_mode_name: Callable[..., tuple[str | None, dict[str, Any]]]
     cap_notification_wait: Callable[..., dict[str, Any]]
     should_drop: Callable[..., bool]
+    should_drop_duplicate: Callable[..., bool]
     append_log: Callable[..., Any]
 
 
@@ -60,6 +63,9 @@ def project_ollama_response(
 ) -> dict[str, Any]:
     decoded = services.text.decode(data)
     content: list[dict[str, Any]] = []
+    thinking_block = services.text.thinking_to_block(decoded.thinking)
+    if thinking_block is not None:
+        content.append(thinking_block)
     raw_text = decoded.text
     text = services.text.strip_thinking(raw_text)
     if text != raw_text:
@@ -71,25 +77,47 @@ def project_ollama_response(
     if text:
         content.append({"type": "text", "text": text})
     tool_id_prefix = f"toolu_ollama_{services.output.timestamp_ms()}_{services.output.process_id()}"
+    repeated_completed_tool_dropped = [False]
     for index, call in enumerate(list(decoded.tool_calls) + pseudo_tool_calls):
-        tool_block = _project_tool_call(call, index, tool_id_prefix, model, source_body, services)
+        tool_block = _project_tool_call(
+            call,
+            index,
+            tool_id_prefix,
+            model,
+            source_body,
+            services,
+            repeated_completed_tool_dropped,
+        )
         if tool_block is not None:
             content.append(tool_block)
 
     emitted = [block for block in content if block.get("type") == "tool_use"]
-    recovered = _recover_response(model, source_body, text, emitted, content, tool_id_prefix, services)
+    if repeated_completed_tool_dropped[0] and not text.strip() and not emitted:
+        text = (
+            "[ciel-runtime] Stopped an identical completed tool call from repeating. "
+            "The previous result is already in context; choose a different action or finish the turn."
+        )
+        content.append({"type": "text", "text": text})
+    recovered = None
+    if thinking_block is None and not repeated_completed_tool_dropped[0]:
+        recovered = _recover_response(model, source_body, text, emitted, content, tool_id_prefix, services)
     if recovered is not None:
         return recovered
     if source_body is not None and not text.strip() and not emitted:
-        text = services.recovery.empty_notice(source_body)
+        text = (
+            services.text.reasoning_only_notice(decoded.done_reason)
+            if thinking_block is not None
+            else services.recovery.empty_notice(source_body)
+        )
         names = ",".join(services.recovery.latest_tool_result_names(source_body)) or "-"
-        services.text.log("WARN", f"ollama_empty_end_turn_notice model={model} latest_tool_results={names}")
+        event = "ollama_reasoning_only_notice" if thinking_block is not None else "ollama_empty_end_turn_notice"
+        services.text.log("WARN", f"{event} model={model} latest_tool_results={names}")
         content.append({"type": "text", "text": text})
 
     input_tokens = decoded.input_tokens
     if input_tokens <= 0 and isinstance(source_body, dict):
         input_tokens = services.output.estimate_tokens(source_body)
-    output_tokens = decoded.output_tokens or max(1, len(text) // 4)
+    output_tokens = decoded.output_tokens or max(1, (len(decoded.thinking) + len(text)) // 4)
     return services.output.encode_message(
         message_id=f"msg_ollama_{services.output.timestamp_ms()}",
         model=model,
@@ -147,6 +175,26 @@ def project_openai_chat_response(
         source_body,
         services,
     )
+    cache_hit = positive_int(usage.get("prompt_cache_hit_tokens"))
+    cache_miss = positive_int(usage.get("prompt_cache_miss_tokens"))
+    details = usage.get("prompt_tokens_details")
+    if cache_hit is None and isinstance(details, dict):
+        cache_hit = positive_int(details.get("cached_tokens"))
+    cache_write = positive_int(usage.get("cache_creation_input_tokens"))
+    if cache_write is None and isinstance(details, dict):
+        cache_write = positive_int(details.get("cache_write_tokens"))
+    if cache_hit is not None or cache_write is not None:
+        prompt_tokens = positive_int(usage.get("prompt_tokens")) or 0
+        uncached = cache_miss if cache_miss is not None else max(
+            0, prompt_tokens - (cache_hit or 0) - (cache_write or 0)
+        )
+        projected_usage = dict(output.get("usage") or {})
+        projected_usage["input_tokens"] = uncached
+        if cache_hit is not None:
+            projected_usage["cache_read_input_tokens"] = cache_hit
+        if cache_write is not None:
+            projected_usage["cache_creation_input_tokens"] = cache_write
+        output = {**output, "usage": projected_usage}
     thinking_block = reasoning_to_block(message.get("reasoning_content"))
     if thinking_block is None:
         return output
@@ -165,6 +213,7 @@ def _project_tool_call(
     model: str,
     source_body: dict[str, Any] | None,
     services: OllamaResponseServices,
+    repeated_completed_tool_dropped: list[bool],
 ) -> dict[str, Any] | None:
     function = call.get("function") if isinstance(call, dict) else {}
     if not isinstance(function, dict) or not function.get("name"):
@@ -181,6 +230,9 @@ def _project_tool_call(
     tool_input = services.tools.cap_notification_wait(name, tool_input)
     if services.tools.should_drop(name, tool_input, raw_name, source_body):
         return None
+    if services.tools.should_drop_duplicate(name, tool_input, raw_name, source_body):
+        repeated_completed_tool_dropped[0] = True
+        return None
     services.tools.append_log(
         "ollama_nonstream_tool_call",
         {

package/ciel_runtime_support/protocols/openai_reasoning.py

@@ -47,7 +47,7 @@ class OpenAiReasoningPolicy:
         self, provider: str, model: str | None, config: dict[str, Any]
     ) -> bool:
         adapter = self.adapter_for(provider, config)
-        return adapter.openai_reasoning_passback_enabled(
+        return adapter.reasoning_passback_enabled(
             self.config_for(provider, config), model
         )
 
@@ -65,7 +65,10 @@ class OpenAiReasoningPolicy:
     ) -> bool:
         if body.get("tool_choice") is None:
             return False
-        return self.passback_enabled(provider, model, config)
+        adapter = self.adapter_for(provider, config)
+        return adapter.should_omit_openai_tool_choice(
+            self.config_for(provider, config), model, body
+        )
 
 
 __all__ = [

package/ciel_runtime_support/protocols/openai_responses.py

@@ -11,6 +11,7 @@ import uuid
 from typing import Any
 
 from ..architecture import MessageProtocolAdapter
+from ..responses_input_compatibility import router_synthesized_item_id
 
 
 def _positive_int(value: Any) -> int | None:
@@ -54,6 +55,17 @@ def _content_blocks(content: Any) -> list[dict[str, Any]]:
     return [{"type": "text", "text": text}] if text else []
 
 
+def _reasoning_summary_text(item: dict[str, Any]) -> str:
+    summary = item.get("summary")
+    if not isinstance(summary, list):
+        return ""
+    return "\n".join(
+        str(part.get("text") or "")
+        for part in summary
+        if isinstance(part, dict) and part.get("type") == "summary_text"
+    ).strip()
+
+
 def _tools_to_anthropic(tools: Any) -> list[dict[str, Any]]:
     out: list[dict[str, Any]] = []
     if not isinstance(tools, list):
@@ -117,25 +129,36 @@ def openai_responses_to_anthropic_messages(body: dict[str, Any], fallback_model:
         raw_input = [raw_input]
     if not isinstance(raw_input, list):
         raw_input = []
+    saw_conversation_item = False
+    pending_reasoning = ""
     for item in raw_input:
         if not isinstance(item, dict):
             continue
         item_type = str(item.get("type") or "message")
+        if item_type == "reasoning":
+            pending_reasoning = _reasoning_summary_text(item)
+            continue
         if item_type == "function_call":
             call_id = str(item.get("call_id") or item.get("id") or f"call_{len(messages) + 1}")
+            content: list[dict[str, Any]] = []
+            if pending_reasoning:
+                content.append({"type": "thinking", "thinking": pending_reasoning})
+                pending_reasoning = ""
+            content.append(
+                {
+                    "type": "tool_use",
+                    "id": call_id,
+                    "name": str(item.get("name") or "tool"),
+                    "input": _json_object(item.get("arguments")),
+                }
+            )
             messages.append(
                 {
                     "role": "assistant",
-                    "content": [
-                        {
-                            "type": "tool_use",
-                            "id": call_id,
-                            "name": str(item.get("name") or "tool"),
-                            "input": _json_object(item.get("arguments")),
-                        }
-                    ],
+                    "content": content,
                 }
             )
+            saw_conversation_item = True
             continue
         if item_type == "function_call_output":
             call_id = str(item.get("call_id") or item.get("id") or "call_tool")
@@ -151,17 +174,22 @@ def openai_responses_to_anthropic_messages(body: dict[str, Any], fallback_model:
                     ],
                 }
             )
+            saw_conversation_item = True
             continue
         role = str(item.get("role") or "user").strip().lower()
         blocks = _content_blocks(item.get("content", item.get("text", "")))
         if not blocks:
             continue
-        if role in ("system", "developer"):
+        if role in ("system", "developer") and not saw_conversation_item:
             system_parts.append(_content_text(blocks))
             continue
+        if role in ("system", "developer"):
+            role = "user"
+            blocks = [{"type": "text", "text": f"[Runtime system context]\n{_content_text(blocks)}"}]
         if role not in ("user", "assistant"):
             role = "user"
         messages.append({"role": role, "content": blocks})
+        saw_conversation_item = True
     if not messages:
         messages.append({"role": "user", "content": [{"type": "text", "text": ""}]})
     out: dict[str, Any] = {
@@ -180,21 +208,29 @@ def openai_responses_to_anthropic_messages(body: dict[str, Any], fallback_model:
         out["max_tokens"] = max_tokens
     reasoning = body.get("reasoning")
     if isinstance(reasoning, dict) and reasoning.get("effort") is not None:
+        effort = str(reasoning["effort"])
         out["thinking"] = {
-            "type": "enabled",
-            "effort": str(reasoning["effort"]),
+            "type": "disabled" if effort.strip().lower() in {"none", "minimal"} else "enabled",
+            "effort": effort,
         }
     if system_parts:
         out["system"] = [{"type": "text", "text": part} for part in system_parts if part]
     return out
 
 
-def _usage_from_anthropic(message: dict[str, Any]) -> dict[str, int]:
+def _usage_from_anthropic(message: dict[str, Any]) -> dict[str, Any]:
     usage = message.get("usage") if isinstance(message.get("usage"), dict) else {}
-    input_tokens = _positive_int(usage.get("input_tokens")) or 0
+    uncached_input = _positive_int(usage.get("input_tokens")) or 0
+    cached_input = _positive_int(usage.get("cache_read_input_tokens")) or 0
+    cache_write = _positive_int(usage.get("cache_creation_input_tokens")) or 0
+    input_tokens = uncached_input + cached_input + cache_write
     output_tokens = _positive_int(usage.get("output_tokens")) or 0
     return {
         "input_tokens": input_tokens,
+        "input_tokens_details": {
+            "cached_tokens": cached_input,
+            "cache_write_tokens": cache_write,
+        },
         "output_tokens": output_tokens,
         "total_tokens": input_tokens + output_tokens,
     }
@@ -215,7 +251,7 @@ def anthropic_message_to_openai_response(
             text = str(block.get("text") or "")
             output.append(
                 {
-                    "id": f"msg_{response_id[5:13]}_{index}",
+                    "id": router_synthesized_item_id("msg", response_id, index),
                     "type": "message",
                     "status": "completed",
                     "role": "assistant",
@@ -226,7 +262,7 @@ def anthropic_message_to_openai_response(
             call_id = str(block.get("id") or f"call_{index + 1}")
             output.append(
                 {
-                    "id": f"fc_{response_id[5:13]}_{index}",
+                    "id": router_synthesized_item_id("fc", response_id, index),
                     "type": "function_call",
                     "status": "completed",
                     "call_id": call_id,
@@ -234,6 +270,16 @@ def anthropic_message_to_openai_response(
                     "arguments": json.dumps(block.get("input") or {}, ensure_ascii=False),
                 }
             )
+        elif block_type == "thinking":
+            thinking = str(block.get("thinking") or "")
+            if thinking:
+                output.append(
+                    {
+                        "id": router_synthesized_item_id("rs", response_id, index),
+                        "type": "reasoning",
+                        "summary": [{"type": "summary_text", "text": thinking}],
+                    }
+                )
     return {
         "id": response_id,
         "object": "response",

package/ciel_runtime_support/provider_adapters.py

@@ -28,6 +28,11 @@ from .providers.zai import ZaiProviderAdapter
 from .providers.kimi import KimiProviderAdapter
 from .providers.fireworks import FireworksProviderAdapter
 from .providers.meta import MetaModelProviderAdapter
+from .providers.alibaba import (
+    AlibabaIndividualTokenPlanProviderAdapter,
+    AlibabaModelStudioProviderAdapter,
+    AlibabaTokenPlanProviderAdapter,
+)
 from .providers.github_copilot_oauth import (
     GitHubCopilotOAuthProviderAdapter,
 )
@@ -65,6 +70,24 @@ PROVIDER_DESCRIPTORS = ProviderDescriptorRegistry(
             MetaModelProviderAdapter,
             aliases=("muse", "muse-spark", "meta-model-api"),
         ),
+        ProviderDescriptor(
+            "alims-intl",
+            "Alibaba Model Studio International",
+            AlibabaModelStudioProviderAdapter,
+            aliases=("dashscope-intl",),
+        ),
+        ProviderDescriptor(
+            "alitoken",
+            "Alibaba Model Studio Token Plan (Singapore)",
+            AlibabaTokenPlanProviderAdapter,
+            aliases=("alibaba-token", "alibaba-token-plan", "bailian-token"),
+        ),
+        ProviderDescriptor(
+            "alitoken-individual",
+            "Alibaba Token Plan Individual",
+            AlibabaIndividualTokenPlanProviderAdapter,
+            aliases=("alibaba-token-individual", "bailian-token-individual"),
+        ),
         ProviderDescriptor(
             "github-copilot-oauth",
             "GitHub Copilot OAuth",
@@ -147,6 +170,9 @@ __all__ = [
     "GitHubCopilotOAuthProviderAdapter",
     "LMStudioProviderAdapter",
     "MetaModelProviderAdapter",
+    "AlibabaModelStudioProviderAdapter",
+    "AlibabaIndividualTokenPlanProviderAdapter",
+    "AlibabaTokenPlanProviderAdapter",
     "NvidiaHostedProviderAdapter",
     "OllamaCloudProviderAdapter",
     "OllamaProviderAdapter",