agenthub-python 0.4.5__tar.gz → 0.4.7__tar.gz

{agenthub_python-0.4.5 → agenthub_python-0.4.7}/PKG-INFO

@@ -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 → agenthub_python-0.4.7}/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_python-0.4.7/agenthub/deepseek_v4/client.py

@@ -0,0 +1,371 @@
+# 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
+import os
+from typing import Any, AsyncIterator
+
+from openai import AsyncOpenAI
+from openai.types.responses import ResponseInputParam, ResponseStreamEvent
+
+from ..base_client import LLMClient
+from ..errors import UnsupportedParameterError, parse_tool_call_arguments
+from ..types import (
+    EventType,
+    FinishReason,
+    PartialContentItem,
+    PromptCaching,
+    ThinkingLevel,
+    ToolChoice,
+    UniConfig,
+    UniEvent,
+    UniMessage,
+    UsageMetadata,
+)
+from ..utils import is_debug_enabled
+
+
+class DeepSeekV4Client(LLMClient):
+    """DeepSeek V4-specific LLM client implementation using the OpenAI-compatible Responses API."""
+
+    def __init__(
+        self,
+        model: str,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        default_headers: dict[str, str] | None = None,
+    ):
+        """Initialize DeepSeek client with model, API key, and base URL."""
+        self._model = model
+        api_key = api_key or os.getenv("DEEPSEEK_API_KEY")
+        base_url = base_url or os.getenv("DEEPSEEK_BASE_URL") or "https://api.deepseek.com"
+        self._client = AsyncOpenAI(api_key=api_key, base_url=base_url, default_headers=default_headers)
+        self._history: list[UniMessage] = []
+
+    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. 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.LOW: "low",
+            ThinkingLevel.MEDIUM: "high",
+            ThinkingLevel.HIGH: "high",
+            ThinkingLevel.XHIGH: "high",
+            ThinkingLevel.MAX: "max",
+        }
+        return mapping[thinking_level]
+
+    def _convert_tool_choice(self, tool_choice: ToolChoice) -> str:
+        """Convert ToolChoice to DeepSeek's Responses-compatible tool_choice format."""
+        if tool_choice in ["auto", "none"]:
+            return tool_choice
+        raise UnsupportedParameterError(
+            self.__class__.__name__, "tool_choice", "DeepSeek V4 only supports 'auto' and 'none' for tool_choice."
+        )
+
+    def transform_uni_config_to_model_config(self, config: UniConfig) -> dict[str, Any]:
+        """
+        Transform universal configuration to DeepSeek-specific configuration.
+
+        Args:
+            config: Universal configuration dict
+
+        Returns:
+            DeepSeek configuration dictionary
+        """
+        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_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."
+            )
+
+        # 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", **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"])
+
+        if config.get("fast_mode"):
+            raise UnsupportedParameterError(
+                self.__class__.__name__, "fast_mode", "DeepSeek V4 does not support fast mode."
+            )
+
+        if config.get("prompt_caching") is not None and config["prompt_caching"] != PromptCaching.ENABLE:
+            raise UnsupportedParameterError(
+                self.__class__.__name__, "prompt_caching", "prompt_caching must be ENABLE for DeepSeek."
+            )
+
+        return deepseek_config
+
+    def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> ResponseInputParam:
+        """
+        Transform universal message format to DeepSeek's Responses-compatible input format.
+
+        Args:
+            messages: List of universal message dictionaries
+
+        Returns:
+            List of input items for the Responses API
+        """
+        # 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_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":
+                    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":
+                    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":
+                    # 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":
+                    input_list.append(
+                        {
+                            "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.")
+
+                    # 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.")
+
+                        for image_url in item["images"]:
+                            tool_result.append({"type": "input_image", "image_url": image_url})
+
+                    input_list.append(
+                        {"type": "function_call_output", "call_id": item["tool_call_id"], "output": tool_result}
+                    )
+                else:
+                    raise ValueError(f"Unknown item: {item}")
+
+            if content_items:
+                input_list.append({"role": msg["role"], "content": content_items})
+
+        return input_list
+
+    def transform_model_output_to_uni_event(self, model_output: ResponseStreamEvent) -> UniEvent:
+        """
+        Transform DeepSeek streaming event to universal event format.
+
+        Args:
+            model_output: Responses API streaming event
+
+        Returns:
+            Universal event dictionary
+        """
+        event_type: EventType | None = None
+        content_items: list[PartialContentItem] = []
+        usage_metadata: UsageMetadata | None = None
+        finish_reason: FinishReason | None = None
+
+        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})
+
+        elif deepseek_event_type == "response.output_item.added":
+            if model_output.item.type == "function_call":
+                event_type = "start"
+                content_items.append(
+                    {
+                        "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": ""}
+            )
+
+        elif deepseek_event_type == "response.function_call_arguments.done":
+            event_type = "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,
+                }
+
+        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",
+            "event_type": event_type,
+            "content_items": content_items,
+            "usage_metadata": usage_metadata,
+            "finish_reason": finish_reason,
+        }
+
+    async def _streaming_response_internal(
+        self,
+        messages: list[UniMessage],
+        config: UniConfig,
+    ) -> AsyncIterator[UniEvent]:
+        """Stream generate using DeepSeek's OpenAI-compatible Responses API."""
+        # Use unified config conversion
+        deepseek_config = self.transform_uni_config_to_model_config(config)
+
+        # Use unified message conversion
+        input_list = self.transform_uni_message_to_model_input(messages)
+
+        # Stream generate
+        partial_tool_call = {}
+        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":
+                        # 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 "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"],
+                                "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 = {}
+
+                if event["finish_reason"] or event["usage_metadata"]:
+                    yield event
+
+    async def list_models(self) -> list[str]:
+        """
+        List the model ids the configured endpoint serves.
+
+        Returns:
+            list[str]: The model ids, in the order the endpoint returned them.
+        """
+        return [model.id async for model in self._client.models.list()]

{agenthub_python-0.4.5 → agenthub_python-0.4.7}/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_python-0.4.5 → agenthub_python-0.4.7}/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