agenthub-python 0.1.0__tar.gz → 0.2.0__tar.gz

{agenthub_python-0.1.0 → agenthub_python-0.2.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: agenthub-python
-Version: 0.1.0
-Summary: AgentHub package
+Version: 0.2.0
+Summary: AgentHub is the only SDK you need to connect to state-of-the-art LLMs
 Requires-Dist: google-genai>=1.5.0
-Requires-Dist: httpx[socks]
 Requires-Dist: anthropic>=0.40.0
 Requires-Dist: flask>=3.0.0
+Requires-Dist: openai>=1.0.0
 Requires-Python: >=3.11

{agenthub_python-0.1.0 → agenthub_python-0.2.0}/agenthub/__init__.py

@@ -13,8 +13,7 @@
 # limitations under the License.
 
 from .auto_client import AutoLLMClient
-from .tracer import Tracer
-from .types import ThinkingLevel
+from .types import PromptCaching, ThinkingLevel
 
 
-__all__ = ["AutoLLMClient", "ThinkingLevel", "Tracer"]
+__all__ = ["AutoLLMClient", "PromptCaching", "ThinkingLevel"]

{agenthub_python-0.1.0 → agenthub_python-0.2.0}/agenthub/auto_client.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 from typing import Any, AsyncIterator
 
 from .base_client import LLMClient
@@ -26,30 +27,50 @@ class AutoLLMClient(LLMClient):
     conversation history for that specific model.
     """
 
-    def __init__(self, model: str, api_key: str | None = None):
+    def __init__(
+        self, model: str, api_key: str | None = None, base_url: str | None = None, client_type: str | None = None
+    ):
         """
         Initialize AutoLLMClient with a specific model.
 
         Args:
             model: Model identifier (determines which client to use)
             api_key: Optional API key
+            base_url: Optional base URL for API requests
+            client_type: Optional client type override
         """
-        self._client = self._create_client_for_model(model, api_key)
+        self._client = self._create_client_for_model(model, api_key, base_url, client_type)
 
-    def _create_client_for_model(self, model: str, api_key: str | None = None) -> LLMClient:
+    def _create_client_for_model(
+        self, model: str, api_key: str | None = None, base_url: str | None = None, client_type: str | None = None
+    ) -> LLMClient:
         """Create the appropriate client for the given model."""
-        if "gemini-3" in model.lower():  # e.g., gemini-3-flash-preview
+        client_type = client_type or os.getenv("CLIENT_TYPE", model.lower())
+        if "gemini-3" in client_type:  # e.g., gemini-3-flash-preview
             from .gemini3 import Gemini3Client
 
-            return Gemini3Client(model=model, api_key=api_key)
-        elif "claude" in model.lower() and "4-5" in model.lower():  # e.g., claude-sonnet-4-5
+            return Gemini3Client(model=model, api_key=api_key, base_url=base_url)
+        elif "claude" in client_type and "4-5" in client_type:  # e.g., claude-sonnet-4-5
             from .claude4_5 import Claude4_5Client
 
-            return Claude4_5Client(model=model, api_key=api_key)
-        elif "gpt-5.2" in model.lower():  # e.g., gpt-5.2
-            raise NotImplementedError("GPT models not yet implemented.")
+            return Claude4_5Client(model=model, api_key=api_key, base_url=base_url)
+        elif "gpt-5.1" in client_type or "gpt-5.2" in client_type:  # e.g., gpt-5.2
+            from .gpt5_2 import GPT5_2Client
+
+            return GPT5_2Client(model=model, api_key=api_key, base_url=base_url)
+        elif "glm-4.7" in client_type:  # e.g., glm-4.7
+            from .glm4_7 import GLM4_7Client
+
+            return GLM4_7Client(model=model, api_key=api_key, base_url=base_url)
+        elif "qwen3" in client_type:
+            from .qwen3 import Qwen3Client
+
+            return Qwen3Client(model=model, api_key=api_key, base_url=base_url)
         else:
-            raise ValueError(f"{model} is not supported.")
+            raise ValueError(
+                f"{client_type} is not supported. "
+                "Supported client types: gemini-3, claude-4-5, gpt-5.2, glm-4.7, qwen3."
+            )
 
     def transform_uni_config_to_model_config(self, config: UniConfig) -> Any:
         """Delegate to underlying client's transform_uni_config_to_model_config."""

{agenthub_python-0.1.0 → agenthub_python-0.2.0}/agenthub/base_client.py

@@ -26,6 +26,7 @@ class LLMClient(ABC):
     the required abstract methods for complete SDK abstraction.
     """
 
+    _model: str
     _history: list[UniMessage] = []
 
     @abstractmethod
@@ -99,8 +100,11 @@ class LLMClient(ABC):
                         content_items[-1]["thinking"] += item["thinking"]
                         if "signature" in item:  # signature may appear at the last item
                             content_items[-1]["signature"] = item["signature"]
-                    elif item["thinking"]:  # omit empty thinking items
+                    elif item["thinking"] or item.get("signature"):  # 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
+                    pass
                 else:
                     content_items.append(item.copy())
 
@@ -171,10 +175,10 @@ class LLMClient(ABC):
 
         # Save history to file if trace_id is specified
         if config.get("trace_id"):
-            from .tracer import Tracer
+            from .integration.tracer import Tracer
 
             tracer = Tracer()
-            tracer.save_history(self._history, config["trace_id"], config)
+            tracer.save_history(self._model, self._history, config["trace_id"], config)
 
     def clear_history(self) -> None:
         """Clear the message history."""

{agenthub_python-0.1.0 → agenthub_python-0.2.0}/agenthub/claude4_5/client.py

@@ -21,9 +21,10 @@ from anthropic.types import MessageParam, MessageStreamEvent
 
 from ..base_client import LLMClient
 from ..types import (
+    EventType,
     FinishReason,
     PartialContentItem,
-    PartialUniEvent,
+    PromptCaching,
     ThinkingLevel,
     ToolChoice,
     UniConfig,
@@ -36,14 +37,15 @@ from ..types import (
 class Claude4_5Client(LLMClient):
     """Claude 4.5-specific LLM client implementation."""
 
-    def __init__(self, model: str, api_key: str | None = None):
+    def __init__(self, model: str, api_key: str | None = None, base_url: str | None = None):
         """Initialize Claude 4.5 client with model and API key."""
         self._model = model
         api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
-        self._client = AsyncAnthropic(api_key=api_key)
+        base_url = base_url or os.getenv("ANTHROPIC_BASE_URL")
+        self._client = AsyncAnthropic(api_key=api_key, base_url=base_url)
         self._history: list[UniMessage] = []
 
-    def _convert_thinking_level_to_budget(self, thinking_level: ThinkingLevel) -> dict:
+    def _convert_thinking_level_to_budget(self, thinking_level: ThinkingLevel) -> dict[str, Any]:
         """Convert ThinkingLevel enum to Claude's budget_tokens."""
 
         mapping = {
@@ -54,7 +56,7 @@ class Claude4_5Client(LLMClient):
         }
         return mapping.get(thinking_level)
 
-    def _convert_tool_choice(self, tool_choice: ToolChoice) -> dict[str, Any]:
+    def _convert_tool_choice(self, tool_choice: ToolChoice) -> dict[str, str]:
         """Convert ToolChoice to Claude's tool_choice format."""
         if isinstance(tool_choice, list):
             if len(tool_choice) > 1:
@@ -80,21 +82,17 @@ class Claude4_5Client(LLMClient):
         """
         claude_config = {"model": self._model}
 
-        # Add max_tokens (required for Claude)
+        if config.get("system_prompt") is not None:
+            claude_config["system"] = config["system_prompt"]
+
         if config.get("max_tokens") is not None:
             claude_config["max_tokens"] = config["max_tokens"]
         else:
             claude_config["max_tokens"] = 32768  # Claude requires max_tokens to be specified
 
-        # Add temperature
         if config.get("temperature") is not None:
             claude_config["temperature"] = config["temperature"]
 
-        # Add system prompt
-        if config.get("system_prompt") is not None:
-            claude_config["system"] = config["system_prompt"]
-
-        # Convert thinking configuration
         # NOTE: Claude always provides thinking summary
         if config.get("thinking_level") is not None:
             claude_config["temperature"] = 1.0  # `temperature` may only be set to 1 when thinking is enabled
@@ -148,7 +146,7 @@ class Claude4_5Client(LLMClient):
                             "type": "tool_use",
                             "id": item["tool_call_id"],
                             "name": item["name"],
-                            "input": item["argument"],
+                            "input": item["arguments"],
                         }
                     )
                 elif item["type"] == "tool_result":
@@ -165,7 +163,7 @@ class Claude4_5Client(LLMClient):
 
         return claude_messages
 
-    def transform_model_output_to_uni_event(self, model_output: MessageStreamEvent) -> PartialUniEvent:
+    def transform_model_output_to_uni_event(self, model_output: MessageStreamEvent) -> UniEvent:
         """
         Transform Claude model output to universal event format.
 
@@ -177,7 +175,7 @@ class Claude4_5Client(LLMClient):
         Returns:
             Universal event dictionary
         """
-        event_type = None
+        event_type: EventType | None = None
         content_items: list[PartialContentItem] = []
         usage_metadata: UsageMetadata | None = None
         finish_reason: FinishReason | None = None
@@ -188,7 +186,7 @@ class Claude4_5Client(LLMClient):
             block = model_output.content_block
             if block.type == "tool_use":
                 content_items.append(
-                    {"type": "partial_tool_call", "name": block.name, "argument": "", "tool_call_id": block.id}
+                    {"type": "partial_tool_call", "name": block.name, "arguments": "", "tool_call_id": block.id}
                 )
 
         elif claude_event_type == "content_block_delta":
@@ -199,7 +197,9 @@ class Claude4_5Client(LLMClient):
             elif delta.type == "text_delta":
                 content_items.append({"type": "text", "text": delta.text})
             elif delta.type == "input_json_delta":
-                content_items.append({"type": "partial_tool_call", "argument": delta.partial_json})
+                content_items.append(
+                    {"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})
 
@@ -214,6 +214,7 @@ class Claude4_5Client(LLMClient):
                     "prompt_tokens": message.usage.input_tokens,
                     "thoughts_tokens": None,
                     "response_tokens": None,
+                    "cached_tokens": message.usage.cache_read_input_tokens,
                 }
 
         elif claude_event_type == "message_delta":
@@ -233,6 +234,7 @@ class Claude4_5Client(LLMClient):
                     "prompt_tokens": None,
                     "thoughts_tokens": None,
                     "response_tokens": model_output.usage.output_tokens,
+                    "cached_tokens": None,
                 }
 
         elif claude_event_type == "message_stop":
@@ -246,7 +248,7 @@ class Claude4_5Client(LLMClient):
 
         return {
             "role": "assistant",
-            "event": event_type,
+            "event_type": event_type,
             "content_items": content_items,
             "usage_metadata": usage_metadata,
             "finish_reason": finish_reason,
@@ -264,51 +266,81 @@ class Claude4_5Client(LLMClient):
         # Use unified message conversion
         claude_messages = self.transform_uni_message_to_model_input(messages)
 
+        # Add cache_control to last user message's last item if enabled
+        prompt_caching = config.get("prompt_caching", PromptCaching.ENABLE)
+        if prompt_caching != PromptCaching.DISABLE and claude_messages:
+            try:
+                last_user_message = next(filter(lambda x: x["role"] == "user", claude_messages[::-1]))
+                last_content_item = last_user_message["content"][-1]
+                last_content_item["cache_control"] = {
+                    "type": "ephemeral",
+                    "ttl": "1h" if prompt_caching == PromptCaching.ENHANCE else "5m",
+                }
+            except StopIteration:
+                pass
+
         # Stream generate
         partial_tool_call = {}
         partial_usage = {}
         async with self._client.messages.stream(**claude_config, messages=claude_messages) as stream:
             async for event in stream:
                 event = self.transform_model_output_to_uni_event(event)
-                if event["event"] == "start":
-                    if event["content_items"] and event["content_items"][0]["type"] == "partial_tool_call":
-                        partial_tool_call["name"] = event["content_items"][0]["name"]
-                        partial_tool_call["argument"] = ""
-                        partial_tool_call["tool_call_id"] = event["content_items"][0]["tool_call_id"]
+                if event["event_type"] == "start":
+                    for item in event["content_items"]:
+                        if item["type"] == "partial_tool_call":
+                            # initialize partial_tool_call
+                            partial_tool_call = {
+                                "name": item["name"],
+                                "arguments": "",
+                                "tool_call_id": item["tool_call_id"],
+                            }
+                            yield event
 
                     if event["usage_metadata"] is not None:
-                        partial_usage["prompt_tokens"] = event["usage_metadata"]["prompt_tokens"]
+                        # initialize partial_usage
+                        partial_usage = {
+                            "prompt_tokens": event["usage_metadata"]["prompt_tokens"],
+                            "cached_tokens": event["usage_metadata"]["cached_tokens"],
+                        }
+
+                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"]
 
-                elif event["event"] == "delta":
-                    if event["content_items"][0]["type"] == "partial_tool_call":
-                        partial_tool_call["argument"] += event["content_items"][0]["argument"]
-                    else:
-                        event.pop("event")
-                        yield event
+                    yield event
 
-                elif event["event"] == "stop":
-                    if "name" in partial_tool_call and "argument" in partial_tool_call:
+                elif event["event_type"] == "stop":
+                    if "name" in partial_tool_call and "arguments" in partial_tool_call:
+                        # finish partial_tool_call
                         yield {
                             "role": "assistant",
+                            "event_type": "delta",
                             "content_items": [
                                 {
                                     "type": "tool_call",
                                     "name": partial_tool_call["name"],
-                                    "argument": json.loads(partial_tool_call["argument"]),
+                                    "arguments": json.loads(partial_tool_call["arguments"]),
                                     "tool_call_id": partial_tool_call["tool_call_id"],
                                 }
                             ],
+                            "usage_metadata": None,
+                            "finish_reason": None,
                         }
                         partial_tool_call = {}
 
                     if "prompt_tokens" in partial_usage and event["usage_metadata"] is not None:
+                        # finish partial_usage
                         yield {
                             "role": "assistant",
+                            "event_type": "stop",
                             "content_items": [],
                             "usage_metadata": {
                                 "prompt_tokens": partial_usage["prompt_tokens"],
                                 "thoughts_tokens": None,
                                 "response_tokens": event["usage_metadata"]["response_tokens"],
+                                "cached_tokens": partial_usage["cached_tokens"],
                             },
                             "finish_reason": event["finish_reason"],
                         }

{agenthub_python-0.1.0 → agenthub_python-0.2.0}/agenthub/gemini3/client.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import os
 from typing import AsyncIterator
 
@@ -20,9 +21,10 @@ from google.genai import types
 
 from ..base_client import LLMClient
 from ..types import (
+    EventType,
     FinishReason,
     PartialContentItem,
-    PartialUniEvent,
+    PromptCaching,
     ThinkingLevel,
     ToolChoice,
     UniConfig,
@@ -35,11 +37,14 @@ from ..types import (
 class Gemini3Client(LLMClient):
     """Gemini 3-specific LLM client implementation."""
 
-    def __init__(self, model: str, api_key: str | None = None):
+    def __init__(self, model: str, api_key: str | None = None, base_url: str | None = None):
         """Initialize Gemini 3 client with model and API key."""
         self._model = model
         api_key = api_key or os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
-        self._client = genai.Client(api_key=api_key) if api_key else genai.Client()
+        base_url = base_url or os.getenv("GOOGLE_GEMINI_BASE_URL")
+        self._client = (
+            genai.Client(api_key=api_key, http_options={"base_url": base_url}) if api_key else genai.Client()
+        )
         self._history: list[UniMessage] = []
 
     def _detect_mime_type(self, url: str) -> str | None:
@@ -49,7 +54,7 @@ class Gemini3Client(LLMClient):
         mime_type, _ = mimetypes.guess_type(url)
         return mime_type
 
-    def _convert_thinking_level(self, thinking_level: ThinkingLevel) -> types.ThinkingLevel | None:
+    def _convert_thinking_level(self, thinking_level: ThinkingLevel | None) -> types.ThinkingLevel | None:
         """Convert ThinkingLevel enum to Gemini's ThinkingLevel."""
         mapping = {
             ThinkingLevel.NONE: types.ThinkingLevel.MINIMAL,
@@ -90,7 +95,6 @@ class Gemini3Client(LLMClient):
         if config.get("temperature") is not None:
             config_params["temperature"] = config["temperature"]
 
-        # Convert thinking level
         thinking_summary = config.get("thinking_summary")
         thinking_level = config.get("thinking_level")
         if thinking_summary is not None or thinking_level is not None:
@@ -98,7 +102,6 @@ class Gemini3Client(LLMClient):
                 include_thoughts=thinking_summary, thinking_level=self._convert_thinking_level(thinking_level)
             )
 
-        # Convert tools and tool choice
         if config.get("tools") is not None:
             config_params["tools"] = [types.Tool(function_declarations=config["tools"])]
             tool_choice = config.get("tool_choice")
@@ -106,6 +109,9 @@ class Gemini3Client(LLMClient):
                 tool_config = self._convert_tool_choice(tool_choice)
                 config_params["tool_config"] = types.ToolConfig(function_calling_config=tool_config)
 
+        if config.get("prompt_caching") is not None and config["prompt_caching"] != PromptCaching.ENABLE:
+            raise ValueError("prompt_caching must be ENABLE for Gemini 3.")
+
         return types.GenerateContentConfig(**config_params) if config_params else None
 
     def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[types.Content]:
@@ -135,7 +141,7 @@ class Gemini3Client(LLMClient):
                         types.Part(text=item["thinking"], thought=True, thought_signature=item.get("signature"))
                     )
                 elif item["type"] == "tool_call":
