agno 2.3.0__tar.gz → 2.3.2__tar.gz

{agno-2.3.0 → agno-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.3.0
+Version: 2.3.2
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com

{agno-2.3.0 → agno-2.3.2}/agno/agent/agent.py

@@ -1501,7 +1501,7 @@ class Agent:
         add_session_state_to_context: Optional[bool] = None,
         dependencies: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None,
-        yield_run_response: bool = False,  # To be deprecated: use yield_run_output instead
+        yield_run_response: Optional[bool] = None,  # To be deprecated: use yield_run_output instead
         yield_run_output: bool = False,
         debug_mode: Optional[bool] = None,
         **kwargs: Any,

{agno-2.3.0 → agno-2.3.2}/agno/db/schemas/memory.py

@@ -2,6 +2,8 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
+from agno.utils.dttm import now_epoch_s
+
 
 @dataclass
 class UserMemory:
@@ -12,8 +14,8 @@ class UserMemory:
     topics: Optional[List[str]] = None
     user_id: Optional[str] = None
     input: Optional[str] = None
-    created_at: Optional[datetime] = None
-    updated_at: Optional[datetime] = None
+    created_at: Optional[int] = None
+    updated_at: Optional[int] = None
     feedback: Optional[str] = None
 
     agent_id: Optional[str] = None
@@ -22,15 +24,15 @@ class UserMemory:
     def __post_init__(self) -> None:
         """Automatically set created_at if not provided."""
         if self.created_at is None:
-            self.created_at = datetime.now(timezone.utc)
+            self.created_at = now_epoch_s()
 
     def to_dict(self) -> Dict[str, Any]:
         _dict = {
             "memory_id": self.memory_id,
             "memory": self.memory,
             "topics": self.topics,
-            "created_at": self.created_at.isoformat() if self.created_at else None,
-            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+            "created_at": datetime.fromtimestamp(self.created_at).isoformat() if self.created_at else None,
+            "updated_at": datetime.fromtimestamp(self.updated_at).isoformat() if self.updated_at else None,
             "input": self.input,
             "user_id": self.user_id,
             "agent_id": self.agent_id,

{agno-2.3.0 → agno-2.3.2}/agno/db/sqlite/async_sqlite.py

@@ -28,7 +28,7 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
 
 try:
-    from sqlalchemy import Column, MetaData, Table, and_, func, select, text
+    from sqlalchemy import Column, MetaData, String, Table, func, select, text
     from sqlalchemy.dialects import sqlite
     from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
     from sqlalchemy.schema import Index, UniqueConstraint
@@ -1182,8 +1182,8 @@ class AsyncSqliteDb(AsyncBaseDb):
                 if team_id is not None:
                     stmt = stmt.where(table.c.team_id == team_id)
                 if topics is not None:
-                    topic_conditions = [text(f"topics::text LIKE '%\"{topic}\"%'") for topic in topics]
-                    stmt = stmt.where(and_(*topic_conditions))
+                    for topic in topics:
+                        stmt = stmt.where(func.cast(table.c.topics, String).like(f'%"{topic}"%'))
                 if search_content is not None:
                     stmt = stmt.where(table.c.memory.ilike(f"%{search_content}%"))
 

{agno-2.3.0 → agno-2.3.2}/agno/db/sqlite/sqlite.py

@@ -28,7 +28,7 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
 
 try:
-    from sqlalchemy import Column, MetaData, Table, and_, func, select, text
+    from sqlalchemy import Column, MetaData, String, Table, func, select, text
     from sqlalchemy.dialects import sqlite
     from sqlalchemy.engine import Engine, create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
@@ -1176,8 +1176,8 @@ class SqliteDb(BaseDb):
                 if team_id is not None:
                     stmt = stmt.where(table.c.team_id == team_id)
                 if topics is not None:
-                    topic_conditions = [text(f"topics::text LIKE '%\"{topic}\"%'") for topic in topics]
-                    stmt = stmt.where(and_(*topic_conditions))
+                    for topic in topics:
+                        stmt = stmt.where(func.cast(table.c.topics, String).like(f'%"{topic}"%'))
                 if search_content is not None:
                     stmt = stmt.where(table.c.memory.ilike(f"%{search_content}%"))
 
@@ -1252,7 +1252,7 @@ class SqliteDb(BaseDb):
                 )
 
                 count_stmt = select(func.count()).select_from(stmt.alias())
-                total_count = sess.execute(count_stmt).scalar()
+                total_count = sess.execute(count_stmt).scalar() or 0
 
                 # Pagination
                 if limit is not None:

{agno-2.3.0 → agno-2.3.2}/agno/memory/manager.py

@@ -13,6 +13,7 @@ from agno.models.base import Model
 from agno.models.message import Message
 from agno.models.utils import get_model
 from agno.tools.function import Function
+from agno.utils.dttm import now_epoch_s
 from agno.utils.log import (
     log_debug,
     log_error,
@@ -227,7 +228,7 @@ class MemoryManager:
             memory.user_id = user_id
 
             if not memory.updated_at:
-                memory.updated_at = datetime.now()
+                memory.updated_at = now_epoch_s()
 
             self._upsert_db_memory(memory=memory)
             return memory.memory_id
@@ -255,7 +256,7 @@ class MemoryManager:
                 user_id = "default"
 
             if not memory.updated_at:
-                memory.updated_at = datetime.now()
+                memory.updated_at = now_epoch_s()
 
             memory.memory_id = memory_id
             memory.user_id = user_id
@@ -671,7 +672,7 @@ class MemoryManager:
             # If updated_at is None, place at the beginning of the list
             sorted_memories_list = sorted(
                 memories_list,
-                key=lambda memory: memory.updated_at or datetime.min,
+                key=lambda m: m.updated_at if m.updated_at is not None else 0,
             )
         else:
             sorted_memories_list = []
@@ -694,6 +695,7 @@ class MemoryManager:
         if memories is None:
             memories = {}
 
+        MAX_UNIX_TS = 2**63 - 1
         memories_list = memories.get(user_id, [])
         # Sort memories by updated_at timestamp if available
         if memories_list:
@@ -701,7 +703,7 @@ class MemoryManager:
             # If updated_at is None, place at the end of the list
             sorted_memories_list = sorted(
                 memories_list,
-                key=lambda memory: memory.updated_at or datetime.max,
+                key=lambda m: m.updated_at if m.updated_at is not None else MAX_UNIX_TS,
             )
 
         else:

{agno-2.3.0 → agno-2.3.2}/agno/models/anthropic/claude.py

@@ -5,7 +5,7 @@ from os import getenv
 from typing import Any, Dict, List, Optional, Type, Union
 
 import httpx
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
 from agno.exceptions import ModelProviderError, ModelRateLimitError
 from agno.models.base import Model
@@ -80,6 +80,30 @@ class Claude(Model):
         "claude-3-5-haiku-latest",
     }
 
+    # Models that DO NOT support native structured outputs
+    # All future models are assumed to support structured outputs
+    NON_STRUCTURED_OUTPUT_MODELS = {
+        # Claude 3.x family (all versions)
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307",
+        "claude-3-opus",
+        "claude-3-sonnet",
+        "claude-3-haiku",
+        # Claude 3.5 family (all versions except Sonnet 4.5)
+        "claude-3-5-sonnet-20240620",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-sonnet",
+        "claude-3-5-haiku-20241022",
+        "claude-3-5-haiku-latest",
+        "claude-3-5-haiku",
+        # Claude Sonnet 4.x family (versions before 4.5)
+        "claude-sonnet-4-20250514",
+        "claude-sonnet-4",
+        # Claude Opus 4.x family (versions before 4.1)
+        # (Add any Opus 4.x models released before 4.1 if they exist)
+    }
+
     id: str = "claude-sonnet-4-5-20250929"
     name: str = "Claude"
     provider: str = "Anthropic"
@@ -118,6 +142,9 @@ class Claude(Model):
         # Validate thinking support immediately at model creation
         if self.thinking:
             self._validate_thinking_support()
+        # Set structured outputs capability flag for supported models
+        if self._supports_structured_outputs():
+            self.supports_native_structured_outputs = True
         # Set up skills configuration if skills are enabled
         if self.skills:
             self._setup_skills_configuration()
@@ -141,13 +168,72 @@ class Claude(Model):
             client_params["default_headers"] = self.default_headers
         return client_params
 
-    def _has_beta_features(self) -> bool:
+    def _supports_structured_outputs(self) -> bool:
+        """
+        Check if the current model supports native structured outputs.
+
+        Returns:
+            bool: True if model supports structured outputs
+        """
+        # If model is in blacklist, it doesn't support structured outputs
+        if self.id in self.NON_STRUCTURED_OUTPUT_MODELS:
+            log_warning(
+                f"Model '{self.id}' does not support structured outputs. "
+                "Structured output features will not be available for this model."
+            )
+            return False
+
+        # Check for legacy model patterns that don't support structured outputs
+        if self.id.startswith("claude-3-"):
+            return False
+        if self.id.startswith("claude-sonnet-4-") and not self.id.startswith("claude-sonnet-4-5"):
+            return False
+        if self.id.startswith("claude-opus-4-") and not self.id.startswith("claude-opus-4-1"):
+            return False
+
+        return True
+
+    def _using_structured_outputs(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> bool:
+        """
+        Check if structured outputs are being used in this request.
+
+        Args:
+            response_format: Response format parameter
+            tools: Tools list to check for strict mode
+
+        Returns:
+            bool: True if structured outputs are in use
+        """
+        # Check for output_format usage
+        if response_format is not None and self._supports_structured_outputs():
+            return True
+
+        # Check for strict tools
+        if tools:
+            for tool in tools:
+                if tool.get("type") == "function":
+                    func_def = tool.get("function", {})
+                    if func_def.get("strict") is True:
+                        return True
+
+        return False
+
+    def _has_beta_features(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> bool:
         """Check if the model has any Anthropic beta features enabled."""
         return (
             self.mcp_servers is not None
             or self.context_management is not None
             or self.skills is not None
             or self.betas is not None
+            or self._using_structured_outputs(response_format, tools)
         )
 
     def get_client(self) -> AnthropicClient:
@@ -230,7 +316,70 @@ class Claude(Model):
                 if beta not in self.betas:
                     self.betas.append(beta)
 
-    def get_request_params(self) -> Dict[str, Any]:
+    def _ensure_additional_properties_false(self, schema: Dict[str, Any]) -> None:
+        """
+        Recursively ensure all object types have additionalProperties: false.
+        """
+        if isinstance(schema, dict):
+            if schema.get("type") == "object":
+                schema["additionalProperties"] = False
+
+            # Recursively process nested schemas
+            for key, value in schema.items():
+                if key in ["properties", "items", "allOf", "anyOf", "oneOf"]:
+                    if isinstance(value, dict):
+                        self._ensure_additional_properties_false(value)
+                    elif isinstance(value, list):
+                        for item in value:
+                            if isinstance(item, dict):
+                                self._ensure_additional_properties_false(item)
+
+    def _build_output_format(self, response_format: Optional[Union[Dict, Type[BaseModel]]]) -> Optional[Dict[str, Any]]:
+        """
+        Build Anthropic output_format parameter from response_format.
+
+        Args:
+            response_format: Pydantic model or dict format
+
+        Returns:
+            Dict with output_format structure or None
+        """
+        if response_format is None:
+            return None
+
+        if not self._supports_structured_outputs():
+            return None
+
+        # Handle Pydantic BaseModel
+        if isinstance(response_format, type) and issubclass(response_format, BaseModel):
+            try:
+                # Try to use Anthropic SDK's transform_schema helper if available
+                from anthropic import transform_schema
+
+                schema = transform_schema(response_format.model_json_schema())
+            except (ImportError, AttributeError):
+                # Fallback to direct schema conversion
+                schema = response_format.model_json_schema()
+                # Ensure additionalProperties is False
+                if isinstance(schema, dict):
+                    if "additionalProperties" not in schema:
+                        schema["additionalProperties"] = False
+                    # Recursively ensure all object types have additionalProperties: false
+                    self._ensure_additional_properties_false(schema)
+
+            return {"type": "json_schema", "schema": schema}
+
+        # Handle dict format (already in correct structure)
+        elif isinstance(response_format, dict):
+            return response_format
+
+        return None
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
         """
         Generate keyword arguments for API requests.
         """
@@ -251,8 +400,20 @@ class Claude(Model):
             _request_params["top_p"] = self.top_p
         if self.top_k:
             _request_params["top_k"] = self.top_k
-        if self.betas:
-            _request_params["betas"] = self.betas
+
+        # Build betas list - include existing betas and add new one if needed
+        betas_list = list(self.betas) if self.betas else []
+
+        # Add structured outputs beta header if using structured outputs
+        if self._using_structured_outputs(response_format, tools):
+            beta_header = "structured-outputs-2025-11-13"
+            if beta_header not in betas_list:
+                betas_list.append(beta_header)
+
+        # Include betas if any are present
+        if betas_list:
+            _request_params["betas"] = betas_list
+
         if self.context_management:
             _request_params["context_management"] = self.context_management
         if self.mcp_servers:
@@ -260,26 +421,51 @@ class Claude(Model):
                 {k: v for k, v in asdict(server).items() if v is not None} for server in self.mcp_servers
             ]
         if self.skills:
-            _request_params["betas"] = self.betas
             _request_params["container"] = {"skills": self.skills}
         if self.request_params:
             _request_params.update(self.request_params)
 
         return _request_params
 
+    def _validate_structured_outputs_usage(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> None:
+        """
+        Validate that structured outputs are only used with supported models.
+
+        Raises:
+            ValueError: If structured outputs are used with unsupported model
+        """
+        if not self._using_structured_outputs(response_format, tools):
+            return
+
+        if not self._supports_structured_outputs():
+            raise ValueError(f"Model '{self.id}' does not support structured outputs.\n\n")
+
     def _prepare_request_kwargs(
-        self, system_message: str, tools: Optional[List[Dict[str, Any]]] = None
+        self,
+        system_message: str,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
     ) -> Dict[str, Any]:
         """
         Prepare the request keyword arguments for the API call.
 
         Args:
             system_message (str): The concatenated system messages.
+            tools: Optional list of tools
+            response_format: Optional response format (Pydantic model or dict)
 
         Returns:
             Dict[str, Any]: The request keyword arguments.
         """
-        request_kwargs = self.get_request_params().copy()
+        # Validate structured outputs usage
+        self._validate_structured_outputs_usage(response_format, tools)
+
+        # Pass response_format and tools to get_request_params for beta header handling
+        request_kwargs = self.get_request_params(response_format=response_format, tools=tools).copy()
         if system_message:
             if self.cache_system_prompt:
                 cache_control = (
@@ -300,9 +486,15 @@ class Claude(Model):
             else:
                 tools = [code_execution_tool]
 
+        # Format tools (this will handle strict mode)
         if tools:
             request_kwargs["tools"] = format_tools_for_model(tools)
 
+        # Build output_format if response_format is provided
+        output_format = self._build_output_format(response_format)
+        if output_format:
+            request_kwargs["output_format"] = output_format
+
         if request_kwargs:
             log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
         return request_kwargs
@@ -324,9 +516,9 @@ class Claude(Model):
                 run_response.metrics.set_time_to_first_token()
 
             chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 provider_response = self.get_client().beta.messages.create(
                     model=self.id,
@@ -387,14 +579,14 @@ class Claude(Model):
             APIStatusError: For other API-related errors
         """
         chat_messages, system_message = format_messages(messages)
-        request_kwargs = self._prepare_request_kwargs(system_message, tools)
+        request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
             # Beta features
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 with self.get_client().beta.messages.stream(
                     model=self.id,
@@ -402,7 +594,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     for chunk in stream:
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
             else:
                 assistant_message.metrics.start_timer()
                 with self.get_client().messages.stream(
@@ -411,7 +603,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     for chunk in stream:  # type: ignore
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
 
             assistant_message.metrics.stop_timer()
 
@@ -447,10 +639,10 @@ class Claude(Model):
                 run_response.metrics.set_time_to_first_token()
 
             chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
             # Beta features
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 provider_response = await self.get_async_client().beta.messages.create(
                     model=self.id,
@@ -512,9 +704,9 @@ class Claude(Model):
                 run_response.metrics.set_time_to_first_token()
 
             chat_messages, system_message = format_messages(messages)
-            request_kwargs = self._prepare_request_kwargs(system_message, tools)
+            request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
-            if self._has_beta_features():
+            if self._has_beta_features(response_format=response_format, tools=tools):
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().beta.messages.stream(
                     model=self.id,
@@ -522,7 +714,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     async for chunk in stream:
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
             else:
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().messages.stream(
@@ -531,7 +723,7 @@ class Claude(Model):
                     **request_kwargs,
                 ) as stream:
                     async for chunk in stream:  # type: ignore
-                        yield self._parse_provider_response_delta(chunk)  # type: ignore
+                        yield self._parse_provider_response_delta(chunk, response_format=response_format)  # type: ignore
 
             assistant_message.metrics.stop_timer()
 
@@ -556,12 +748,18 @@ class Claude(Model):
             return tool_call_prompt
         return None
 
-    def _parse_provider_response(self, response: Union[AnthropicMessage, BetaMessage], **kwargs) -> ModelResponse:
+    def _parse_provider_response(
+        self,
+        response: Union[AnthropicMessage, BetaMessage],
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        **kwargs,
+    ) -> ModelResponse:
         """
         Parse the Claude response into a ModelResponse.
 
         Args:
             response: Raw response from Anthropic
+            response_format: Optional response format for structured output parsing
 
         Returns:
             ModelResponse: Parsed response data
@@ -574,10 +772,32 @@ class Claude(Model):
         if response.content:
             for block in response.content:
                 if block.type == "text":
+                    text_content = block.text
+
                     if model_response.content is None:
-                        model_response.content = block.text
+                        model_response.content = text_content
                     else:
-                        model_response.content += block.text
+                        model_response.content += text_content
+
+                    # Handle structured outputs (JSON outputs)
+                    if (
+                        response_format is not None
+                        and isinstance(response_format, type)
+                        and issubclass(response_format, BaseModel)
+                    ):
+                        if text_content:
+                            try:
+                                # Parse JSON from text content
+                                parsed_data = json.loads(text_content)
+                                # Validate against Pydantic model
+                                model_response.parsed = response_format.model_validate(parsed_data)
+                                log_debug(f"Successfully parsed structured output: {model_response.parsed}")
+                            except json.JSONDecodeError as e:
+                                log_warning(f"Failed to parse JSON from structured output: {e}")
+                            except ValidationError as e:
+                                log_warning(f"Failed to validate structured output against schema: {e}")
+                            except Exception as e:
+                                log_warning(f"Unexpected error parsing structured output: {e}")
 
                     # Capture citations from the response
                     if block.citations is not None:
@@ -669,12 +889,14 @@ class Claude(Model):
             ParsedBetaContentBlockStopEvent,
             ParsedBetaMessageStopEvent,
         ],
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
     ) -> ModelResponse:
         """
         Parse the Claude streaming response into ModelProviderResponse objects.
 
         Args:
             response: Raw response chunk from Anthropic
+            response_format: Optional response format for structured output parsing
 
         Returns:
             ModelResponse: Iterator of parsed response data
@@ -717,11 +939,24 @@ class Claude(Model):
                     }
                 ]
 
-        # Capture citations from the final response
+        # Capture citations from the final response and handle structured outputs
         elif isinstance(response, (MessageStopEvent, ParsedBetaMessageStopEvent)):
+            # In streaming mode, content has already been emitted via ContentBlockDeltaEvent chunks
+            # Setting content here would cause duplication since _populate_stream_data accumulates with +=
+            # Keep content empty to avoid duplication
             model_response.content = ""
             model_response.citations = Citations(raw=[], urls=[], documents=[])
+
+            # Accumulate text content for structured output parsing (but don't set model_response.content)
+            # The text was already streamed via ContentBlockDeltaEvent chunks
+            accumulated_text = ""
+
             for block in response.message.content:  # type: ignore
+                # Handle text blocks for structured output parsing
+                if block.type == "text":
+                    accumulated_text += block.text
+
+                # Handle citations
                 citations = getattr(block, "citations", None)
                 if not citations:
                     continue
@@ -736,6 +971,28 @@ class Claude(Model):
                             DocumentCitation(document_title=citation.document_title, cited_text=citation.cited_text)
                         )
 
+            # Handle structured outputs (JSON outputs) from accumulated text
+            # Note: We parse from accumulated_text but don't set model_response.content to avoid duplication
+            # The content was already streamed via ContentBlockDeltaEvent chunks
+            if (
+                response_format is not None
+                and isinstance(response_format, type)
+                and issubclass(response_format, BaseModel)
+            ):
+                if accumulated_text:
+                    try:
+                        # Parse JSON from accumulated text content
+                        parsed_data = json.loads(accumulated_text)
+                        # Validate against Pydantic model
+                        model_response.parsed = response_format.model_validate(parsed_data)
+                        log_debug(f"Successfully parsed structured output from stream: {model_response.parsed}")
+                    except json.JSONDecodeError as e:
+                        log_warning(f"Failed to parse JSON from structured output in stream: {e}")
+                    except ValidationError as e:
+                        log_warning(f"Failed to validate structured output against schema in stream: {e}")
+                    except Exception as e:
+                        log_warning(f"Unexpected error parsing structured output in stream: {e}")
+
             # Capture context management information if present
             if self.context_management is not None and hasattr(response.message, "context_management"):  # type: ignore
                 context_mgmt = response.message.context_management  # type: ignore