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

agenthub_python-0.3.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.3
+Name: agenthub-python
+Version: 0.3.0
+Summary: AgentHub is the LLM API Hub for the Agent era, built for high-precision autonomous agents.
+Requires-Dist: google-genai>=1.5.0
+Requires-Dist: anthropic[bedrock]>=0.40.0
+Requires-Dist: flask>=3.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Python: >=3.11

{agenthub_python-0.1.0 → agenthub_python-0.3.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.3.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,54 @@ 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 or "gemini-3.1-" 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
-            from .claude4_5 import Claude4_5Client
+            return Gemini3Client(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
 
-            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_6Client(model=model, api_key=api_key, base_url=base_url)
+        elif "gpt-5.4" in client_type:  # e.g., gpt-5.4
+            from .gpt5_4 import GPT5_4Client
+
+            return GPT5_4Client(model=model, api_key=api_key, base_url=base_url)
+        elif "glm-5" in client_type:
+            from .glm5 import GLM5Client
+
+            return GLM5Client(model=model, api_key=api_key, base_url=base_url)
+        elif "kimi-k2.5" in client_type:
+            from .kimi_k2_5 import KimiK2_5Client
+
+            return KimiK2_5Client(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-6, gpt-5.4, glm-5, kimi-k2.5, qwen3."
+            )
 
     def transform_uni_config_to_model_config(self, config: UniConfig) -> Any:
         """Delegate to underlying client's transform_uni_config_to_model_config."""
@@ -63,6 +88,13 @@ class AutoLLMClient(LLMClient):
         """Delegate to underlying client's transform_model_output_to_uni_event."""
         return self._client.transform_model_output_to_uni_event(model_output)
 
+    async def _streaming_response_internal(
+        self,
+        messages: list[UniMessage],
+        config: UniConfig,
+    ) -> AsyncIterator[UniEvent]:
+        raise NotImplementedError("Please use streaming_response instead.")
+
     async def streaming_response(
         self,
         messages: list[UniMessage],

{agenthub_python-0.1.0 → agenthub_python-0.3.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
@@ -88,19 +89,31 @@ class LLMClient(ABC):
             # Merge content_items from all events
             for item in event["content_items"]:
                 if item["type"] == "text":
-                    if content_items and content_items[-1]["type"] == "text":
+                    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
+                    ):
                         content_items[-1]["text"] += item["text"]
-                        if "signature" in item:  # signature may appear at the last item
+                        if "signature" in item:  # finish the current item if signature is not None
                             content_items[-1]["signature"] = item["signature"]
-                    elif item["text"]:  # omit empty text items
+                    elif item["text"] or item.get("phase") is not None:  # text or new phase starts an item
                         content_items.append(item.copy())
                 elif item["type"] == "thinking":
-                    if content_items and content_items[-1]["type"] == "thinking":
+                    if (
+                        content_items
+                        and content_items[-1]["type"] == "thinking"
+                        and content_items[-1].get("signature") is None  # no signature yet
+                    ):
                         content_items[-1]["thinking"] += item["thinking"]
-                        if "signature" in item:  # signature may appear at the last item
+                        if "signature" in item:  # finish the current item if signature is not None
                             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())
 
@@ -115,6 +128,26 @@ class LLMClient(ABC):
         }
 
     @abstractmethod
+    async def _streaming_response_internal(
+        self,
+        messages: list[UniMessage],
+        config: UniConfig,
+    ) -> AsyncIterator[UniEvent]:
+        """
+        Internal method to handle streaming response.
+
+        This method should be implemented by each model client to handle
+        the actual streaming request and yield model-specific events.
+
+        Args:
+            messages: List of universal message dictionaries
+            config: Universal configuration dict
+
+        Yields:
+            Model-specific events from the streaming response
+        """
+        pass
+
     async def streaming_response(
         self,
         messages: list[UniMessage],
@@ -134,7 +167,12 @@ class LLMClient(ABC):
         Yields:
             Universal events from the streaming response
         """
-        pass
+        last_event: UniEvent | None = None
+        async for event in self._streaming_response_internal(messages, config):
+            last_event = event
+            yield event
+
+        self._validate_last_event(last_event)
 
     async def streaming_response_stateful(
         self,
@@ -155,26 +193,49 @@ class LLMClient(ABC):
         Yields:
             Universal events from the streaming response
         """
-        # Add user message to history
-        self._history.append(message)
+        # Build a temporary messages list for inference without mutating history yet
+        temp_messages = self._history + [message]
 
         # Collect all events for history
         events = []
-        async for event in self.streaming_response(messages=self._history, config=config):
+        async for event in self.streaming_response(messages=temp_messages, config=config):
             events.append(event)
             yield event
 
-        # Convert events to message and add to history
+        # Only update history after successful inference
         if events:
             assistant_message = self.concat_uni_events_to_uni_message(events)
+            self._history.append(message)
             self._history.append(assistant_message)
 
         # 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)
+
+    @staticmethod
+    def _validate_last_event(last_event: UniEvent | None) -> None:
+        """Validate that the last event has usage_metadata and finish_reason.
+
+        This validation guards against servers that silently terminate streaming
+        output partway through without sending a proper final event.
+
+        Args:
+            last_event: The last event yielded by streaming_response
+
+        Raises:
+            ValueError: If last_event is None or missing usage_metadata/finish_reason
+        """
+        if last_event is None:
+            raise ValueError("Streaming response yielded no events")
+
+        if last_event["usage_metadata"] is None:
+            raise ValueError(f"Last event must carry usage_metadata, got: {last_event}")
+
+        if last_event["finish_reason"] is None:
+            raise ValueError(f"Last event must carry finish_reason, got: {last_event}")
 
     def clear_history(self) -> None:
         """Clear the message history."""

{agenthub_python-0.1.0/agenthub/claude4_5 → agenthub_python-0.3.0/agenthub/claude4_6}/__init__.py

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

agenthub_python-0.3.0/agenthub/claude4_6/client.py

@@ -0,0 +1,415 @@
+# 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 base64
+import json
+import mimetypes
+import os
+import re
+from typing import Any, AsyncIterator
+
+import httpx
+from anthropic import AsyncAnthropic, AsyncAnthropicBedrock
+from anthropic.types.beta import BetaMessageParam, BetaRawMessageStreamEvent
+
+from ..base_client import LLMClient
+from ..types import (
+    EventType,
+    FinishReason,
+    PartialContentItem,
+    PromptCaching,
+    ThinkingLevel,
+    ToolChoice,
+    UniConfig,
+    UniEvent,
+    UniMessage,
+    UsageMetadata,
+)
+
+
+REDACTED_THINKING = "_REDACTED_THINKING"
+
+
+class Claude4_6Client(LLMClient):
+    """Claude 4.6-specific LLM client implementation."""
+
+    def __init__(self, model: str, api_key: str | None = None, base_url: str | None = None):
+        """Initialize Claude 4.6 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")
+        if base_url and base_url.startswith("bedrock://"):  # example: bedrock://us-east-1
+            region = base_url.replace("bedrock://", "")
+            access_key, secret_key = api_key.split(",")
+            self._client = AsyncAnthropicBedrock(
+                aws_secret_key=secret_key, aws_access_key=access_key, aws_region=region
+            )
+            self._use_bedrock = True
+        else:
+            self._client = AsyncAnthropic(api_key=api_key, base_url=base_url)
+            self._use_bedrock = False
+
+        self._history: list[UniMessage] = []
+
+    async def _convert_image_url_to_source(self, url: str) -> dict[str, Any]:
+        """Convert image URL to image source.
+
+        Bedrock does not support image url sources, so we need to fetch the image bytes and encode them.
+
+        Args:
+            url: Image URL to convert
+
+        Returns:
+            Image source
+        """
+        if url.startswith("data:"):
+            match = re.match(r"data:([^;]+);base64,(.+)", url)
+            if match:
+                media_type = match.group(1)
+                base64_data = match.group(2)
+                source = {
+                    "type": "image",
+                    "source": {"type": "base64", "media_type": media_type, "data": base64_data},
+                }
+            else:
+                raise ValueError(f"Invalid base64 image: {url}")
+        elif self._use_bedrock:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(url)
+                response.raise_for_status()
+                image_bytes = response.content
+                mime_type = mimetypes.guess_type(url)[0] or "image/jpeg"
+                source = {
+                    "type": "image",
+                    "source": {
+                        "type": "base64",
+                        "media_type": mime_type,
+                        "data": base64.b64encode(image_bytes).decode("utf-8"),
+                    },
+                }
+        else:
+            source = {"type": "image", "source": {"type": "url", "url": url}}
+
+        return source
+
+    def _convert_thinking_level_to_thinking_config(self, thinking_level: ThinkingLevel) -> dict[str, Any]:
+        """Convert ThinkingLevel enum to Claude's adaptive thinking config."""
+        mapping = {
+            ThinkingLevel.NONE: {},  # omit thinking config
+            ThinkingLevel.LOW: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "low"}},
+            ThinkingLevel.MEDIUM: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "medium"}},
+            ThinkingLevel.HIGH: {"thinking": {"type": "adaptive"}, "output_config": {"effort": "high"}},
+        }
+        return mapping.get(thinking_level)
+
+    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:
+                raise ValueError("Claude supports only one tool choice.")
+
+            return {"type": "any", "name": tool_choice[0]}
+        elif tool_choice == "none":
+            return {"type": "none"}
+        elif tool_choice == "auto":
+            return {"type": "auto"}
+        elif tool_choice == "required":
+            return {"type": "any"}
+
+    def transform_uni_config_to_model_config(self, config: UniConfig) -> dict[str, Any]:
+        """
+        Transform universal configuration to Claude-specific configuration.
+
+        Args:
+            config: Universal configuration dict
+
+        Returns:
+            Claude configuration dictionary
+        """
+        claude_config = {"model": self._model, "stream": True}
+
+        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
+
+        if config.get("temperature") is not None:
+            claude_config["temperature"] = config["temperature"]
+
+        # 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
+            claude_config.update(self._convert_thinking_level_to_thinking_config(config["thinking_level"]))
+
+        # Convert tools to Claude's tool schema
+        if config.get("tools") is not None:
+            claude_tools = []
+            for tool in config["tools"]:
+                claude_tool = {}
+                for key, value in tool.items():
+                    claude_tool[key.replace("parameters", "input_schema")] = value
+
+                claude_tools.append(claude_tool)
+
+            claude_config["tools"] = claude_tools
+
+        # Convert tool_choice
+        if config.get("tool_choice") is not None:
+            claude_config["tool_choice"] = self._convert_tool_choice(config["tool_choice"])
+
+        return claude_config
+
+    async def transform_uni_message_to_model_input(self, messages: list[UniMessage]) -> list[BetaMessageParam]:
+        """
+        Transform universal message format to Claude's BetaMessageParam format.
+
+        Args:
+            messages: List of universal message dictionaries
+
+        Returns:
+            List of Claude BetaMessageParam objects
+        """
+        claude_messages: list[BetaMessageParam] = []
+
+        for msg in messages:
+            content_blocks = []
+            for item in msg["content_items"]:
+                if item["type"] == "text":
+                    content_blocks.append({"type": "text", "text": item["text"]})
+                elif item["type"] == "image_url":
+                    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"]})
+                    else:
+                        content_blocks.append(
+                            {"type": "thinking", "thinking": item["thinking"], "signature": item["signature"]}
+                        )
+                elif item["type"] == "tool_call":
+                    content_blocks.append(
+                        {
+                            "type": "tool_use",
+                            "id": item["tool_call_id"],
+                            "name": item["name"],
+                            "input": item["arguments"],
+                        }
+                    )
+                elif item["type"] == "tool_result":
+                    if "tool_call_id" not in item:
+                        raise ValueError("tool_call_id is required for tool result.")
+
+                    tool_result = [{"type": "text", "text": item["text"]}]
+                    if "images" in item:
+                        for image_url in item["images"]:
+                            tool_result.append(await self._convert_image_url_to_source(image_url))
+
+                    content_blocks.append(
+                        {"type": "tool_result", "content": tool_result, "tool_use_id": item["tool_call_id"]}
+                    )
+                else:
+                    raise ValueError(f"Unknown item: {item}")
+
+            claude_messages.append({"role": msg["role"], "content": content_blocks})
+
+        return claude_messages
+
+    def transform_model_output_to_uni_event(self, model_output: BetaRawMessageStreamEvent) -> UniEvent:
+        """
+        Transform Claude model output to universal event format.
+
+        NOTE: Claude always has only one content item per event.
+
+        Args:
+            model_output: Claude 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
+
+        claude_event_type = model_output.type
+        if claude_event_type == "content_block_start":
+            event_type = "start"
+            block = model_output.content_block
+            if block.type == "tool_use":
+                content_items.append(
+                    {"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})
+
+        elif claude_event_type == "content_block_delta":
+            event_type = "delta"
+            delta = model_output.delta
+            if delta.type == "thinking_delta":
+                content_items.append({"type": "thinking", "thinking": delta.thinking})
+            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", "name": "", "arguments": delta.partial_json, "tool_call_id": ""}
+                )
+            elif delta.type == "signature_delta":
+                content_items.append({"type": "thinking", "thinking": "", "signature": delta.signature})
+
+        elif claude_event_type == "content_block_stop":
+            event_type = "stop"
+
+        elif claude_event_type == "message_start":
+            event_type = "start"
+            message = model_output.message
+            if getattr(message, "usage", None):
+                cache_creation_tokens = message.usage.cache_creation_input_tokens or 0
+                usage_metadata = {
+                    "cached_tokens": message.usage.cache_read_input_tokens,
+                    "prompt_tokens": message.usage.input_tokens + cache_creation_tokens,
+                    "thoughts_tokens": None,
+                    "response_tokens": None,
+                }
+
+        elif claude_event_type == "message_delta":
+            event_type = "stop"
+            delta = model_output.delta
+            if getattr(delta, "stop_reason", None):
+                stop_reason_mapping = {
+                    "end_turn": "stop",
+                    "max_tokens": "length",
+                    "stop_sequence": "stop",
+                    "tool_use": "tool_call",
+                }
+                finish_reason = stop_reason_mapping.get(delta.stop_reason, "unknown")
+
+            if getattr(model_output, "usage", None):
+                # In message_delta, we only update response_tokens
+                usage_metadata = {
+                    "cached_tokens": None,
+                    "prompt_tokens": None,
+                    "thoughts_tokens": None,
+                    "response_tokens": model_output.usage.output_tokens,
+                }
+
+        elif claude_event_type == "message_stop":
+            event_type = "stop"
+
+        elif claude_event_type in ["text", "thinking", "signature", "input_json"]:
+            event_type = "unused"
+
+        else:
+            raise ValueError(f"Unknown output: {model_output}")
+
+        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 Claude SDK with unified conversion methods."""
+        # Use unified config conversion
+        claude_config = self.transform_uni_config_to_model_config(config)
+
+        # Use unified message conversion
+        claude_messages = await 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 = {}
+        stream = await self._client.beta.messages.create(**claude_config, messages=claude_messages)
+        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
+
+                if event["usage_metadata"] is not None:
+                    # 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"]
+
+                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": 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"],
+                    }
+                    partial_usage = {}