agenthub-python 0.3.2__tar.gz → 0.4.0__tar.gz

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenthub-python
-Version: 0.3.2
+Version: 0.4.0
 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
@@ -16,6 +16,9 @@ Requires-Dist: pytest-asyncio>=0.23.0 ; extra == 'dev'
 Requires-Dist: ruff>=0.14.3 ; extra == 'dev'
 Requires-Dist: pillow>=10.0.0 ; extra == 'dev'
 Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/Prism-Shadow/agenthub
+Project-URL: Repository, https://github.com/Prism-Shadow/agenthub
+Project-URL: Issues, https://github.com/Prism-Shadow/agenthub/issues
 Provides-Extra: dev
 Description-Content-Type: text/markdown
 

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/__init__.py

@@ -13,7 +13,15 @@
 # limitations under the License.
 
 from .auto_client import AutoLLMClient
+from .errors import AgentHubError, EmptyResponseError, ToolCallArgumentParseError
 from .types import PromptCaching, ThinkingLevel
 
 
-__all__ = ["AutoLLMClient", "PromptCaching", "ThinkingLevel"]
+__all__ = [
+    "AgentHubError",
+    "AutoLLMClient",
+    "EmptyResponseError",
+    "PromptCaching",
+    "ThinkingLevel",
+    "ToolCallArgumentParseError",
+]

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/auto_client.py

@@ -53,10 +53,12 @@ class AutoLLMClient(LLMClient):
             from .gemini3 import Gemini3Client
 
             return Gemini3Client(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):  # e.g., claude-opus-4-7
-            from .claude4_8 import Claude4_8Client
+        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
+            from .claude5 import Claude5Client
 
-            return Claude4_8Client(model=model, api_key=api_key, base_url=base_url)
+            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
 
@@ -77,14 +79,18 @@ class AutoLLMClient(LLMClient):
             from .deepseek_v4 import DeepSeekV4Client
 
             return DeepSeekV4Client(model=model, api_key=api_key, base_url=base_url)
-        elif "openai" in client_type:
+        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
 
             return OpenaiClient(model=model, api_key=api_key, base_url=base_url)
         else:
             raise ValueError(
                 f"{client_type} is not supported. "
-                "Supported client types: gemini-3, claude-4-8, claude-4-7, claude-4-6, gpt-5.5, gpt-5.4, glm-5.1, kimi-k2.6, kimi-k2.5, deepseek-v4, openai."
+                "Supported client types: gemini-3, claude-5, claude-4-8, claude-4-7, claude-4-6, gpt-5.5, gpt-5.4, glm-5.1, kimi-k2.6, kimi-k2.5, deepseek-v4, openai-embedding, openai."
             )
 
     def transform_uni_config_to_model_config(self, config: UniConfig) -> Any:

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/base_client.py

@@ -19,6 +19,7 @@ from contextlib import suppress
 from typing import Any, AsyncIterator
 
 from .abort_signal import AbortSignal
