agenthub-python 0.4.13__tar.gz → 0.4.15__tar.gz

{agenthub_python-0.4.13 → agenthub_python-0.4.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenthub-python
-Version: 0.4.13
+Version: 0.4.15
 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.13 → agenthub_python-0.4.15}/agenthub/deepseek_v4/client.py

@@ -201,16 +201,23 @@ class DeepSeekV4Client(LLMClient):
                         raise ValueError("tool_call_id is required for tool result.")
 
                     # NOTE: tool results are input items
-                    tool_result = [{"type": "input_text", "text": item["text"]}]
+                    image_parts = []
                     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})
+                            image_parts.append({"type": "input_image", "image_url": image_url})
+
+                    # a plain string is the form the Responses API documents for a text result and the
+                    # one every endpoint that fronts this model accepts; the content-part list is
+                    # reserved for results carrying images
+                    output = (
+                        [{"type": "input_text", "text": item["text"]}, *image_parts] if image_parts else item["text"]
+                    )
 
                     input_list.append(
-                        {"type": "function_call_output", "call_id": item["tool_call_id"], "output": tool_result}
+                        {"type": "function_call_output", "call_id": item["tool_call_id"], "output": output}
                     )
                 else:
                     raise ValueError(f"Unknown item: {item}")
@@ -253,6 +260,7 @@ class DeepSeekV4Client(LLMClient):
                         "name": model_output.item.name,
                         "arguments": "",
                         "tool_call_id": model_output.item.call_id,
+                        "item_id": model_output.item.id,
                     }
                 )
             else:
@@ -261,11 +269,27 @@ class DeepSeekV4Client(LLMClient):
         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": ""}
+                {
+                    "type": "partial_tool_call",
+                    "name": "",
+                    "arguments": model_output.delta,
+                    "tool_call_id": "",
+                    "item_id": model_output.item_id,
+                }
             )
 
         elif deepseek_event_type == "response.function_call_arguments.done":
+            # a stop naming the item closes that call
             event_type = "stop"
+            content_items.append(
+                {
+                    "type": "partial_tool_call",
+                    "name": "",
+                    "arguments": "",
+                    "tool_call_id": "",
+                    "item_id": model_output.item_id,
+                }
+            )
 
         elif deepseek_event_type in ("response.completed", "response.incomplete"):
             event_type = "stop"
@@ -327,51 +351,61 @@ class DeepSeekV4Client(LLMClient):
         # Use unified message conversion
         input_list = self.transform_uni_message_to_model_input(messages)
 
+        # Calls still streaming, keyed by the item id their fragments carry (the call id when a
+        # server sends none): a gateway may open several before closing any of them.
+        open_tool_calls: dict[str, dict] = {}
+        last_opened = ""
+
+        def key_of(item_id: str | None) -> str:
+            return item_id if item_id in open_tool_calls else last_opened
+
         # 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)
+        async for model_event in stream:
+            event = self.transform_model_output_to_uni_event(model_event)
+            fragments = [item for item in event["content_items"] if item["type"] == "partial_tool_call"]
             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
+                for item in fragments:
+                    last_opened = item.get("item_id") or item["tool_call_id"]
+                    open_tool_calls[last_opened] = {
+                        "name": item["name"],
+                        "tool_call_id": item["tool_call_id"],
+                        "arguments": "",
+                    }
+                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"]
-
+                for item in fragments:
+                    tool_call = open_tool_calls.get(key_of(item.get("item_id")))
+                    if tool_call is not None:
+                        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
+                # a stop that names calls closes them; the end of the response closes whatever
+                # a gateway never closed on its own
+                closing = [key_of(item.get("item_id")) for item in fragments] or list(open_tool_calls)
+                for key in closing:
+                    tool_call = open_tool_calls.pop(key, None)
+                    if tool_call is None:
+                        continue
                     yield {
                         "role": "assistant",
                         "event_type": "delta",
                         "content_items": [
                             {
                                 "type": "tool_call",
-                                "name": partial_tool_call["name"],
+                                "name": tool_call["name"],
                                 "arguments": parse_tool_call_arguments(
-                                    partial_tool_call["arguments"],
+                                    tool_call["arguments"],
                                     self.__class__.__name__,
-                                    partial_tool_call["name"],
-                                    partial_tool_call["tool_call_id"],
+                                    tool_call["name"],
+                                    tool_call["tool_call_id"],
                                 ),
-                                "tool_call_id": partial_tool_call["tool_call_id"],
+                                "tool_call_id": tool_call["tool_call_id"],
                             }
                         ],
                         "usage_metadata": None,
                         "finish_reason": None,
                     }
