agenthub-python 0.4.1__py3-none-any.whl → 0.4.2__py3-none-any.whl

agenthub/{glm5_1 → ant_messages}/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .client import GLM5_1Client
+from .client import AntMessagesClient
 
 
-__all__ = ["GLM5_1Client"]
+__all__ = ["AntMessagesClient"]

agenthub/{claude4_6 → ant_messages}/client.py

@@ -12,14 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import base64
-import mimetypes
 import os
 import re
 from typing import Any, AsyncIterator
 
-import httpx
-from anthropic import AsyncAnthropic, AsyncAnthropicBedrock
+from anthropic import AsyncAnthropic
 from anthropic.types.beta import BetaMessageParam, BetaRawMessageStreamEvent
 
 from ..base_client import LLMClient
@@ -36,93 +33,60 @@ from ..types import (
     UniMessage,
     UsageMetadata,
 )
+from ..utils import fix_openrouter_usage_metadata
 
 
 REDACTED_THINKING = "_REDACTED_THINKING"
 
 
-class Claude4_6Client(LLMClient):
-    """Claude 4.6-specific LLM client implementation."""
+class AntMessagesClient(LLMClient):
+    """Anthropic Messages-compatible client implementation."""
 
     def __init__(self, model: str, api_key: str | None = None, base_url: str | None = None):
-        """Initialize Claude 4.6 client with model and API key."""
+        """Initialize Anthropic Messages-compatible client with model, API key, and base URL."""
         self._model = model
         api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
         base_url = base_url or os.getenv("ANTHROPIC_BASE_URL")
-        if base_url and base_url.startswith("bedrock://"):  # example: bedrock://us-east-1
-            region = base_url.replace("bedrock://", "")
-            access_key, secret_key = api_key.split(",")
-            self._client = AsyncAnthropicBedrock(
-                aws_secret_key=secret_key, aws_access_key=access_key, aws_region=region
-            )
-            self._use_bedrock = True
-        else:
-            self._client = AsyncAnthropic(api_key=api_key, base_url=base_url)
-            self._use_bedrock = False
-
+        # send the credential through both header conventions: Anthropic and DeepSeek read
+        # x-api-key while gateways such as OpenRouter and Z.AI read Authorization: Bearer
+        self._client = AsyncAnthropic(api_key=api_key, auth_token=api_key, base_url=base_url)
         self._history: list[UniMessage] = []
 
-    async def _convert_image_url_to_source(self, url: str) -> dict[str, Any]:
-        """Convert image URL to image source.
-
-        Bedrock does not support image url sources, so we need to fetch the image bytes and encode them.
-
-        Args:
-            url: Image URL to convert
-
-        Returns:
-            Image source
-        """
+    def _convert_image_url_to_source(self, url: str) -> dict[str, Any]:
+        """Convert image URL to an Anthropic image source block."""
         if url.startswith("data:"):
             match = re.match(r"data:([^;]+);base64,(.+)", url)
-            if match:
-                media_type = match.group(1)
-                base64_data = match.group(2)
-                source = {
-                    "type": "image",
-                    "source": {"type": "base64", "media_type": media_type, "data": base64_data},
-                }
-            else:
+            if not match:
                 raise ValueError(f"Invalid base64 image: {url}")
-        elif self._use_bedrock:
-            async with httpx.AsyncClient() as client:
-                response = await client.get(url)
-                response.raise_for_status()
-                image_bytes = response.content
-                mime_type = mimetypes.guess_type(url)[0] or "image/jpeg"
-                source = {
-                    "type": "image",
-                    "source": {
-                        "type": "base64",
-                        "media_type": mime_type,
-                        "data": base64.b64encode(image_bytes).decode("utf-8"),
-                    },
-                }
-        else:
-            source = {"type": "image", "source": {"type": "url", "url": url}}
 
-        return source
+            return {
+                "type": "image",
+                "source": {"type": "base64", "media_type": match.group(1), "data": match.group(2)},
+            }
+
+        return {"type": "image", "source": {"type": "url", "url": url}}
 
     def _convert_thinking_level_to_thinking_config(self, thinking_level: ThinkingLevel) -> dict[str, Any]:
