agno 2.3.21__py3-none-any.whl → 2.3.23__py3-none-any.whl

agno/db/singlestore/singlestore.py

@@ -31,7 +31,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 Index, UniqueConstraint, and_, func, select, update
+    from sqlalchemy import ForeignKey, Index, UniqueConstraint, and_, func, select, update
     from sqlalchemy.dialects import mysql
     from sqlalchemy.engine import Engine, create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
@@ -151,7 +151,10 @@ class SingleStoreDb(BaseDb):
             Table: SQLAlchemy Table object with column definitions
         """
         try:
-            table_schema = get_table_schema_definition(table_type)
+            # Pass traces_table_name and db_schema for spans table foreign key resolution
+            table_schema = get_table_schema_definition(
+                table_type, traces_table_name=self.trace_table_name, db_schema=self.db_schema or "agno"
+            )
 
             columns: List[Column] = []
             # Get the columns from the table schema
@@ -207,7 +210,10 @@ class SingleStoreDb(BaseDb):
         """
         table_ref = f"{self.db_schema}.{table_name}" if self.db_schema else table_name
         try:
-            table_schema = get_table_schema_definition(table_type)
+            # Pass traces_table_name and db_schema for spans table foreign key resolution
+            table_schema = get_table_schema_definition(
+                table_type, traces_table_name=self.trace_table_name, db_schema=self.db_schema or "agno"
+            ).copy()
 
             columns: List[Column] = []
             indexes: List[str] = []
@@ -227,6 +233,11 @@ class SingleStoreDb(BaseDb):
                 if col_config.get("unique", False):
                     column_kwargs["unique"] = True
                     unique_constraints.append(col_name)
+
+                # Handle foreign key constraint
+                if "foreign_key" in col_config:
+                    column_args.append(ForeignKey(col_config["foreign_key"]))
+
                 columns.append(Column(*column_args, **column_kwargs))
 
             # Create the table object

agno/db/sqlite/async_sqlite.py

@@ -31,7 +31,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, String, Table, func, select, text
+    from sqlalchemy import Column, ForeignKey, 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
@@ -174,7 +174,8 @@ class AsyncSqliteDb(AsyncBaseDb):
             Table: SQLAlchemy Table object
         """
         try:
-            table_schema = get_table_schema_definition(table_type)
+            # Pass traces_table_name for spans table foreign key resolution
+            table_schema = get_table_schema_definition(table_type, traces_table_name=self.trace_table_name).copy()
 
             columns: List[Column] = []
             indexes: List[str] = []
@@ -196,6 +197,10 @@ class AsyncSqliteDb(AsyncBaseDb):
                     column_kwargs["unique"] = True
                     unique_constraints.append(col_name)
 
+                # Handle foreign key constraint
+                if "foreign_key" in col_config:
+                    column_args.append(ForeignKey(col_config["foreign_key"]))
+
                 columns.append(Column(*column_args, **column_kwargs))  # type: ignore
 
             # Create the table object

agno/db/sqlite/schemas.py

@@ -111,25 +111,36 @@ TRACE_TABLE_SCHEMA = {
     "created_at": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
 }
 
-SPAN_TABLE_SCHEMA = {
-    "span_id": {"type": String, "primary_key": True, "nullable": False},
-    "trace_id": {
-        "type": String,
-        "nullable": False,
-        "index": True,
-        "foreign_key": "agno_traces.trace_id",  # Foreign key to traces table
-    },
-    "parent_span_id": {"type": String, "nullable": True, "index": True},
-    "name": {"type": String, "nullable": False},
-    "span_kind": {"type": String, "nullable": False},
-    "status_code": {"type": String, "nullable": False},
-    "status_message": {"type": String, "nullable": True},
-    "start_time": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
-    "end_time": {"type": String, "nullable": False},  # ISO 8601 datetime string
-    "duration_ms": {"type": BigInteger, "nullable": False},
-    "attributes": {"type": JSON, "nullable": True},
-    "created_at": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
-}
+
+def _get_span_table_schema(traces_table_name: str = "agno_traces") -> dict[str, Any]:
+    """Get the span table schema with the correct foreign key reference.
+
+    Args:
+        traces_table_name: The name of the traces table to reference in the foreign key.
+
+    Returns:
+        The span table schema dictionary.
+    """
+    return {
+        "span_id": {"type": String, "primary_key": True, "nullable": False},
+        "trace_id": {
+            "type": String,
+            "nullable": False,
+            "index": True,
+            "foreign_key": f"{traces_table_name}.trace_id",
+        },
+        "parent_span_id": {"type": String, "nullable": True, "index": True},
+        "name": {"type": String, "nullable": False},
+        "span_kind": {"type": String, "nullable": False},
+        "status_code": {"type": String, "nullable": False},
+        "status_message": {"type": String, "nullable": True},
+        "start_time": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
+        "end_time": {"type": String, "nullable": False},  # ISO 8601 datetime string
+        "duration_ms": {"type": BigInteger, "nullable": False},
+        "attributes": {"type": JSON, "nullable": True},
+        "created_at": {"type": String, "nullable": False, "index": True},  # ISO 8601 datetime string
+    }
+
 
 CULTURAL_KNOWLEDGE_TABLE_SCHEMA = {
     "id": {"type": String, "primary_key": True, "nullable": False},
@@ -152,16 +163,21 @@ VERSIONS_TABLE_SCHEMA = {
 }
 
 
-def get_table_schema_definition(table_type: str) -> dict[str, Any]:
+def get_table_schema_definition(table_type: str, traces_table_name: str = "agno_traces") -> dict[str, Any]:
     """
     Get the expected schema definition for the given table.
 
     Args:
         table_type (str): The type of table to get the schema for.
