agno 1.8.0__py3-none-any.whl → 1.8.2__py3-none-any.whl

agno/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("agno")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = ["__version__"]

agno/agent/agent.py

@@ -352,6 +352,7 @@ class Agent:
         agent_id: Optional[str] = None,
         introduction: Optional[str] = None,
         user_id: Optional[str] = None,
+        app_id: Optional[str] = None,
         session_id: Optional[str] = None,
         session_name: Optional[str] = None,
         session_state: Optional[Dict[str, Any]] = None,
@@ -443,6 +444,7 @@ class Agent:
         self.agent_id = agent_id
         self.introduction = introduction
         self.user_id = user_id
+        self.app_id = app_id
 
         self.session_id = session_id
         self.session_name = session_name
@@ -747,9 +749,7 @@ class Agent:
                 self.session_id = session_id = str(uuid4())
 
         # Use the default user_id when necessary
-        if user_id is not None and user_id != "":
-            user_id = user_id
-        else:
+        if user_id is None or user_id == "":
             user_id = self.user_id
 
         # Determine the session_state
@@ -1476,7 +1476,7 @@ class Agent:
 
         # Read existing session from storage
         if self.context is not None:
-            self.resolve_run_context()
+            await self.aresolve_run_context()
 
         # Prepare arguments for the model
         self.set_default_model()
@@ -2152,7 +2152,7 @@ class Agent:
 
         # Read existing session from storage
         if self.context is not None:
-            self.resolve_run_context()
+            await self.aresolve_run_context()
 
         # Prepare arguments for the model
         self.set_default_model()

agno/agent/metrics.py

@@ -69,7 +69,10 @@ class SessionMetrics:
             # Add values from other
             if other.prompt_tokens_details:
                 for key, value in other.prompt_tokens_details.items():
-                    result.prompt_tokens_details[key] = result.prompt_tokens_details.get(key, 0) + value
+                    existing_value = result.prompt_tokens_details.get(key, 0)
+                    if not isinstance(existing_value, int):
+                        continue
+                    result.prompt_tokens_details[key] = existing_value + value
 
         # Handle completion_tokens_details similarly
         if self.completion_tokens_details or other.completion_tokens_details:

agno/app/agui/utils.py

@@ -27,6 +27,7 @@ from agno.models.message import Message
 from agno.run.response import RunEvent, RunResponseContentEvent, RunResponseEvent, RunResponsePausedEvent
 from agno.run.team import RunResponseContentEvent as TeamRunResponseContentEvent
 from agno.run.team import TeamRunEvent, TeamRunResponseEvent
+from agno.utils.message import get_text_from_message
 
 
 @dataclass
@@ -106,17 +107,23 @@ def extract_team_response_chunk_content(response: TeamRunResponseContentEvent) -
                     members_content.append(f"Team member: {member_content}")
     members_response = "\n".join(members_content) if members_content else ""
 
-    return str(response.content) + members_response
+    # Handle structured outputs
+    main_content = get_text_from_message(response.content) if response.content is not None else ""
+
+    return main_content + members_response
 
 
 def extract_response_chunk_content(response: RunResponseContentEvent) -> str:
     """Given a response stream chunk, find and extract the content."""
+
     if hasattr(response, "messages") and response.messages:  # type: ignore
         for msg in reversed(response.messages):  # type: ignore
             if hasattr(msg, "role") and msg.role == "assistant" and hasattr(msg, "content") and msg.content:
-                return str(msg.content)
+                # Handle structured outputs from messages
+                return get_text_from_message(msg.content)
 