-        """Convert ThinkingLevel enum to Claude's adaptive thinking config."""
+        """Convert ThinkingLevel enum to the Messages API thinking config."""
+        # NONE is explicit rather than omitted because some servers (e.g. Z.AI) think by default
         mapping = {
-            ThinkingLevel.NONE: {},  # omit thinking config
+            ThinkingLevel.NONE: {"thinking": {"type": "disabled"}},
             ThinkingLevel.LOW: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "low"}},
             ThinkingLevel.MEDIUM: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "medium"}},
             ThinkingLevel.HIGH: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "high"}},
-            ThinkingLevel.XHIGH: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "high"}},
+            ThinkingLevel.XHIGH: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "xhigh"}},
         }
         return mapping.get(thinking_level)
 
     def _convert_tool_choice(self, tool_choice: ToolChoice) -> dict[str, str]:
-        """Convert ToolChoice to Claude's tool_choice format."""
+        """Convert ToolChoice to the Messages API tool_choice format."""
         if isinstance(tool_choice, list):
             if len(tool_choice) > 1:
                 raise UnsupportedParameterError(
-                    self.__class__.__name__, "tool_choice", "Claude supports only one tool choice."
+                    self.__class__.__name__, "tool_choice", "The Messages API does not support multiple tool choices."
                 )
 
-            return {"type": "any", "name": tool_choice[0]}
+            return {"type": "tool", "name": tool_choice[0]}
         elif tool_choice == "none":
             return {"type": "none"}
         elif tool_choice == "auto":
@@ -132,70 +96,70 @@ class Claude4_6Client(LLMClient):
 
     def transform_uni_config_to_model_config(self, config: UniConfig) -> dict[str, Any]:
         """
-        Transform universal configuration to Claude-specific configuration.
+        Transform universal configuration to Anthropic Messages-compatible configuration.
 
         Args:
             config: Universal configuration dict
 
         Returns:
-            Claude configuration dictionary
+            Anthropic Messages API configuration dictionary
         """
-        claude_config = {"model": self._model, "stream": True}
+        ant_config = {"model": self._model, "stream": True}
 
         if config.get("system_prompt") is not None:
-            claude_config["system"] = config["system_prompt"]
+            ant_config["system"] = config["system_prompt"]
 
         if config.get("max_tokens") is not None:
-            claude_config["max_tokens"] = config["max_tokens"]
+            ant_config["max_tokens"] = config["max_tokens"]
         else:
-            claude_config["max_tokens"] = 64000  # Claude requires max_tokens to be specified
+            ant_config["max_tokens"] = 64000  # the Messages API requires max_tokens to be specified
 
         if config.get("temperature") is not None:
-            claude_config["temperature"] = config["temperature"]
+            ant_config["temperature"] = config["temperature"]
 
-        # NOTE: Claude always provides thinking summary
         if config.get("thinking_level") is not None:
-            claude_config["temperature"] = 1.0  # `temperature` may only be set to 1 when thinking is enabled
-            claude_config.update(self._convert_thinking_level_to_thinking_config(config["thinking_level"]))
+            ant_config.update(self._convert_thinking_level_to_thinking_config(config["thinking_level"]))
+            if config.get("thinking_summary") and ant_config.get("thinking", {}).get("type") == "adaptive":
+                ant_config["thinking"]["display"] = "summarized"
 
-        # Convert tools to Claude's tool schema
+        # Convert tools to the Messages API tool schema
         if config.get("tools") is not None:
-            claude_tools = []
+            ant_tools = []
             for tool in config["tools"]:
-                claude_tool = {}
+                ant_tool = {}
                 for key, value in tool.items():
-                    claude_tool[key.replace("parameters", "input_schema")] = value
+                    ant_tool[key.replace("parameters", "input_schema")] = value
 
-                claude_tools.append(claude_tool)
+                ant_tools.append(ant_tool)
 
-            claude_config["tools"] = claude_tools
+            ant_config["tools"] = ant_tools
 
         # Convert tool_choice
         if config.get("tool_choice") is not None:
-            claude_config["tool_choice"] = self._convert_tool_choice(config["tool_choice"])
+            ant_config["tool_choice"] = self._convert_tool_choice(config["tool_choice"])
+
+        if config.get("fast_mode"):
+            ant_config["speed"] = "fast"
+            ant_config["betas"] = ["fast-mode-2026-02-01"]
 
-        # Add cache_control if prompt caching is enabled
-        # TODO: wait for bedrock to support cache_control in config
-        if not self._use_bedrock:
-            prompt_caching = config.get("prompt_caching", PromptCaching.ENABLE)
-            if prompt_caching == PromptCaching.ENABLE:
-                claude_config["cache_control"] = {"type": "ephemeral"}
-            elif prompt_caching == PromptCaching.ENHANCE:
-                claude_config["cache_control"] = {"type": "ephemeral", "ttl": "1h"}
+        if config.get("prompt_caching") is not None and config["prompt_caching"] != PromptCaching.ENABLE:
+            raise UnsupportedParameterError(
+                self.__class__.__name__, "prompt_caching", "prompt_caching must be ENABLE for the Messages API."
+            )
 
-        return claude_config
+        return ant_config
 
-    async def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[BetaMessageParam]:
+    def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[BetaMessageParam]:
         """
-        Transform universal message format to Claude's BetaMessageParam format.
+        Transform universal message format to the Messages API BetaMessageParam format.
 
         Args:
             messages: List of universal message dictionaries
 
         Returns:
-            List of Claude BetaMessageParam objects
+            List of Messages API BetaMessageParam objects
         """
-        claude_messages: list[BetaMessageParam] = []
+        ant_messages: list[BetaMessageParam] = []
 
         for msg in messages:
             content_blocks = []
@@ -203,18 +167,19 @@ class Claude4_6Client(LLMClient):
                 if item["type"] == "text":
                     content_blocks.append({"type": "text", "text": item["text"]})
                 elif item["type"] == "image_url":
-                    content_blocks.append(await self._convert_image_url_to_source(item["image_url"]))
+                    content_blocks.append(self._convert_image_url_to_source(item["image_url"]))
                 elif item["type"] == "thinking":
                     if item["thinking"] == REDACTED_THINKING:
                         content_blocks.append({"type": "redacted_thinking", "data": item["fidelity"]["signature"]})
                     else:
-                        content_blocks.append(
-                            {
-                                "type": "thinking",
-                                "thinking": item["thinking"],
-                                "signature": item["fidelity"]["signature"],
-                            }
-                        )
+                        # third-party servers accept thinking without a signature, but the
+                        # official API requires the one it emitted
+                        thinking_block = {"type": "thinking", "thinking": item["thinking"]}
+                        signature = (item.get("fidelity") or {}).get("signature")
+                        if signature is not None:
+                            thinking_block["signature"] = signature
+
+                        content_blocks.append(thinking_block)
                 elif item["type"] == "tool_call":
                     content_blocks.append(
                         {
@@ -231,7 +196,7 @@ class Claude4_6Client(LLMClient):
                     tool_result = [{"type": "text", "text": item["text"]}]
                     if "images" in item:
                         for image_url in item["images"]:
-                            tool_result.append(await self._convert_image_url_to_source(image_url))
+                            tool_result.append(self._convert_image_url_to_source(image_url))
 
                     content_blocks.append(
                         {"type": "tool_result", "content": tool_result, "tool_use_id": item["tool_call_id"]}
@@ -239,18 +204,18 @@ class Claude4_6Client(LLMClient):
                 else:
                     raise ValueError(f"Unknown item: {item}")
 
-            claude_messages.append({"role": msg["role"], "content": content_blocks})
+            ant_messages.append({"role": msg["role"], "content": content_blocks})
 
-        return claude_messages
+        return ant_messages
 
     def transform_model_output_to_uni_event(self, model_output: BetaRawMessageStreamEvent) -> UniEvent:
         """
-        Transform Claude model output to universal event format.
+        Transform a Messages API streaming event to universal event format.
 
-        NOTE: Claude always has only one content item per event.
+        NOTE: the Messages API always has only one content item per event.
 
         Args:
-            model_output: Claude streaming event
+            model_output: Messages API streaming event
 
         Returns:
             Universal event dictionary
@@ -260,8 +225,8 @@ class Claude4_6Client(LLMClient):
         usage_metadata: UsageMetadata | None = None
         finish_reason: FinishReason | None = None
 
-        claude_event_type = model_output.type
-        if claude_event_type == "content_block_start":
+        ant_event_type = model_output.type
+        if ant_event_type == "content_block_start":
             event_type = "start"
             block = model_output.content_block
             if block.type == "tool_use":
@@ -273,7 +238,7 @@ class Claude4_6Client(LLMClient):
                     {"type": "thinking", "thinking": REDACTED_THINKING, "fidelity": {"signature": block.data}}
                 )
 
-        elif claude_event_type == "content_block_delta":
+        elif ant_event_type == "content_block_delta":
             event_type = "delta"
             delta = model_output.delta
             if delta.type == "thinking_delta":
@@ -287,10 +252,10 @@ class Claude4_6Client(LLMClient):
             elif delta.type == "signature_delta":
                 content_items.append({"type": "thinking", "thinking": "", "fidelity": {"signature": delta.signature}})
 
-        elif claude_event_type == "content_block_stop":
+        elif ant_event_type == "content_block_stop":
             event_type = "stop"
 
-        elif claude_event_type == "message_start":
+        elif ant_event_type == "message_start":
             event_type = "start"
             message = model_output.message
             if getattr(message, "usage", None):
@@ -302,7 +267,7 @@ class Claude4_6Client(LLMClient):
                     "response_tokens": None,
                 }
 
-        elif claude_event_type == "message_delta":
+        elif ant_event_type == "message_delta":
             event_type = "stop"
             delta = model_output.delta
             if getattr(delta, "stop_reason", None):
@@ -314,19 +279,28 @@ class Claude4_6Client(LLMClient):
                 }
                 finish_reason = stop_reason_mapping.get(delta.stop_reason, "unknown")
 
-            if getattr(model_output, "usage", None):
-                # In message_delta, we only update response_tokens
+            usage = getattr(model_output, "usage", None)
+            if usage:
+                # gateways report zero usage in message_start and the full counts here, so the
+                # delta also carries the input-side fields (None on servers that omit them)
+                if usage.input_tokens is not None:
+                    prompt_tokens = usage.input_tokens + (usage.cache_creation_input_tokens or 0)
+                else:
+                    prompt_tokens = None
+
+                output_details = getattr(usage, "output_tokens_details", None)
+                thinking_tokens = getattr(output_details, "thinking_tokens", None) if output_details else None
                 usage_metadata = {
-                    "cached_tokens": None,
-                    "prompt_tokens": None,
-                    "thoughts_tokens": None,
-                    "response_tokens": model_output.usage.output_tokens,
+                    "cached_tokens": usage.cache_read_input_tokens,
+                    "prompt_tokens": prompt_tokens,
+                    "thoughts_tokens": thinking_tokens,
+                    "response_tokens": usage.output_tokens - (thinking_tokens or 0),
                 }
 
-        elif claude_event_type == "message_stop":
+        elif ant_event_type == "message_stop":
             event_type = "stop"
 
-        elif claude_event_type in ["text", "thinking", "signature", "input_json"]:
+        elif ant_event_type in ["text", "thinking", "signature", "input_json"]:
             event_type = "unused"
 
         else:
@@ -345,32 +319,17 @@ class Claude4_6Client(LLMClient):
         messages: list[UniMessage],
         config: UniConfig,
     ) -> AsyncIterator[UniEvent]:
-        """Stream generate using Claude SDK with unified conversion methods."""
+        """Stream generate using an Anthropic Messages-compatible API with unified conversion methods."""
         # Use unified config conversion
-        claude_config = self.transform_uni_config_to_model_config(config)
+        ant_config = self.transform_uni_config_to_model_config(config)
 
         # Use unified message conversion
-        claude_messages = await self.transform_uni_message_to_model_input(messages)
-
-        # Add cache_control to last user message's last item if using bedrock and enabled prompt caching
-        # TODO: remove after bedrock supports cache_control in config
-        if self._use_bedrock:
-            prompt_caching = config.get("prompt_caching", PromptCaching.ENABLE)
-            if prompt_caching != PromptCaching.DISABLE and claude_messages:
-                try:
-                    last_user_message = next(filter(lambda x: x["role"] == "user", claude_messages[::-1]))
-                    last_content_item = last_user_message["content"][-1]
-                    last_content_item["cache_control"] = {
-                        "type": "ephemeral",
-                        "ttl": "1h" if prompt_caching == PromptCaching.ENHANCE else "5m",
-                    }
-                except StopIteration:
-                    pass
+        ant_messages = self.transform_uni_message_to_model_input(messages)
 
         # Stream generate
         partial_tool_call = {}
         partial_usage = {}
-        stream = await self._client.beta.messages.create(**claude_config, messages=claude_messages)
+        stream = await self._client.beta.messages.create(**ant_config, messages=ant_messages)
         async for event in stream:
             event = self.transform_model_output_to_uni_event(event)
             if event["event_type"] == "start":
@@ -425,18 +384,28 @@ class Claude4_6Client(LLMClient):
                     }
                     partial_tool_call = {}
 
-                if "prompt_tokens" in partial_usage and event["usage_metadata"] is not None:
-                    # finish partial_usage
+                if event["usage_metadata"] is not None:
+                    # finish partial_usage: the message_delta counts win over message_start
+                    delta_usage = event["usage_metadata"]
+                    usage_metadata = {
+                        "prompt_tokens": (
+                            delta_usage["prompt_tokens"]
+                            if delta_usage["prompt_tokens"] is not None
+                            else partial_usage.get("prompt_tokens")
+                        ),
+                        "cached_tokens": (
+                            delta_usage["cached_tokens"]
+                            if delta_usage["cached_tokens"] is not None
+                            else partial_usage.get("cached_tokens")
+                        ),
+                        "thoughts_tokens": delta_usage["thoughts_tokens"],
+                        "response_tokens": delta_usage["response_tokens"],
+                    }
                     yield {
                         "role": "assistant",
                         "event_type": "stop",
                         "content_items": [],
-                        "usage_metadata": {
-                            "prompt_tokens": partial_usage["prompt_tokens"],
-                            "thoughts_tokens": None,
-                            "response_tokens": event["usage_metadata"]["response_tokens"],
-                            "cached_tokens": partial_usage["cached_tokens"],
-                        },
+                        "usage_metadata": fix_openrouter_usage_metadata(usage_metadata, str(self._client.base_url)),
                         "finish_reason": event["finish_reason"],
                     }
                     partial_usage = {}

agenthub/auto_client.py

@@ -46,66 +46,65 @@ class AutoLLMClient(LLMClient):
         self, model: str, api_key: str | None = None, base_url: str | None = None, client_type: str | None = None
     ) -> LLMClient:
         """Create the appropriate client for the given model."""
-        client_type = (client_type or os.getenv("CLIENT_TYPE", model)).lower()
-        # gemini-3.6 must be matched before the broader gemini-3 prefix below
-        if any(
-            prefix in client_type for prefix in ("gemini-3.6", "gemini-3.5-flash-lite")
-        ):  # e.g., gemini-3.6-flash; gemini-3.5-flash-lite shares the sampling-parameter deprecation
-            from .gemini3_6 import Gemini3_6Client
+        client_type = (client_type or os.getenv("CLIENT_TYPE") or model).lower()
+        if client_type == "minimax-m3":
+            from .minimax_m3 import MiniMaxM3Client
 
-            return Gemini3_6Client(model=model, api_key=api_key, base_url=base_url)
-        elif any(
+            return MiniMaxM3Client(model=model, api_key=api_key, base_url=base_url)
+        # every Gemini generation shares the unified client ("gemini-3" also matches the
+        # gemini-3.7/gemini-3.6/gemini-3.5-flash-lite client types)
+        if any(
             prefix in client_type for prefix in ("gemini-3", "gemini-embedding")
-        ):  # e.g., gemini-3-flash-preview, gemini-embedding-2
-            from .gemini3 import Gemini3Client
+        ):  # e.g., gemini-3.7-flash, gemini-3-flash-preview, gemini-embedding-2
+            from .gemini3_7 import Gemini3_7Client
 
-            return Gemini3Client(model=model, api_key=api_key, base_url=base_url)
+            return Gemini3_7Client(model=model, api_key=api_key, base_url=base_url)
         elif "claude" in client_type and (
-            "4-7" in client_type or "4-8" in client_type or "-5" in client_type
-        ):  # e.g., claude-opus-4-7
+            "4-6" in client_type or "4-7" in client_type or "4-8" in client_type or "-5" in client_type
+        ):  # the whole Claude 4.6+ series shares the unified client, e.g., claude-sonnet-4-6
             from .claude5 import Claude5Client
 
             return Claude5Client(model=model, api_key=api_key, base_url=base_url)
-        elif "claude" in client_type and "4-6" in client_type:  # e.g., claude-sonnet-4-6
-            from .claude4_6 import Claude4_6Client
-
-            return Claude4_6Client(model=model, api_key=api_key, base_url=base_url)
-        elif "gpt-5.4" in client_type or "gpt-5.5" in client_type:  # e.g., gpt-5.5
-            from .gpt5_5 import GPT5_5Client
-
-            return GPT5_5Client(model=model, api_key=api_key, base_url=base_url)
-        elif "glm-5.2" in client_type:
-            from .glm5_2 import GLM5_2Client
+        elif "gpt-5.4" in client_type or "gpt-5.5" in client_type or "gpt-5.6" in client_type:  # e.g., gpt-5.6
+            from .gpt5_6 import GPT5_6Client
 
-            return GLM5_2Client(model=model, api_key=api_key, base_url=base_url)
-        elif "glm-5" in client_type or "glm-5.1" in client_type:
-            from .glm5_1 import GLM5_1Client
+            return GPT5_6Client(model=model, api_key=api_key, base_url=base_url)
+        elif "glm-5" in client_type:  # the whole GLM series shares the unified client
+            from .glm5_3 import GLM5_3Client
 
-            return GLM5_1Client(model=model, api_key=api_key, base_url=base_url)
-        elif "kimi-k3" in client_type:
+            return GLM5_3Client(model=model, api_key=api_key, base_url=base_url)
+        elif "kimi-k3" in client_type or "kimi-k2.5" in client_type or "kimi-k2.6" in client_type:
+            # the whole Kimi K2.5+ series shares the unified client
             from .kimi_k3 import KimiK3Client
 
             return KimiK3Client(model=model, api_key=api_key, base_url=base_url)
-        elif "kimi-k2.5" in client_type or "kimi-k2.6" in client_type:
-            from .kimi_k2_6 import KimiK2_6Client
-
-            return KimiK2_6Client(model=model, api_key=api_key, base_url=base_url)
         elif "deepseek-v4" in client_type:
             from .deepseek_v4 import DeepSeekV4Client
 
             return DeepSeekV4Client(model=model, api_key=api_key, base_url=base_url)
+        elif "ant-messages" in client_type:
+            from .ant_messages import AntMessagesClient
+
+            return AntMessagesClient(model=model, api_key=api_key, base_url=base_url)
+        elif "openai-responses" in client_type:
+            from .openai_responses import OpenaiResponsesClient
+
+            return OpenaiResponsesClient(model=model, api_key=api_key, base_url=base_url)
         elif "openai" in client_type and "embedding" in client_type:
             from .openai_embedding import OpenaiEmbeddingClient
 
             return OpenaiEmbeddingClient(model=model, api_key=api_key, base_url=base_url)
-        elif "openai" in client_type and "embedding" not in client_type:
-            from .openai import OpenaiClient
+        elif "openai" in client_type and "embedding" not in client_type:  # openai-chat, plus bare "openai" as alias
+            from .openai_chat import OpenaiChatClient
 
-            return OpenaiClient(model=model, api_key=api_key, base_url=base_url)
+            return OpenaiChatClient(model=model, api_key=api_key, base_url=base_url)
         else:
             raise ValueError(
                 f"{client_type} is not supported. "
-                "Supported client types: gemini-3.6, gemini-3, claude-5, claude-4-8, claude-4-7, claude-4-6, gpt-5.5, gpt-5.4, glm-5.2, glm-5.1, kimi-k3, kimi-k2.6, kimi-k2.5, deepseek-v4, openai-embedding, openai."
+                "Supported client types: minimax-m3, gemini-3.7, gemini-3.6, gemini-3, "
+                "claude-5, claude-4-8, claude-4-7, claude-4-6, gpt-5.6, gpt-5.5, gpt-5.4, "
+                "glm-5.3, glm-5.2, glm-5.1, kimi-k3, kimi-k2.6, kimi-k2.5, deepseek-v4, "
+                "openai-embedding, ant-messages, openai-responses, openai-chat."
             )
 
     def transform_uni_config_to_model_config(self, config: UniConfig) -> Any:

agenthub/claude5/client.py

@@ -42,7 +42,7 @@ REDACTED_THINKING = "_REDACTED_THINKING"
 
 
 class Claude5Client(LLMClient):
-    """Claude 5-specific LLM client implementation."""
+    """Claude 5-specific LLM client implementation (also serves Claude 4.6 through 4.8)."""
 
     def __init__(self, model: str, api_key: str | None = None, base_url: str | None = None):
         """Initialize Claude 5 client with model and API key."""
@@ -110,7 +110,11 @@ class Claude5Client(LLMClient):
             ThinkingLevel.LOW: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "low"}},
             ThinkingLevel.MEDIUM: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "medium"}},
             ThinkingLevel.HIGH: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "high"}},
-            ThinkingLevel.XHIGH: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "xhigh"}},
+            # Claude 4.6 has no xhigh effort, so XHIGH degrades to the closest supported level
+            ThinkingLevel.XHIGH: {
+                "thinking": {"type": "adaptive"},
+                "output_config": {"effort": "high" if "4-6" in self._model else "xhigh"},
+            },
         }
         return mapping.get(thinking_level)
 
@@ -152,7 +156,10 @@ class Claude5Client(LLMClient):
 
         if config.get("temperature") is not None and config["temperature"] != 1.0:
             raise UnsupportedParameterError(
-                self.__class__.__name__, "temperature", "Claude 4.8 does not support setting temperature."
+                self.__class__.__name__,
+                "temperature",
+                "Claude models do not support setting temperature; the API dropped it "
+                "starting with the 4.7 generation and the unified client rejects it for the whole family.",
             )
 
         if config.get("thinking_level") is not None:
@@ -176,6 +183,20 @@ class Claude5Client(LLMClient):
         if config.get("tool_choice") is not None:
             claude_config["tool_choice"] = self._convert_tool_choice(config["tool_choice"])
 
+        if config.get("fast_mode"):
+            if self._use_bedrock:
+                raise UnsupportedParameterError(
+                    self.__class__.__name__, "fast_mode", "Bedrock does not support fast mode."
+                )
+
+            if "4-6" in self._model:
+                raise UnsupportedParameterError(
+                    self.__class__.__name__, "fast_mode", "Claude 4.6 does not support fast mode."
+                )
+
+            claude_config["speed"] = "fast"
+            claude_config["betas"] = ["fast-mode-2026-02-01"]
+
         # Add cache_control if prompt caching is enabled
         # TODO: wait for bedrock to support cache_control in config
         if not self._use_bedrock:

agenthub/deepseek_v4/client.py

@@ -109,6 +109,11 @@ class DeepSeekV4Client(LLMClient):
         if config.get("tool_choice") is not None:
             deepseek_config["tool_choice"] = self._convert_tool_choice(config["tool_choice"])
 
+        if config.get("fast_mode"):
+            raise UnsupportedParameterError(
+                self.__class__.__name__, "fast_mode", "DeepSeek V4 does not support fast mode."
+            )
+
         if config.get("prompt_caching") is not None and config["prompt_caching"] != PromptCaching.ENABLE:
             raise UnsupportedParameterError(
                 self.__class__.__name__, "prompt_caching", "prompt_caching must be ENABLE for DeepSeek."

agenthub/{claude4_6 → gemini3_7}/__init__.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .client import Claude4_6Client
+from .client import Gemini3_7Client
 
 
-__all__ = ["Claude4_6Client"]
+__all__ = ["Gemini3_7Client"]