agno 2.0.6__py3-none-any.whl → 2.0.8__py3-none-any.whl

agno/models/llama_cpp/llama_cpp.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+from agno.models.openai.like import OpenAILike
+
+
+@dataclass
+class LlamaCpp(OpenAILike):
+    """
+    A class for interacting with LLMs using Llama CPP.
+
+    Attributes:
+        id (str): The id of the Llama CPP model. Default is "ggml-org/gpt-oss-20b-GGUF".
+        name (str): The name of this chat model instance. Default is "LlamaCpp".
+        provider (str): The provider of the model. Default is "LlamaCpp".
+        base_url (str): The base url to which the requests are sent.
+    """
+
+    id: str = "ggml-org/gpt-oss-20b-GGUF"
+    name: str = "LlamaCpp"
+    provider: str = "LlamaCpp"
+
+    base_url: str = "http://127.0.0.1:8080/v1"

agno/models/nexus/__init__.py

@@ -1,3 +1,3 @@
 from agno.models.nexus.nexus import Nexus
 
-__all__ = ["Nexus"]
+__all__ = ["Nexus"]

agno/models/nexus/nexus.py

@@ -6,13 +6,12 @@ from agno.models.openai.like import OpenAILike
 @dataclass
 class Nexus(OpenAILike):
     """
-    A class for interacting with Nvidia models.
+    A class for interacting with LLMs using Nexus.
 
     Attributes:
-        id (str): The id of the Nexus model to use. Default is "nvidia/llama-3.1-nemotron-70b-instruct".
+        id (str): The id of the Nexus model to use. Default is "openai/gpt-4".
         name (str): The name of this chat model instance. Default is "Nexus"
         provider (str): The provider of the model. Default is "Nexus".
-        api_key (str): The api key to authorize request to Nexus.
         base_url (str): The base url to which the requests are sent.
     """
 
@@ -21,5 +20,3 @@ class Nexus(OpenAILike):
     provider: str = "Nexus"
 
     base_url: str = "http://localhost:8000/llm/v1/"
-
-    supports_native_structured_outputs: bool = False

agno/models/ollama/chat.py

@@ -84,7 +84,8 @@ class Ollama(Model):
         if self.async_client is not None:
             return self.async_client
 
-        return AsyncOllamaClient(**self._get_client_params())
+        self.async_client = AsyncOllamaClient(**self._get_client_params())
+        return self.async_client
 
     def get_request_params(
         self,
@@ -144,6 +145,28 @@ class Ollama(Model):
             "role": message.role,
             "content": message.content,
         }
+
+        if message.role == "assistant" and message.tool_calls is not None:
+            # Format tool calls for assistant messages
+            formatted_tool_calls = []
+            for tool_call in message.tool_calls:
+                if "function" in tool_call:
+                    function_data = tool_call["function"]
+                    formatted_tool_call = {
+                        "id": tool_call.get("id"),
+                        "type": "function",
+                        "function": {
+                            "name": function_data["name"],
+                            "arguments": json.loads(function_data["arguments"])
+                            if isinstance(function_data["arguments"], str)
+                            else function_data["arguments"],
+                        },
+                    }
+                    formatted_tool_calls.append(formatted_tool_call)
+
+            if formatted_tool_calls:
+                _message["tool_calls"] = formatted_tool_calls
+
         if message.role == "user":
             if message.images is not None:
                 message_images = []

agno/models/openai/chat.py

@@ -22,13 +22,8 @@ try:
     from openai import AsyncOpenAI as AsyncOpenAIClient
     from openai import OpenAI as OpenAIClient
     from openai.types import CompletionUsage
-    from openai.types.chat import ChatCompletionAudio
-    from openai.types.chat.chat_completion import ChatCompletion
-    from openai.types.chat.chat_completion_chunk import (
-        ChatCompletionChunk,
-        ChoiceDelta,
-        ChoiceDeltaToolCall,
-    )
+    from openai.types.chat import ChatCompletion, ChatCompletionAudio, ChatCompletionChunk
+    from openai.types.chat.chat_completion_chunk import ChoiceDelta, ChoiceDeltaToolCall
 except (ImportError, ModuleNotFoundError):
     raise ImportError("`openai` not installed. Please install using `pip install openai`")
 

agno/models/openai/responses.py

@@ -19,10 +19,7 @@ from agno.utils.models.schema_utils import get_response_schema_for_provider
 
 try:
     from openai import APIConnectionError, APIStatusError, AsyncOpenAI, OpenAI, RateLimitError