-                    function_call = types.FunctionCall(name=item["name"], args=item["argument"])
+                    function_call = types.FunctionCall(name=item["name"], args=item["arguments"])
                     parts.append(types.Part(function_call=function_call, thought_signature=item.get("signature")))
                 elif item["type"] == "tool_result":
                     if "tool_call_id" not in item:
@@ -153,7 +159,7 @@ class Gemini3Client(LLMClient):
 
         return contents
 
-    def transform_model_output_to_uni_event(self, model_output: types.GenerateContentResponse) -> PartialUniEvent:
+    def transform_model_output_to_uni_event(self, model_output: types.GenerateContentResponse) -> UniEvent:
         """
         Transform Gemini model output to universal event format.
 
@@ -163,6 +169,7 @@ class Gemini3Client(LLMClient):
         Returns:
             Universal event dictionary
         """
+        event_type: EventType = "delta"
         content_items: list[PartialContentItem] = []
         usage_metadata: UsageMetadata | None = None
         finish_reason: FinishReason | None = None
@@ -174,7 +181,7 @@ class Gemini3Client(LLMClient):
                     {
                         "type": "tool_call",
                         "name": part.function_call.name,
-                        "argument": part.function_call.args,
+                        "arguments": part.function_call.args,
                         "tool_call_id": part.function_call.name,
                         "signature": part.thought_signature,
                     }
