fix(google_provider): wrongly setting "parsed" attribute on generation

Author: arthurbrenno

agentle/generations/providers/google/adapters/generate_generate_content_response_to_generation_adapter.py

@@ -253,16 +253,19 @@ async def _adapt_streaming(
                 _all_parts.extend(_parts)
 
                 if _optional_model is not None:
-                    optional_model = parse_streaming_json(
-                        "".join([str(p.text) for p in _all_parts]),
+                    # Parse streaming JSON and update final_parsed
+                    accumulated_json_text = "".join([str(p.text) for p in _all_parts])
+                    parsed_optional_model = parse_streaming_json(
+                        accumulated_json_text,
                         model=_optional_model,
                     )
-                    chunk.parsed = optional_model
+                    # Cast the optional model back to T for use in the generation
+                    final_parsed = cast(T, parsed_optional_model)
                 else:
-                    chunk.parsed = None
+                    final_parsed = None
 
-            # Extract parsed data (usually only available in final chunk)
-            if hasattr(chunk, "parsed") and chunk.parsed is not None:
+            # Also check if chunk has parsed attribute from Google API
+            elif hasattr(chunk, "parsed") and chunk.parsed is not None:
                 final_parsed = cast(T | None, chunk.parsed)
 
             # Extract usage (usually only in final chunk)

agentle/generations/providers/google/google_generation_provider.py

@@ -182,6 +182,37 @@ def organization(self) -> str:
         """
         return "google"
 
+    @overload
+    def stream_async[T](
+        self,
+        *,
+        model: str | ModelKind | None = None,
+        messages: Sequence[Message],
+        response_schema: type[T],
+        generation_config: GenerationConfig | GenerationConfigDict | None = None,
+    ) -> AsyncGenerator[Generation[T], None]: ...
+
+    @overload
+    def stream_async(
+        self,
+        *,
+        model: str | ModelKind | None = None,
+        messages: Sequence[Message],
+        response_schema: None = None,
+        generation_config: GenerationConfig | GenerationConfigDict | None = None,
+        tools: Sequence[Tool],
+    ) -> AsyncGenerator[Generation[WithoutStructuredOutput], None]: ...
+
+    @overload
+    def stream_async(
+        self,
+        *,
+        model: str | ModelKind | None = None,
+        messages: Sequence[Message],
+        response_schema: None = None,
+        generation_config: GenerationConfig | GenerationConfigDict | None = None,
+    ) -> AsyncGenerator[Generation[WithoutStructuredOutput], None]: ...
+
     async def stream_async[T = WithoutStructuredOutput](
         self,
         *,
@@ -190,7 +221,7 @@ async def stream_async[T = WithoutStructuredOutput](
         response_schema: type[T] | None = None,
         generation_config: GenerationConfig | GenerationConfigDict | None = None,
         tools: Sequence[Tool] | None = None,
-    ) -> AsyncGenerator[Generation[WithoutStructuredOutput], None]:
+    ) -> AsyncGenerator[Generation[T], None]:
         from google.genai import types
 
         if self._normalize_generation_config(generation_config).n > 1:
@@ -260,6 +291,7 @@ async def stream_async[T = WithoutStructuredOutput](
             tools=_tools,
             max_output_tokens=_generation_config.max_output_tokens,
             response_schema=response_schema if bool(response_schema) else None,
+            response_mime_type="application/json" if bool(response_schema) else None,
             automatic_function_calling=types.AutomaticFunctionCallingConfig(
                 disable=disable_function_calling,
                 maximum_remote_calls=maximum_remote_calls,
@@ -295,10 +327,8 @@ async def stream_async[T = WithoutStructuredOutput](
             raise
 
         # Create the response
-        response = GenerateGenerateContentResponseToGenerationAdapter[
-            WithoutStructuredOutput
-        ](
-            response_schema=None,
+        response = GenerateGenerateContentResponseToGenerationAdapter[T](
+            response_schema=response_schema,
             model=used_model,
         ).adapt(generate_content_response_stream)
 

examples/providers.py

@@ -4,46 +4,51 @@
 This example demonstrates how to use different model providers with the Agentle framework.
 """
 
+import asyncio
 from dotenv import load_dotenv
+from rsb.models.base_model import BaseModel
+
 
-from agentle.generations.models.message_parts.file import FilePart
 from agentle.generations.models.message_parts.text import TextPart
 from agentle.generations.models.messages.user_message import UserMessage
 from agentle.generations.providers.base.generation_provider import GenerationProvider
-from agentle.generations.providers.openrouter.openrouter_generation_provider import (
-    OpenRouterGenerationProvider,
+from agentle.generations.providers.google.google_generation_provider import (
+    GoogleGenerationProvider,
 )
 
 load_dotenv()
 
 
-def add_numbers(a: float, b: float) -> float:
-    return a + b
+class PoemResponse(BaseModel):
+    poem: str
 
 
 # Example 1: Create an agent with Google's Gemini model
-provider: GenerationProvider = OpenRouterGenerationProvider().with_fallback_models(
-    "openai/gpt-5-nano"
-)
-
-example_file = FilePart.from_local_file(
-    "/Users/arthurbrenno/Documents/Dev/Paragon/agentle/examples/harvard.wav",
-    "audio/mp3",
-)
-
-# Run the Google agent
-generation = provider.generate(
-    model="google/gemini-2.5-flash",
-    messages=[
-        UserMessage(
-            parts=[
-                example_file,
-                TextPart(
-                    text="O que tem nesse audio?",
-                ),
-            ]
-        )
-    ],
-)
-
-print(generation)
+provider: GenerationProvider = GoogleGenerationProvider()
+
+
+async def main() -> None:
+    # Run the Google agent
+    stream = provider.stream_async(
+        model="google/gemini-2.5-flash",
+        messages=[
+            UserMessage(
+                parts=[
+                    TextPart(
+                        text="Escreva um poema sobre o amor",
+                    ),
+                ]
+            )
+        ],
+        response_schema=PoemResponse,
+    )
+
+    async for generation in stream:
+        print(generation)
+        print()
+        print()
+        print()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())