-    return str(response.content) if response.content else ""
+    # Handle structured outputs
+    return get_text_from_message(response.content) if response.content is not None else ""
 
 
 def _create_events_from_chunk(
@@ -202,11 +209,11 @@ def _create_events_from_chunk(
 
     # Handle reasoning
     elif chunk.event == RunEvent.reasoning_started:
-        step_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")
-        events_to_emit.append(step_event)
+        step_started_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")
+        events_to_emit.append(step_started_event)
     elif chunk.event == RunEvent.reasoning_completed:
-        step_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
-        events_to_emit.append(step_event)
+        step_finished_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
+        events_to_emit.append(step_finished_event)
 
     return events_to_emit, message_started
 
@@ -220,7 +227,7 @@ def _create_completion_events(
     run_id: str,
 ) -> List[BaseEvent]:
     """Create events for run completion."""
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     # End remaining active tool calls if needed
     for tool_call_id in list(event_buffer.active_tool_call_ids):
@@ -271,7 +278,7 @@ def _create_completion_events(
 
 def _emit_event_logic(event: BaseEvent, event_buffer: EventBuffer) -> List[BaseEvent]:
     """Process an event through the buffer and return events to actually emit."""
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     if event_buffer.is_blocked():
         # Handle events related to the current blocking tool call

agno/app/discord/client.py

@@ -8,6 +8,7 @@ from agno.agent.agent import Agent, RunResponse
 from agno.media import Audio, File, Image, Video
 from agno.team.team import Team, TeamRunResponse
 from agno.utils.log import log_info, log_warning
+from agno.utils.message import get_text_from_message
 
 try:
     import discord
@@ -167,7 +168,10 @@ class DiscordClient:
                 thread=thread, message=f"Reasoning: \n{response.reasoning_content}", italics=True
             )
 
-        await self._send_discord_messages(thread=thread, message=str(response.content))
+        # Handle structured outputs properly
+        content_message = get_text_from_message(response.content) if response.content is not None else ""
+
+        await self._send_discord_messages(thread=thread, message=content_message)
 
     async def _send_discord_messages(self, thread: discord.channel, message: str, italics: bool = False):  # type: ignore
         if len(message) < 1500:

agno/app/playground/async_router.py

@@ -528,6 +528,7 @@ def get_async_playground_router(
                     session_id=session.session_id,
                     session_name=session.session_data.get("session_name") if session.session_data else None,
                     created_at=session.created_at,
+                    updated_at=session.updated_at,
                 )
             )
         return agent_sessions
@@ -751,6 +752,7 @@ def get_async_playground_router(
                     "session_id": session.session_id,
                     "session_name": session.session_data.get("session_name") if session.session_data else None,
                     "created_at": session.created_at,
+                    "updated_at": session.updated_at,
                 }  # type: ignore
             )
         return workflow_sessions
@@ -945,6 +947,7 @@ def get_async_playground_router(
                     session_id=session.session_id,
                     session_name=session.session_data.get("session_name") if session.session_data else None,
                     created_at=session.created_at,
+                    updated_at=session.updated_at,
                 )
             )
         return team_sessions

agno/app/playground/schemas.py

@@ -91,6 +91,7 @@ class AgentSessionsResponse(BaseModel):
     session_id: Optional[str] = None
     session_name: Optional[str] = None
     created_at: Optional[int] = None
+    updated_at: Optional[int] = None
 
 
 class MemoryResponse(BaseModel):
@@ -115,6 +116,7 @@ class WorkflowSessionResponse(BaseModel):
     session_id: Optional[str] = None
     session_name: Optional[str] = None
     created_at: Optional[int] = None
+    updated_at: Optional[int] = None
 
 
 class WorkflowGetResponse(BaseModel):
@@ -213,6 +215,7 @@ class TeamSessionResponse(BaseModel):
     session_id: Optional[str] = None
     session_name: Optional[str] = None
     created_at: Optional[int] = None
+    updated_at: Optional[int] = None
 
 
 class TeamRenameRequest(BaseModel):

agno/app/playground/sync_router.py

@@ -528,6 +528,7 @@ def get_sync_playground_router(
                     session_id=session.session_id,
                     session_name=session.session_data.get("session_name") if session.session_data else None,
                     created_at=session.created_at,
+                    updated_at=session.updated_at,
                 )
             )
         return agent_sessions
@@ -743,6 +744,7 @@ def get_sync_playground_router(
                     "session_id": session.session_id,
                     "session_name": session.session_data.get("session_name") if session.session_data else None,
                     "created_at": session.created_at,
+                    "updated_at": session.updated_at,
                 }  # type: ignore
             )
         return workflow_sessions
@@ -940,6 +942,7 @@ def get_sync_playground_router(
                     session_id=session.session_id,
                     session_name=session.session_data.get("session_name") if session.session_data else None,
                     created_at=session.created_at,
+                    updated_at=session.updated_at,
                 )
             )
         return team_sessions

agno/knowledge/agent.py

@@ -161,7 +161,8 @@ class AgentKnowledge(BaseModel):
 
             # Upsert documents if upsert is True and vector db supports upsert
             if upsert and self.vector_db.upsert_available():
