agenthub-python 0.4.5__py3-none-any.whl → 0.4.7__py3-none-any.whl

agenthub/base_client.py

@@ -28,6 +28,7 @@ from .types import (
     UniMessage,
     UsageMetadata,
 )
+from .utils import is_debug_enabled
 
 
 class LLMClient(ABC):
@@ -139,6 +140,17 @@ class LLMClient(ABC):
                 elif item["type"] == "partial_tool_call":
                     # Skip partial_tool_call items - they should already be converted to tool_call
                     pass
+                elif item["type"] == "inline_data" and (item.get("mime_type") or "").startswith("audio/"):
+                    # a spoken response streams as many small audio chunks; the message keeps the
+                    # whole utterance as one playable item
+                    if (
+                        content_items
+                        and content_items[-1]["type"] == "inline_data"
+                        and content_items[-1].get("mime_type") == item["mime_type"]
+                    ):
+                        content_items[-1]["data"] += item["data"]
+                    else:
+                        content_items.append(item.copy())
                 else:
                     content_items.append(item.copy())
 
@@ -254,6 +266,14 @@ class LLMClient(ABC):
                 finally:
                     waiting_for_stream = False
 
+                if event["event_type"] == "unused":
+                    # a client marks a wire event it has nothing to emit for as "unused"; that is
+                    # its own bookkeeping and must not reach a caller
+                    if is_debug_enabled():
+                        raise ValueError(f"{self.__class__.__name__} yielded an internal unused event: {event}")
+
+                    continue
+
                 event["created_at"] = int(time.time() * 1000)
                 last_event = event
                 events.append(event)

agenthub/deepseek_v4/client.py

@@ -17,7 +17,7 @@ import os
 from typing import Any, AsyncIterator
 
 from openai import AsyncOpenAI
-from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageParam
+from openai.types.responses import ResponseInputParam, ResponseStreamEvent
 
 from ..base_client import LLMClient
 from ..errors import UnsupportedParameterError, parse_tool_call_arguments
@@ -33,10 +33,11 @@ from ..types import (
     UniMessage,
     UsageMetadata,
 )
+from ..utils import is_debug_enabled
 
 
 class DeepSeekV4Client(LLMClient):