-    from openai.types.responses.response import Response
-    from openai.types.responses.response_reasoning_item import ResponseReasoningItem
-    from openai.types.responses.response_stream_event import ResponseStreamEvent
-    from openai.types.responses.response_usage import ResponseUsage
+    from openai.types.responses import Response, ResponseReasoningItem, ResponseStreamEvent, ResponseUsage
 except ImportError as e:
     raise ImportError("`openai` not installed. Please install using `pip install openai -U`") from e
 
@@ -407,21 +404,28 @@ class OpenAIResponses(Model):
         """
         formatted_messages: List[Union[Dict[str, Any], ResponseReasoningItem]] = []
 
-        if self._using_reasoning_model():
+        messages_to_format = messages
+        previous_response_id: Optional[str] = None
+        
+        if self._using_reasoning_model() and self.store is not False:
             # Detect whether we're chaining via previous_response_id. If so, we should NOT
             # re-send prior function_call items; the Responses API already has the state and
             # expects only the corresponding function_call_output items.
-            previous_response_id: Optional[str] = None
-            if self.store is not False:
-                for msg in reversed(messages):
-                    if (
-                        msg.role == "assistant"
-                        and hasattr(msg, "provider_data")
-                        and msg.provider_data
-                        and "response_id" in msg.provider_data
-                    ):
-                        previous_response_id = msg.provider_data["response_id"]
-                        break
+        
+            for msg in reversed(messages):
+                if (
+                    msg.role == "assistant" 
+                    and hasattr(msg, "provider_data") 
+                    and msg.provider_data 
+                    and "response_id" in msg.provider_data
+                ):
+                    previous_response_id = msg.provider_data["response_id"]
+                    msg_index = messages.index(msg)
+                    
+                    # Include messages after this assistant message
+                    messages_to_format = messages[msg_index + 1:]
+                    
+                    break
 
         # Build a mapping from function_call id (fc_*) → call_id (call_*) from prior assistant tool_calls
         fc_id_to_call_id: Dict[str, str] = {}
@@ -434,7 +438,7 @@ class OpenAIResponses(Model):
                     if isinstance(fc_id, str) and isinstance(call_id, str):
                         fc_id_to_call_id[fc_id] = call_id
 
-        for message in messages:
+        for message in messages_to_format:
             if message.role in ["user", "system"]:
                 message_dict: Dict[str, Any] = {
                     "role": self.role_map[message.role],

agno/os/app.py

@@ -9,7 +9,6 @@ from fastapi.responses import JSONResponse
 from fastapi.routing import APIRoute
 from rich import box
 from rich.panel import Panel
-from starlette.middleware.cors import CORSMiddleware
 from starlette.requests import Request
 
 from agno.agent.agent import Agent
@@ -37,6 +36,7 @@ from agno.os.routers.memory import get_memory_router
 from agno.os.routers.metrics import get_metrics_router
 from agno.os.routers.session import get_session_router
 from agno.os.settings import AgnoAPISettings
+from agno.os.utils import update_cors_middleware
 from agno.team.team import Team
 from agno.utils.log import logger
 from agno.utils.string import generate_id, generate_id_from_name
@@ -286,14 +286,8 @@ class AgentOS:
 
             self.fastapi_app.middleware("http")(general_exception_handler)
 
-            self.fastapi_app.add_middleware(
-                CORSMiddleware,
-                allow_origins=self.settings.cors_origin_list,  # type: ignore
-                allow_credentials=True,
-                allow_methods=["*"],
-                allow_headers=["*"],
-                expose_headers=["*"],
-            )
+        # Update CORS middleware
+        update_cors_middleware(self.fastapi_app, self.settings.cors_origin_list)  # type: ignore
 
         return self.fastapi_app
 
@@ -368,7 +362,7 @@ class AgentOS:
                 for route in self.fastapi_app.routes:
                     for conflict in conflicts:
                         if isinstance(route, APIRoute):
-                            if route.path == conflict["path"] and list(route.methods) == list(conflict["methods"]):
+                            if route.path == conflict["path"] and list(route.methods) == list(conflict["methods"]):  # type: ignore
                                 self.fastapi_app.routes.pop(self.fastapi_app.routes.index(route))
 
                 self.fastapi_app.include_router(router)

agno/os/interfaces/agui/agui.py

@@ -19,8 +19,8 @@ class AGUI(BaseInterface):
         self.agent = agent
         self.team = team
 
-        if not self.agent and not self.team:
-            raise ValueError("AGUI requires an agent and a team")
+        if not (self.agent or self.team):
+            raise ValueError("AGUI requires an agent or a team")
 
     def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden

agno/os/interfaces/agui/utils.py

@@ -35,10 +35,16 @@ class EventBuffer:
 
     active_tool_call_ids: Set[str]  # All currently active tool calls
     ended_tool_call_ids: Set[str]  # All tool calls that have ended
+    current_text_message_id: str = ""  # ID of the current text message context (for tool call parenting)
+    next_text_message_id: str = ""  # Pre-generated ID for the next text message
+    pending_tool_calls_parent_id: str = ""  # Parent message ID for pending tool calls
 
     def __init__(self):
         self.active_tool_call_ids = set()
         self.ended_tool_call_ids = set()
+        self.current_text_message_id = ""
+        self.next_text_message_id = str(uuid.uuid4())
+        self.pending_tool_calls_parent_id = ""
 
     def start_tool_call(self, tool_call_id: str) -> None:
         """Start a new tool call."""
@@ -49,6 +55,29 @@ class EventBuffer:
         self.active_tool_call_ids.discard(tool_call_id)
         self.ended_tool_call_ids.add(tool_call_id)
 
+    def start_text_message(self) -> str:
+        """Start a new text message and return its ID."""
+        # Use the pre-generated next ID as current, and generate a new next ID
+        self.current_text_message_id = self.next_text_message_id
+        self.next_text_message_id = str(uuid.uuid4())
+        return self.current_text_message_id
+
+    def get_parent_message_id_for_tool_call(self) -> str:
+        """Get the message ID to use as parent for tool calls."""
+        # If we have a pending parent ID set (from text message end), use that
+        if self.pending_tool_calls_parent_id:
+            return self.pending_tool_calls_parent_id
+        # Otherwise use current text message ID
+        return self.current_text_message_id
+
+    def set_pending_tool_calls_parent_id(self, parent_id: str) -> None:
+        """Set the parent message ID for upcoming tool calls."""
+        self.pending_tool_calls_parent_id = parent_id
+
+    def clear_pending_tool_calls_parent_id(self) -> None:
+        """Clear the pending parent ID when a new text message starts."""
+        self.pending_tool_calls_parent_id = ""
+
 
 def convert_agui_messages_to_agno_messages(messages: List[AGUIMessage]) -> List[Message]:
     """Convert AG-UI messages to Agno messages."""
@@ -113,10 +142,18 @@ def _create_events_from_chunk(
     message_id: str,
     message_started: bool,
     event_buffer: EventBuffer,
-) -> Tuple[List[BaseEvent], bool]:
+) -> Tuple[List[BaseEvent], bool, str]:
     """
     Process a single chunk and return events to emit + updated message_started state.