+from .errors import EmptyResponseError
 from .types import (
     ContentItem,
     FinishReason,
@@ -100,28 +101,40 @@ class LLMClient(ABC):
         for event in events:
             # Merge content_items from all events
             for item in event["content_items"]:
+                last_fidelity = (content_items[-1].get("fidelity") or {}) if content_items else {}
+                item_fidelity = item.get("fidelity") or {}
                 if item["type"] == "text":
+                    # a delta announcing a different phase starts a new item; same-phase and
+                    # phaseless deltas merge until a signature finishes the item
                     if (
                         content_items
                         and content_items[-1]["type"] == "text"
-                        and content_items[-1].get("signature") is None  # no signature yet
-                        and item.get("phase") is None  # no new phase
+                        and last_fidelity.get("signature") is None  # not finished by a signature yet
+                        and (
+                            item_fidelity.get("phase") is None  # phaseless deltas continue the item
+                            or item_fidelity.get("phase") == last_fidelity.get("phase")  # same phase merges
+                        )
                     ):
                         content_items[-1]["text"] += item["text"]
-                        if "signature" in item:  # finish the current item if signature is not None
-                            content_items[-1]["signature"] = item["signature"]
-                    elif item["text"] or item.get("phase") is not None:  # text or new phase starts an item
+                        if item_fidelity:  # a signature finishes the current item
+                            content_items[-1]["fidelity"] = {**last_fidelity, **item_fidelity}
+                    elif item["text"] or item_fidelity.get("phase") is not None:  # text or new phase starts an item
                         content_items.append(item.copy())
                 elif item["type"] == "thinking":
+                    # a new item starts only when the open item's fidelity is non-empty and
+                    # differs from the incoming delta's; everything else merges into it
                     if (
                         content_items
                         and content_items[-1]["type"] == "thinking"
-                        and content_items[-1].get("signature") is None  # no signature yet
+                        and (
+                            not last_fidelity  # not finished by fidelity yet
+                            or last_fidelity == item_fidelity  # a run of equal fidelity is one item
+                        )
                     ):
                         content_items[-1]["thinking"] += item["thinking"]
-                        if "signature" in item:  # finish the current item if signature is not None
-                            content_items[-1]["signature"] = item["signature"]
-                    elif item["thinking"] or item.get("signature"):  # omit empty thinking items
+                        if item_fidelity:  # fidelity finishes the current item
+                            content_items[-1]["fidelity"] = item_fidelity
+                    elif item["thinking"] or item_fidelity:  # omit empty thinking items
                         content_items.append(item.copy())
                 elif item["type"] == "partial_tool_call":
                     # Skip partial_tool_call items - they should already be converted to tool_call
@@ -244,6 +257,7 @@ class LLMClient(ABC):
             await stream.aclose()
 
         self._validate_last_event(last_event)
+        self._validate_non_thinking_output(events)
 
         # Save history to file if trace_id is specified
         if config.get("trace_id") and events:
@@ -312,6 +326,25 @@ class LLMClient(ABC):
         if last_event["finish_reason"] is None:
             raise ValueError(f"Last event must carry finish_reason, got: {last_event}")
 
+    def _validate_non_thinking_output(self, events: list[UniEvent]) -> None:
+        """Validate that the completed response carries content other than thinking.
+
+        Replaying a thinking-only assistant message on the next turn fails with a 400
+        error, so the response is rejected as soon as the stream completes.
+
+        Args:
+            events: All events yielded by streaming_response
+
+        Raises:
+            EmptyResponseError: If every content item in the response is thinking
+        """
+        thinking_only = all(
+            item["type"] in ("thinking", "inline_thinking") for event in events for item in event["content_items"]
+        )
+        if thinking_only:
+            finish_reason = events[-1]["finish_reason"] if events else None
+            raise EmptyResponseError(self.__class__.__name__, finish_reason)
+
     def clear_history(self) -> None:
         """Clear the message history."""
         self._history.clear()

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/claude4_6/client.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import base64
-import json
 import mimetypes
 import os
 import re
@@ -24,6 +23,7 @@ from anthropic import AsyncAnthropic, AsyncAnthropicBedrock
 from anthropic.types.beta import BetaMessageParam, BetaRawMessageStreamEvent
 
 from ..base_client import LLMClient
+from ..errors import parse_tool_call_arguments
 from ..types import (
     EventType,
     FinishReason,
@@ -204,10 +204,14 @@ class Claude4_6Client(LLMClient):
                     content_blocks.append(await 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["signature"]})
+                        content_blocks.append({"type": "redacted_thinking", "data": item["fidelity"]["signature"]})
                     else:
                         content_blocks.append(
-                            {"type": "thinking", "thinking": item["thinking"], "signature": item["signature"]}
+                            {
+                                "type": "thinking",
+                                "thinking": item["thinking"],
+                                "signature": item["fidelity"]["signature"],
+                            }
                         )
                 elif item["type"] == "tool_call":
                     content_blocks.append(
@@ -263,7 +267,9 @@ class Claude4_6Client(LLMClient):
                     {"type": "partial_tool_call", "name": block.name, "arguments": "", "tool_call_id": block.id}
                 )
             elif block.type == "redacted_thinking":
-                content_items.append({"type": "thinking", "thinking": REDACTED_THINKING, "signature": block.data})
+                content_items.append(
+                    {"type": "thinking", "thinking": REDACTED_THINKING, "fidelity": {"signature": block.data}}
+                )
 
         elif claude_event_type == "content_block_delta":
             event_type = "delta"
@@ -277,7 +283,7 @@ class Claude4_6Client(LLMClient):
                     {"type": "partial_tool_call", "name": "", "arguments": delta.partial_json, "tool_call_id": ""}
                 )
             elif delta.type == "signature_delta":
-                content_items.append({"type": "thinking", "thinking": "", "signature": delta.signature})
+                content_items.append({"type": "thinking", "thinking": "", "fidelity": {"signature": delta.signature}})
 
         elif claude_event_type == "content_block_stop":
             event_type = "stop"
@@ -403,7 +409,12 @@ class Claude4_6Client(LLMClient):
                             {
                                 "type": "tool_call",
                                 "name": partial_tool_call["name"],
-                                "arguments": json.loads(partial_tool_call["arguments"]),
+                                "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"],
                             }
                         ],

agenthub_python-0.4.0/agenthub/claude5/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2025 Prism Shadow. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .client import Claude5Client
+
+
+__all__ = ["Claude5Client"]

{agenthub_python-0.3.2/agenthub/claude4_8 → agenthub_python-0.4.0/agenthub/claude5}/client.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import base64
-import json
 import mimetypes
 import os
 import re
@@ -24,6 +23,7 @@ from anthropic import AsyncAnthropic, AsyncAnthropicBedrock
 from anthropic.types.beta import BetaMessageParam, BetaRawMessageStreamEvent
 
 from ..base_client import LLMClient
+from ..errors import parse_tool_call_arguments
 from ..types import (
     EventType,
     FinishReason,
@@ -41,11 +41,11 @@ from ..types import (
 REDACTED_THINKING = "_REDACTED_THINKING"
 
 
-class Claude4_8Client(LLMClient):
-    """Claude 4.8-specific LLM client implementation."""
+class Claude5Client(LLMClient):
+    """Claude 5-specific LLM client implementation."""
 
     def __init__(self, model: str, api_key: str | None = None, base_url: str | None = None):
-        """Initialize Claude 4.8 client with model and API key."""
+        """Initialize Claude 5 client with model and API key."""
         self._model = model
         api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
         base_url = base_url or os.getenv("ANTHROPIC_BASE_URL")
@@ -204,10 +204,14 @@ class Claude4_8Client(LLMClient):
                     content_blocks.append(await 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["signature"]})
+                        content_blocks.append({"type": "redacted_thinking", "data": item["fidelity"]["signature"]})
                     else:
                         content_blocks.append(
-                            {"type": "thinking", "thinking": item["thinking"], "signature": item["signature"]}
+                            {
+                                "type": "thinking",
+                                "thinking": item["thinking"],
+                                "signature": item["fidelity"]["signature"],
+                            }
                         )
                 elif item["type"] == "tool_call":
                     content_blocks.append(
@@ -263,7 +267,9 @@ class Claude4_8Client(LLMClient):
                     {"type": "partial_tool_call", "name": block.name, "arguments": "", "tool_call_id": block.id}
                 )
             elif block.type == "redacted_thinking":
-                content_items.append({"type": "thinking", "thinking": REDACTED_THINKING, "signature": block.data})
+                content_items.append(
+                    {"type": "thinking", "thinking": REDACTED_THINKING, "fidelity": {"signature": block.data}}
+                )
 
         elif claude_event_type == "content_block_delta":
             event_type = "delta"
@@ -277,7 +283,7 @@ class Claude4_8Client(LLMClient):
                     {"type": "partial_tool_call", "name": "", "arguments": delta.partial_json, "tool_call_id": ""}
                 )
             elif delta.type == "signature_delta":