-                    partial_tool_call = {}
 
                 if event["finish_reason"] or event["usage_metadata"]:
                     yield event

{agenthub_python-0.4.13 → agenthub_python-0.4.15}/agenthub/gpt6/client.py

@@ -212,13 +212,20 @@ class GPT6Client(LLMClient):
                         raise ValueError("tool_call_id is required for tool result.")
 
                     # NOTE: tool results are input items
-                    tool_result = [{"type": "input_text", "text": item["text"]}]
+                    image_parts = []
                     if "images" in item:
                         for image_url in item["images"]:
-                            tool_result.append(self._convert_image_url(image_url))
+                            image_parts.append(self._convert_image_url(image_url))
+
+                    # a plain string is the form the Responses API documents for a text result and the
+                    # one every endpoint that fronts this model accepts; the content-part list is
+                    # reserved for results carrying images
+                    output = (
+                        [{"type": "input_text", "text": item["text"]}, *image_parts] if image_parts else item["text"]
+                    )
 
                     input_list.append(
-                        {"type": "function_call_output", "call_id": item["tool_call_id"], "output": tool_result}
+                        {"type": "function_call_output", "call_id": item["tool_call_id"], "output": output}
                     )
                 else:
                     raise ValueError(f"Unknown item: {item}")
@@ -265,6 +272,7 @@ class GPT6Client(LLMClient):
                         "name": model_output.item.name,
                         "arguments": "",
                         "tool_call_id": model_output.item.call_id,
+                        "item_id": model_output.item.id,
                     }
                 )
             elif model_output.item.type == "message":
@@ -281,11 +289,27 @@ class GPT6Client(LLMClient):
         elif openai_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": ""}
+                {
+                    "type": "partial_tool_call",
+                    "name": "",
+                    "arguments": model_output.delta,
+                    "tool_call_id": "",
+                    "item_id": model_output.item_id,
+                }
             )
 
         elif openai_event_type == "response.function_call_arguments.done":
+            # a stop naming the item closes that call
             event_type = "stop"
+            content_items.append(
+                {
+                    "type": "partial_tool_call",
+                    "name": "",
+                    "arguments": "",
+                    "tool_call_id": "",
+                    "item_id": model_output.item_id,
+                }
+            )
 
         elif openai_event_type in ("response.completed", "response.incomplete"):
             event_type = "stop"
@@ -375,51 +399,61 @@ class GPT6Client(LLMClient):
         # Use unified message conversion
         input_list = self.transform_uni_message_to_model_input(messages)
 
+        # Calls still streaming, keyed by the item id their fragments carry (the call id when a
+        # server sends none): a gateway may open several before closing any of them.
+        open_tool_calls: dict[str, dict] = {}
+        last_opened = ""
+
+        def key_of(item_id: str | None) -> str:
+            return item_id if item_id in open_tool_calls else last_opened
+
         # Stream generate
-        partial_tool_call = {}
         stream = await self._client.responses.create(**openai_config, input=input_list, stream=True)
-        async for event in stream:
-            event = self.transform_model_output_to_uni_event(event)
+        async for model_event in stream:
+            event = self.transform_model_output_to_uni_event(model_event)
+            fragments = [item for item in event["content_items"] if item["type"] == "partial_tool_call"]
             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
+                for item in fragments:
+                    last_opened = item.get("item_id") or item["tool_call_id"]
+                    open_tool_calls[last_opened] = {
+                        "name": item["name"],
+                        "tool_call_id": item["tool_call_id"],
+                        "arguments": "",
+                    }
+                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"]
-
+                for item in fragments:
+                    tool_call = open_tool_calls.get(key_of(item.get("item_id")))
+                    if tool_call is not None:
+                        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
+                # a stop that names calls closes them; the end of the response closes whatever
+                # a gateway never closed on its own
+                closing = [key_of(item.get("item_id")) for item in fragments] or list(open_tool_calls)
+                for key in closing:
+                    tool_call = open_tool_calls.pop(key, None)
+                    if tool_call is None:
+                        continue
                     yield {
                         "role": "assistant",
                         "event_type": "delta",
                         "content_items": [
                             {
                                 "type": "tool_call",
-                                "name": partial_tool_call["name"],
+                                "name": tool_call["name"],
                                 "arguments": parse_tool_call_arguments(
-                                    partial_tool_call["arguments"],
+                                    tool_call["arguments"],
                                     self.__class__.__name__,
-                                    partial_tool_call["name"],
-                                    partial_tool_call["tool_call_id"],
+                                    tool_call["name"],
+                                    tool_call["tool_call_id"],
                                 ),
-                                "tool_call_id": partial_tool_call["tool_call_id"],
+                                "tool_call_id": tool_call["tool_call_id"],
                             }
                         ],
                         "usage_metadata": None,
                         "finish_reason": None,
                     }