-    Returns: (events_to_emit, new_message_started_state)
+
+    Args:
+        chunk: The event chunk to process
+        message_id: Current message identifier
+        message_started: Whether a message is currently active
+        event_buffer: Event buffer for tracking tool call state
+
+    Returns:
+        Tuple of (events_to_emit, new_message_started_state, message_id)
     """
     events_to_emit: List[BaseEvent] = []
 
@@ -133,6 +170,11 @@ def _create_events_from_chunk(
         # Handle the message start event, emitted once per message
         if not message_started:
             message_started = True
+            message_id = event_buffer.start_text_message()
+
+            # Clear pending tool calls parent ID when starting new text message
+            event_buffer.clear_pending_tool_calls_parent_id()
+
             start_event = TextMessageStartEvent(
                 type=EventType.TEXT_MESSAGE_START,
                 message_id=message_id,
@@ -149,21 +191,37 @@ def _create_events_from_chunk(
             )
             events_to_emit.append(content_event)  # type: ignore
 
-    # Handle starting a new tool call
-    elif chunk.event == RunEvent.tool_call_started:
-        # End the current text message if one is active before starting tool calls
-        if message_started:
-            end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=message_id)
-            events_to_emit.append(end_message_event)
-            message_started = False  # Reset message_started state
-
+    # Handle starting a new tool
+    elif chunk.event == RunEvent.tool_call_started or chunk.event == TeamRunEvent.tool_call_started:
         if chunk.tool is not None:  # type: ignore
             tool_call = chunk.tool  # type: ignore
+
+            # End current text message and handle for tool calls
+            current_message_id = message_id
+            if message_started:
+                # End the current text message
+                end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=current_message_id)
+                events_to_emit.append(end_message_event)
+
+                # Set this message as the parent for any upcoming tool calls
+                # This ensures multiple sequential tool calls all use the same parent
+                event_buffer.set_pending_tool_calls_parent_id(current_message_id)
+
+                # Reset message started state and generate new message_id for future messages
+                message_started = False
+                message_id = str(uuid.uuid4())
+
+            # Get the parent message ID - this will use pending parent if set, ensuring multiple tool calls in sequence have the same parent
+            parent_message_id = event_buffer.get_parent_message_id_for_tool_call()
+
+            if not parent_message_id:
+                parent_message_id = current_message_id
+
             start_event = ToolCallStartEvent(
                 type=EventType.TOOL_CALL_START,
                 tool_call_id=tool_call.tool_call_id,  # type: ignore
                 tool_call_name=tool_call.tool_name,  # type: ignore
-                parent_message_id=message_id,
+                parent_message_id=parent_message_id,
             )
             events_to_emit.append(start_event)
 
@@ -175,7 +233,7 @@ def _create_events_from_chunk(
             events_to_emit.append(args_event)  # type: ignore
 
     # Handle tool call completion
-    elif chunk.event == RunEvent.tool_call_completed:
+    elif chunk.event == RunEvent.tool_call_completed or chunk.event == TeamRunEvent.tool_call_completed:
         if chunk.tool is not None:  # type: ignore
             tool_call = chunk.tool  # type: ignore
             if tool_call.tool_call_id not in event_buffer.ended_tool_call_ids:
@@ -203,7 +261,7 @@ def _create_events_from_chunk(
         step_finished_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
         events_to_emit.append(step_finished_event)
 
-    return events_to_emit, message_started
+    return events_to_emit, message_started, message_id
 
 
 def _create_completion_events(
@@ -237,11 +295,16 @@ def _create_completion_events(
             if tool.tool_call_id is None or tool.tool_name is None:
                 continue
 
+            # Use the current text message ID from event buffer as parent
+            parent_message_id = event_buffer.get_parent_message_id_for_tool_call()
+            if not parent_message_id:
+                parent_message_id = message_id  # Fallback to the passed message_id
+
             start_event = ToolCallStartEvent(
                 type=EventType.TOOL_CALL_START,
                 tool_call_id=tool.tool_call_id,
                 tool_call_name=tool.tool_name,
-                parent_message_id=message_id,
+                parent_message_id=parent_message_id,
             )
             events_to_emit.append(start_event)
 
@@ -285,7 +348,7 @@ def stream_agno_response_as_agui_events(
     response_stream: Iterator[Union[RunOutputEvent, TeamRunOutputEvent]], thread_id: str, run_id: str
 ) -> Iterator[BaseEvent]:
     """Map the Agno response stream to AG-UI format, handling event ordering constraints."""
-    message_id = str(uuid.uuid4())
+    message_id = ""  # Will be set by EventBuffer when text message starts
     message_started = False
     event_buffer = EventBuffer()
     stream_completed = False
@@ -304,7 +367,7 @@ def stream_agno_response_as_agui_events(
             stream_completed = True
         else:
             # Process regular chunk immediately
-            events_from_chunk, message_started = _create_events_from_chunk(
+            events_from_chunk, message_started, message_id = _create_events_from_chunk(
                 chunk, message_id, message_started, event_buffer
             )
 
@@ -345,7 +408,7 @@ async def async_stream_agno_response_as_agui_events(
     run_id: str,
 ) -> AsyncIterator[BaseEvent]:
     """Map the Agno response stream to AG-UI format, handling event ordering constraints."""
-    message_id = str(uuid.uuid4())
+    message_id = ""  # Will be set by EventBuffer when text message starts
     message_started = False
     event_buffer = EventBuffer()
     stream_completed = False
@@ -364,7 +427,7 @@ async def async_stream_agno_response_as_agui_events(
             stream_completed = True
         else:
             # Process regular chunk immediately
-            events_from_chunk, message_started = _create_events_from_chunk(
+            events_from_chunk, message_started, message_id = _create_events_from_chunk(
                 chunk, message_id, message_started, event_buffer
             )
 

agno/os/interfaces/slack/slack.py

@@ -20,8 +20,8 @@ class Slack(BaseInterface):
         self.agent = agent
         self.team = team
 
-        if not self.agent and not self.team:
-            raise ValueError("Slack requires an agent and a team")
+        if not (self.agent or self.team):
+            raise ValueError("Slack requires an agent or a team")
 
     def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden

agno/os/interfaces/whatsapp/whatsapp.py

@@ -17,8 +17,8 @@ class Whatsapp(BaseInterface):
         self.agent = agent
         self.team = team
 
-        if not self.agent and not self.team:
-            raise ValueError("Whatsapp requires an agent and a team")
+        if not (self.agent or self.team):
+            raise ValueError("Whatsapp requires an agent or a team")
 
     def get_router(self, **kwargs) -> APIRouter:
         # Cannot be overridden

agno/os/router.py

@@ -731,10 +731,9 @@ def get_base_router(
                 ]:
                     # Process document files
                     try:
-                        file_content = await file.read()
-                        input_files.append(
-                            FileMedia(content=file_content, filename=file.filename, mime_type=file.content_type)
-                        )
+                        input_file = process_document(file)
+                        if input_file is not None:
+                            input_files.append(input_file)
                     except Exception as e:
                         log_error(f"Error processing file {file.filename}: {e}")
                         continue

agno/os/routers/evals/evals.py

@@ -380,7 +380,7 @@ def parse_eval_types_filter(
     eval_types: Optional[str] = Query(
         default=None,
         description="Comma-separated eval types (accuracy,performance,reliability)",
-        example="accuracy,performance",
+        examples=["accuracy,performance"],
     ),
 ) -> Optional[List[EvalType]]:
     """Parse comma-separated eval types into EvalType enums for filtering evaluation runs."""

agno/os/routers/memory/memory.py

@@ -396,7 +396,7 @@ def parse_topics(
     topics: Optional[List[str]] = Query(
         default=None,
         description="Comma-separated list of topics to filter by",
-        example=["preferences,technical,communication_style"],
+        examples=["preferences,technical,communication_style"],
     ),
 ) -> Optional[List[str]]:
     """Parse comma-separated topics into a list for filtering memories by topic."""

agno/os/schema.py

@@ -461,11 +461,8 @@ class TeamResponse(BaseModel):
             "stream_member_events": False,
         }
 
-        if team.model is None:
-            raise ValueError("Team model is required")
-
         team.determine_tools_for_model(
-            model=team.model,
+            model=team.model,  # type: ignore
             session=TeamSession(session_id=str(uuid4()), session_data={}),
             run_response=TeamRunOutput(run_id=str(uuid4())),
             async_mode=True,
@@ -763,6 +760,7 @@ class TeamSessionDetailSchema(BaseModel):
     session_state: Optional[dict]
     metrics: Optional[dict]
     team_data: Optional[dict]
+    chat_history: Optional[List[dict]]
     created_at: Optional[datetime]
     updated_at: Optional[datetime]
     total_tokens: Optional[int]
@@ -784,6 +782,7 @@ class TeamSessionDetailSchema(BaseModel):
             if session.session_data
             else None,
             metrics=session.session_data.get("session_metrics", {}) if session.session_data else None,
+            chat_history=[message.to_dict() for message in session.get_chat_history()],
             created_at=datetime.fromtimestamp(session.created_at, tz=timezone.utc) if session.created_at else None,
             updated_at=datetime.fromtimestamp(session.updated_at, tz=timezone.utc) if session.updated_at else None,
         )

agno/os/utils.py

@@ -1,6 +1,7 @@
 from typing import Any, Callable, Dict, List, Optional, Union
 
-from fastapi import HTTPException, UploadFile
+from fastapi import FastAPI, HTTPException, UploadFile
+from starlette.middleware.cors import CORSMiddleware
 
 from agno.agent.agent import Agent
 from agno.db.base import BaseDb
@@ -60,6 +61,14 @@ def get_run_input(run_dict: Dict[str, Any], is_workflow_run: bool = False) -> st
                 if message.get("role") == "user":
                     return message.get("content", "")
 
+        # Check the input field directly as final fallback
+        if run_dict.get("input") is not None:
+            input_value = run_dict.get("input")
+            if isinstance(input_value, str):
+                return input_value
+            else:
+                return str(input_value)
+
     if run_dict.get("messages") is not None:
         for message in run_dict["messages"]:
             if message.get("role") == "user":
@@ -109,27 +118,21 @@ def process_image(file: UploadFile) -> Image:
     content = file.file.read()
     if not content:
         raise HTTPException(status_code=400, detail="Empty file")
-    return Image(content=content)
+    return Image(content=content, format=extract_format(file), mime_type=file.content_type)
 
 
 def process_audio(file: UploadFile) -> Audio:
     content = file.file.read()
     if not content:
         raise HTTPException(status_code=400, detail="Empty file")
-    format = None
-    if file.filename and "." in file.filename:
-        format = file.filename.split(".")[-1].lower()
-    elif file.content_type:
-        format = file.content_type.split("/")[-1]
-
-    return Audio(content=content, format=format)
+    return Audio(content=content, format=extract_format(file), mime_type=file.content_type)
 
 
 def process_video(file: UploadFile) -> Video:
     content = file.file.read()
     if not content:
         raise HTTPException(status_code=400, detail="Empty file")
-    return Video(content=content, format=file.content_type)
+    return Video(content=content, format=extract_format(file), mime_type=file.content_type)
 
 
 def process_document(file: UploadFile) -> Optional[FileMedia]:
@@ -137,13 +140,23 @@ def process_document(file: UploadFile) -> Optional[FileMedia]:
         content = file.file.read()
         if not content:
             raise HTTPException(status_code=400, detail="Empty file")
-
-        return FileMedia(content=content, filename=file.filename, mime_type=file.content_type)
+        return FileMedia(
+            content=content, filename=file.filename, format=extract_format(file), mime_type=file.content_type
+        )
     except Exception as e:
         logger.error(f"Error processing document {file.filename}: {e}")
         return None
 
 
+def extract_format(file: UploadFile):
+    format = None
+    if file.filename and "." in file.filename:
+        format = file.filename.split(".")[-1].lower()
+    elif file.content_type:
+        format = file.content_type.split("/")[-1]
+    return format
+
+
 def format_tools(agent_tools: List[Union[Dict[str, Any], Toolkit, Function, Callable]]):
     formatted_tools = []
     if agent_tools is not None:
@@ -260,3 +273,33 @@ def _generate_schema_from_params(params: Dict[str, Any]) -> Dict[str, Any]:
         schema["required"] = required
 
     return schema
+
+
+def update_cors_middleware(app: FastAPI, new_origins: list):
+    existing_origins: List[str] = []
+
+    # TODO: Allow more options where CORS is properly merged and user can disable this behaviour
+
+    # Extract existing origins from current CORS middleware
+    for middleware in app.user_middleware:
+        if middleware.cls == CORSMiddleware:
+            if hasattr(middleware, "kwargs"):
+                existing_origins = middleware.kwargs.get("allow_origins", [])
+            break
+    # Merge origins
+    merged_origins = list(set(new_origins + existing_origins))
+    final_origins = [origin for origin in merged_origins if origin != "*"]
+
+    # Remove existing CORS
+    app.user_middleware = [m for m in app.user_middleware if m.cls != CORSMiddleware]
+    app.middleware_stack = None
+
+    # Add updated CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=final_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+        expose_headers=["*"],
+    )

agno/reasoning/default.py

@@ -14,6 +14,7 @@ def get_default_reasoning_agent(
     min_steps: int,
     max_steps: int,
     tools: Optional[List[Union[Toolkit, Callable, Function, Dict]]] = None,
+    tool_call_limit: Optional[int] = None,
     use_json_mode: bool = False,
     telemetry: bool = True,
     debug_mode: bool = False,
@@ -56,7 +57,7 @@ def get_default_reasoning_agent(
             - **validate**: When you reach a potential answer, signaling it's ready for validation.
             - **final_answer**: Only if you have confidently validated the solution.
             - **reset**: Immediately restart analysis if a critical error or incorrect result is identified.
-        6. **Confidence Score**: Provide a numeric confidence score (0.0–1.0) indicating your certainty in the step’s correctness and its outcome.
+        6. **Confidence Score**: Provide a numeric confidence score (0.0–1.0) indicating your certainty in the step's correctness and its outcome.
 
         Step 5 - Validation (mandatory before finalizing an answer):
         - Explicitly validate your solution by:
@@ -82,6 +83,7 @@ def get_default_reasoning_agent(
         - Only create a single instance of ReasoningSteps for your response.\
         """),
         tools=tools,
+        tool_call_limit=tool_call_limit,
         output_schema=ReasoningSteps,
         use_json_mode=use_json_mode,
         telemetry=telemetry,