autobyteus 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/llm/api/openai_compatible_llm.py

@@ -1,85 +1,59 @@
 import logging
+import inspect
 import os
 from abc import ABC
 from typing import Optional, List, AsyncGenerator, Dict, Any
 from openai import OpenAI
 from openai.types.completion_usage import CompletionUsage
 from openai.types.chat import ChatCompletionChunk
-import asyncio
 
 from autobyteus.llm.base_llm import BaseLLM
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.utils.llm_config import LLMConfig
-from autobyteus.llm.utils.media_payload_formatter import image_source_to_base64, create_data_uri, get_mime_type, is_valid_image_path
 from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
-from autobyteus.llm.user_message import LLMUserMessage
 from autobyteus.llm.utils.messages import Message
+from autobyteus.llm.prompt_renderers.openai_chat_renderer import OpenAIChatRenderer
 
 logger = logging.getLogger(__name__)
 
-async def _format_openai_history(messages: List[Message]) -> List[Dict[str, Any]]:
-    """A local async function to format history for the OpenAI SDK, handling image processing."""
-    formatted_messages = []
-    for msg in messages:
-        # For multimodal messages, build the content list of parts
-        if msg.image_urls or msg.audio_urls or msg.video_urls:
-            content_parts: List[Dict[str, Any]] = []
-            if msg.content:
-                content_parts.append({"type": "text", "text": msg.content})
-
-            image_tasks = []
-            if msg.image_urls:
-                for url in msg.image_urls:
-                    # Create an async task for each image to process them concurrently
-                    image_tasks.append(image_source_to_base64(url))
-            
-            try:
-                base64_images = await asyncio.gather(*image_tasks)
-                for i, b64_image in enumerate(base64_images):
-                    original_url = msg.image_urls[i]
-                    # Determine mime type from original path if possible, otherwise default
-                    mime_type = get_mime_type(original_url) if is_valid_image_path(original_url) else "image/jpeg"
-                    content_parts.append(create_data_uri(mime_type, b64_image))
-            except Exception as e:
-                logger.error(f"Error processing one or more images: {e}")
-
-            # Placeholder for future audio/video processing
-            if msg.audio_urls:
-                logger.warning("OpenAI compatible layer does not yet support audio; skipping.")
-            if msg.video_urls:
-                logger.warning("OpenAI compatible layer does not yet support video; skipping.")
-
-            formatted_messages.append({"role": msg.role.value, "content": content_parts})
-        else:
-            # For text-only messages, use the simple string format
-            formatted_messages.append({"role": msg.role.value, "content": msg.content})
-    return formatted_messages
-
-
 class OpenAICompatibleLLM(BaseLLM, ABC):
     def __init__(
         self,
         model: LLMModel,
-        llm_config: LLMConfig,
         api_key_env_var: str,
         base_url: str,
+        llm_config: Optional[LLMConfig] = None,
         api_key_default: Optional[str] = None
     ):
+        model_default_config = model.default_config if hasattr(model, "default_config") else None
+        if model_default_config:
+            effective_config = LLMConfig.from_dict(model_default_config.to_dict())
+            if llm_config:
+                effective_config.merge_with(llm_config)
+        else:
+            effective_config = llm_config or LLMConfig()
+
+        # Try to get from env
         api_key = os.getenv(api_key_env_var)
+        
+        # If not in env, try default (explicit check)
+        if (api_key is None or api_key == "") and api_key_default is not None:
+            api_key = api_key_default
+            logger.info(f"{api_key_env_var} not set, using default key: {api_key_default}")
+
+        # Final check
         if not api_key:
-            if api_key_default:
-                api_key = api_key_default
-                logger.info(f"{api_key_env_var} not set, using default key.")
-            else:
-                logger.error(f"{api_key_env_var} environment variable is not set.")
-                raise ValueError(f"{api_key_env_var} environment variable is not set.")
+             logger.error(f"{api_key_env_var} environment variable is not set and no default provided.")
+             raise ValueError(f"{api_key_env_var} environment variable is not set. Default was: {api_key_default}")
 
         self.client = OpenAI(api_key=api_key, base_url=base_url)
         logger.info(f"Initialized OpenAI compatible client with base_url: {base_url}")
         