-                    partial_tool_call = {}
 
                 if event["finish_reason"] or event["usage_metadata"]:
                     yield event

{agenthub_python-0.4.13 → agenthub_python-0.4.15}/agenthub/minimax_m3/client.py

@@ -217,17 +217,34 @@ class MiniMaxM3Client(LLMClient):
                         "name": model_output.item.name,
                         "arguments": "",
                         "tool_call_id": model_output.item.call_id,
+                        "item_id": model_output.item.id,
                     }
                 )
 
         elif minimax_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": ""}
+                {
+                    "type": "partial_tool_call",
+                    "name": "",
+                    "arguments": model_output.delta,
+                    "tool_call_id": "",
+                    "item_id": model_output.item_id,
+                }
             )
 
         elif minimax_event_type == "response.function_call_arguments.done":
+            # a stop naming the item closes that call
             event_type = "stop"
+            content_items.append(
+                {
+                    "type": "partial_tool_call",
+                    "name": "",
+                    "arguments": "",
+                    "tool_call_id": "",
+                    "item_id": model_output.item_id,
+                }
+            )
 
         elif minimax_event_type in ("response.completed", "response.incomplete"):
             event_type = "stop"
@@ -279,50 +296,60 @@ class MiniMaxM3Client(LLMClient):
         minimax_config = self.transform_uni_config_to_model_config(config)
         input_list = self.transform_uni_message_to_model_input(messages)
 
-        partial_tool_call = {}
+        # Calls still streaming, keyed by the item id their fragments carry (the call id when a
+        # server sends none): a gateway may open several before closing any of them.
+        open_tool_calls: dict[str, dict] = {}
+        last_opened = ""
+
+        def key_of(item_id: str | None) -> str:
+            return item_id if item_id in open_tool_calls else last_opened
+
         stream = await self._client.responses.create(**minimax_config, input=input_list, stream=True)
         async for model_event in stream:
             event = self.transform_model_output_to_uni_event(model_event)
+            fragments = [item for item in event["content_items"] if item["type"] == "partial_tool_call"]
             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
+                for item in fragments:
+                    last_opened = item.get("item_id") or item["tool_call_id"]
+                    open_tool_calls[last_opened] = {
+                        "name": item["name"],
+                        "tool_call_id": item["tool_call_id"],
+                        "arguments": "",
+                    }
+                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"]
-
+                for item in fragments:
+                    tool_call = open_tool_calls.get(key_of(item.get("item_id")))
+                    if tool_call is not None:
+                        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
+                # a stop that names calls closes them; the end of the response closes whatever
+                # a gateway never closed on its own
+                closing = [key_of(item.get("item_id")) for item in fragments] or list(open_tool_calls)
+                for key in closing:
+                    tool_call = open_tool_calls.pop(key, None)
+                    if tool_call is None:
+                        continue
                     yield {
                         "role": "assistant",
                         "event_type": "delta",
                         "content_items": [
                             {
                                 "type": "tool_call",
-                                "name": partial_tool_call["name"],
+                                "name": tool_call["name"],
                                 "arguments": parse_tool_call_arguments(
-                                    partial_tool_call["arguments"],
+                                    tool_call["arguments"],
                                     self.__class__.__name__,
-                                    partial_tool_call["name"],
-                                    partial_tool_call["tool_call_id"],
+                                    tool_call["name"],
+                                    tool_call["tool_call_id"],
                                 ),
-                                "tool_call_id": partial_tool_call["tool_call_id"],
+                                "tool_call_id": tool_call["tool_call_id"],
                             }
                         ],
                         "usage_metadata": None,
                         "finish_reason": None,
                     }
-                    partial_tool_call = {}
 
                 if event["finish_reason"] or event["usage_metadata"]:
                     yield event

{agenthub_python-0.4.13 → agenthub_python-0.4.15}/agenthub/openai_responses/client.py

@@ -268,6 +268,7 @@ class OpenaiResponsesClient(LLMClient):
                         "name": model_output.item.name,
                         "arguments": "",
                         "tool_call_id": model_output.item.call_id,