-                content_items.append({"type": "thinking", "thinking": "", "signature": delta.signature})
+                content_items.append({"type": "thinking", "thinking": "", "fidelity": {"signature": delta.signature}})
 
         elif claude_event_type == "content_block_stop":
             event_type = "stop"
@@ -403,7 +409,12 @@ class Claude4_8Client(LLMClient):
                             {
                                 "type": "tool_call",
                                 "name": partial_tool_call["name"],
-                                "arguments": json.loads(partial_tool_call["arguments"]),
+                                "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"],
                             }
                         ],

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/deepseek_v4/client.py

@@ -20,6 +20,7 @@ from openai import AsyncOpenAI
 from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageParam
 
 from ..base_client import LLMClient
+from ..errors import parse_tool_call_arguments
 from ..types import (
     EventType,
     FinishReason,
@@ -200,7 +201,15 @@ class DeepSeekV4Client(LLMClient):
 
             if getattr(delta, "reasoning_content", None):
                 event_type = "delta"
-                content_items.append({"type": "thinking", "thinking": getattr(delta, "reasoning_content")})
+                # record the wire field so a replay through another OpenAI-compatible
+                # client reproduces the exact field DeepSeek produced
+                content_items.append(
+                    {
+                        "type": "thinking",
+                        "thinking": getattr(delta, "reasoning_content"),
+                        "fidelity": {"reasoning_field": "reasoning_content"},
+                    }
+                )
 
             if delta.content:
                 event_type = "delta"
@@ -289,7 +298,12 @@ class DeepSeekV4Client(LLMClient):
                                     {
                                         "type": "tool_call",
                                         "name": partial_tool_call["name"],
-                                        "arguments": json.loads(partial_tool_call["arguments"] or "{}"),
+                                        "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"],
                                     }
                                 ],
@@ -317,7 +331,12 @@ class DeepSeekV4Client(LLMClient):
                             {
                                 "type": "tool_call",
                                 "name": partial_tool_call["name"],
-                                "arguments": json.loads(partial_tool_call["arguments"] or "{}"),
+                                "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"],
                             }
                         ],

agenthub_python-0.4.0/agenthub/errors.py

@@ -0,0 +1,75 @@
+# Copyright 2025 Prism Shadow. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from typing import Any
+
+
+def _preview_tool_call_arguments(raw: str) -> str:
+    max_length = 160
+    if len(raw) <= max_length:
+        return raw
+
+    edge_length = 72
+    return f"{raw[:edge_length]}...[truncated]...{raw[-edge_length:]}"
+
+
+class AgentHubError(ValueError):
+    """Base class for errors raised by AgentHub clients."""
+
+
+class EmptyResponseError(AgentHubError):
+    """Raised when a completed response carries no non-thinking content and no tool calls.
+
+    Models occasionally finish a turn with thinking output only (reasoning models in
+    particular); replaying such an assistant message on the next turn fails with a 400
+    error, so the response is rejected as soon as the stream completes.
+    """
+
+    def __init__(self, client: str, finish_reason: str | None) -> None:
+        self.client = client
+        self.finish_reason = finish_reason
+        super().__init__(f"{client} returned no content other than thinking (finish_reason={finish_reason!r}).")
+
+
+class ToolCallArgumentParseError(AgentHubError):
+    def __init__(self, client: str, tool_name: str, tool_call_id: str, raw_arguments: str, reason: str) -> None:
+        self.client = client
+        self.tool_name = tool_name
+        self.tool_call_id = tool_call_id
+        self.raw_arguments_length = len(raw_arguments)
+        self.raw_arguments_preview = _preview_tool_call_arguments(raw_arguments)
+        super().__init__(
+            f'Invalid streamed tool call arguments from {client} for tool "{tool_name}" '
+            f'(tool_call_id="{tool_call_id}", length={self.raw_arguments_length}, '
+            f"preview={self.raw_arguments_preview!r}): {reason}"
+        )
+
+
+def parse_tool_call_arguments(
+    raw_arguments: str | None,
+    client: str,
+    tool_name: str,
+    tool_call_id: str,
+) -> dict[str, Any]:
+    raw = raw_arguments or "{}"
+    try:
+        parsed = json.loads(raw)
+    except (TypeError, ValueError) as exc:
+        raise ToolCallArgumentParseError(client, tool_name, tool_call_id, raw, str(exc)) from exc
+
+    if not isinstance(parsed, dict):
+        raise ToolCallArgumentParseError(client, tool_name, tool_call_id, raw, "Expected a JSON object.")
+
+    return parsed

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/gemini3/client.py

