agno 2.0.10__py3-none-any.whl → 2.1.0__py3-none-any.whl

agno/models/base.py

@@ -715,6 +715,7 @@ class Model(ABC):
             assistant_message = Message(role=self.assistant_message_role)
             # Create assistant message and stream data
             stream_data = MessageData()
+            model_response = ModelResponse()
             if stream_model_response:
                 # Generate response
                 yield from self.process_response_stream(
@@ -744,7 +745,6 @@ class Model(ABC):
                     assistant_message.tool_calls = self.parse_tool_calls(stream_data.response_tool_calls)
 
             else:
-                model_response = ModelResponse()
                 self._process_model_response(
                     messages=messages,
                     assistant_message=assistant_message,
@@ -784,6 +784,10 @@ class Model(ABC):
                     self.format_function_call_results(
                         messages=messages, function_call_results=function_call_results, **stream_data.extra
                     )
+                elif model_response and model_response.extra is not None:
+                    self.format_function_call_results(
+                        messages=messages, function_call_results=function_call_results, **model_response.extra
+                    )
                 else:
                     self.format_function_call_results(messages=messages, function_call_results=function_call_results)
 
@@ -879,9 +883,10 @@ class Model(ABC):
             # Create assistant message and stream data
             assistant_message = Message(role=self.assistant_message_role)
             stream_data = MessageData()
+            model_response = ModelResponse()
             if stream_model_response:
                 # Generate response
-                async for response in self.aprocess_response_stream(
+                async for model_response in self.aprocess_response_stream(
                     messages=messages,
                     assistant_message=assistant_message,
                     stream_data=stream_data,
@@ -890,7 +895,7 @@ class Model(ABC):
                     tool_choice=tool_choice or self._tool_choice,
                     run_response=run_response,
                 ):
-                    yield response
+                    yield model_response
 
                 # Populate assistant message from stream data
                 if stream_data.response_content:
@@ -907,7 +912,6 @@ class Model(ABC):
                     assistant_message.tool_calls = self.parse_tool_calls(stream_data.response_tool_calls)
 
             else:
-                model_response = ModelResponse()
                 await self._aprocess_model_response(
                     messages=messages,
                     assistant_message=assistant_message,
@@ -948,6 +952,10 @@ class Model(ABC):
                     self.format_function_call_results(
                         messages=messages, function_call_results=function_call_results, **stream_data.extra
                     )
+                elif model_response and model_response.extra is not None:
+                    self.format_function_call_results(
+                        messages=messages, function_call_results=function_call_results, **model_response.extra or {}
+                    )
                 else:
                     self.format_function_call_results(messages=messages, function_call_results=function_call_results)
 
@@ -1573,30 +1581,35 @@ class Model(ABC):
             *(self.arun_function_call(fc) for fc in function_calls_to_run), return_exceptions=True
         )
 
-        # Process results
+        # Separate async generators from other results for concurrent processing
+        async_generator_results: List[Any] = []
+        non_async_generator_results: List[Any] = []
+
         for result in results:
-            # If result is an exception, skip processing it
             if isinstance(result, BaseException):
-                log_error(f"Error during function call: {result}")
-                raise result
+                non_async_generator_results.append(result)
+                continue
 
-            # Unpack result
             function_call_success, function_call_timer, function_call, function_execution_result = result
 
-            updated_session_state = function_execution_result.updated_session_state
+            # Check if this result contains an async generator
+            if isinstance(function_call.result, (AsyncGeneratorType, AsyncIterator)):
+                async_generator_results.append(result)
+            else:
+                non_async_generator_results.append(result)
 
-            # Handle AgentRunException
-            if isinstance(function_call_success, AgentRunException):
-                a_exc = function_call_success
-                # Update additional messages from function call
-                _handle_agent_exception(a_exc, additional_input)
-                # Set function call success to False if an exception occurred
-                function_call_success = False
+        # Process async generators with real-time event streaming using asyncio.Queue
+        async_generator_outputs: Dict[int, Tuple[Any, str, Optional[BaseException]]] = {}
+        event_queue: asyncio.Queue = asyncio.Queue()
+        active_generators_count: int = len(async_generator_results)
 
-            # Process function call output
-            function_call_output: str = ""
-            if isinstance(function_call.result, (GeneratorType, collections.abc.Iterator)):
-                for item in function_call.result:
+        # Create background tasks for each async generator
+        async def process_async_generator(result, generator_id):
+            function_call_success, function_call_timer, function_call, function_execution_result = result
+            function_call_output = ""
+
+            try:
+                async for item in function_call.result:
                     # This function yields agent/team run events
                     if isinstance(item, tuple(get_args(RunOutputEvent))) or isinstance(
                         item, tuple(get_args(TeamRunOutputEvent))
@@ -1610,17 +1623,102 @@ class Model(ABC):
                                 function_call_output += item.content or ""
 
                             if function_call.function.show_result:
-                                yield ModelResponse(content=item.content)
+                                await event_queue.put(ModelResponse(content=item.content))
                                 continue
 
-                        # Yield the event itself to bubble it up
-                        yield item
+                            if isinstance(item, CustomEvent):
+                                function_call_output += str(item)
+
+                        # Put the event into the queue to be yielded
+                        await event_queue.put(item)
+
+                    # Yield custom events emitted by the tool
                     else:
                         function_call_output += str(item)
                         if function_call.function.show_result:
-                            yield ModelResponse(content=str(item))
-            elif isinstance(function_call.result, (AsyncGeneratorType, collections.abc.AsyncIterator)):
-                async for item in function_call.result:
+                            await event_queue.put(ModelResponse(content=str(item)))
+
+                # Store the final output for this generator
+                async_generator_outputs[generator_id] = (result, function_call_output, None)
+
+            except Exception as e:
+                # Store the exception
+                async_generator_outputs[generator_id] = (result, "", e)
+
+            # Signal that this generator is done
+            await event_queue.put(("GENERATOR_DONE", generator_id))
+
+        # Start all async generator tasks
+        generator_tasks = []
+        for i, result in enumerate(async_generator_results):
+            task = asyncio.create_task(process_async_generator(result, i))
+            generator_tasks.append(task)
+
+        # Stream events from the queue as they arrive
+        completed_generators_count = 0
+        while completed_generators_count < active_generators_count:
+            try:
+                event = await event_queue.get()
+
+                # Check if this is a completion signal
+                if isinstance(event, tuple) and event[0] == "GENERATOR_DONE":
+                    completed_generators_count += 1
+                    continue
+
+                # Yield the actual event
+                yield event
+
+            except Exception as e:
+                log_error(f"Error processing async generator event: {e}")
+                break
+
+        # Now process all results (non-async generators and completed async generators)
+        for i, original_result in enumerate(results):
+            # If result is an exception, skip processing it
+            if isinstance(original_result, BaseException):
+                log_error(f"Error during function call: {original_result}")
+                raise original_result
+
+            # Unpack result
+            function_call_success, function_call_timer, function_call, function_execution_result = original_result
+
+            # Check if this was an async generator that was already processed
+            async_function_call_output = None
+            if isinstance(function_call.result, (AsyncGeneratorType, collections.abc.AsyncIterator)):
+                # Find the corresponding processed result
+                async_gen_index = 0
+                for j, result in enumerate(results[: i + 1]):
+                    if not isinstance(result, BaseException):
+                        _, _, fc, _ = result
+                        if isinstance(fc.result, (AsyncGeneratorType, collections.abc.AsyncIterator)):
+                            if j == i:  # This is our async generator
+                                if async_gen_index in async_generator_outputs:
+                                    _, async_function_call_output, error = async_generator_outputs[async_gen_index]
+                                    if error:
+                                        log_error(f"Error in async generator: {error}")
+                                        raise error
+                                break
+                            async_gen_index += 1
+
+            updated_session_state = function_execution_result.updated_session_state
+
+            # Handle AgentRunException
+            if isinstance(function_call_success, AgentRunException):
+                a_exc = function_call_success
+                # Update additional messages from function call
+                _handle_agent_exception(a_exc, additional_input)
+                # Set function call success to False if an exception occurred
+                function_call_success = False
+
+            # Process function call output
+            function_call_output: str = ""
+
+            # Check if this was an async generator that was already processed
+            if async_function_call_output is not None:
+                function_call_output = async_function_call_output
+                # Events from async generators were already yielded in real-time above
+            elif isinstance(function_call.result, (GeneratorType, collections.abc.Iterator)):
+                for item in function_call.result:
                     # This function yields agent/team run events
                     if isinstance(item, tuple(get_args(RunOutputEvent))) or isinstance(
                         item, tuple(get_args(TeamRunOutputEvent))
@@ -1637,13 +1735,8 @@ class Model(ABC):
                                 yield ModelResponse(content=item.content)
                                 continue
 
-                            if isinstance(item, CustomEvent):
-                                function_call_output += str(item)
-
                         # Yield the event itself to bubble it up
                         yield item
-
-                    # Yield custom events emitted by the tool
                     else:
                         function_call_output += str(item)
                         if function_call.function.show_result:

agno/models/cerebras/cerebras.py

@@ -136,6 +136,7 @@ class Cerebras(Model):
         self,
         tools: Optional[List[Dict[str, Any]]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.

agno/models/cerebras/cerebras_openai.py

@@ -25,6 +25,7 @@ class CerebrasOpenAI(OpenAILike):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.

agno/models/dashscope/dashscope.py

@@ -73,6 +73,7 @@ class DashScope(OpenAILike):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)
 

agno/models/google/gemini.py

@@ -26,6 +26,7 @@ try:
     from google.genai.types import (
         Content,
         DynamicRetrievalConfig,
+        FunctionCallingConfigMode,
         GenerateContentConfig,
         GenerateContentResponse,
         GenerateContentResponseUsageMetadata,
@@ -150,6 +151,7 @@ class Gemini(Model):
         system_message: Optional[str] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """
         Returns the request keyword arguments for the GenerativeModel client.
@@ -245,6 +247,18 @@ class Gemini(Model):
         elif tools:
             config["tools"] = [format_function_definitions(tools)]
 
+        if tool_choice is not None:
+            if isinstance(tool_choice, str) and tool_choice.lower() == "auto":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.AUTO}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "none":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.NONE}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "validated":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.VALIDATED}}
+            elif isinstance(tool_choice, str) and tool_choice.lower() == "any":
+                config["tool_config"] = {"function_calling_config": {"mode": FunctionCallingConfigMode.ANY}}
+            else:
+                config["tool_config"] = {"function_calling_config": {"mode": tool_choice}}
+
         config = {k: v for k, v in config.items() if v is not None}
 
         if config:
@@ -271,7 +285,9 @@ class Gemini(Model):
         Invokes the model with a list of messages and returns the response.
         """
         formatted_messages, system_message = self._format_messages(messages)
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
@@ -315,7 +331,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
         try:
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
@@ -356,7 +374,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
 
         try:
             if run_response and run_response.metrics:
@@ -400,7 +420,9 @@ class Gemini(Model):
         """
         formatted_messages, system_message = self._format_messages(messages)
 
-        request_kwargs = self.get_request_params(system_message, response_format=response_format, tools=tools)
+        request_kwargs = self.get_request_params(
+            system_message, response_format=response_format, tools=tools, tool_choice=tool_choice
+        )
 
         try:
             if run_response and run_response.metrics:
@@ -1051,9 +1073,9 @@ class Gemini(Model):
 
         metrics.input_tokens = response_usage.prompt_token_count or 0
         metrics.output_tokens = response_usage.candidates_token_count or 0
-        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
         if response_usage.thoughts_token_count is not None:
             metrics.output_tokens += response_usage.thoughts_token_count or 0
+        metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
 
         metrics.cache_read_tokens = response_usage.cached_content_token_count or 0
 

agno/models/litellm/chat.py

@@ -38,6 +38,10 @@ class LiteLLM(Model):
     max_tokens: Optional[int] = None
     temperature: float = 0.7
     top_p: float = 1.0
+    metadata: Optional[Dict[str, Any]] = None
+    extra_headers: Optional[Dict[str, Any]] = None
+    extra_query: Optional[Dict[str, Any]] = None
+    extra_body: Optional[Dict[str, Any]] = None
     request_params: Optional[Dict[str, Any]] = None
 
     client: Optional[Any] = None
@@ -148,10 +152,23 @@ class LiteLLM(Model):
             base_params["api_key"] = self.api_key
         if self.api_base:
             base_params["api_base"] = self.api_base
+        if self.extra_headers:
+            base_params["extra_headers"] = self.extra_headers
+        if self.extra_query:
+            base_params["extra_query"] = self.extra_query
         if tools:
             base_params["tools"] = tools
             base_params["tool_choice"] = "auto"
 
+        # Handle metadata via extra_body as per LiteLLM docs
+        if self.metadata:
+            if self.extra_body:
+                base_params["extra_body"] = {**self.extra_body, "metadata": self.metadata}
+            else:
+                base_params["extra_body"] = {"metadata": self.metadata}
+        elif self.extra_body:
+            base_params["extra_body"] = self.extra_body
+
         # Add additional request params if provided
         request_params: Dict[str, Any] = {k: v for k, v in base_params.items() if v is not None}
         if self.request_params:

agno/models/openai/chat.py

@@ -160,6 +160,7 @@ class OpenAIChat(Model):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.
@@ -370,7 +371,9 @@ class OpenAIChat(Model):
             provider_response = self.get_client().chat.completions.create(
                 model=self.id,
                 messages=[self._format_message(m) for m in messages],  # type: ignore
-                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+                **self.get_request_params(
+                    response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+                ),
             )
             assistant_message.metrics.stop_timer()
 
@@ -447,7 +450,9 @@ class OpenAIChat(Model):
             response = await self.get_async_client().chat.completions.create(
                 model=self.id,
                 messages=[self._format_message(m) for m in messages],  # type: ignore
-                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+                **self.get_request_params(
+                    response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+                ),
             )
             assistant_message.metrics.stop_timer()
 
@@ -524,7 +529,9 @@ class OpenAIChat(Model):
                 messages=[self._format_message(m) for m in messages],  # type: ignore
                 stream=True,
                 stream_options={"include_usage": True},
-                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+                **self.get_request_params(
+                    response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+                ),
             ):
                 yield self._parse_provider_response_delta(chunk)
 
@@ -598,7 +605,9 @@ class OpenAIChat(Model):
                 messages=[self._format_message(m) for m in messages],  # type: ignore
                 stream=True,
                 stream_options={"include_usage": True},
-                **self.get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice),
+                **self.get_request_params(
+                    response_format=response_format, tools=tools, tool_choice=tool_choice, run_response=run_response
+                ),
             )
 
             async for chunk in async_stream:

agno/models/perplexity/perplexity.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from os import getenv
-from typing import Any, Dict, List, Optional, Type, Union
+from typing import Any, Dict, Optional, Type, Union
 
 from pydantic import BaseModel
 
@@ -53,8 +53,7 @@ class Perplexity(OpenAILike):
     def get_request_params(
         self,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests.

agno/models/requesty/__init__.py

@@ -0,0 +1,5 @@
+from agno.models.requesty.requesty import Requesty
+
+__all__ = [
+    "Requesty",
+]

agno/models/requesty/requesty.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass, field
+from os import getenv
+from typing import Any, Dict, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from agno.models.openai.like import OpenAILike
+from agno.run.agent import RunOutput
+
+
+@dataclass
+class Requesty(OpenAILike):
+    """
+    A class for using models hosted on Requesty.
+
+    Attributes:
+        id (str): The model id. Defaults to "openai/gpt-4.1".
+        provider (str): The provider name. Defaults to "Requesty".
+        api_key (Optional[str]): The API key.
+        base_url (str): The base URL. Defaults to "https://router.requesty.ai/v1".
+        max_tokens (int): The maximum number of tokens. Defaults to 1024.
+    """
+
+    id: str = "openai/gpt-4.1"
+    name: str = "Requesty"
+    provider: str = "Requesty"
+
+    api_key: Optional[str] = field(default_factory=lambda: getenv("REQUESTY_API_KEY"))
+    base_url: str = "https://router.requesty.ai/v1"
+    max_tokens: int = 1024
+
+    def get_request_params(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[RunOutput] = None,
+    ) -> Dict[str, Any]:
+        params = super().get_request_params(response_format=response_format, tools=tools, tool_choice=tool_choice)
+
+        if "extra_body" not in params:
+            params["extra_body"] = {}
+        params["extra_body"]["requesty"] = {}
+        if run_response and run_response.user_id:
+            params["extra_body"]["requesty"]["user_id"] = run_response.user_id
+        if run_response and run_response.session_id:
+            params["extra_body"]["requesty"]["trace_id"] = run_response.session_id
+
+        return params

agno/models/vllm/vllm.py

@@ -57,6 +57,7 @@ class VLLM(OpenAILike):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         request_kwargs = super().get_request_params(
             response_format=response_format, tools=tools, tool_choice=tool_choice

agno/models/xai/xai.py

@@ -44,6 +44,7 @@ class xAI(OpenAILike):
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        **kwargs: Any,
     ) -> Dict[str, Any]:
         """
         Returns keyword arguments for API requests, including search parameters.