+                        "item_id": model_output.item.id,
                     }
                 )
             elif model_output.item.type == "message" and getattr(model_output.item, "phase", None):
@@ -295,11 +296,27 @@ class OpenaiResponsesClient(LLMClient):
         elif openai_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": ""}
+                {
+                    "type": "partial_tool_call",
+                    "name": "",
+                    "arguments": model_output.delta,
+                    "tool_call_id": "",
+                    "item_id": model_output.item_id,
+                }
             )
 
         elif openai_event_type == "response.function_call_arguments.done":
+            # a stop naming the item closes that call
             event_type = "stop"
+            content_items.append(
+                {
+                    "type": "partial_tool_call",
+                    "name": "",
+                    "arguments": "",
+                    "tool_call_id": "",
+                    "item_id": model_output.item_id,
+                }
+            )
 
         elif openai_event_type in ("response.completed", "response.incomplete"):
             event_type = "stop"
@@ -364,51 +381,61 @@ class OpenaiResponsesClient(LLMClient):
         # Use unified message conversion
         input_list = self.transform_uni_message_to_model_input(messages)
 
+        # Calls still streaming, keyed by the item id their fragments carry (the call id when a
+        # server sends none): a gateway may open several before closing any of them.
+        open_tool_calls: dict[str, dict] = {}
+        last_opened = ""
+
+        def key_of(item_id: str | None) -> str:
+            return item_id if item_id in open_tool_calls else last_opened
+
         # Stream generate
-        partial_tool_call = {}
         stream = await self._client.responses.create(**openai_config, input=input_list, stream=True)
-        async for event in stream:
-            event = self.transform_model_output_to_uni_event(event)
+        async for model_event in stream:
+            event = self.transform_model_output_to_uni_event(model_event)
+            fragments = [item for item in event["content_items"] if item["type"] == "partial_tool_call"]
             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
+                for item in fragments:
+                    last_opened = item.get("item_id") or item["tool_call_id"]
+                    open_tool_calls[last_opened] = {
+                        "name": item["name"],
+                        "tool_call_id": item["tool_call_id"],
+                        "arguments": "",
+                    }
+                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"]
-
+                for item in fragments:
+                    tool_call = open_tool_calls.get(key_of(item.get("item_id")))
+                    if tool_call is not None:
+                        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
+                # a stop that names calls closes them; the end of the response closes whatever
+                # a gateway never closed on its own
+                closing = [key_of(item.get("item_id")) for item in fragments] or list(open_tool_calls)
+                for key in closing:
+                    tool_call = open_tool_calls.pop(key, None)
+                    if tool_call is None:
+                        continue
                     yield {
                         "role": "assistant",
                         "event_type": "delta",
                         "content_items": [
                             {
                                 "type": "tool_call",
-                                "name": partial_tool_call["name"],
+                                "name": tool_call["name"],
                                 "arguments": parse_tool_call_arguments(
-                                    partial_tool_call["arguments"],
+                                    tool_call["arguments"],
                                     self.__class__.__name__,
-                                    partial_tool_call["name"],
-                                    partial_tool_call["tool_call_id"],
+                                    tool_call["name"],
+                                    tool_call["tool_call_id"],
                                 ),
-                                "tool_call_id": partial_tool_call["tool_call_id"],
+                                "tool_call_id": tool_call["tool_call_id"],
                             }
                         ],
                         "usage_metadata": None,
                         "finish_reason": None,
                     }
-                    partial_tool_call = {}
 
                 if event["finish_reason"] or event["usage_metadata"]:
                     yield event

{agenthub_python-0.4.13 → agenthub_python-0.4.15}/agenthub/types.py

@@ -96,6 +96,9 @@ class PartialToolCallContentItem(TypedDict):
     name: str
     arguments: str
     tool_call_id: str
+    # id of the streamed item this fragment belongs to, when the provider sends one (the
+    # Responses output item id); ties fragments to their call when several calls stream at once
+    item_id: NotRequired[str | None]
     fidelity: NotRequired[Fidelity]
 
 

{agenthub_python-0.4.13 → agenthub_python-0.4.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agenthub-python"
-version = "0.4.13"
+version = "0.4.15"
 description = "AgentHub is the LLM API Hub for the Agent era, built for high-precision autonomous agents."
 keywords = [
     "agent",

{agenthub_python-0.4.13 → agenthub_python-0.4.15}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "agenthub-python"
-version = "0.4.13"
+version = "0.4.15"
 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"