-        super().__init__(model=model, llm_config=llm_config)
-        self.max_tokens = 8000
+        super().__init__(model=model, llm_config=effective_config)
+        # Respect user/configured limit; let provider default if unspecified.
+        self.max_tokens = effective_config.max_tokens
+        self._renderer = OpenAIChatRenderer()
 
     def _create_token_usage(self, usage_data: Optional[CompletionUsage]) -> Optional[TokenUsage]:
         if not usage_data:
@@ -90,29 +64,32 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
             total_tokens=usage_data.total_tokens
         )
 
-    async def _send_user_message_to_llm(
-        self, user_message: LLMUserMessage, **kwargs
+    async def _send_messages_to_llm(
+        self, messages: List[Message], **kwargs
     ) -> CompleteResponse:
-        self.add_user_message(user_message)
-        
         try:
-            formatted_messages = await _format_openai_history(self.messages)
-            logger.info(f"Sending request to {self.model.provider.value} API")
-            
+            formatted_messages = await self._renderer.render(messages)
+            logger.info("Sending request to %s API", self.model.provider.value)
+
             params: Dict[str, Any] = {
                 "model": self.model.value,
                 "messages": formatted_messages,
             }
 
-            if self.config.uses_max_completion_tokens:
+            if self.max_tokens is not None:
+                # For OpenAI-compatible APIs, prefer max_completion_tokens; legacy max_tokens removed.
                 params["max_completion_tokens"] = self.max_tokens
-            else:
-                params["max_tokens"] = self.max_tokens
+            if self.config.extra_params:
+                self._apply_extra_params(params, self.config.extra_params)
+
+            if kwargs.get("tools"):
+                params["tools"] = kwargs["tools"]
+            if kwargs.get("tool_choice") is not None:
+                params["tool_choice"] = kwargs["tool_choice"]
 
             response = self.client.chat.completions.create(**params)
             full_message = response.choices[0].message
 
-            # --- PRESERVED ORIGINAL LOGIC ---
             reasoning = None
             if hasattr(full_message, "reasoning_content") and full_message.reasoning_content:
                 reasoning = full_message.reasoning_content
@@ -124,34 +101,30 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
                 main_content = full_message.content
             elif "content" in full_message and full_message["content"]:
                 main_content = full_message["content"]
-            # --- END PRESERVED LOGIC ---
-
-            self.add_assistant_message(main_content, reasoning_content=reasoning)
 
             token_usage = self._create_token_usage(response.usage)
-            logger.info(f"Received response from {self.model.provider.value} API with usage data")
-            
+            logger.info("Received response from %s API with usage data", self.model.provider.value)
+
             return CompleteResponse(
                 content=main_content,
                 reasoning=reasoning,
-                usage=token_usage
+                usage=token_usage,
             )
         except Exception as e:
-            logger.error(f"Error in {self.model.provider.value} API request: {str(e)}")
+            logger.error("Error in %s API request: %s", self.model.provider.value, str(e))
             raise ValueError(f"Error in {self.model.provider.value} API request: {str(e)}")
 
-    async def _stream_user_message_to_llm(
-        self, user_message: LLMUserMessage, **kwargs
+    async def _stream_messages_to_llm(
+        self, messages: List[Message], **kwargs
     ) -> AsyncGenerator[ChunkResponse, None]:
-        self.add_user_message(user_message)
-
         accumulated_reasoning = ""
         accumulated_content = ""
+        tool_calls_logged = False
 
         try:
-            formatted_messages = await _format_openai_history(self.messages)
-            logger.info(f"Starting streaming request to {self.model.provider.value} API")
-            
+            formatted_messages = await self._renderer.render(messages)
+            logger.info("Starting streaming request to %s API", self.model.provider.value)
+
             params: Dict[str, Any] = {
                 "model": self.model.value,
                 "messages": formatted_messages,
@@ -159,10 +132,15 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
                 "stream_options": {"include_usage": True},
             }
 
-            if self.config.uses_max_completion_tokens:
+            if self.max_tokens is not None:
                 params["max_completion_tokens"] = self.max_tokens
-            else:
-                params["max_tokens"] = self.max_tokens
+            if self.config.extra_params:
+                self._apply_extra_params(params, self.config.extra_params)
+
+            if kwargs.get("tools"):
+                params["tools"] = kwargs["tools"]
+            if kwargs.get("tool_choice") is not None:
+                params["tool_choice"] = kwargs["tool_choice"]
 
             stream = self.client.chat.completions.create(**params)
 
@@ -170,25 +148,41 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
                 chunk: ChatCompletionChunk
                 if not chunk.choices:
                     continue
-                
+
                 delta = chunk.choices[0].delta
 
-                # --- PRESERVED ORIGINAL LOGIC (adapted for streaming) ---
                 reasoning_chunk = None
                 if hasattr(delta, "reasoning_content") and delta.reasoning_content:
                     reasoning_chunk = delta.reasoning_content
                 elif isinstance(delta, dict) and "reasoning_content" in delta and delta["reasoning_content"]:
                     reasoning_chunk = delta["reasoning_content"]
-                
+
                 if reasoning_chunk:
                     accumulated_reasoning += reasoning_chunk
                     yield ChunkResponse(content="", reasoning=reasoning_chunk)
-                # --- END PRESERVED LOGIC ---
+
+                tool_call_deltas = None
+                if hasattr(delta, "tool_calls") and delta.tool_calls:
+                    from autobyteus.llm.converters.openai_tool_call_converter import convert_openai_tool_calls
+                    tool_call_deltas = convert_openai_tool_calls(delta.tool_calls)
+                    if tool_call_deltas and not tool_calls_logged:
+                        logger.info(
+                            "Streaming tool call deltas received from %s (count=%d).",
+                            self.model.provider.value,
+                            len(tool_call_deltas),
+                        )
+                        tool_calls_logged = True
 
                 main_token = delta.content
-                if main_token:
-                    accumulated_content += main_token
-                    yield ChunkResponse(content=main_token, reasoning=None)
+
+                if main_token or tool_call_deltas:
+                    if main_token:
+                        accumulated_content += main_token
+                    yield ChunkResponse(
+                        content=main_token or "",
+                        reasoning=None,
+                        tool_calls=tool_call_deltas,
+                    )
 
                 if hasattr(chunk, "usage") and chunk.usage is not None:
                     token_usage = self._create_token_usage(chunk.usage)
@@ -196,15 +190,57 @@ class OpenAICompatibleLLM(BaseLLM, ABC):
                         content="",
                         reasoning=None,
                         is_complete=True,
-                        usage=token_usage
+                        usage=token_usage,
                     )
-            
-            self.add_assistant_message(accumulated_content, reasoning_content=accumulated_reasoning)
-            logger.info(f"Completed streaming response from {self.model.provider.value} API")
+
+            logger.info("Completed streaming response from %s API", self.model.provider.value)
 
         except Exception as e:
-            logger.error(f"Error in {self.model.provider.value} API streaming: {str(e)}")
+            logger.error("Error in %s API streaming: %s", self.model.provider.value, str(e))
             raise ValueError(f"Error in {self.model.provider.value} API streaming: {str(e)}")
 
+    def _apply_extra_params(self, params: Dict[str, Any], extra_params: Dict[str, Any]) -> None:
+        # Use extra_body for provider-specific fields not in the OpenAI client signature.
+        if not extra_params:
+            return
+        extra = dict(extra_params)
+        allowed = self._get_chat_completion_param_names()
+
+        if any(key not in allowed for key in extra.keys()):
+            existing_body = params.get("extra_body")
+            if isinstance(existing_body, dict):
+                merged = dict(existing_body)
+                merged.update(extra)
+                params["extra_body"] = merged
+            else:
+                params["extra_body"] = extra
+        else:
+            params.update(extra)
+
+    def _get_chat_completion_param_names(self) -> set:
+        try:
+            return self._chat_completion_param_names
+        except AttributeError:
+            allowed = set(inspect.signature(self.client.chat.completions.create).parameters.keys())
+            self._chat_completion_param_names = allowed
+            return allowed
+
+
+class OpenAIChatCompletionsLLM(OpenAICompatibleLLM):
+    """Strict OpenAI Chat Completions client: rejects unsupported extra params."""
+
+    def _apply_extra_params(self, params: Dict[str, Any], extra_params: Dict[str, Any]) -> None:
+        if not extra_params:
+            return
+        extra = dict(extra_params)
+        allowed = self._get_chat_completion_param_names()
+        unknown = [key for key in extra.keys() if key not in allowed]
+        if unknown:
+            raise ValueError(
+                "Unsupported OpenAI chat.completions params: "
+                + ", ".join(sorted(unknown))
+            )
+        params.update(extra)
+
     async def cleanup(self):
         await super().cleanup()

autobyteus/llm/api/openai_llm.py

@@ -2,15 +2,15 @@ import logging
 from typing import Optional
 from autobyteus.llm.models import LLMModel
 from autobyteus.llm.utils.llm_config import LLMConfig
-from autobyteus.llm.api.openai_compatible_llm import OpenAICompatibleLLM
+from autobyteus.llm.api.openai_responses_llm import OpenAIResponsesLLM
 
 logger = logging.getLogger(__name__)
 
-class OpenAILLM(OpenAICompatibleLLM):
+class OpenAILLM(OpenAIResponsesLLM):
     def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
         # Provide defaults if not specified
         if model is None:
-            model = LLMModel['gpt-4o']  # Use factory access
+            model = LLMModel['gpt-5.2']  # Default to latest OpenAI model
         if llm_config is None:
             llm_config = LLMConfig()
             

autobyteus/llm/api/openai_responses_llm.py

@@ -0,0 +1,324 @@
+import logging
+import os
+from typing import Optional, List, AsyncGenerator, Dict, Any
+
+from openai import AsyncOpenAI
+from openai.types.responses import ResponseStreamEvent
+
+from autobyteus.llm.base_llm import BaseLLM
+from autobyteus.llm.models import LLMModel
+from autobyteus.llm.utils.llm_config import LLMConfig
+from autobyteus.llm.utils.messages import Message
+from autobyteus.llm.prompt_renderers.openai_responses_renderer import OpenAIResponsesRenderer
+from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
+from autobyteus.llm.utils.token_usage import TokenUsage
+from autobyteus.llm.utils.tool_call_delta import ToolCallDelta
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIResponsesLLM(BaseLLM):
+    def __init__(
+        self,
+        model: LLMModel,
+        api_key_env_var: str,
+        base_url: str,
+        llm_config: Optional[LLMConfig] = None,
+        api_key_default: Optional[str] = None,
+    ):
+        model_default_config = model.default_config if hasattr(model, "default_config") else None
+        if model_default_config:
+            effective_config = LLMConfig.from_dict(model_default_config.to_dict())
+            if llm_config:
+                effective_config.merge_with(llm_config)
+        else:
+            effective_config = llm_config or LLMConfig()
+
+        api_key = os.getenv(api_key_env_var)
+        if not api_key:
+            api_key = api_key_default
+
+        if not api_key:
+            raise ValueError(f"Missing API key. Set env var {api_key_env_var} or provide api_key_default.")
+
+        self.client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+        logger.info(f"Initialized OpenAI Responses client with base_url: {base_url}")
+
+        super().__init__(model=model, llm_config=effective_config)
+        self.max_tokens = effective_config.max_tokens
+        self._renderer = OpenAIResponsesRenderer()
+
+    def _create_token_usage(self, usage_data) -> Optional[TokenUsage]:
+        if not usage_data:
+            return None
+        return TokenUsage(
+            prompt_tokens=usage_data.input_tokens,
+            completion_tokens=usage_data.output_tokens,
+            total_tokens=usage_data.total_tokens,
+        )
+
+    @staticmethod
+    def _extract_output_content(output_items: List[Any]) -> (str, Optional[str]):
+        content_chunks: List[str] = []
+        reasoning_chunks: List[str] = []
+
+        for item in output_items:
+            item_type = getattr(item, "type", None)
+            if item_type == "message":
+                for content_part in getattr(item, "content", []) or []:
+                    if getattr(content_part, "type", None) == "output_text":
+                        content_chunks.append(content_part.text)
+            elif item_type == "reasoning":
+                for summary in getattr(item, "summary", []) or []:
+                    if getattr(summary, "type", None) == "summary_text":
+                        reasoning_chunks.append(summary.text)
+
+        content = "".join(content_chunks)
+        reasoning = "".join(reasoning_chunks) if reasoning_chunks else None
+        return content, reasoning
+
+    def _build_reasoning_param(self) -> Optional[Dict[str, Any]]:
+        if not self.config.extra_params:
+            return None
+
+        reasoning_effort = self.config.extra_params.get("reasoning_effort")
+        reasoning_summary = self.config.extra_params.get("reasoning_summary")
+
+        reasoning: Dict[str, Any] = {}
+        if reasoning_effort:
+            reasoning["effort"] = reasoning_effort
+        if reasoning_summary and reasoning_summary != "none":
+            reasoning["summary"] = reasoning_summary
+
+        return reasoning or None
+
+    def _filter_extra_params(self) -> Dict[str, Any]:
+        if not self.config.extra_params:
+            return {}
+        filtered = dict(self.config.extra_params)
+        filtered.pop("reasoning_effort", None)
+        filtered.pop("reasoning_summary", None)
+        return filtered
+
+    @staticmethod
+    def _normalize_tools(tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        normalized: List[Dict[str, Any]] = []
+        for tool in tools:
+            if tool.get("type") == "function" and isinstance(tool.get("function"), dict):
+                fn = tool["function"]
+                normalized.append({
+                    "type": "function",
+                    "name": fn.get("name"),
+                    "description": fn.get("description"),
+                    "parameters": fn.get("parameters"),
+                })
+            else:
+                normalized.append(tool)
+        return normalized
+
+    async def _send_messages_to_llm(self, messages: List[Message], **kwargs) -> CompleteResponse:
+        try:
+            formatted_messages = await self._renderer.render(messages)
+            logger.info("Sending request to %s Responses API", self.model.provider.value)
+
+            params: Dict[str, Any] = {
+                "model": self.model.value,
+                "input": formatted_messages,
+            }
+
+            if self.max_tokens is not None:
+                params["max_output_tokens"] = self.max_tokens
+
+            reasoning_param = self._build_reasoning_param()
+            if reasoning_param:
+                params["reasoning"] = reasoning_param
+
+            extra_params = self._filter_extra_params()
+            if extra_params:
+                params.update(extra_params)
+
+            if kwargs.get("tools"):
+                params["tools"] = self._normalize_tools(kwargs["tools"])
+            if kwargs.get("tool_choice") is not None:
+                params["tool_choice"] = kwargs["tool_choice"]
+
+            response = await self.client.responses.create(**params)
+
+            content, reasoning = self._extract_output_content(response.output)
+
+            token_usage = self._create_token_usage(response.usage)
+            logger.info("Received response from %s Responses API", self.model.provider.value)
+
+            return CompleteResponse(content=content, reasoning=reasoning, usage=token_usage)
+        except Exception as e:
+            logger.error("Error in %s Responses API request: %s", self.model.provider.value, str(e))
+            raise ValueError(f"Error in {self.model.provider.value} Responses API request: {str(e)}")
+
+    async def _stream_messages_to_llm(
+        self, messages: List[Message], **kwargs
+    ) -> AsyncGenerator[ChunkResponse, None]:
+        accumulated_content = ""
+        accumulated_reasoning = ""
+        tool_call_state: Dict[int, Dict[str, Any]] = {}
+        text_delta_seen: set[str] = set()
+        summary_delta_seen: set[str] = set()
+
+        try:
+            formatted_messages = await self._renderer.render(messages)
+            logger.info("Starting streaming request to %s Responses API", self.model.provider.value)
+
+            params: Dict[str, Any] = {
+                "model": self.model.value,
+                "input": formatted_messages,
+                "stream": True,
+            }
+
+            if self.max_tokens is not None:
+                params["max_output_tokens"] = self.max_tokens
+
+            reasoning_param = self._build_reasoning_param()
+            if reasoning_param:
+                params["reasoning"] = reasoning_param
+
+            extra_params = self._filter_extra_params()
+            if extra_params:
+                params.update(extra_params)
+
+            if kwargs.get("tools"):
+                params["tools"] = self._normalize_tools(kwargs["tools"])
+            if kwargs.get("tool_choice") is not None:
+                params["tool_choice"] = kwargs["tool_choice"]
+
+            stream = await self.client.responses.create(**params)
+
+            async for event in stream:
+                event: ResponseStreamEvent
+                event_type = getattr(event, "type", None)
+
+                if event_type == "response.output_text.delta":
+                    text_delta_seen.add(event.item_id)
+                    accumulated_content += event.delta
+                    yield ChunkResponse(content=event.delta, reasoning=None)
+                    continue
+
+                if event_type == "response.output_text.done":
+                    if event.item_id not in text_delta_seen:
+                        accumulated_content += event.text
+                        yield ChunkResponse(content=event.text, reasoning=None)
+                    continue
+
+                if event_type == "response.reasoning_summary_text.delta":
+                    summary_delta_seen.add(event.item_id)
+                    accumulated_reasoning += event.delta
+                    yield ChunkResponse(content="", reasoning=event.delta)
+                    continue
+
+                if event_type == "response.reasoning_summary_text.done":
+                    if event.item_id not in summary_delta_seen:
+                        accumulated_reasoning += event.text
+                        yield ChunkResponse(content="", reasoning=event.text)
+                    continue
+
+                if event_type == "response.output_item.added":
+                    item = event.item
+                    if getattr(item, "type", None) == "function_call":
+                        tool_call_state[event.output_index] = {
+                            "call_id": item.call_id,
+                            "name": item.name,
+                            "args_seen": False,
+                            "emitted": True,
+                        }
+                        yield ChunkResponse(
+                            content="",
+                            reasoning=None,
+                            tool_calls=[
+                                ToolCallDelta(
+                                    index=event.output_index,
+                                    call_id=item.call_id,
+                                    name=item.name,
+                                )
+                            ],
+                        )
+                    continue
+
+                if event_type == "response.function_call_arguments.delta":
+                    state = tool_call_state.get(event.output_index)
+                    if state:
+                        state["args_seen"] = True
+                        yield ChunkResponse(
+                            content="",
+                            reasoning=None,
+                            tool_calls=[
+                                ToolCallDelta(
+                                    index=event.output_index,
+                                    arguments_delta=event.delta,
+                                )
+                            ],
+                        )
+                    continue
+
+                if event_type == "response.function_call_arguments.done":
+                    state = tool_call_state.get(event.output_index)
+                    if state and not state.get("args_seen"):
+                        yield ChunkResponse(
+                            content="",
+                            reasoning=None,
+                            tool_calls=[
+                                ToolCallDelta(
+                                    index=event.output_index,
+                                    arguments_delta=event.arguments,
+                                )
+                            ],
+                        )
+                    continue
+
+                if event_type == "response.completed":
+                    response = event.response
+                    for idx, item in enumerate(response.output or []):
+                        if getattr(item, "type", None) != "function_call":
+                            continue
+                        state = tool_call_state.get(idx)
+                        if not state or not state.get("emitted"):
+                            yield ChunkResponse(
+                                content="",
+                                reasoning=None,
+                                tool_calls=[
+                                    ToolCallDelta(
+                                        index=idx,
+                                        call_id=item.call_id,
+                                        name=item.name,
+                                    )
+                                ],
+                            )
+                            tool_call_state[idx] = {
+                                "call_id": item.call_id,
+                                "name": item.name,
+                                "args_seen": False,
+                                "emitted": True,
+                            }
+                            state = tool_call_state[idx]
+
+                        if not state.get("args_seen"):
+                            yield ChunkResponse(
+                                content="",
+                                reasoning=None,
+                                tool_calls=[
+                                    ToolCallDelta(
+                                        index=idx,
+                                        arguments_delta=item.arguments,
+                                    )
+                                ],
+                            )
+                            state["args_seen"] = True
+
+                    token_usage = self._create_token_usage(response.usage)
+                    yield ChunkResponse(content="", reasoning=None, is_complete=True, usage=token_usage)
+
+            logger.info("Completed streaming response from %s Responses API", self.model.provider.value)
+
+        except Exception as e:
+            logger.error("Error in %s Responses API streaming: %s", self.model.provider.value, str(e))
+            raise ValueError(f"Error in {self.model.provider.value} Responses API streaming: {str(e)}")
+
+    async def cleanup(self):
+        await super().cleanup()