-    """DeepSeek V4-specific LLM client implementation using OpenAI-compatible Chat Completions."""
+    """DeepSeek V4-specific LLM client implementation using the OpenAI-compatible Responses API."""
 
     def __init__(
         self,
@@ -52,27 +53,17 @@ class DeepSeekV4Client(LLMClient):
         self._client = AsyncOpenAI(api_key=api_key, base_url=base_url, default_headers=default_headers)
         self._history: list[UniMessage] = []
 
-    def _convert_thinking_level_to_config(self, thinking_level: ThinkingLevel) -> dict[str, str]:
-        """Convert ThinkingLevel enum to DeepSeek's thinking configuration."""
-        mapping = {
-            ThinkingLevel.NONE: {"type": "disabled"},
-            ThinkingLevel.LOW: {"type": "enabled"},
-            ThinkingLevel.MEDIUM: {"type": "enabled"},
-            ThinkingLevel.HIGH: {"type": "enabled"},
-            ThinkingLevel.XHIGH: {"type": "enabled"},
-            ThinkingLevel.MAX: {"type": "enabled"},
-        }
-        return mapping[thinking_level]
-
-    def _convert_reasoning_effort(self, thinking_level: ThinkingLevel) -> str | None:
-        """Convert ThinkingLevel enum to DeepSeek's reasoning_effort.
+    def _convert_thinking_level_to_effort(self, thinking_level: ThinkingLevel) -> str:
+        """Convert ThinkingLevel enum to DeepSeek's reasoning effort.
 
         DeepSeek accepts low/high/max and maps medium and xhigh onto high server-side
         (llmsdk_docs/deepseek_v4/docs/thinking-mode.md), so this sends the value the
-        server would settle on anyway.
+        server would settle on anyway. Effort "none" is what turns thinking off on this
+        endpoint: the Chat Completions `thinking` toggle is ignored here (verified live
+        2026-08-21).
         """
         mapping = {
-            ThinkingLevel.NONE: None,
+            ThinkingLevel.NONE: "none",
             ThinkingLevel.LOW: "low",
             ThinkingLevel.MEDIUM: "high",
             ThinkingLevel.HIGH: "high",
@@ -82,7 +73,7 @@ class DeepSeekV4Client(LLMClient):
         return mapping[thinking_level]
 
     def _convert_tool_choice(self, tool_choice: ToolChoice) -> str:
-        """Convert ToolChoice to DeepSeek's OpenAI-compatible tool_choice format."""
+        """Convert ToolChoice to DeepSeek's Responses-compatible tool_choice format."""
         if tool_choice in ["auto", "none"]:
             return tool_choice
         raise UnsupportedParameterError(
@@ -99,25 +90,25 @@ class DeepSeekV4Client(LLMClient):
         Returns:
             DeepSeek configuration dictionary
         """
-        deepseek_config = {"model": self._model, "stream": True, "stream_options": {"include_usage": True}}
+        deepseek_config = {"model": self._model, "store": False}
+
+        if config.get("system_prompt") is not None:
+            deepseek_config["instructions"] = config["system_prompt"]
 
         if config.get("max_tokens") is not None:
-            deepseek_config["max_tokens"] = config["max_tokens"]
+            deepseek_config["max_output_tokens"] = config["max_tokens"]
 
         if config.get("temperature") is not None and config["temperature"] != 1.0:
             raise UnsupportedParameterError(
                 self.__class__.__name__, "temperature", "DeepSeek V4 does not support setting temperature."
             )
 
-        thinking_level = config.get("thinking_level")
-        if thinking_level is not None:
-            deepseek_config["extra_body"] = {"thinking": self._convert_thinking_level_to_config(thinking_level)}
-            reasoning_effort = self._convert_reasoning_effort(thinking_level)
-            if reasoning_effort is not None:
-                deepseek_config["reasoning_effort"] = reasoning_effort
+        # a thinking summary is accepted but never generated, so the parameter is left out
+        if config.get("thinking_level") is not None:
+            deepseek_config["reasoning"] = {"effort": self._convert_thinking_level_to_effort(config["thinking_level"])}
 
         if config.get("tools") is not None:
-            deepseek_config["tools"] = [{"type": "function", "function": tool} for tool in config["tools"]]
+            deepseek_config["tools"] = [{"type": "function", **tool} for tool in config["tools"]]
 
         if config.get("tool_choice") is not None:
             deepseek_config["tool_choice"] = self._convert_tool_choice(config["tool_choice"])
@@ -134,82 +125,92 @@ class DeepSeekV4Client(LLMClient):
 
         return deepseek_config
 
-    def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[ChatCompletionMessageParam]:
+    def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> ResponseInputParam:
         """
-        Transform universal message format to DeepSeek's OpenAI-compatible message format.
+        Transform universal message format to DeepSeek's Responses-compatible input format.
 
         Args:
             messages: List of universal message dictionaries
 
         Returns:
-            List of OpenAI-compatible message dictionaries
+            List of input items for the Responses API
         """
-        deepseek_messages = []
+        # only a vision model reads image parts; every other DeepSeek model answers from a
+        # placeholder instead of failing (llmsdk_docs/deepseek_v4/docs/responses-api.md), so an
+        # image is refused here rather than silently dropped
+        supports_image = "vision" in self._model.lower()
+        input_list: list[ResponseInputParam] = []
 
         for msg in messages:
-            content_parts = []  # may be empty for tool results
-            tool_calls = []  # may be empty for no tool calls
-            thinking = ""
+            content_items: list = []
+
             for item in msg["content_items"]:
+                # anything that is not message content becomes an input item of its own, so the
+                # text collected so far is flushed first to keep the original order: DeepSeek
+                # merges a function call into the adjacent assistant message and answers a call
+                # whose output does not follow it with "No tool output found for tool call"
+                # (verified live 2026-08-21)
+                if item["type"] not in ("text", "image_url") and content_items:
+                    input_list.append({"role": msg["role"], "content": content_items})
+                    content_items = []
+
                 if item["type"] == "text":
-                    content_parts.append({"type": "text", "text": item["text"]})
+                    if msg["role"] == "user":
+                        content_items.append({"type": "input_text", "text": item["text"]})
+                    else:
+                        content_items.append({"type": "output_text", "text": item["text"]})
                 elif item["type"] == "image_url":
-                    raise ValueError("DeepSeek does not support image url inputs.")
+                    if not supports_image:
+                        raise ValueError(f"DeepSeek {self._model} does not support image inputs.")
+
+                    content_items.append({"type": "input_image", "image_url": item["image_url"]})
                 elif item["type"] == "thinking":
-                    thinking += item["thinking"]
+                    # DeepSeek carries the chain of thought as plain reasoning_text and ignores the
+                    # summary and encrypted_content channels, so the item is rebuilt from the text
+                    reasoning = {"type": "reasoning", "summary": []}
+                    if item["thinking"]:
+                        reasoning["content"] = [{"type": "reasoning_text", "text": item["thinking"]}]
+
+                    input_list.append(reasoning)
                 elif item["type"] == "tool_call":
-                    tool_calls.append(
+                    input_list.append(
                         {
-                            "id": item["tool_call_id"],
-                            "type": "function",
-                            "function": {
-                                "name": item["name"],
-                                "arguments": json.dumps(item["arguments"], ensure_ascii=False),
-                            },
+                            "type": "function_call",
+                            "call_id": item["tool_call_id"],
+                            "name": item["name"],
+                            "arguments": json.dumps(item["arguments"], ensure_ascii=False),
                         }
                     )
                 elif item["type"] == "tool_result":
                     if "tool_call_id" not in item:
                         raise ValueError("tool_call_id is required for tool result.")
 
-                    content = [{"type": "text", "text": item["text"]}]
+                    # NOTE: tool results are input items
+                    tool_result = [{"type": "input_text", "text": item["text"]}]
+                    if "images" in item:
+                        if not supports_image:
+                            raise ValueError(f"DeepSeek {self._model} does not support images in tool results.")
 
-                    if "images" in item and item["images"]:
-                        raise ValueError("DeepSeek does not support images in tool results.")
+                        for image_url in item["images"]:
+                            tool_result.append({"type": "input_image", "image_url": image_url})
 
-                    # Tool results are sent as separate messages
-                    deepseek_messages.append(
-                        {
-                            "role": "tool",
-                            "tool_call_id": item["tool_call_id"],
-                            "content": content,
-                        }
+                    input_list.append(
+                        {"type": "function_call_output", "call_id": item["tool_call_id"], "output": tool_result}
                     )
                 else:
-                    raise ValueError(f"Unknown item type: {item['type']}")
-
-            message = {"role": msg["role"]}
-            if content_parts:
-                message["content"] = content_parts
-
-            if tool_calls:
-                message["tool_calls"] = tool_calls
+                    raise ValueError(f"Unknown item: {item}")
 
-            if thinking:
-                message["reasoning_content"] = thinking
+            if content_items:
+                input_list.append({"role": msg["role"], "content": content_items})
 
-            # message may be empty for tool results
-            if len(message.keys()) > 1:
-                deepseek_messages.append(message)
+        return input_list
 
-        return deepseek_messages
-
-    def transform_model_output_to_uni_event(self, model_output: ChatCompletionChunk) -> UniEvent:
+    def transform_model_output_to_uni_event(self, model_output: ResponseStreamEvent) -> UniEvent:
         """
-        Transform DeepSeek streaming chunk to universal event format.
+        Transform DeepSeek streaming event to universal event format.
 
         Args:
-            model_output: OpenAI-compatible streaming chunk
+            model_output: Responses API streaming event
 
         Returns:
             Universal event dictionary
@@ -219,64 +220,77 @@ class DeepSeekV4Client(LLMClient):
         usage_metadata: UsageMetadata | None = None
         finish_reason: FinishReason | None = None
 
-        # gateways inject content-free heartbeat chunks on long generations, whose choices
-        # the SDK leaves as None rather than an empty list
-        if model_output.choices:
-            choice = model_output.choices[0]
-            delta = choice.delta
+        deepseek_event_type = model_output.type
+        if deepseek_event_type == "response.output_text.delta":
+            event_type = "delta"
+            content_items.append({"type": "text", "text": model_output.delta})
+
+        elif deepseek_event_type == "response.reasoning_text.delta":
+            event_type = "delta"
+            content_items.append({"type": "thinking", "thinking": model_output.delta})
 
-            if getattr(delta, "reasoning_content", None):
-                event_type = "delta"
-                # record the wire field so a replay through another OpenAI-compatible
-                # client reproduces the exact field DeepSeek produced
+        elif deepseek_event_type == "response.output_item.added":
+            if model_output.item.type == "function_call":
+                event_type = "start"
                 content_items.append(
                     {
-                        "type": "thinking",
-                        "thinking": getattr(delta, "reasoning_content"),
-                        "fidelity": {"reasoning_field": "reasoning_content"},
+                        "type": "partial_tool_call",
+                        "name": model_output.item.name,
+                        "arguments": "",
+                        "tool_call_id": model_output.item.call_id,
                     }
                 )
+            else:
+                event_type = "unused"
+
+        elif deepseek_event_type == "response.function_call_arguments.delta":
+            event_type = "delta"
+            content_items.append(
+                {"type": "partial_tool_call", "name": "", "arguments": model_output.delta, "tool_call_id": ""}
+            )
 
-            if delta.content:
-                event_type = "delta"
-                content_items.append({"type": "text", "text": delta.content})
+        elif deepseek_event_type == "response.function_call_arguments.done":
+            event_type = "stop"
 
-            if delta.tool_calls:
-                event_type = "delta"
-                for tool_call in delta.tool_calls:
-                    content_item: PartialContentItem = {
-                        "type": "partial_tool_call",
-                        "name": tool_call.function.name or "",
-                        "arguments": tool_call.function.arguments or "",
-                        "tool_call_id": tool_call.id or "",
-                    }
-                    content_items.append(content_item)
-
-            if choice.finish_reason:
-                event_type = event_type or "stop"
-                finish_reason_mapping = {
-                    "stop": "stop",
-                    "length": "length",
-                    "tool_calls": "tool_call",
-                    "content_filter": "stop",
+        elif deepseek_event_type in ("response.completed", "response.incomplete"):
+            event_type = "stop"
+            finish_reason_mapping = {
+                "completed": "stop",
+                "incomplete": "length",
+            }
+            finish_reason = finish_reason_mapping.get(model_output.response.status, "unknown")
+
+            if model_output.response.usage:
+                input_details = model_output.response.usage.input_tokens_details
+                output_details = model_output.response.usage.output_tokens_details
+                cached_tokens = input_details.cached_tokens if input_details else 0
+                reasoning_tokens = output_details.reasoning_tokens if output_details else 0
+                usage_metadata = {
+                    "cached_tokens": cached_tokens,
+                    "prompt_tokens": model_output.response.usage.input_tokens - cached_tokens,
+                    "thoughts_tokens": reasoning_tokens,
+                    "response_tokens": model_output.response.usage.output_tokens - reasoning_tokens,
                 }
-                finish_reason = finish_reason_mapping.get(choice.finish_reason, "unknown")
 
-        if model_output.usage:
-            event_type = event_type or "stop"
-            completion_token_details = model_output.usage.completion_tokens_details
-            reasoning_tokens = (
-                getattr(completion_token_details, "reasoning_tokens", None) if completion_token_details else None
-            )
-            response_tokens = model_output.usage.completion_tokens - (reasoning_tokens or 0)
-
-            # usage.prompt_tokens = prompt_cache_hit_tokens + prompt_cache_miss_tokens
-            usage_metadata = {
-                "cached_tokens": getattr(model_output.usage, "prompt_cache_hit_tokens", 0),
-                "prompt_tokens": getattr(model_output.usage, "prompt_cache_miss_tokens", 0),
-                "thoughts_tokens": reasoning_tokens,
-                "response_tokens": response_tokens,
-            }
+        elif deepseek_event_type in (
+            "response.created",
+            "response.in_progress",
+            "response.output_item.done",
+            "response.output_text.done",
+            "response.reasoning_text.done",
+            "response.content_part.added",
+            "response.content_part.done",
+            "keepalive",  # gateway heartbeat on long generations; carries no content
+        ):
+            event_type = "unused"
+
+        elif is_debug_enabled():
+            raise ValueError(f"Unknown output: {model_output}")
+
+        else:
+            # a gateway injects its own events (heartbeats, cost tickers) into the stream, and
+            # killing a long generation over one costs more than dropping it
+            event_type = "unused"
 
         return {
             "role": "assistant",
@@ -291,65 +305,38 @@ class DeepSeekV4Client(LLMClient):
         messages: list[UniMessage],
         config: UniConfig,
     ) -> AsyncIterator[UniEvent]:
-        """Stream generate using DeepSeek's OpenAI-compatible Chat Completions API."""
+        """Stream generate using DeepSeek's OpenAI-compatible Responses API."""
+        # Use unified config conversion
         deepseek_config = self.transform_uni_config_to_model_config(config)
-        deepseek_messages = self.transform_uni_message_to_model_input(messages)
-
-        if config.get("system_prompt"):
-            deepseek_messages.insert(0, {"role": "system", "content": config["system_prompt"]})
 
-        stream = await self._client.chat.completions.create(**deepseek_config, messages=deepseek_messages)
+        # Use unified message conversion
+        input_list = self.transform_uni_message_to_model_input(messages)
 
+        # Stream generate
         partial_tool_call = {}
-        partial_usage = {}
-        async for chunk in stream:
-            event = self.transform_model_output_to_uni_event(chunk)
-            partial_usage["finish_reason"] = event["finish_reason"] or partial_usage.get("finish_reason")
-            partial_usage["usage_metadata"] = event["usage_metadata"] or partial_usage.get("usage_metadata")
-
-            if event["event_type"] == "delta":
+        stream = await self._client.responses.create(**deepseek_config, input=input_list, stream=True)
+        async for event in stream:
+            event = self.transform_model_output_to_uni_event(event)
+            if event["event_type"] == "start":
                 for item in event["content_items"]:
                     if item["type"] == "partial_tool_call":
-                        if not partial_tool_call:
-                            partial_tool_call = {
-                                "name": item["name"],
-                                "arguments": item["arguments"],
-                                "tool_call_id": item["tool_call_id"],
-                            }
-                        elif item["name"]:
-                            yield {
-                                "role": "assistant",
-                                "event_type": "delta",
-                                "content_items": [
-                                    {
-                                        "type": "tool_call",
-                                        "name": partial_tool_call["name"],
-                                        "arguments": parse_tool_call_arguments(
-                                            partial_tool_call["arguments"],
-                                            self.__class__.__name__,
-                                            partial_tool_call["name"],
-                                            partial_tool_call["tool_call_id"],
-                                        ),
-                                        "tool_call_id": partial_tool_call["tool_call_id"],
-                                    }
-                                ],
-                                "usage_metadata": None,
-                                "finish_reason": None,
-                            }
-                            partial_tool_call = {
-                                "name": item["name"],
-                                "arguments": item["arguments"],
-                                "tool_call_id": item["tool_call_id"],
-                            }
-                        else:
-                            partial_tool_call["arguments"] += item["arguments"]
-                            partial_tool_call["tool_call_id"] = (
-                                item["tool_call_id"] or partial_tool_call["tool_call_id"]
-                            )
+                        # initialize partial_tool_call
+                        partial_tool_call = {
+                            "name": item["name"],
+                            "arguments": "",
+                            "tool_call_id": item["tool_call_id"],
+                        }
+                        yield event
+            elif event["event_type"] == "delta":
+                for item in event["content_items"]:
+                    if item["type"] == "partial_tool_call":
+                        # update partial_tool_call
+                        partial_tool_call["arguments"] += item["arguments"]
 
                 yield event
             elif event["event_type"] == "stop":
-                if partial_tool_call:
+                if "name" in partial_tool_call and "arguments" in partial_tool_call:
+                    # finish partial_tool_call
                     yield {
                         "role": "assistant",
                         "event_type": "delta",
@@ -371,15 +358,8 @@ class DeepSeekV4Client(LLMClient):
                     }
                     partial_tool_call = {}
 
-                if partial_usage.get("finish_reason") and partial_usage.get("usage_metadata"):
-                    yield {
-                        "role": "assistant",
-                        "event_type": "stop",
-                        "content_items": event["content_items"],
-                        "usage_metadata": partial_usage["usage_metadata"],
-                        "finish_reason": partial_usage["finish_reason"],
-                    }
-                    partial_usage = {}
+                if event["finish_reason"] or event["usage_metadata"]:
+                    yield event
 
     async def list_models(self) -> list[str]:
         """

agenthub/gemini3_7/client.py

@@ -43,6 +43,24 @@ from ..types import (
 from ..utils import is_debug_enabled
 
 
+def _split_function_response_runs(parts: list[types.Part]) -> list[list[types.Part]]:
+    """Split parts into consecutive runs of function_response and other parts.
+
+    Vertex AI requires function responses to sit in a content of their own (see the call
+    site); order is preserved, and a message without function responses — or with nothing
+    else — comes back as one run.
+    """
+    runs: list[list[types.Part]] = []
+    last_is_response: bool | None = None
+    for part in parts:
+        is_response = part.function_response is not None
+        if is_response != last_is_response:
+            runs.append([])
+            last_is_response = is_response
+        runs[-1].append(part)
+    return runs if runs else [parts]
+
+
 class Gemini3_7Client(LLMClient):
     """Unified client for the Gemini family, named for the newest generation it serves (3.7).
 
@@ -201,12 +219,6 @@ class Gemini3_7Client(LLMClient):
             Gemini GenerateContentConfig object or None if no config needed
         """
         config_params = {}
-        if config.get("system_prompt") is not None:
-            config_params["system_instruction"] = config["system_prompt"]
-
-        if config.get("max_tokens") is not None:
-            config_params["max_output_tokens"] = config["max_tokens"]
-
         if config.get("temperature") is not None:
             raise UnsupportedParameterError(
                 self.__class__.__name__,
@@ -215,22 +227,6 @@ class Gemini3_7Client(LLMClient):
                 "sampling parameters starting with the 3.6 generation.",
             )
 
-        # include_thoughts asks for thought summaries, but whether generateContent returns any
-        # is model-dependent (llmsdk_docs/gemini3_7/docs/thinking.md)
-        thinking_summary = config.get("thinking_summary")
-        thinking_level = config.get("thinking_level")
-        if thinking_summary is not None or thinking_level is not None:
-            config_params["thinking_config"] = types.ThinkingConfig(
-                include_thoughts=thinking_summary, thinking_level=self._convert_thinking_level(thinking_level)
-            )
-
-        if config.get("tools") is not None:
-            config_params["tools"] = [types.Tool(function_declarations=config["tools"])]
-            tool_choice = config.get("tool_choice")
-            if tool_choice is not None:
-                tool_config = self._convert_tool_choice(tool_choice)
-                config_params["tool_config"] = types.ToolConfig(function_calling_config=tool_config)
-
         if config.get("fast_mode"):
             raise UnsupportedParameterError(self.__class__.__name__, "fast_mode", "Gemini does not support fast mode.")
 
@@ -239,10 +235,12 @@ class Gemini3_7Client(LLMClient):
                 self.__class__.__name__, "prompt_caching", "prompt_caching must be ENABLE for Gemini."
             )
 
-        if config.get("image_config") is not None:
-            config_params["image_config"] = types.ImageConfig(**config["image_config"])
+        if config.get("max_tokens") is not None:
+            config_params["max_output_tokens"] = config["max_tokens"]
 
-        # tts config
+        # A TTS model takes the speech settings and nothing else: a system instruction, a
+        # thinking config, or a tool declaration each comes back as a 400 (verified live
+        # 2026-08-20), so the rest of the universal config never reaches the request.
         if "tts" in self._model.lower():
             config_params["response_modalities"] = ["AUDIO"]
             tts_config = config.get("tts_config") or [{"voice": "Kore"}]
@@ -277,6 +275,30 @@ class Gemini3_7Client(LLMClient):
                     )
                 )
 
+            return types.GenerateContentConfig(**config_params)
+
+        if config.get("system_prompt") is not None:
+            config_params["system_instruction"] = config["system_prompt"]
+
+        # include_thoughts asks for thought summaries, but whether generateContent returns any
+        # is model-dependent (llmsdk_docs/gemini3_7/docs/thinking.md)
+        thinking_summary = config.get("thinking_summary")
+        thinking_level = config.get("thinking_level")
+        if thinking_summary is not None or thinking_level is not None:
+            config_params["thinking_config"] = types.ThinkingConfig(
+                include_thoughts=thinking_summary, thinking_level=self._convert_thinking_level(thinking_level)
+            )
+
+        if config.get("tools") is not None:
+            config_params["tools"] = [types.Tool(function_declarations=config["tools"])]
+            tool_choice = config.get("tool_choice")
+            if tool_choice is not None:
+                tool_config = self._convert_tool_choice(tool_choice)
+                config_params["tool_config"] = types.ToolConfig(function_calling_config=tool_config)
+
+        if config.get("image_config") is not None:
+            config_params["image_config"] = types.ImageConfig(**config["image_config"])
+
         return types.GenerateContentConfig(**config_params) if config_params else None
 
     @staticmethod
@@ -373,7 +395,14 @@ class Gemini3_7Client(LLMClient):
                 else:
                     raise ValueError(f"Unknown item: {item}")
 
-            contents.append(types.Content(role=mapping[msg["role"]], parts=parts))
+            # Vertex AI rejects a content that mixes function_response parts with any other
+            # part kind — the request fails with a misleading 400, "Requests ending with a
+            # model turn are not supported" (the Gemini API endpoint accepts the mix). Split
+            # such a message into consecutive same-role contents: each run of function
+            # responses becomes its own content, the surrounding parts keep theirs, and the
+            # part order is preserved. Homogeneous messages stay a single content.
+            for run_parts in _split_function_response_runs(parts):
+                contents.append(types.Content(role=mapping[msg["role"]], parts=run_parts))
 
         return contents
 
@@ -514,8 +543,12 @@ class Gemini3_7Client(LLMClient):
         # Use unified config conversion
         gemini_config = self.transform_uni_config_to_model_config(config)
 
-        # check if all items are text for tts model
+        # A TTS model synthesizes a single text turn: a conversation comes back as "Multiturn chat
+        # is not enabled for this model" and an audio part as "Audio input modality is not enabled
+        # for this model" (verified live 2026-08-20), so only the newest message is sent and the
+        # audio a stateful session records stays out of the request.
         if "tts" in self._model.lower():
+            messages = messages[-1:]
             invalid_item = next(
                 (item for message in messages for item in message["content_items"] if item["type"] != "text"),
                 None,

agenthub/gpt5_6/client.py

@@ -134,6 +134,16 @@ class GPT5_6Client(LLMClient):
             last_phase: str | None = None
 
             for item in msg["content_items"]:
+                # anything that is not message content becomes an input item of its own, so the
+                # text collected so far is flushed first to keep the order the model produced
+                if item["type"] not in ("text", "image_url") and content_items:
+                    entry = {"role": msg["role"], "content": content_items}
+                    if last_phase is not None:
+                        entry["phase"] = last_phase
+
+                    input_list.append(entry)
+                    content_items = []
+
                 if item["type"] == "text":
                     phase = (item.get("fidelity") or {}).get("phase")
                     if msg["role"] == "assistant" and phase:  # split different phases

agenthub/integration/playground.py

@@ -415,13 +415,53 @@ def create_chat_app() -> Flask:
                 return `${d.getFullYear()}-${pad(d.getMonth()+1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
             }
 
-            function pcmBase64ToWavDataUrl(pcmBase64, sampleRate = 24000, channels = 1, bitsPerSample = 16) {
-                const binary = atob(pcmBase64);
-                const pcmBytes = new Uint8Array(binary.length);
+            const AUDIO_MIME_TYPES = ['audio/wav', 'audio/x-wav', 'audio/mpeg', 'audio/mp3', 'audio/ogg', 'audio/webm', 'audio/flac', 'audio/aac', 'audio/mp4'];
+
+            function isAudioMimeType(mimeType) {
+                const value = (mimeType || '').toLowerCase();
+                return !value || value === 'application/octet-stream' || value.startsWith('audio/');
+            }
+
+            function base64ToBytes(base64) {
+                const binary = atob(base64);
+                const bytes = new Uint8Array(binary.length);
                 for (let i = 0; i < binary.length; i++) {
-                    pcmBytes[i] = binary.charCodeAt(i);
+                    bytes[i] = binary.charCodeAt(i);
                 }
+                return bytes;
+            }
 
+            function bytesToBase64(bytes) {
+                let binary = '';
+                const chunkSize = 0x8000;
+                for (let i = 0; i < bytes.length; i += chunkSize) {
+                    binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+                }
+                return btoa(binary);
+            }
+
+            function concatBase64Chunks(chunks) {
+                const parts = chunks.map(base64ToBytes);
+                const bytes = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
+                let offset = 0;
+                for (const part of parts) {
+                    bytes.set(part, offset);
+                    offset += part.length;
+                }
+                return bytes;
+            }
+
+            function pcmFormatFromMimeType(mimeType) {
+                // Gemini TTS labels its raw PCM as "audio/l16; rate=24000; channels=1"
+                const params = {};
+                for (const parameter of (mimeType || '').split(';').slice(1)) {
+                    const [key, value] = parameter.split('=');
+                    params[key.trim()] = Number(value);
+                }
+                return { sampleRate: params.rate || 24000, channels: params.channels || 1 };
+            }
+
+            function pcmBytesToWavDataUrl(pcmBytes, sampleRate = 24000, channels = 1, bitsPerSample = 16) {
                 const header = new ArrayBuffer(44);
                 const view = new DataView(header);
                 const byteRate = sampleRate * channels * bitsPerSample / 8;
@@ -450,13 +490,56 @@ def create_chat_app() -> Flask:
                 const wavBytes = new Uint8Array(44 + pcmBytes.length);
                 wavBytes.set(new Uint8Array(header), 0);
                 wavBytes.set(pcmBytes, 44);
+                return `data:audio/wav;base64,${bytesToBase64(wavBytes)}`;
+            }
 
-                let wavBinary = '';
-                const chunkSize = 0x8000;
-                for (let i = 0; i < wavBytes.length; i += chunkSize) {
-                    wavBinary += String.fromCharCode(...wavBytes.subarray(i, i + chunkSize));
+            function renderAudioPlayer(mimeType, chunks) {
+                const bytes = concatBase64Chunks(chunks);
+                if (AUDIO_MIME_TYPES.includes(mimeType)) {
+                    return `<audio controls preload="metadata" class="max-w-xs"><source src="data:${mimeType};base64,${bytesToBase64(bytes)}" type="${mimeType}"></audio>`;
+                }
+
+                const format = pcmFormatFromMimeType(mimeType);
+                const wavDataUrl = pcmBytesToWavDataUrl(bytes, format.sampleRate, format.channels);
+                return `<audio controls preload="metadata" class="max-w-xs"><source src="${wavDataUrl}" type="audio/wav"></audio>`;
+            }
+
+            function audioProgressLabel(audioStream) {
+                if (AUDIO_MIME_TYPES.includes(audioStream.mimeType)) {
+                    return `🔊 Receiving audio... ${Math.round(audioStream.bytes / 1024)} KB`;
+                }
+
+                // raw PCM carries no duration, so 16-bit samples turn the byte count into seconds
+                const format = pcmFormatFromMimeType(audioStream.mimeType);
+                const seconds = audioStream.bytes / (format.sampleRate * format.channels * 2);
+                return `🔊 Receiving audio... ${seconds.toFixed(1)}s`;
+            }
+
+            function appendAudioChunk(contentDiv, item, audioStream) {
+                if (!audioStream.container) {
+                    audioStream.mimeType = (item.mime_type || '').toLowerCase();
+                    audioStream.container = document.createElement('div');
+                    audioStream.container.className = 'mb-3 text-sm text-gray-500';
+                    contentDiv.appendChild(audioStream.container);
+                }
+
+                audioStream.chunks.push(item.data);
+                audioStream.bytes += Math.floor(item.data.length * 3 / 4);
+                audioStream.container.textContent = audioProgressLabel(audioStream);
+            }
+
+            function finalizeAudioStream(audioStream, autoplay = false) {
+                if (audioStream.finalized || !audioStream.container) {
+                    return;
+                }
+
+                audioStream.finalized = true;
+                audioStream.container.className = 'mb-3';
+                audioStream.container.innerHTML = renderAudioPlayer(audioStream.mimeType, audioStream.chunks);
+                if (autoplay) {
+                    // a browser that blocks autoplay leaves the player sitting there ready to press
+                    audioStream.container.querySelector('audio').play().catch(() => {});
                 }
-                return `data:audio/wav;base64,${btoa(wavBinary)}`;
             }
 
             function renderInlineData(item) {
@@ -465,17 +548,7 @@ def create_chat_app() -> Flask:
                     return `<div class="mb-3"><img src="data:${mimeType || 'image/png'};base64,${item.data}" class="max-w-xs rounded border border-gray-300"></div>`;
                 }
 
-                const audioMimeTypes = ['audio/wav', 'audio/x-wav', 'audio/mpeg', 'audio/mp3', 'audio/ogg', 'audio/webm', 'audio/flac', 'audio/aac', 'audio/mp4'];
-                const isAudio = !mimeType || mimeType === 'application/octet-stream' || mimeType.startsWith('audio/');
-                if (!isAudio) {
-                    return `<div class="mb-3 rounded border border-gray-300 bg-gray-50 px-3 py-2 text-xs text-gray-600">Inline data: ${escapeHtml(item.mime_type || 'application/octet-stream')}</div>`;
-                }
-
-                const playableMimeType = audioMimeTypes.includes(mimeType);
-                const audioSrc = playableMimeType
-                    ? `data:${mimeType || 'application/octet-stream'};base64,${item.data}`
-                    : pcmBase64ToWavDataUrl(item.data);
-                return `<div class="mb-3"><audio controls preload="metadata" class="max-w-xs"><source src="${audioSrc}" type="${playableMimeType ? mimeType : 'audio/wav'}"></audio></div>`;
+                return `<div class="mb-3 rounded border border-gray-300 bg-gray-50 px-3 py-2 text-xs text-gray-600">Inline data: ${escapeHtml(item.mime_type || 'application/octet-stream')}</div>`;
             }
 
             function renderEmbedding(item) {
@@ -594,6 +667,8 @@ def create_chat_app() -> Flask:
                 if (comboboxId === 'modelCombobox') {
                     handleModelSelectChange();
                 }
+
+                saveConfig();
             }
 
             function handleComboboxKeydown(event, comboboxId) {
@@ -860,6 +935,85 @@ def create_chat_app() -> Flask:
                 return config;
             }
 
+            const CONFIG_STORAGE_KEY = 'agenthub.playground.config';
+            // saved as typed rather than as parsed values, so an unfinished JSON edit survives too
+            const CONFIG_TEXT_INPUTS = [
+                'apiKeyInput', 'baseUrlInput', 'extraHeadersInput', 'systemPromptInput', 'toolsInput', 'traceIdInput'
+            ];
+            const CONFIG_COMBOBOXES = [
+                ['thinkingLevelCombobox', 'thinkingLevelSelect'],
+                ['thinkingSummaryCombobox', 'thinkingSummaryCheckbox'],
+                ['toolChoiceCombobox', 'toolChoiceSelect']
+            ];
+            let restoringConfig = false;
+
+            function comboboxOption(comboboxId, value) {
+                return document.querySelector('#' + comboboxId + ' [data-combobox-option][data-value="' + value + '"]');
+            }
+
+            function saveConfig() {
+                if (restoringConfig) {
+                    return;
+                }
+
+                const saved = { model: getSelectedModel(), client_type: getSelectedClientType() };
+                CONFIG_TEXT_INPUTS.forEach((id) => {
+                    saved[id] = document.getElementById(id).value;
+                });
+                CONFIG_COMBOBOXES.forEach(([, valueId]) => {
+                    saved[valueId] = document.getElementById(valueId).value;
+                });
+                try {
+                    localStorage.setItem(CONFIG_STORAGE_KEY, JSON.stringify(saved));
+                } catch (error) {
+                    // a browser that refuses storage still runs the playground, just without the memory
+                }
+            }
+
+            function restoreConfig() {
+                let saved = null;
+                try {
+                    saved = JSON.parse(localStorage.getItem(CONFIG_STORAGE_KEY) || 'null');
+                } catch (error) {
+                    saved = null;
+                }
+                if (!saved) {
+                    return;
+                }
+
+                restoringConfig = true;
+                try {
+                    CONFIG_TEXT_INPUTS.forEach((id) => {
+                        if (typeof saved[id] === 'string') {
+                            document.getElementById(id).value = saved[id];
+                        }
+                    });
+                    CONFIG_COMBOBOXES.forEach(([comboboxId, valueId]) => {
+                        const option = comboboxOption(comboboxId, saved[valueId] || '');
+                        if (option) {
+                            selectComboboxOption(comboboxId, option);
+                        }
+                    });
+
+                    // a model the menu does not list — one that was listed, or typed in — comes back as a custom entry
+                    const modelOption = saved.model ? comboboxOption('modelCombobox', saved.model) : null;
+                    if (modelOption) {
+                        selectComboboxOption('modelCombobox', modelOption);
+                    } else if (saved.model) {
+                        document.getElementById('customModelInput').value = saved.model;
+                        selectComboboxOption('modelCombobox', comboboxOption('modelCombobox', '__custom__'));
+                        // the custom option focuses its id field on selection, which a page load should not do
+                        document.getElementById('customModelInput').blur();
+                    }
+                    if (saved.client_type) {
+                        document.getElementById('customClientTypeInput').value = saved.client_type;
+                        handleClientTypeInput();
+                    }
+                } finally {
+                    restoringConfig = false;
+                }
+            }
+
             function addMessageCard(role, content, metadata = null, images = [], timestamp = null, tookMs = null) {
                 const container = document.getElementById('messagesContainer');
 
@@ -973,6 +1127,8 @@ def create_chat_app() -> Flask:
 
                 const assistantCard = addMessageCard('assistant', '');
                 const contentDiv = assistantCard.querySelector('.message-content');
+                // a spoken response streams as many small chunks that only play as one clip
+                const audioStream = { mimeType: '', chunks: [], bytes: 0, container: null, finalized: false };
 
                 try {
                     const config = getConfig();
@@ -1086,10 +1242,14 @@ def create_chat_app() -> Flask:
                                             toolResultDiv.innerHTML = `<strong class="text-sm">✅ Tool Result:</strong><br><div class="mt-1 text-xs whitespace-pre-wrap">${escapeHtml(item.text)}</div>`;
                                             contentDiv.appendChild(toolResultDiv);
                                         } else if (item.type === 'inline_data') {
-                                            const inlineDataDiv = document.createElement('div');
-                                            inlineDataDiv.innerHTML = renderInlineData(item);
-                                            if (inlineDataDiv.firstChild) {
-                                                contentDiv.appendChild(inlineDataDiv.firstChild);
+                                            if (isAudioMimeType(item.mime_type)) {
+                                                appendAudioChunk(contentDiv, item, audioStream);
+                                            } else {
+                                                const inlineDataDiv = document.createElement('div');
+                                                inlineDataDiv.innerHTML = renderInlineData(item);
+                                                if (inlineDataDiv.firstChild) {
+                                                    contentDiv.appendChild(inlineDataDiv.firstChild);
+                                                }
                                             }
                                         } else if (item.type === 'embedding') {
                                             const embeddingDiv = document.createElement('div');
@@ -1128,6 +1288,8 @@ def create_chat_app() -> Flask:
                         }
                     }
 
+                    finalizeAudioStream(audioStream, true);
+
                     if (lastCreatedAt) {
                         const timestampEl = assistantCard.querySelector('.msg-timestamp');
                         if (timestampEl) {
@@ -1156,11 +1318,13 @@ def create_chat_app() -> Flask:
                             metadataHtml += `<div class="flex items-center gap-1">🏁 ${metadata.finish_reason}</div>`;
                         }
                         metadataHtml += '</div>';
-                        assistantCard.innerHTML += metadataHtml;
+                        // appended rather than re-parsed into the card, which would restart a playing clip
+                        assistantCard.insertAdjacentHTML('beforeend', metadataHtml);
                     }
 
                 } catch (error) {
                     if (error.name === 'AbortError') {
+                        finalizeAudioStream(audioStream);
                         markInterrupted(contentDiv);
                     } else {
                         contentDiv.textContent = `Error: ${error.message}`;
@@ -1218,6 +1382,9 @@ def create_chat_app() -> Flask:
             textarea.addEventListener('input', resizeMessageInput);
             resizeMessageInput();
 
+            document.getElementById('configPanel').addEventListener('input', saveConfig);
+            restoreConfig();
+
         </script>
     </body>
     </html>

agenthub/minimax_m3/client.py

@@ -134,6 +134,12 @@ class MiniMaxM3Client(LLMClient):
         for message in messages:
             content_items: list[dict[str, Any]] = []
             for item in message["content_items"]:
+                # anything that is not message content becomes an input item of its own, so the
+                # text collected so far is flushed first to keep the order the model produced
+                if item["type"] not in ("text", "image_url") and content_items:
+                    input_list.append({"role": message["role"], "content": content_items})
+                    content_items = []
+
                 if item["type"] == "text":
                     content_items.append(
                         {

agenthub/openai_responses/client.py

@@ -130,6 +130,18 @@ class OpenaiResponsesClient(LLMClient):
             last_phase: str | None = None
 
             for item in msg["content_items"]:
+                # anything that is not message content becomes an input item of its own, so the
+                # text collected so far is flushed first to keep the original order: a server that
+                # merges a function call into the adjacent assistant message rejects a call whose
+                # output does not follow it (DeepSeek answers "No tool output found for tool call")
+                if item["type"] not in ("text", "image_url") and content_items:
+                    entry = {"role": msg["role"], "content": content_items}
+                    if last_phase is not None:
+                        entry["phase"] = last_phase
+
+                    input_list.append(entry)
+                    content_items = []
+
                 if item["type"] == "text":
                     phase = (item.get("fidelity") or {}).get("phase")
                     if msg["role"] == "assistant" and phase:  # split different phases

agenthub/registry.py

@@ -309,6 +309,17 @@ _SUPPORTED_MODELS: list[SupportedModel] = [
         # (Beijing 9:00-12:00, 14:00-18:00) are double
         "pricing": _cny(1.5, 4.5, cached=0.05),
     },
+    {
+        "model": "deepseek-v4-flash-vision-exp",
+        "base_url": _DEEPSEEK,
+        "client": "deepseek-v4",
+        "input_modalities": ["Text", "Image"],
+        "output_modalities": ["Text"],
+        "context_window": 1000000,
+        # priced as deepseek-v4-flash; official off-peak list price (verified 2026-08-21), and
+        # peak-hour rates (Beijing 9:00-12:00, 14:00-18:00) are double
+        "pricing": _cny(1.5, 4.5, cached=0.05),
+    },
     {
         "model": "deepseek-v4-pro",
         "base_url": _DEEPSEEK,
@@ -550,7 +561,7 @@ _SUPPORTED_MODELS: list[SupportedModel] = [
     {
         "model": "deepseek-ai/DeepSeek-V4-Flash",
         "base_url": _SILICONFLOW,
-        "client": "deepseek-v4",
+        "client": "openai-chat",
         "input_modalities": ["Text"],
         "output_modalities": ["Text"],
         "context_window": 1000000,
@@ -559,7 +570,7 @@ _SUPPORTED_MODELS: list[SupportedModel] = [
     {
         "model": "deepseek-ai/DeepSeek-V4-Pro",
         "base_url": _SILICONFLOW,
-        "client": "deepseek-v4",
+        "client": "openai-chat",
         "input_modalities": ["Text"],
         "output_modalities": ["Text"],
         "context_window": 1000000,

agenthub/types.py

@@ -38,6 +38,9 @@ class PromptCaching(StrEnum):
 # Tool choice can be a literal string or a list of tool names
 ToolChoice = Literal["auto", "required", "none"] | list[str]
 Role = Literal["user", "assistant"]
+# "start" opens an item, "delta" carries content, and "stop" closes the response with usage and
+# a finish reason. "unused" is a client's own marker for a wire event that carries nothing
+# universal, and never leaves the client.
 EventType = Literal["start", "delta", "stop", "unused"]
 FinishReason = Literal["stop", "length", "tool_call", "unknown"]
 AspectRatio = Literal["1:1", "2:3", "3:2", "3:4", "4:3", "9:16", "16:9", "21:9"]

{agenthub_python-0.4.5.dist-info → agenthub_python-0.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenthub-python
-Version: 0.4.5
+Version: 0.4.7
 Summary: AgentHub is the LLM API Hub for the Agent era, built for high-precision autonomous agents.
 Keywords: agent,llm,gemini,claude,gpt
 Author: PrismShadow

{agenthub_python-0.4.5.dist-info → agenthub_python-0.4.7.dist-info}/RECORD

@@ -3,34 +3,34 @@ agenthub/abort_signal.py,sha256=_j99RBZluBPdHLuRpZMyo15amll_8ZzmLO8fjLwEsaM,3744
 agenthub/ant_messages/__init__.py,sha256=wEz05advA7ggsvOYBffat7g8PN9TkOxYRBdeYPuoihY,672
 agenthub/ant_messages/client.py,sha256=Xo5qIKszI2vnEpRb67iV3YZdSL2F_2El5L74gMC3jaA,19098
 agenthub/auto_client.py,sha256=dlY__e1Dr5JAt87rnyxTZFBV6Q7n90IMLjRlf8eW4Y8,9036
-agenthub/base_client.py,sha256=6c4521Q3Ro0TNLHzVSWdhGXZaZL2eHwh4VEhHphnRVA,14263
+agenthub/base_client.py,sha256=K751iiWaFu_umqsYBITHCYuzDiNSoDqDFGxRsfj_NWo,15361
 agenthub/claude5/__init__.py,sha256=FzP_ijkZ67kK6W-VJwRYTswzSCt_YaWbOEcybQ_2FyM,664
 agenthub/claude5/client.py,sha256=S3qY8V8SfUqbC6YaUnbC3kRw7n-aMIiEGRKRpSB102A,21151
 agenthub/deepseek_v4/__init__.py,sha256=MEBBJlx2kicstbG3ncJp1gLpIeTG_fwNh_uZVsc7JcI,670
-agenthub/deepseek_v4/client.py,sha256=k5zTn1MLH01SRINrVXIhP89JPCqTAthavarVngRC76g,16803
+agenthub/deepseek_v4/client.py,sha256=qo0DWou3z9Rw2-qez7ncqhJVxjF1FX_U7goPtYyIeFg,16115
 agenthub/errors.py,sha256=hBDqqkKx7grNSnUoByzFXc7egLDKCiGWE-ZC_driZjA,3907
 agenthub/gemini3_7/__init__.py,sha256=bMyPUwyiuyGPU0h2q5bqmL4gfwh7FcSeqK_6kLn9WGI,668
-agenthub/gemini3_7/client.py,sha256=lx-mS-q2MWAMKJs3Z6reSScLnM1jaLV_b8y7otOY9sw,25443
+agenthub/gemini3_7/client.py,sha256=w66GBbII9oTGPwBdhe4gf5gzCkISBEvESZ6cKKcct2c,27450
 agenthub/glm5_3/__init__.py,sha256=DJhHMvliHikxdNA8HLNmxzRXLPASCc6aFJZTfpMX7fg,662
 agenthub/glm5_3/client.py,sha256=gBbSTwfnB-JZQNVopsXFciikN321tQTfVkesBuyDkYc,19853
 agenthub/gpt5_6/__init__.py,sha256=_KgiOi_VqTL82pf9Ks7VM-d_x5-at8v-N1KZDWLVvt8,662
-agenthub/gpt5_6/client.py,sha256=KPmZ-5ox96CJKZrePSpPlEKj5Ja9tz-Y1xhEHw_DU3I,17541
+agenthub/gpt5_6/client.py,sha256=ZOuJAW3_aqjcTykK6Q1_rCZvpPDb5TLBRiFnWFYkKIc,18072
 agenthub/integration/__init__.py,sha256=tlqmpVlFYm8uyMSa4RFebx5vi0FSS_GcES57JWVeu8c,600
-agenthub/integration/playground.py,sha256=BAyw6rb11WqsGuoVXQu4lbKXbAx_MS0QVp9u4KG1hSY,82308
+agenthub/integration/playground.py,sha256=7PVzhZZH9EPvhR2MhKenqcU_HZvWlPQ7cOpKLRdSTT4,90245
 agenthub/integration/tracer.py,sha256=qAcU8rvnDJMgJHg4niwN9aANwSnxh8MrMaWpKBwLaZo,41963
 agenthub/kimi_k3/__init__.py,sha256=MnoMhqRI6tlaXmQCHEud-2BqAvyxa_7Bxv3X8khfC3g,662
 agenthub/kimi_k3/client.py,sha256=S0P0pxjW3Yir0F_dP6P9E6mqxo74dRXSKWHa_pmB9dA,20905
 agenthub/minimax_m3/__init__.py,sha256=FTykS-0le7AdiU8zLeMjbj4QGBwR0oSIkOICqEFGoaw,668
-agenthub/minimax_m3/client.py,sha256=_WkP8B-VOYzXgpO6tGFAVSwQrv1tKk5x3wyzahSR0cQ,14612
+agenthub/minimax_m3/client.py,sha256=PuidXczWc901w3EgTj5DNLMZ8SlAQzbJn0zUP3aWdeY,15013
 agenthub/openai_chat/__init__.py,sha256=6X-4sX0Xy9MqSYVglW4ytt3NMSAzoRM3I_NFKwqOIVQ,670
 agenthub/openai_chat/client.py,sha256=-3g7krZMOrNKUDHoC43LXaE1fXo7VnTXelqrfe7Dfn0,18504
 agenthub/openai_embedding/__init__.py,sha256=t1W8kBvZUXICjDfgjTVxw-uIh5qoneUgmSsGIYan02s,680
 agenthub/openai_embedding/client.py,sha256=j0TM0JgU1ezSLkDFHHMXDOiAaE1NXtkSHTM-R6BmT4Y,4165
 agenthub/openai_responses/__init__.py,sha256=Y0YAAnkRYpIEq62phw5EpTfPt_osFXptujhpwBggM1E,680
-agenthub/openai_responses/client.py,sha256=08frEJaEhBJXvE3nXRiuCvCeaRu5u219RiZu0cvM5dY,16911
-agenthub/registry.py,sha256=SYvdOo_9uzeQ_jCxCruyvAH0geFQeC2IL-Fhpca-KDA,22072
-agenthub/types.py,sha256=hQapO7gvXHrlj3coh9Qw7OsOHkhXn04ni6GwdPA5xLw,5360
+agenthub/openai_responses/client.py,sha256=rEVw5IpD5w9Te6Ct0HxqBPyxmeS45FuJmbq9CHU80Z4,17645
+agenthub/registry.py,sha256=gh2rPyBI0yp3w92FyE7NmGvJm5luNhHxWk7ZDP8DpY4,22533
+agenthub/types.py,sha256=OUdtKpC2vzr8ZzB1Z3vpnl3RK02w6EL_7tnPosb31jI,5589
 agenthub/utils.py,sha256=nL4vlOZ6S-bZp6SBNvKjAhGiWhdAeJzVegZ2ALN88N0,1848
-agenthub_python-0.4.5.dist-info/WHEEL,sha256=4OL6Foqnnp3xRY5wMkjgc25_i5YJC6dKsC6LPcjqEoU,80
-agenthub_python-0.4.5.dist-info/METADATA,sha256=UYOwsKu0EWt0oLhYH9dbcbNfYoTKn6xkXOVQqjdiHy4,9171
-agenthub_python-0.4.5.dist-info/RECORD,,
+agenthub_python-0.4.7.dist-info/WHEEL,sha256=4OL6Foqnnp3xRY5wMkjgc25_i5YJC6dKsC6LPcjqEoU,80
+agenthub_python-0.4.7.dist-info/METADATA,sha256=6CSJXU8PvBQoUWFh_GI8t7l-VOzBEGVCXyvz0RNnWTc,9171
+agenthub_python-0.4.7.dist-info/RECORD,,