-                self.vector_db.upsert(documents=documents_to_load, filters=doc.meta_data)
+                for doc in documents_to_load:
+                    self.vector_db.upsert(documents=[doc], filters=doc.meta_data)
             # Insert documents
             else:
                 # Filter out documents which already exist in the vector db
@@ -170,7 +171,8 @@ class AgentKnowledge(BaseModel):
                     documents_to_load = self.filter_existing_documents(document_list)
 
                 if documents_to_load:
-                    self.vector_db.insert(documents=documents_to_load, filters=doc.meta_data)
+                    for doc in documents_to_load:
+                        self.vector_db.insert(documents=[doc], filters=doc.meta_data)
 
             num_documents += len(documents_to_load)
         log_info(f"Added {num_documents} documents to knowledge base")
@@ -204,7 +206,8 @@ class AgentKnowledge(BaseModel):
 
             # Upsert documents if upsert is True and vector db supports upsert
             if upsert and self.vector_db.upsert_available():
-                await self.vector_db.async_upsert(documents=documents_to_load, filters=doc.meta_data)
+                for doc in documents_to_load:
+                    await self.vector_db.async_upsert(documents=[doc], filters=doc.meta_data)
             # Insert documents
             else:
                 # Filter out documents which already exist in the vector db
@@ -213,7 +216,8 @@ class AgentKnowledge(BaseModel):
                     documents_to_load = await self.async_filter_existing_documents(document_list)
 
                 if documents_to_load:
-                    await self.vector_db.async_insert(documents=documents_to_load, filters=doc.meta_data)
+                    for doc in documents_to_load:
+                        await self.vector_db.async_insert(documents=[doc], filters=doc.meta_data)
 
             num_documents += len(documents_to_load)
         log_info(f"Added {num_documents} documents to knowledge base")

agno/media.py

@@ -157,7 +157,7 @@ class Video(BaseModel):
 
     @classmethod
     def from_artifact(cls, artifact: VideoArtifact) -> "Video":
-        return cls(url=artifact.url)
+        return cls(url=artifact.url, content=artifact.content, format=artifact.mime_type)
 
 
 class Audio(BaseModel):
@@ -329,7 +329,7 @@ class Image(BaseModel):
 
     @classmethod
     def from_artifact(cls, artifact: ImageArtifact) -> "Image":
-        return cls(url=artifact.url)
+        return cls(url=artifact.url, content=artifact.content, format=artifact.mime_type)
 
 
 class File(BaseModel):

agno/models/anthropic/claude.py

@@ -11,7 +11,7 @@ from agno.models.base import Model
 from agno.models.message import Citations, DocumentCitation, Message, UrlCitation
 from agno.models.response import ModelResponse
 from agno.utils.log import log_debug, log_error, log_warning