@@ -26,7 +26,9 @@ from google.oauth2 import service_account
 
 from ..base_client import LLMClient
 from ..types import (
+    ContentItem,
     EventType,
+    Fidelity,
     FinishReason,
     PartialContentItem,
     PromptCaching,
@@ -188,6 +190,19 @@ class Gemini3Client(LLMClient):
 
         return types.GenerateContentConfig(**config_params) if config_params else None
 
+    @staticmethod
+    def _part_fidelity(part: types.Part) -> dict[str, Fidelity]:
+        """Wrap a part's thought signature as a fidelity payload, or nothing when absent."""
+        if part.thought_signature is None:
+            return {}
+
+        return {"fidelity": {"signature": part.thought_signature}}
+
+    @staticmethod
+    def _item_thought_signature(item: ContentItem) -> str | bytes | None:
+        """Read the thought signature recorded in an item's fidelity payload."""
+        return (item.get("fidelity") or {}).get("signature")
+
     async def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[types.Content]:
         """
         Transform universal message format to Gemini's Content format.
@@ -204,26 +219,34 @@ class Gemini3Client(LLMClient):
             parts = []
             for item in msg["content_items"]:
                 if item["type"] == "text":
-                    parts.append(types.Part(text=item["text"], thought_signature=item.get("signature")))
+                    parts.append(types.Part(text=item["text"], thought_signature=self._item_thought_signature(item)))
                 elif item["type"] == "image_url":
                     image_url = item["image_url"]
                     image_data = await self._get_image_bytes_and_mime_type(image_url)
                     parts.append(types.Part.from_bytes(**image_data))
                 elif item["type"] == "inline_data":
                     inline_data = types.Blob(data=item["data"], mime_type=item["mime_type"])
-                    parts.append(types.Part(inline_data=inline_data, thought_signature=item.get("signature")))
+                    parts.append(
+                        types.Part(inline_data=inline_data, thought_signature=self._item_thought_signature(item))
+                    )
                 elif item["type"] == "thinking":
                     parts.append(
-                        types.Part(text=item["thinking"], thought=True, thought_signature=item.get("signature"))
+                        types.Part(
+                            text=item["thinking"], thought=True, thought_signature=self._item_thought_signature(item)
+                        )
                     )
                 elif item["type"] == "inline_thinking":
                     inline_data = types.Blob(data=item["data"], mime_type=item["mime_type"])
                     parts.append(
-                        types.Part(inline_data=inline_data, thought=True, thought_signature=item.get("signature"))
+                        types.Part(
+                            inline_data=inline_data, thought=True, thought_signature=self._item_thought_signature(item)
+                        )
                     )
                 elif item["type"] == "tool_call":
                     function_call = types.FunctionCall(name=item["name"], args=item["arguments"])
-                    parts.append(types.Part(function_call=function_call, thought_signature=item.get("signature")))
+                    parts.append(
+                        types.Part(function_call=function_call, thought_signature=self._item_thought_signature(item))
+                    )
                 elif item["type"] == "tool_result":
                     if "tool_call_id" not in item:
                         raise ValueError("tool_call_id is required for tool result.")
@@ -266,31 +289,30 @@ class Gemini3Client(LLMClient):
         usage_metadata: UsageMetadata | None = None
         finish_reason: FinishReason | None = None
 
-        if len(model_output.candidates) > 0:
+        if model_output.candidates:
             candidate = model_output.candidates[0]
-            for part in candidate.content.parts:
+            content = getattr(candidate, "content", None)
+            for part in getattr(content, "parts", None) or []:
                 if part.function_call is not None:
                     content_items.append(
                         {
                             "type": "tool_call",
                             "name": part.function_call.name,
-                            "arguments": part.function_call.args,
+                            "arguments": part.function_call.args or {},
                             "tool_call_id": part.function_call.name,
-                            "signature": part.thought_signature,
+                            **self._part_fidelity(part),
                         }
                     )
                 elif part.thought:
                     if part.text is not None:
-                        content_items.append(
-                            {"type": "thinking", "thinking": part.text, "signature": part.thought_signature}
-                        )
+                        content_items.append({"type": "thinking", "thinking": part.text, **self._part_fidelity(part)})
                     elif part.inline_data is not None:
                         content_items.append(
                             {
                                 "type": "inline_thinking",
                                 "data": part.inline_data.data,
                                 "mime_type": part.inline_data.mime_type,
-                                "signature": part.thought_signature,
+                                **self._part_fidelity(part),
                             }
                         )
                 elif part.inline_data is not None:
@@ -299,11 +321,11 @@ class Gemini3Client(LLMClient):
                             "type": "inline_data",
                             "data": part.inline_data.data,
                             "mime_type": part.inline_data.mime_type,
-                            "signature": part.thought_signature,
+                            **self._part_fidelity(part),
                         }
                     )
                 elif part.text is not None:
-                    content_items.append({"type": "text", "text": part.text, "signature": part.thought_signature})
+                    content_items.append({"type": "text", "text": part.text, **self._part_fidelity(part)})
                 else:
                     raise ValueError(f"Unknown output: {part}")
 
@@ -414,7 +436,7 @@ class Gemini3Client(LLMClient):
                                 "name": item["name"],
                                 "arguments": json.dumps(item["arguments"], ensure_ascii=False),
                                 "tool_call_id": item["tool_call_id"],
-                                "signature": item.get("signature"),
+                                "fidelity": item.get("fidelity"),
                             }
                         ],
                         "usage_metadata": None,

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/glm5_1/client.py

@@ -20,6 +20,7 @@ from openai import AsyncOpenAI
 from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageParam
 
 from ..base_client import LLMClient
+from ..errors import parse_tool_call_arguments
 from ..types import (
     EventType,
     FinishReason,
@@ -115,6 +116,7 @@ class GLM5_1Client(LLMClient):
             content_parts = []  # may be empty for tool results
             tool_calls = []  # may be empty for no tool calls
             thinking = ""
+            thinking_fields: set[str | None] = set()
             for item in msg["content_items"]:
                 if item["type"] == "text":
                     content_parts.append({"type": "text", "text": item["text"]})
@@ -122,6 +124,7 @@ class GLM5_1Client(LLMClient):
                     raise ValueError("GLM-5 does not support image inputs.")
                 elif item["type"] == "thinking":
                     thinking += item["thinking"]
+                    thinking_fields.add((item.get("fidelity") or {}).get("reasoning_field"))
                 elif item["type"] == "tool_call":
                     tool_calls.append(
                         {
@@ -159,8 +162,15 @@ class GLM5_1Client(LLMClient):
                 message["tool_calls"] = tool_calls
 
             if thinking:
-                message["reasoning_content"] = thinking  # vLLM & siliconflow compatibility
-                message["reasoning"] = thinking  # openrouter compatibility
+                # send thinking back through the exact field the upstream produced (recorded
+                # in the item fidelity); servers may reject the spelling they did not emit
+                if thinking_fields == {"reasoning_content"}:
+                    message["reasoning_content"] = thinking
+                elif thinking_fields == {"reasoning"}:
+                    message["reasoning"] = thinking
+                else:
+                    message["reasoning_content"] = thinking  # vLLM & siliconflow compatibility
+                    message["reasoning"] = thinking  # openrouter compatibility
 
             # message may be empty for tool results
             if len(message.keys()) > 1:
@@ -191,15 +201,29 @@ class GLM5_1Client(LLMClient):
                 event_type = "delta"
                 content_items.append({"type": "text", "text": delta.content})
 
-            # vLLM & siliconflow compatibility
-            if getattr(delta, "reasoning_content", None):
+            # the thinking field name differs by server: vLLM & siliconflow use reasoning_content
+            # while openrouter uses reasoning; record the wire field that carried each delta
+            # so a replay can reproduce exactly the field the upstream produced
+            reasoning_content = getattr(delta, "reasoning_content", None)
+            reasoning = getattr(delta, "reasoning", None)
+            if reasoning_content and reasoning:
                 event_type = "delta"
-                content_items.append({"type": "thinking", "thinking": getattr(delta, "reasoning_content")})
-
-            # openrouter compatibility
-            elif getattr(delta, "reasoning", None):
+                # ambiguous origin: record no fidelity so a replay sends both fields back
+                content_items.append({"type": "thinking", "thinking": reasoning_content})
+            elif reasoning_content:
+                event_type = "delta"
+                content_items.append(
+                    {
+                        "type": "thinking",
+                        "thinking": reasoning_content,
+                        "fidelity": {"reasoning_field": "reasoning_content"},
+                    }
+                )
+            elif reasoning:
                 event_type = "delta"
-                content_items.append({"type": "thinking", "thinking": getattr(delta, "reasoning")})
+                content_items.append(
+                    {"type": "thinking", "thinking": reasoning, "fidelity": {"reasoning_field": "reasoning"}}
+                )
 
             if delta.tool_calls:
                 event_type = "delta"
@@ -307,7 +331,12 @@ class GLM5_1Client(LLMClient):
                                     {
                                         "type": "tool_call",
                                         "name": partial_tool_call["name"],
-                                        "arguments": json.loads(partial_tool_call["arguments"] or "{}"),
+                                        "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"],
                                     }
                                 ],
@@ -335,7 +364,12 @@ class GLM5_1Client(LLMClient):
                             {
                                 "type": "tool_call",
                                 "name": partial_tool_call["name"],
-                                "arguments": json.loads(partial_tool_call["arguments"] or "{}"),
+                                "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"],
                             }
                         ],

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/gpt5_5/client.py

@@ -20,6 +20,7 @@ from openai import AsyncOpenAI
 from openai.types.responses import ResponseInputParam, ResponseStreamEvent
 
 from ..base_client import LLMClient
+from ..errors import parse_tool_call_arguments
 from ..types import (
     EventType,
     FinishReason,
@@ -119,12 +120,13 @@ class GPT5_5Client(LLMClient):
 
             for item in msg["content_items"]:
                 if item["type"] == "text":
-                    if msg["role"] == "assistant" and item.get("phase"):  # split different phases
-                        if last_phase is not None and content_items:
+                    phase = (item.get("fidelity") or {}).get("phase")
+                    if msg["role"] == "assistant" and phase:  # split different phases
+                        if last_phase is not None and last_phase != phase and content_items:
                             input_list.append({"role": msg["role"], "content": content_items, "phase": last_phase})
                             content_items = []
 
-                        last_phase = item["phase"]
+                        last_phase = phase
 
                     if msg["role"] == "user":
                         content_items.append({"type": "input_text", "text": item["text"]})
@@ -133,15 +135,15 @@ class GPT5_5Client(LLMClient):
                 elif item["type"] == "image_url":
                     content_items.append({"type": "input_image", "image_url": item["image_url"]})
                 elif item["type"] == "thinking":
-                    signature = json.loads(item["signature"])
+                    fidelity = item["fidelity"]
                     input_list.append(
                         {
                             "type": "reasoning",
-                            "id": signature["id"],
+                            "id": fidelity["id"],
                             "summary": [{"type": "summary_text", "text": item["thinking"]}]
                             if item["thinking"]
                             else [],
-                            "encrypted_content": signature["encrypted_content"],
+                            "encrypted_content": fidelity["encrypted_content"],
                         }
                     )
                 elif item["type"] == "tool_call":
@@ -216,16 +218,16 @@ class GPT5_5Client(LLMClient):
             # adding the following thinking item leads to 400 invalid request error, why?
             # elif model_output.item.type == "reasoning":
             #     event_type = "delta"
-            #     signature = {
+            #     fidelity = {
             #         "id": model_output.item.id,
             #         "encrypted_content": model_output.item.encrypted_content,
             #     }
-            #     content_items.append({"type": "thinking", "thinking": "", "signature": json.dumps(signature)})
+            #     content_items.append({"type": "thinking", "thinking": "", "fidelity": fidelity})
             elif model_output.item.type == "message":
                 if hasattr(model_output.item, "phase"):
                     event_type = "delta"
                     content_items.append(
-                        {"type": "text", "text": "", "phase": getattr(model_output.item, "phase", None)}
+                        {"type": "text", "text": "", "fidelity": {"phase": getattr(model_output.item, "phase", None)}}
                     )
                 else:
                     event_type = "unused"
@@ -236,11 +238,11 @@ class GPT5_5Client(LLMClient):
             # not sure about the signature of openai, need to check
             if model_output.item.type == "reasoning":
                 event_type = "delta"
-                signature = {
+                fidelity = {
                     "id": model_output.item.id,
                     "encrypted_content": model_output.item.encrypted_content,
                 }
-                content_items.append({"type": "thinking", "thinking": "", "signature": json.dumps(signature)})
+                content_items.append({"type": "thinking", "thinking": "", "fidelity": fidelity})
             else:
                 event_type = "unused"
 
@@ -341,7 +343,12 @@ class GPT5_5Client(LLMClient):
                             {
                                 "type": "tool_call",
                                 "name": partial_tool_call["name"],
-                                "arguments": json.loads(partial_tool_call["arguments"]),
+                                "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"],
                             }
                         ],

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/kimi_k2_6/client.py

@@ -23,6 +23,7 @@ from openai import AsyncOpenAI
 from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageParam
 
 from ..base_client import LLMClient
+from ..errors import parse_tool_call_arguments
 from ..types import (
     EventType,
     FinishReason,
@@ -143,6 +144,7 @@ class KimiK2_6Client(LLMClient):
             content_parts = []  # may be empty for tool results
             tool_calls = []  # may be empty for no tool calls
             thinking = ""
+            thinking_fields: set[str | None] = set()
             for item in msg["content_items"]:
                 if item["type"] == "text":
                     content_parts.append({"type": "text", "text": item["text"]})
@@ -151,6 +153,7 @@ class KimiK2_6Client(LLMClient):
                     content_parts.append({"type": "image_url", "image_url": {"url": base64_image}})
                 elif item["type"] == "thinking":
                     thinking += item["thinking"]
+                    thinking_fields.add((item.get("fidelity") or {}).get("reasoning_field"))
                 elif item["type"] == "tool_call":
                     tool_calls.append(
                         {
@@ -196,8 +199,15 @@ class KimiK2_6Client(LLMClient):
                 message["tool_calls"] = tool_calls
 
             if thinking:
-                message["reasoning_content"] = thinking  # vLLM & siliconflow compatibility
-                message["reasoning"] = thinking  # openrouter compatibility
+                # send thinking back through the exact field the upstream produced (recorded
+                # in the item fidelity); servers may reject the spelling they did not emit
+                if thinking_fields == {"reasoning_content"}:
+                    message["reasoning_content"] = thinking
+                elif thinking_fields == {"reasoning"}:
+                    message["reasoning"] = thinking
+                else:
+                    message["reasoning_content"] = thinking  # vLLM & siliconflow compatibility
+                    message["reasoning"] = thinking  # openrouter compatibility
 
             # message may be empty for tool results
             if len(message.keys()) > 1:
@@ -228,15 +238,29 @@ class KimiK2_6Client(LLMClient):
                 event_type = "delta"
                 content_items.append({"type": "text", "text": delta.content})
 
-            # vLLM & siliconflow compatibility
-            if getattr(delta, "reasoning_content", None):
+            # the thinking field name differs by server: vLLM & siliconflow use reasoning_content
+            # while openrouter uses reasoning; record the wire field that carried each delta
+            # so a replay can reproduce exactly the field the upstream produced
+            reasoning_content = getattr(delta, "reasoning_content", None)
+            reasoning = getattr(delta, "reasoning", None)
+            if reasoning_content and reasoning:
                 event_type = "delta"
-                content_items.append({"type": "thinking", "thinking": getattr(delta, "reasoning_content")})
-
-            # openrouter compatibility
-            elif getattr(delta, "reasoning", None):
+                # ambiguous origin: record no fidelity so a replay sends both fields back
+                content_items.append({"type": "thinking", "thinking": reasoning_content})
+            elif reasoning_content:
+                event_type = "delta"
+                content_items.append(
+                    {
+                        "type": "thinking",
+                        "thinking": reasoning_content,
+                        "fidelity": {"reasoning_field": "reasoning_content"},
+                    }
+                )
+            elif reasoning:
                 event_type = "delta"
-                content_items.append({"type": "thinking", "thinking": getattr(delta, "reasoning")})
+                content_items.append(
+                    {"type": "thinking", "thinking": reasoning, "fidelity": {"reasoning_field": "reasoning"}}
+                )
 
             if delta.tool_calls:
                 event_type = "delta"
@@ -341,7 +365,12 @@ class KimiK2_6Client(LLMClient):
                                     {
                                         "type": "tool_call",
                                         "name": partial_tool_call["name"],
-                                        "arguments": json.loads(partial_tool_call["arguments"] or "{}"),
+                                        "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"],
                                     }
                                 ],
@@ -369,7 +398,12 @@ class KimiK2_6Client(LLMClient):
                             {
                                 "type": "tool_call",
                                 "name": partial_tool_call["name"],
-                                "arguments": json.loads(partial_tool_call["arguments"] or "{}"),
+                                "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"],
                             }
                         ],

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/openai/client.py

@@ -23,6 +23,7 @@ from openai import AsyncOpenAI
 from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageParam
 
 from ..base_client import LLMClient
+from ..errors import parse_tool_call_arguments
 from ..types import (
     EventType,
     FinishReason,
@@ -128,6 +129,7 @@ class OpenaiClient(LLMClient):
             content_parts = []  # may be empty for tool results
             tool_calls = []  # may be empty for no tool calls
             thinking = ""
+            thinking_fields: set[str | None] = set()
             for item in msg["content_items"]:
                 if item["type"] == "text":
                     content_parts.append({"type": "text", "text": item["text"]})
@@ -136,6 +138,7 @@ class OpenaiClient(LLMClient):
                     content_parts.append({"type": "image_url", "image_url": {"url": base64_image}})
                 elif item["type"] == "thinking":
                     thinking += item["thinking"]
+                    thinking_fields.add((item.get("fidelity") or {}).get("reasoning_field"))
                 elif item["type"] == "tool_call":
                     tool_calls.append(
                         {
@@ -181,8 +184,15 @@ class OpenaiClient(LLMClient):
                 message["tool_calls"] = tool_calls
 
             if thinking:
-                message["reasoning_content"] = thinking  # vLLM & siliconflow compatibility
-                message["reasoning"] = thinking  # openrouter compatibility
+                # send thinking back through the exact field the upstream produced (recorded
+                # in the item fidelity); servers may reject the spelling they did not emit
+                if thinking_fields == {"reasoning_content"}:
+                    message["reasoning_content"] = thinking
+                elif thinking_fields == {"reasoning"}:
+                    message["reasoning"] = thinking
+                else:
+                    message["reasoning_content"] = thinking  # vLLM & siliconflow compatibility
+                    message["reasoning"] = thinking  # openrouter compatibility
 
             # message may be empty for tool results
             if len(message.keys()) > 1:
@@ -213,15 +223,29 @@ class OpenaiClient(LLMClient):
                 event_type = "delta"
                 content_items.append({"type": "text", "text": delta.content})
 
-            # vLLM & siliconflow compatibility
-            if getattr(delta, "reasoning_content", None):
+            # the thinking field name differs by server: vLLM & siliconflow use reasoning_content
+            # while openrouter uses reasoning; record the wire field that carried each delta
+            # so a replay can reproduce exactly the field the upstream produced
+            reasoning_content = getattr(delta, "reasoning_content", None)
+            reasoning = getattr(delta, "reasoning", None)
+            if reasoning_content and reasoning:
                 event_type = "delta"
-                content_items.append({"type": "thinking", "thinking": getattr(delta, "reasoning_content")})
-
-            # openrouter compatibility
-            elif getattr(delta, "reasoning", None):
+                # ambiguous origin: record no fidelity so a replay sends both fields back
+                content_items.append({"type": "thinking", "thinking": reasoning_content})
+            elif reasoning_content:
+                event_type = "delta"
+                content_items.append(
+                    {
+                        "type": "thinking",
+                        "thinking": reasoning_content,
+                        "fidelity": {"reasoning_field": "reasoning_content"},
+                    }
+                )
+            elif reasoning:
                 event_type = "delta"
-                content_items.append({"type": "thinking", "thinking": getattr(delta, "reasoning")})
+                content_items.append(
+                    {"type": "thinking", "thinking": reasoning, "fidelity": {"reasoning_field": "reasoning"}}
+                )
 
             if delta.tool_calls:
                 for tool_call in delta.tool_calls:
@@ -325,7 +349,12 @@ class OpenaiClient(LLMClient):
                                     {
                                         "type": "tool_call",
                                         "name": partial_tool_call["name"],
-                                        "arguments": json.loads(partial_tool_call["arguments"] or "{}"),
+                                        "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"],
                                     }
                                 ],
@@ -353,7 +382,12 @@ class OpenaiClient(LLMClient):
                             {
                                 "type": "tool_call",
                                 "name": partial_tool_call["name"],
-                                "arguments": json.loads(partial_tool_call["arguments"] or "{}"),
+                                "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"],
                             }
                         ],

{agenthub_python-0.3.2/agenthub/claude4_8 → agenthub_python-0.4.0/agenthub/openai_embedding}/__init__.py

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

agenthub_python-0.4.0/agenthub/openai_embedding/client.py

@@ -0,0 +1,80 @@
+# Copyright 2025 Prism Shadow. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from typing import Any, AsyncIterator
+
+from openai import AsyncOpenAI
+
+from ..base_client import LLMClient
+from ..types import UniConfig, UniEvent, UniMessage
+
+
+class OpenaiEmbeddingClient(LLMClient):
+    """OpenAI Embeddings-compatible client implementation."""
+
+    def __init__(self, model: str, api_key: str | None = None, base_url: str | None = None):
+        """Initialize OpenAI-compatible embedding client with model, API key, and base URL."""
+        self._model = model
+        api_key = api_key or os.getenv("OPENAI_API_KEY")
+        base_url = base_url or os.getenv("OPENAI_BASE_URL")
+        self._client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+        self._history: list[UniMessage] = []
+
+    def transform_uni_config_to_model_config(self, config: UniConfig) -> dict[str, Any]:
+        """Transform universal configuration to OpenAI Embeddings configuration."""
+        params: dict[str, Any] = {"model": self._model}
+        embedding_config = config.get("embedding_config") or {}
+        if embedding_config.get("dimensions") is not None:
+            params["dimensions"] = embedding_config["dimensions"]
+        return params
+
+    def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[str]:
+        """Transform universal messages to OpenAI Embeddings input strings."""
+        texts = []
+        for msg in messages:
+            msg_text = ""
+            for item in msg["content_items"]:
+                if item["type"] != "text":
+                    raise ValueError("OpenAI embeddings only support text content items.")
+                msg_text += item["text"]
+            texts.append(msg_text or " ")
+        return texts
+
+    def transform_model_output_to_uni_event(self, model_output: Any) -> UniEvent:
+        """Transform OpenAI Embeddings response to universal event format."""
+        usage = getattr(model_output, "usage", None)
+        return {
+            "role": "assistant",
+            "event_type": "stop",
+            "content_items": [{"type": "embedding", "embedding": item.embedding} for item in model_output.data],
+            "usage_metadata": {
+                "cached_tokens": None,
+                "prompt_tokens": usage.prompt_tokens if usage else None,
+                "thoughts_tokens": None,
+                "response_tokens": None,
+            },
+            "finish_reason": "stop",
+        }
+
+    async def _streaming_response_internal(
+        self,
+        messages: list[UniMessage],
+        config: UniConfig,
+    ) -> AsyncIterator[UniEvent]:
+        """Generate embeddings using OpenAI Embeddings-compatible API."""
+        params = self.transform_uni_config_to_model_config(config)
+        params["input"] = self.transform_uni_message_to_model_input(messages)
+        result = await self._client.embeddings.create(**params)
+        yield self.transform_model_output_to_uni_event(result)

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/agenthub/types.py

@@ -42,12 +42,16 @@ 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"]
 ImageSize = Literal["1K", "2K"]
 
+# Arbitrary JSON-style payload of wire-fidelity data recorded by a client, such as
+# thinking signatures, phase labels, or the upstream reasoning field name. Opaque to
+# consumers: pass it back unchanged so a replay reproduces the original wire message.
+Fidelity = dict[str, Any]
+
 
 class TextContentItem(TypedDict):
     type: Literal["text"]
     text: str
-    phase: NotRequired[str | None]
-    signature: NotRequired[str | bytes]
+    fidelity: NotRequired[Fidelity]
 
 
 class ImageContentItem(TypedDict):
@@ -59,20 +63,20 @@ class InlineDataContentItem(TypedDict):
     type: Literal["inline_data"]
     data: bytes
     mime_type: str
-    signature: NotRequired[str | bytes]
+    fidelity: NotRequired[Fidelity]
 
 
 class ThinkingContentItem(TypedDict):
     type: Literal["thinking"]
     thinking: str
-    signature: NotRequired[str | bytes]
+    fidelity: NotRequired[Fidelity]
 
 
 class InlineThinkingContentItem(TypedDict):
     type: Literal["inline_thinking"]
     data: bytes
     mime_type: str
-    signature: NotRequired[str | bytes]
+    fidelity: NotRequired[Fidelity]
 
 
 class ToolCallContentItem(TypedDict):
@@ -80,7 +84,7 @@ class ToolCallContentItem(TypedDict):
     name: str
     arguments: dict[str, Any]
     tool_call_id: str
-    signature: NotRequired[str | bytes]
+    fidelity: NotRequired[Fidelity]
 
 
 class PartialToolCallContentItem(TypedDict):
@@ -88,7 +92,7 @@ class PartialToolCallContentItem(TypedDict):
     name: str
     arguments: str
     tool_call_id: str
-    signature: NotRequired[str | bytes]
+    fidelity: NotRequired[Fidelity]
 
 
 class ToolResultContentItem(TypedDict):

{agenthub_python-0.3.2 → agenthub_python-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agenthub-python"
-version = "0.3.2"
+version = "0.4.0"
 description = "AgentHub is the LLM API Hub for the Agent era, built for high-precision autonomous agents."
 keywords = ["agent", "llm", "gemini", "claude", "gpt"]
 readme = "README.md"
@@ -11,6 +11,11 @@ authors = [
   {name = "PrismShadow"},
 ]
 
+[project.urls]
+Homepage = "https://github.com/Prism-Shadow/agenthub"
+Repository = "https://github.com/Prism-Shadow/agenthub"
+Issues = "https://github.com/Prism-Shadow/agenthub/issues"
+
 [project.optional-dependencies]
 dev = ["httpx[socks]", "pytest>=8.4.2", "pytest-asyncio>=0.23.0", "ruff>=0.14.3", "pillow>=10.0.0"]