@@ -186,23 +193,26 @@ class Gemini3Client(LLMClient):
             else:
                 raise ValueError(f"Unknown output: {part}")
 
-        if model_output.usage_metadata:
-            usage_metadata = {
-                "prompt_tokens": model_output.usage_metadata.prompt_token_count,
-                "thoughts_tokens": model_output.usage_metadata.thoughts_token_count,
-                "response_tokens": model_output.usage_metadata.candidates_token_count,
-            }
-
         if candidate.finish_reason:
+            event_type = "stop"
             stop_reason_mapping = {
                 types.FinishReason.STOP: "stop",
                 types.FinishReason.MAX_TOKENS: "length",
             }
             finish_reason = stop_reason_mapping.get(candidate.finish_reason, "unknown")
 
+        if model_output.usage_metadata:
+            event_type = event_type or "delta"  # deal with separate usage data
+            usage_metadata = {
+                "prompt_tokens": model_output.usage_metadata.prompt_token_count,
+                "thoughts_tokens": model_output.usage_metadata.thoughts_token_count,
+                "response_tokens": model_output.usage_metadata.candidates_token_count,
+                "cached_tokens": model_output.usage_metadata.cached_content_token_count,
+            }
+
         return {
             "role": "assistant",
-            "event": "delta",
+            "event_type": event_type,
             "content_items": content_items,
             "usage_metadata": usage_metadata,
             "finish_reason": finish_reason,
@@ -226,6 +236,23 @@ class Gemini3Client(LLMClient):
         )
         async for chunk in response_stream:
             event = self.transform_model_output_to_uni_event(chunk)
-            if event["event"] == "delta":
-                event.pop("event")
-                yield event
+            for item in event["content_items"]:
+                if item["type"] == "tool_call":
+                    # gemini 3 does not support partial tool call, mock a partial tool call event
+                    yield {
+                        "role": "assistant",
+                        "event_type": "delta",
+                        "content_items": [
+                            {
+                                "type": "partial_tool_call",
+                                "name": item["name"],
+                                "arguments": json.dumps(item["arguments"], ensure_ascii=False),
+                                "tool_call_id": item["tool_call_id"],
+                                "signature": item.get("signature"),
+                            }
+                        ],
+                        "usage_metadata": None,
+                        "finish_reason": None,
+                    }
+
+            yield event

agenthub_python-0.2.0/agenthub/glm4_7/__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 GLM4_7Client
+
+
+__all__ = ["GLM4_7Client"]