-from agno.utils.models.claude import MCPServerConfiguration, format_messages
+from agno.utils.models.claude import MCPServerConfiguration, format_messages, format_tools_for_model
 
 try:
     from anthropic import (
@@ -176,59 +176,12 @@ class Claude(Model):
                 request_kwargs["system"] = [{"text": system_message, "type": "text"}]
 
         if tools:
-            request_kwargs["tools"] = self._format_tools_for_model(tools)
+            request_kwargs["tools"] = format_tools_for_model(tools)
 
         if request_kwargs:
             log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
         return request_kwargs
 
-    def _format_tools_for_model(self, tools: Optional[List[Dict[str, Any]]] = None) -> Optional[List[Dict[str, Any]]]:
-        """
-        Transforms function definitions into a format accepted by the Anthropic API.
-        """
-        if not tools:
-            return None
-
-        parsed_tools: List[Dict[str, Any]] = []
-        for tool_def in tools:
-            if tool_def.get("type", "") != "function":
-                parsed_tools.append(tool_def)
-                continue
-
-            func_def = tool_def.get("function", {})
-            parameters: Dict[str, Any] = func_def.get("parameters", {})
-            properties: Dict[str, Any] = parameters.get("properties", {})
-            required_params: List[str] = []
-
-            for param_name, param_info in properties.items():
-                param_type = param_info.get("type", "")
-                param_type_list: List[str] = [param_type] if isinstance(param_type, str) else param_type or []
-
-                if "null" not in param_type_list:
-                    required_params.append(param_name)
-
-            input_properties: Dict[str, Dict[str, Union[str, List[str]]]] = {}
-            for param_name, param_info in properties.items():
-                input_properties[param_name] = {
-                    "description": param_info.get("description", ""),
-                }
-                if "type" not in param_info and "anyOf" in param_info:
-                    input_properties[param_name]["anyOf"] = param_info["anyOf"]
-                else:
-                    input_properties[param_name]["type"] = param_info.get("type", "")
-
-            tool = {
-                "name": func_def.get("name") or "",
-                "description": func_def.get("description") or "",
-                "input_schema": {
-                    "type": parameters.get("type", "object"),
-                    "properties": input_properties,
-                    "required": required_params,
-                },
-            }
-            parsed_tools.append(tool)
-        return parsed_tools
-
     def invoke(
         self,
         messages: List[Message],
@@ -570,16 +523,7 @@ class Claude(Model):
                 }
 
         elif isinstance(response, ContentBlockStopEvent):
-            # Handle completed thinking content
-            if response.content_block.type == "thinking":  # type: ignore
-                model_response.thinking = response.content_block.thinking  # type: ignore
-                # Store signature if available
-                if hasattr(response.content_block, "signature"):  # type: ignore
-                    model_response.provider_data = {
-                        "signature": response.content_block.signature,  # type: ignore
-                    }
-            # Handle tool calls
-            elif response.content_block.type == "tool_use":  # type: ignore
+            if response.content_block.type == "tool_use":  # type: ignore
                 tool_use = response.content_block  # type: ignore
                 tool_name = tool_use.name
                 tool_input = tool_use.input

agno/models/aws/bedrock.py

@@ -179,14 +179,10 @@ class AwsBedrock(Model):
                 required = []
 
                 for param_name, param_info in func_def.get("parameters", {}).get("properties", {}).items():
-                    param_type = param_info.get("type")
-                    if isinstance(param_type, list):
-                        param_type = [t for t in param_type if t != "null"][0]
+                    properties[param_name] = param_info.copy()
 
-                    properties[param_name] = {
-                        "type": param_type or "string",
-                        "description": param_info.get("description") or "",
-                    }
+                    if "description" not in properties[param_name]:
+                        properties[param_name]["description"] = ""
 
                     if "null" not in (
                         param_info.get("type") if isinstance(param_info.get("type"), list) else [param_info.get("type")]

agno/models/dashscope/dashscope.py

@@ -19,7 +19,7 @@ class DashScope(OpenAILike):
         provider (str): The provider name. Defaults to "Qwen".
         api_key (Optional[str]): The DashScope API key.
         base_url (str): The base URL. Defaults to "https://dashscope-intl.aliyuncs.com/compatible-mode/v1".
-        enable_thinking (Optional[bool]): Enable thinking process (DashScope native parameter). Defaults to None.
+        enable_thinking (bool): Enable thinking process (DashScope native parameter). Defaults to False.
         include_thoughts (Optional[bool]): Include thinking process in response (alternative parameter). Defaults to None.
     """
 
@@ -31,8 +31,9 @@ class DashScope(OpenAILike):
     base_url: str = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
 
     # Thinking parameters
-    enable_thinking: Optional[bool] = None
+    enable_thinking: bool = False
     include_thoughts: Optional[bool] = None
+    thinking_budget: Optional[int] = None
 
     # DashScope supports structured outputs
     supports_native_structured_outputs: bool = True
@@ -75,7 +76,15 @@ class DashScope(OpenAILike):
     ) -> Dict[str, Any]:
         params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)
 
-        should_include_thoughts = self.enable_thinking or self.include_thoughts
-        if should_include_thoughts:
-            params["extra_body"] = {"enable_thinking": True}
+        if self.include_thoughts is not None:
+            self.enable_thinking = self.include_thoughts
+
+        if self.enable_thinking is not None:
+            params["extra_body"] = {
+                "enable_thinking": self.enable_thinking,
+            }
+
+            if self.thinking_budget is not None:
+                params["extra_body"]["thinking_budget"] = self.thinking_budget
+
         return params

agno/models/google/gemini.py

@@ -793,12 +793,18 @@ class Gemini(Model):
                 grounding_metadata = response.candidates[0].grounding_metadata.model_dump()
                 citations_raw["grounding_metadata"] = grounding_metadata
 
-                chunks = grounding_metadata.get("grounding_chunks", [])
-                citation_pairs = [
-                    (chunk.get("web", {}).get("uri"), chunk.get("web", {}).get("title"))
-                    for chunk in chunks
-                    if chunk.get("web", {}).get("uri")
-                ]
+                chunks = grounding_metadata.get("grounding_chunks", []) or []
+                citation_pairs = []
+                for chunk in chunks:
+                    if not isinstance(chunk, dict):
+                        continue
+                    web = chunk.get("web")
+                    if not isinstance(web, dict):
+                        continue
+                    uri = web.get("uri")
+                    title = web.get("title")
+                    if uri:
+                        citation_pairs.append((uri, title))
 
                 # Create citation objects from filtered pairs
                 grounding_urls = [UrlCitation(url=url, title=title) for url, title in citation_pairs]
@@ -907,11 +913,17 @@ class Gemini(Model):
 
                 # Extract url and title
                 chunks = grounding_metadata.pop("grounding_chunks", None) or []
-                citation_pairs = [
-                    (chunk.get("web", {}).get("uri"), chunk.get("web", {}).get("title"))
-                    for chunk in chunks
-                    if chunk.get("web", {}).get("uri")
-                ]
+                citation_pairs = []
+                for chunk in chunks:
+                    if not isinstance(chunk, dict):
+                        continue
+                    web = chunk.get("web")
+                    if not isinstance(web, dict):
+                        continue
+                    uri = web.get("uri")
+                    title = web.get("title")
+                    if uri:
+                        citation_pairs.append((uri, title))
 
                 # Create citation objects from filtered pairs
                 citations.urls = [UrlCitation(url=url, title=title) for url, title in citation_pairs]

agno/models/openai/chat.py

@@ -77,7 +77,7 @@ class OpenAIChat(Model):
     max_retries: Optional[int] = None
     default_headers: Optional[Any] = None
     default_query: Optional[Any] = None
-    http_client: Optional[httpx.Client] = None
+    http_client: Optional[Union[httpx.Client, httpx.AsyncClient]] = None
     client_params: Optional[Dict[str, Any]] = None
 
     # The role to map the message role to.
@@ -123,8 +123,11 @@ class OpenAIChat(Model):
             OpenAIClient: An instance of the OpenAI client.
         """
         client_params: Dict[str, Any] = self._get_client_params()
-        if self.http_client is not None:
-            client_params["http_client"] = self.http_client
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                client_params["http_client"] = self.http_client
+            else:
+                log_warning("http_client is not an instance of httpx.Client.")
         return OpenAIClient(**client_params)
 
     def get_async_client(self) -> AsyncOpenAIClient:
@@ -136,7 +139,14 @@ class OpenAIChat(Model):
         """
         client_params: Dict[str, Any] = self._get_client_params()
         if self.http_client:
-            client_params["http_client"] = self.http_client
+            if isinstance(self.http_client, httpx.AsyncClient):
+                client_params["http_client"] = self.http_client
+            else:
+                log_warning("http_client is not an instance of httpx.AsyncClient. Using default httpx.AsyncClient.")
+                # Create a new async HTTP client with custom limits
+                client_params["http_client"] = httpx.AsyncClient(
+                    limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)
+                )
         else:
             # Create a new async HTTP client with custom limits
             client_params["http_client"] = httpx.AsyncClient(

agno/models/openai/responses.py

@@ -44,6 +44,7 @@ class OpenAIResponses(Model):
     reasoning: Optional[Dict[str, Any]] = None
     verbosity: Optional[Literal["low", "medium", "high"]] = None
     reasoning_effort: Optional[Literal["minimal", "medium", "high"]] = None
+    reasoning_summary: Optional[Literal["auto", "concise", "detailed"]] = None
     store: Optional[bool] = None
     temperature: Optional[float] = None
     top_p: Optional[float] = None
@@ -84,6 +85,18 @@ class OpenAIResponses(Model):
         """Return True if the contextual used model is a known reasoning model."""
         return self.id.startswith("o3") or self.id.startswith("o4-mini") or self.id.startswith("gpt-5")
 
+    def _set_reasoning_request_param(self, base_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Set the reasoning request parameter."""
+        base_params["reasoning"] = self.reasoning or {}
+
+        if self.reasoning_effort is not None:
+            base_params["reasoning"]["effort"] = self.reasoning_effort
+
+        if self.reasoning_summary is not None:
+            base_params["reasoning"]["summary"] = self.reasoning_summary
+
+        return base_params
+
     def _get_client_params(self) -> Dict[str, Any]:
         """
         Get client parameters for API requests.
@@ -185,12 +198,8 @@ class OpenAIResponses(Model):
             "user": self.user,
             "service_tier": self.service_tier,
         }
-
-        # Handle reasoning parameter - convert reasoning_effort to reasoning format
-        if self.reasoning is not None:
-            base_params["reasoning"] = self.reasoning
-        elif self.reasoning_effort is not None:
-            base_params["reasoning"] = {"effort": self.reasoning_effort}
+        # Populate the reasoning parameter
+        base_params = self._set_reasoning_request_param(base_params)
 
         # Build text parameter
         text_params: Dict[str, Any] = {}
@@ -478,7 +487,6 @@ class OpenAIResponses(Model):
             request_params = self.get_request_params(
                 messages=messages, response_format=response_format, tools=tools, tool_choice=tool_choice
             )
-
             return self.get_client().responses.create(
                 model=self.id,
                 input=self._format_messages(messages),  # type: ignore
@@ -730,7 +738,10 @@ class OpenAIResponses(Model):
 
         # Add role
         model_response.role = "assistant"
+        reasoning_summary: str = ""
+
         for output in response.output:
+            # Add content
             if output.type == "message":
                 model_response.content = response.output_text
 
@@ -746,6 +757,8 @@ class OpenAIResponses(Model):
                                 citations.urls.append(UrlCitation(url=annotation.url, title=annotation.title))
                         if citations.urls or citations.documents:
                             model_response.citations = citations
+
+            # Add tool calls
             elif output.type == "function_call":
                 if model_response.tool_calls is None:
                     model_response.tool_calls = []
@@ -765,10 +778,24 @@ class OpenAIResponses(Model):
                 model_response.extra = model_response.extra or {}
                 model_response.extra.setdefault("tool_call_ids", []).append(output.call_id)
 
-        # i.e. we asked for reasoning, so we need to add the reasoning content
-        if self.reasoning is not None:
+            # Add reasoning summary
+            elif output.type == "reasoning":
+                if reasoning_summaries := getattr(output, "summary", None):
+                    for summary in reasoning_summaries:
+                        if isinstance(summary, dict):
+                            summary_text = summary.get("text")
+                        else:
+                            summary_text = getattr(summary, "text", None)
+                        if summary_text:
+                            reasoning_summary = (reasoning_summary or "") + summary_text
+
+        # Add reasoning content
+        if reasoning_summary is not None:
+            model_response.reasoning_content = reasoning_summary
+        elif self.reasoning is not None:
             model_response.reasoning_content = response.output_text
 
+        # Add metrics
         if response.usage is not None:
             model_response.response_usage = response.usage
 
@@ -835,7 +862,8 @@ class OpenAIResponses(Model):
             model_response.content = stream_event.delta
             stream_data.response_content += stream_event.delta
 
-            if self.reasoning is not None:
+            # Treat the output_text deltas as reasoning content if the reasoning summary is not requested.
+            if self.reasoning is not None and self.reasoning_summary is None:
                 model_response.reasoning_content = stream_event.delta
                 stream_data.response_thinking += stream_event.delta
 
@@ -868,7 +896,24 @@ class OpenAIResponses(Model):
 
         elif stream_event.type == "response.completed":
             model_response = ModelResponse()
-            # Add usage metrics if present
+
+            # Add reasoning summary
+            if self.reasoning_summary is not None:
+                summary_text: str = ""
+                for out in getattr(stream_event.response, "output", []) or []:
+                    if getattr(out, "type", None) == "reasoning":
+                        summaries = getattr(out, "summary", None)
+                        if summaries:
+                            for s in summaries:
+                                text_val = s.get("text") if isinstance(s, dict) else getattr(s, "text", None)
+                                if text_val:
+                                    if summary_text:
+                                        summary_text += "\n\n"
+                                    summary_text += text_val
+                if summary_text:
+                    model_response.reasoning_content = summary_text
+
+            # Add metrics
             if stream_event.response.usage is not None:
                 model_response.response_usage = stream_event.response.usage