+        traces_table_name (str): The name of the traces table (used for spans foreign key).
 
     Returns:
         Dict[str, Any]: Dictionary containing column definitions for the table
     """
+    # Handle spans table specially to resolve the foreign key reference
+    if table_type == "spans":
+        return _get_span_table_schema(traces_table_name)
+
     schemas = {
         "sessions": SESSION_TABLE_SCHEMA,
         "evals": EVAL_TABLE_SCHEMA,
@@ -169,7 +185,6 @@ def get_table_schema_definition(table_type: str) -> dict[str, Any]:
         "memories": USER_MEMORY_TABLE_SCHEMA,
         "knowledge": KNOWLEDGE_TABLE_SCHEMA,
         "traces": TRACE_TABLE_SCHEMA,
-        "spans": SPAN_TABLE_SCHEMA,
         "culture": CULTURAL_KNOWLEDGE_TABLE_SCHEMA,
         "versions": VERSIONS_TABLE_SCHEMA,
     }

agno/db/sqlite/sqlite.py

@@ -173,7 +173,8 @@ class SqliteDb(BaseDb):
             Table: SQLAlchemy Table object
         """
         try:
-            table_schema = get_table_schema_definition(table_type).copy()
+            # Pass traces_table_name for spans table foreign key resolution
+            table_schema = get_table_schema_definition(table_type, traces_table_name=self.trace_table_name).copy()
 
             columns: List[Column] = []
             indexes: List[str] = []
@@ -197,12 +198,7 @@ class SqliteDb(BaseDb):
 
                 # Handle foreign key constraint
                 if "foreign_key" in col_config:
-                    fk_ref = col_config["foreign_key"]
-                    # For spans table, dynamically replace the traces table reference
-                    # with the actual trace table name configured for this db instance
-                    if table_type == "spans" and "trace_id" in fk_ref:
-                        fk_ref = f"{self.trace_table_name}.trace_id"
-                    column_args.append(ForeignKey(fk_ref))
+                    column_args.append(ForeignKey(col_config["foreign_key"]))
 
                 columns.append(Column(*column_args, **column_kwargs))  # type: ignore
 

agno/knowledge/chunking/document.py

@@ -16,8 +16,9 @@ class DocumentChunking(ChunkingStrategy):
         if len(document.content) <= self.chunk_size:
             return [document]
 
-        # Split on double newlines first (paragraphs)
-        paragraphs = self.clean_text(document.content).split("\n\n")
+        # Split on double newlines first (paragraphs), then clean each paragraph
+        raw_paragraphs = document.content.split("\n\n")
+        paragraphs = [self.clean_text(para) for para in raw_paragraphs]
         chunks: List[Document] = []
         current_chunk = []
         current_size = 0

agno/knowledge/chunking/markdown.py

@@ -35,7 +35,8 @@ class MarkdownChunking(ChunkingStrategy):
                 elements = partition_md(filename=temp_file_path)
 
                 if not elements:
-                    return self.clean_text(content).split("\n\n")
+                    raw_paragraphs = content.split("\n\n")
+                    return [self.clean_text(para) for para in raw_paragraphs]
 
                 # Chunk by title with some default values
                 chunked_elements = chunk_by_title(
@@ -57,7 +58,10 @@ class MarkdownChunking(ChunkingStrategy):
                     if chunk_text.strip():
                         text_chunks.append(chunk_text.strip())
 
-                return text_chunks if text_chunks else self.clean_text(content).split("\n\n")
+                if text_chunks:
+                    return text_chunks
+                raw_paragraphs = content.split("\n\n")
+                return [self.clean_text(para) for para in raw_paragraphs]
 
             # Always clean up the temporary file
             finally:
@@ -65,7 +69,8 @@ class MarkdownChunking(ChunkingStrategy):
 
         # Fallback to simple paragraph splitting if the markdown chunking fails
         except Exception:
-            return self.clean_text(content).split("\n\n")
+            raw_paragraphs = content.split("\n\n")
+            return [self.clean_text(para) for para in raw_paragraphs]
 
     def chunk(self, document: Document) -> List[Document]:
         """Split markdown document into chunks based on markdown structure"""

agno/knowledge/chunking/recursive.py

@@ -31,7 +31,7 @@ class RecursiveChunking(ChunkingStrategy):
         start = 0
         chunk_meta_data = document.meta_data
         chunk_number = 1
-        content = self.clean_text(document.content)
+        content = document.content
 
         while start < len(content):
             end = min(start + self.chunk_size, len(content))
@@ -43,7 +43,7 @@ class RecursiveChunking(ChunkingStrategy):
                         end = start + last_sep + 1
                         break
 
-            chunk = content[start:end]
+            chunk = self.clean_text(content[start:end])
             meta_data = chunk_meta_data.copy()
             meta_data["chunk"] = chunk_number
             chunk_id = None

agno/models/base.py

@@ -1016,6 +1016,8 @@ class Model(ABC):
             model_response.extra.update(provider_response.extra)
         if provider_response.provider_data is not None:
             model_response.provider_data = provider_response.provider_data
+        if provider_response.response_usage is not None:
+            model_response.response_usage = provider_response.response_usage
 
     async def _aprocess_model_response(
         self,
@@ -1073,6 +1075,8 @@ class Model(ABC):
             model_response.extra.update(provider_response.extra)
         if provider_response.provider_data is not None:
             model_response.provider_data = provider_response.provider_data
+        if provider_response.response_usage is not None:
+            model_response.response_usage = provider_response.response_usage
 
     def _populate_assistant_message(
         self,

agno/models/google/gemini.py

@@ -466,7 +466,12 @@ class Gemini(Model):
 
         except (ClientError, ServerError) as e:
             log_error(f"Error from Gemini API: {e}")
-            error_message = str(e.response) if hasattr(e, "response") else str(e)
+            error_message = str(e)
+            if hasattr(e, "response"):
+                if hasattr(e.response, "text"):
+                    error_message = e.response.text
+                else:
+                    error_message = str(e.response)
             raise ModelProviderError(
                 message=error_message,
                 status_code=e.code if hasattr(e, "code") and e.code is not None else 502,
@@ -518,8 +523,14 @@ class Gemini(Model):
 
         except (ClientError, ServerError) as e:
             log_error(f"Error from Gemini API: {e}")
+            error_message = str(e)
+            if hasattr(e, "response"):
+                if hasattr(e.response, "text"):
+                    error_message = e.response.text
+                else:
+                    error_message = str(e.response)
             raise ModelProviderError(
-                message=str(e.response) if hasattr(e, "response") else str(e),
+                message=error_message,
                 status_code=e.code if hasattr(e, "code") and e.code is not None else 502,
                 model_name=self.name,
                 model_id=self.id,
@@ -574,8 +585,14 @@ class Gemini(Model):
 
         except (ClientError, ServerError) as e:
             log_error(f"Error from Gemini API: {e}")
+            error_message = str(e)
+            if hasattr(e, "response"):
+                if hasattr(e.response, "text"):
+                    error_message = e.response.text
+                else:
+                    error_message = str(e.response)
             raise ModelProviderError(
-                message=str(e.response) if hasattr(e, "response") else str(e),
+                message=error_message,
                 status_code=e.code if hasattr(e, "code") and e.code is not None else 502,
                 model_name=self.name,
                 model_id=self.id,
@@ -628,8 +645,14 @@ class Gemini(Model):
 
         except (ClientError, ServerError) as e:
             log_error(f"Error from Gemini API: {e}")
+            error_message = str(e)
+            if hasattr(e, "response"):
+                if hasattr(e.response, "text"):
+                    error_message = e.response.text
+                else:
+                    error_message = str(e.response)
             raise ModelProviderError(
-                message=str(e.response) if hasattr(e, "response") else str(e),
+                message=error_message,
                 status_code=e.code if hasattr(e, "code") and e.code is not None else 502,
                 model_name=self.name,
                 model_id=self.id,

agno/models/openai/chat.py

@@ -248,7 +248,7 @@ class OpenAIChat(Model):
         # Add tools
         if tools is not None and len(tools) > 0:
             # Remove unsupported fields for OpenAILike models
-            if self.provider in ["AIMLAPI", "Fireworks", "Nvidia"]:
+            if self.provider in ["AIMLAPI", "Fireworks", "Nvidia", "VLLM"]:
                 for tool in tools:
                     if tool.get("type") == "function":
                         if tool["function"].get("requires_confirmation") is not None:

agno/models/openai/responses.py

@@ -13,6 +13,7 @@ from agno.models.message import Citations, Message, UrlCitation
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
 from agno.run.agent import RunOutput
+from agno.tools.function import Function
 from agno.utils.http import get_default_async_client, get_default_sync_client
 from agno.utils.log import log_debug, log_error, log_warning
 from agno.utils.models.openai_responses import images_to_message
@@ -364,19 +365,25 @@ class OpenAIResponses(Model):
         return vector_store.id
 
     def _format_tool_params(
-        self, messages: List[Message], tools: Optional[List[Dict[str, Any]]] = None
+        self, messages: List[Message], tools: Optional[List[Union[Function, Dict[str, Any]]]] = None
     ) -> List[Dict[str, Any]]:
         """Format the tool parameters for the OpenAI Responses API."""
         formatted_tools = []
         if tools:
             for _tool in tools:
-                if _tool.get("type") == "function":
+                if isinstance(_tool, Function):
+                    _tool_dict = _tool.to_dict()
+                    _tool_dict["type"] = "function"
+                    for prop in _tool_dict.get("parameters", {}).get("properties", {}).values():
+                        if isinstance(prop.get("type", ""), list):
+                            prop["type"] = prop["type"][0]
+                    formatted_tools.append(_tool_dict)
+                elif _tool.get("type") == "function":
                     _tool_dict = _tool.get("function", {})
                     _tool_dict["type"] = "function"
                     for prop in _tool_dict.get("parameters", {}).get("properties", {}).values():
                         if isinstance(prop.get("type", ""), list):
                             prop["type"] = prop["type"][0]
-
                     formatted_tools.append(_tool_dict)
                 else:
                     formatted_tools.append(_tool)
@@ -395,7 +402,7 @@ class OpenAIResponses(Model):
 
         # Add the file IDs to the tool parameters
         for _tool in formatted_tools:
-            if _tool["type"] == "file_search" and vector_store_id is not None:
+            if _tool.get("type", "") == "file_search" and vector_store_id is not None:
                 _tool["vector_store_ids"] = [vector_store_id]
 
         return formatted_tools
@@ -524,12 +531,12 @@ class OpenAIResponses(Model):
     def count_tokens(
         self,
         messages: List[Message],
-        tools: Optional[List[Dict[str, Any]]] = None,
+        tools: Optional[List[Union[Function, Dict[str, Any]]]] = None,
         output_schema: Optional[Union[Dict, Type[BaseModel]]] = None,
     ) -> int:
         try:
             formatted_input = self._format_messages(messages, compress_tool_results=True)
-            formatted_tools = self._format_tool_params(messages, tools) if tools else None
+            formatted_tools = self._format_tool_params(messages, tools) if tools is not None else None
 
             response = self.get_client().responses.input_tokens.count(
                 model=self.id,
@@ -545,7 +552,7 @@ class OpenAIResponses(Model):
     async def acount_tokens(
         self,
         messages: List[Message],
-        tools: Optional[List[Dict[str, Any]]] = None,
+        tools: Optional[List[Union[Function, Dict[str, Any]]]] = None,
         output_schema: Optional[Union[Dict, Type[BaseModel]]] = None,
     ) -> int:
         """Async version of count_tokens using the async client."""

agno/os/middleware/jwt.py

@@ -5,7 +5,7 @@ import json
 import re
 from enum import Enum
 from os import getenv
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Iterable, List, Optional, Union
 
 import jwt
 from fastapi import Request, Response
@@ -168,7 +168,9 @@ class JWTValidator:
             except Exception as e:
                 log_warning(f"Failed to parse JWKS key: {e}")
 
-    def validate_token(self, token: str, expected_audience: Optional[str] = None) -> Dict[str, Any]:
+    def validate_token(
+        self, token: str, expected_audience: Optional[Union[str, Iterable[str]]] = None
+    ) -> Dict[str, Any]:
         """
         Validate JWT token and extract claims.
 
@@ -191,10 +193,9 @@ class JWTValidator:
         }
 
         # Configure audience verification
-        if expected_audience:
-            decode_kwargs["audience"] = expected_audience
-        else:
-            decode_options["verify_aud"] = False
+        # We'll decode without audience verification and if we need to verify the audience,
+        # we'll manually verify the audience to provide better error messages
+        decode_options["verify_aud"] = False
 
         # If validation is disabled, decode without signature verification
         if not self.validate:
@@ -206,6 +207,7 @@ class JWTValidator:
             decode_kwargs["options"] = decode_options
 
         last_exception: Optional[Exception] = None
+        payload: Optional[Dict[str, Any]] = None
 
         # Try JWKS keys first if configured
         if self.jwks_keys:
@@ -222,9 +224,7 @@ class JWTValidator:
                     jwk = self.jwks_keys["_default"]
 
                 if jwk:
-                    return jwt.decode(token, jwk.key, **decode_kwargs)
-            except jwt.InvalidAudienceError:
-                raise
+                    payload = jwt.decode(token, jwk.key, **decode_kwargs)
             except jwt.ExpiredSignatureError:
                 raise
             except jwt.InvalidTokenError as e:
@@ -233,20 +233,54 @@ class JWTValidator:
                 last_exception = e
 
         # Try each static verification key until one succeeds
-        for key in self.verification_keys:
-            try:
-                return jwt.decode(token, key, **decode_kwargs)
-            except jwt.InvalidAudienceError:
-                raise
-            except jwt.ExpiredSignatureError:
-                raise
-            except jwt.InvalidTokenError as e:
-                last_exception = e
-                continue
+        if payload is None:
+            for key in self.verification_keys:
+                try:
+                    payload = jwt.decode(token, key, **decode_kwargs)
+                    break
+                except jwt.ExpiredSignatureError:
+                    raise
+                except jwt.InvalidTokenError as e:
+                    last_exception = e
+                    continue
 
-        if last_exception:
-            raise last_exception
-        raise jwt.InvalidTokenError("No verification keys configured")
+        if payload is None:
+            if last_exception:
+                raise last_exception
+            raise jwt.InvalidTokenError("No verification keys configured")
+
+        # Manually verify audience if expected_audience was provided
+        if expected_audience:
+            token_audience = payload.get(self.audience_claim)
+            if token_audience is None:
+                raise jwt.InvalidTokenError(
+                    f'Token is missing the "{self.audience_claim}" claim. '
+                    f"Audience verification requires this claim to be present in the token."
+                )
+
+            # Normalize expected_audience to a list
+            if isinstance(expected_audience, str):
+                expected_audiences = [expected_audience]
+            elif isinstance(expected_audience, Iterable):
+                expected_audiences = list(expected_audience)
+            else:
+                expected_audiences = []
+
+            # Normalize token_audience to a list
+            if isinstance(token_audience, str):
+                token_audiences = [token_audience]
+            elif isinstance(token_audience, list):
+                token_audiences = token_audience
+            else:
+                token_audiences = [token_audience] if token_audience else []
+
+            # Check if any token audience matches any expected audience
+            if not any(aud in expected_audiences for aud in token_audiences):
+                raise jwt.InvalidAudienceError(
+                    f"Invalid audience. Expected one of: {expected_audiences}, got: {token_audiences}"
+                )
+
+        return payload
 
     def extract_claims(self, payload: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -364,6 +398,7 @@ class JWTMiddleware(BaseHTTPMiddleware):
         user_id_claim: str = "sub",
         session_id_claim: str = "session_id",
         audience_claim: str = "aud",
+        audience: Optional[Union[str, Iterable[str]]] = None,
         verify_audience: bool = False,
         dependencies_claims: Optional[List[str]] = None,
         session_state_claims: Optional[List[str]] = None,
@@ -400,7 +435,8 @@ class JWTMiddleware(BaseHTTPMiddleware):
             user_id_claim: JWT claim name for user ID (default: "sub")
             session_id_claim: JWT claim name for session ID (default: "session_id")
             audience_claim: JWT claim name for audience/OS ID (default: "aud")
-            verify_audience: Whether to verify the audience claim matches AgentOS ID (default: False)
+            audience: Optional expected audience claim to validate against the token's audience claim (default: AgentOS ID)
+            verify_audience: Whether to verify the token's audience claim matches the expected audience claim (default: False)
             dependencies_claims: A list of claims to extract from the JWT token for dependencies
             session_state_claims: A list of claims to extract from the JWT token for session state
             scope_mappings: Optional dictionary mapping route patterns to required scopes.
@@ -453,6 +489,8 @@ class JWTMiddleware(BaseHTTPMiddleware):
         self.dependencies_claims: List[str] = dependencies_claims or []
         self.session_state_claims: List[str] = session_state_claims or []
 
+        self.audience = audience
+
         # RBAC configuration (opt-in via scope_mappings)
         self.authorization = authorization
 
@@ -648,7 +686,9 @@ class JWTMiddleware(BaseHTTPMiddleware):
 
         try:
             # Validate token and extract claims (with audience verification if configured)
-            expected_audience = agent_os_id if self.verify_audience else None
+            expected_audience = None
+            if self.verify_audience:
+                expected_audience = self.audience or agent_os_id
             payload: Dict[str, Any] = self.validator.validate_token(token, expected_audience)  # type: ignore
 
             # Extract standard claims and store in request.state
@@ -755,11 +795,10 @@ class JWTMiddleware(BaseHTTPMiddleware):
             request.state.authenticated = True
 
         except jwt.InvalidAudienceError:
-            log_warning(f"Invalid audience - expected: {agent_os_id}")
+            log_warning(f"Invalid token audience - expected: {expected_audience}")
             return self._create_error_response(
-                401, "Invalid audience - token not valid for this AgentOS instance", origin, cors_allowed_origins
+                401, "Invalid token audience - token not valid for this AgentOS instance", origin, cors_allowed_origins
             )
-
         except jwt.ExpiredSignatureError as e:
             if self.validate:
                 log_warning(f"Token has expired: {str(e)}")

agno/os/routers/agents/router.py

@@ -220,11 +220,11 @@ def get_agent_router(
         kwargs = await get_request_kwargs(request, create_agent_run)
 
         if hasattr(request.state, "user_id") and request.state.user_id is not None:
-            if user_id:
+            if user_id and user_id != request.state.user_id:
                 log_warning("User ID parameter passed in both request state and kwargs, using request state")
             user_id = request.state.user_id
         if hasattr(request.state, "session_id") and request.state.session_id is not None:
-            if session_id:
+            if session_id and session_id != request.state.session_id:
                 log_warning("Session ID parameter passed in both request state and kwargs, using request state")
             session_id = request.state.session_id
         if hasattr(request.state, "session_state") and request.state.session_state is not None:
@@ -409,7 +409,7 @@ def get_agent_router(
         if agent is None:
             raise HTTPException(status_code=404, detail="Agent not found")
 
-        cancelled = agent.cancel_run(run_id=run_id)
+        cancelled = await agent.acancel_run(run_id=run_id)
         if not cancelled:
             raise HTTPException(status_code=500, detail="Failed to cancel run - run not found or already completed")
 

agno/os/routers/evals/evals.py

@@ -118,8 +118,8 @@ def attach_routes(
         model_id: Optional[str] = Query(default=None, description="Model ID"),
         filter_type: Optional[EvalFilterType] = Query(default=None, description="Filter type", alias="type"),
         eval_types: Optional[List[EvalType]] = Depends(parse_eval_types_filter),
-        limit: Optional[int] = Query(default=20, description="Number of eval runs to return"),
-        page: Optional[int] = Query(default=1, description="Page number"),
+        limit: Optional[int] = Query(default=20, description="Number of eval runs to return", ge=1),
+        page: Optional[int] = Query(default=1, description="Page number", ge=0),
         sort_by: Optional[str] = Query(default="created_at", description="Field to sort by"),
         sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),

agno/os/routers/knowledge/knowledge.py

@@ -297,7 +297,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
             else:
                 raise HTTPException(status_code=400, detail=f"Invalid reader_id: {update_data.reader_id}")
 
-        updated_content_dict = knowledge.patch_content(content)
+        updated_content_dict = await knowledge.apatch_content(content)
         if not updated_content_dict:
             raise HTTPException(status_code=404, detail=f"Content not found: {content_id}")
 
@@ -344,8 +344,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
     )
     async def get_content(
         request: Request,
-        limit: Optional[int] = Query(default=20, description="Number of content entries to return"),
-        page: Optional[int] = Query(default=1, description="Page number"),
+        limit: Optional[int] = Query(default=20, description="Number of content entries to return", ge=1),
+        page: Optional[int] = Query(default=1, description="Page number", ge=0),
         sort_by: Optional[str] = Query(default="created_at", description="Field to sort by"),
         sort_order: Optional[SortOrder] = Query(default="desc", description="Sort order (asc or desc)"),
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
@@ -1029,13 +1029,13 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
                     search_types=search_types,
                 )
             )
-
+        filters = await knowledge.async_get_valid_filters()
         return ConfigResponseSchema(
             readers=reader_schemas,
             vector_dbs=vector_dbs,
             readersForType=types_of_readers,
             chunkers=chunkers_dict,
-            filters=knowledge.get_valid_filters(),
+            filters=filters,
         )
 
     return router