agno 2.1.10__py3-none-any.whl → 2.2.0__py3-none-any.whl

agno/models/anthropic/claude.py

@@ -75,7 +75,7 @@ class Claude(Model):
     provider: str = "Anthropic"
 
     # Request parameters
-    max_tokens: Optional[int] = 4096
+    max_tokens: Optional[int] = 8192
     thinking: Optional[Dict[str, Any]] = None
     temperature: Optional[float] = None
     stop_sequences: Optional[List[str]] = None
@@ -656,7 +656,7 @@ class Claude(Model):
 
         # Anthropic-specific additional fields
         if response_usage.server_tool_use:
-            metrics.provider_metrics = {"server_tool_use": response_usage.server_tool_use}
+            metrics.provider_metrics = {"server_tool_use": response_usage.server_tool_use.model_dump()}
         if isinstance(response_usage, Usage):
             if response_usage.service_tier:
                 metrics.provider_metrics = metrics.provider_metrics or {}

agno/models/ollama/chat.py

@@ -429,8 +429,13 @@ class Ollama(Model):
         """
         metrics = Metrics()
 
-        metrics.input_tokens = response.get("prompt_eval_count", 0)
-        metrics.output_tokens = response.get("eval_count", 0)
+        # Safely handle None values from Ollama Cloud responses
+        input_tokens = response.get("prompt_eval_count")
+        output_tokens = response.get("eval_count")
+
+        # Default to 0 if None
+        metrics.input_tokens = input_tokens if input_tokens is not None else 0
+        metrics.output_tokens = output_tokens if output_tokens is not None else 0
         metrics.total_tokens = metrics.input_tokens + metrics.output_tokens
 
         return metrics

agno/os/app.py

@@ -312,7 +312,7 @@ class AgentOS:
                             async with self._mcp_app.lifespan(app):  # type: ignore
                                 yield
 
-                    final_lifespan = combined_lifespan
+                    final_lifespan = combined_lifespan  # type: ignore
 
                 fastapi_app = self._make_app(lifespan=final_lifespan)
             else:

agno/os/interfaces/a2a/router.py

@@ -221,7 +221,7 @@ def attach_routes(
                     session_id=context_id,
                     user_id=user_id,
                     stream=True,
-                    stream_intermediate_steps=True,
+                    stream_events=True,
                     **kwargs,
                 )
             else:
@@ -234,7 +234,7 @@ def attach_routes(
                     session_id=context_id,
                     user_id=user_id,
                     stream=True,
-                    stream_intermediate_steps=True,
+                    stream_events=True,
                     **kwargs,
                 )
 

agno/os/interfaces/agui/router.py

@@ -44,7 +44,7 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
             input=messages,
             session_id=run_input.thread_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             user_id=user_id,
         )
 
@@ -80,7 +80,7 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
             input=messages,
             session_id=input.thread_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_steps=True,
             user_id=user_id,
         )
 

agno/os/router.py

@@ -250,7 +250,7 @@ async def agent_response_streamer(
             videos=videos,
             files=files,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             **kwargs,
         )
         async for run_response_chunk in run_response:
@@ -287,7 +287,7 @@ async def agent_continue_response_streamer(
             session_id=session_id,
             user_id=user_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
         )
         async for run_response_chunk in continue_response:
             yield format_sse_event(run_response_chunk)  # type: ignore
@@ -335,7 +335,7 @@ async def team_response_streamer(
             videos=videos,
             files=files,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             **kwargs,
         )
         async for run_response_chunk in run_response:
@@ -389,12 +389,12 @@ async def handle_workflow_via_websocket(websocket: WebSocket, message: dict, os:
                 session_id = str(uuid4())
 
         # Execute workflow in background with streaming
-        workflow_result = await workflow.arun(
+        workflow_result = await workflow.arun(  # type: ignore
             input=user_message,
             session_id=session_id,
             user_id=user_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             background=True,
             websocket=websocket,
         )
@@ -435,12 +435,12 @@ async def workflow_response_streamer(
     **kwargs: Any,
 ) -> AsyncGenerator:
     try:
-        run_response = await workflow.arun(
+        run_response = workflow.arun(
             input=input,
             session_id=session_id,
             user_id=user_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             **kwargs,
         )
 

agno/os/routers/evals/schemas.py

@@ -2,7 +2,7 @@ from dataclasses import asdict
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from agno.db.schemas.evals import EvalType
 from agno.eval import AccuracyResult, PerformanceResult, ReliabilityResult
@@ -12,43 +12,43 @@ from agno.eval.reliability import ReliabilityEval
 
 
 class EvalRunInput(BaseModel):
-    agent_id: Optional[str] = None
-    team_id: Optional[str] = None
-
-    model_id: Optional[str] = None
-    model_provider: Optional[str] = None
-    eval_type: EvalType
-    input: str
-    additional_guidelines: Optional[str] = None
-    additional_context: Optional[str] = None
-    num_iterations: Optional[int] = 1
-    name: Optional[str] = None
+    agent_id: Optional[str] = Field(None, description="Agent ID to evaluate")
+    team_id: Optional[str] = Field(None, description="Team ID to evaluate")
+
+    model_id: Optional[str] = Field(None, description="Model ID to use for evaluation")
+    model_provider: Optional[str] = Field(None, description="Model provider name")
+    eval_type: EvalType = Field(..., description="Type of evaluation to run (accuracy, performance, or reliability)")
+    input: str = Field(..., description="Input text/query for the evaluation", min_length=1)
+    additional_guidelines: Optional[str] = Field(None, description="Additional guidelines for the evaluation")
+    additional_context: Optional[str] = Field(None, description="Additional context for the evaluation")
+    num_iterations: int = Field(1, description="Number of times to run the evaluation", ge=1, le=100)
+    name: Optional[str] = Field(None, description="Name for this evaluation run")
 
     # Accuracy eval specific fields
-    expected_output: Optional[str] = None
+    expected_output: Optional[str] = Field(None, description="Expected output for accuracy evaluation")
 
     # Performance eval specific fields
-    warmup_runs: Optional[int] = 0
+    warmup_runs: int = Field(0, description="Number of warmup runs before measuring performance", ge=0, le=10)
 
     # Reliability eval specific fields
-    expected_tool_calls: Optional[List[str]] = None
+    expected_tool_calls: Optional[List[str]] = Field(None, description="Expected tool calls for reliability evaluation")
 
 
 class EvalSchema(BaseModel):
-    id: str
-
-    agent_id: Optional[str] = None
-    model_id: Optional[str] = None
-    model_provider: Optional[str] = None
-    team_id: Optional[str] = None
-    workflow_id: Optional[str] = None
-    name: Optional[str] = None
-    evaluated_component_name: Optional[str] = None
-    eval_type: EvalType
-    eval_data: Dict[str, Any]
-    eval_input: Optional[Dict[str, Any]] = None
-    created_at: Optional[datetime] = None
-    updated_at: Optional[datetime] = None
+    id: str = Field(..., description="Unique identifier for the evaluation run")
+
+    agent_id: Optional[str] = Field(None, description="Agent ID that was evaluated")
+    model_id: Optional[str] = Field(None, description="Model ID used in evaluation")
+    model_provider: Optional[str] = Field(None, description="Model provider name")
+    team_id: Optional[str] = Field(None, description="Team ID that was evaluated")
+    workflow_id: Optional[str] = Field(None, description="Workflow ID that was evaluated")
+    name: Optional[str] = Field(None, description="Name of the evaluation run")
+    evaluated_component_name: Optional[str] = Field(None, description="Name of the evaluated component")
+    eval_type: EvalType = Field(..., description="Type of evaluation (accuracy, performance, or reliability)")
+    eval_data: Dict[str, Any] = Field(..., description="Evaluation results and metrics")
+    eval_input: Optional[Dict[str, Any]] = Field(None, description="Input parameters used for the evaluation")
+    created_at: Optional[datetime] = Field(None, description="Timestamp when evaluation was created")
+    updated_at: Optional[datetime] = Field(None, description="Timestamp when evaluation was last updated")
 
     @classmethod
     def from_dict(cls, eval_run: Dict[str, Any]) -> "EvalSchema":
@@ -135,8 +135,8 @@ class EvalSchema(BaseModel):
 
 
 class DeleteEvalRunsRequest(BaseModel):
-    eval_run_ids: List[str]
+    eval_run_ids: List[str] = Field(..., description="List of evaluation run IDs to delete", min_length=1)
 
 
 class UpdateEvalRunRequest(BaseModel):
-    name: str
+    name: str = Field(..., description="New name for the evaluation run", min_length=1, max_length=255)

agno/os/routers/health.py

@@ -1,3 +1,5 @@
+from datetime import datetime, timezone
+
 from fastapi import APIRouter
 
 from agno.os.schema import HealthResponse
@@ -6,6 +8,8 @@ from agno.os.schema import HealthResponse
 def get_health_router() -> APIRouter:
     router = APIRouter(tags=["Health"])
 
+    started_time_stamp = datetime.now(timezone.utc).timestamp()
+
     @router.get(
         "/health",
         operation_id="health_check",
@@ -15,11 +19,11 @@ def get_health_router() -> APIRouter:
         responses={
             200: {
                 "description": "API is healthy and operational",
-                "content": {"application/json": {"example": {"status": "ok"}}},
+                "content": {"application/json": {"example": {"status": "ok", "instantiated_at": "1760169236.778903"}}},
             }
         },
     )
     async def health_check() -> HealthResponse:
-        return HealthResponse(status="ok")
+        return HealthResponse(status="ok", instantiated_at=str(started_time_stamp))
 
     return router

agno/os/routers/knowledge/schemas.py

@@ -16,23 +16,23 @@ class ContentStatus(str, Enum):
 class ContentStatusResponse(BaseModel):
     """Response model for content status endpoint."""
 
-    status: ContentStatus
-    status_message: str = ""
+    status: ContentStatus = Field(..., description="Current processing status of the content")
+    status_message: str = Field("", description="Status message or error details")
 
 
 class ContentResponseSchema(BaseModel):
-    id: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    type: Optional[str] = None
-    size: Optional[str] = None
-    linked_to: Optional[str] = None
-    metadata: Optional[dict] = None
-    access_count: Optional[int] = None
-    status: Optional[ContentStatus] = None
-    status_message: Optional[str] = None
-    created_at: Optional[datetime] = None
-    updated_at: Optional[datetime] = None
+    id: str = Field(..., description="Unique identifier for the content")
+    name: Optional[str] = Field(None, description="Name of the content")
+    description: Optional[str] = Field(None, description="Description of the content")
+    type: Optional[str] = Field(None, description="MIME type of the content")
+    size: Optional[str] = Field(None, description="Size of the content in bytes")
+    linked_to: Optional[str] = Field(None, description="ID of related content if linked")
+    metadata: Optional[dict] = Field(None, description="Additional metadata as key-value pairs")
+    access_count: Optional[int] = Field(None, description="Number of times content has been accessed", ge=0)
+    status: Optional[ContentStatus] = Field(None, description="Processing status of the content")
+    status_message: Optional[str] = Field(None, description="Status message or error details")
+    created_at: Optional[datetime] = Field(None, description="Timestamp when content was created")
+    updated_at: Optional[datetime] = Field(None, description="Timestamp when content was last updated")
 
     @classmethod
     def from_dict(cls, content: Dict[str, Any]) -> "ContentResponseSchema":
@@ -99,37 +99,39 @@ class ContentUpdateSchema(BaseModel):
 
 
 class ReaderSchema(BaseModel):
-    id: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    chunkers: Optional[List[str]] = None
+    id: str = Field(..., description="Unique identifier for the reader")
+    name: Optional[str] = Field(None, description="Name of the reader")
+    description: Optional[str] = Field(None, description="Description of the reader's capabilities")
+    chunkers: Optional[List[str]] = Field(None, description="List of supported chunking strategies")
 
 
 class ChunkerSchema(BaseModel):
-    key: str
-    name: Optional[str] = None
-    description: Optional[str] = None
+    key: str = Field(..., description="Unique key for the chunker")
+    name: Optional[str] = Field(None, description="Name of the chunker")
+    description: Optional[str] = Field(None, description="Description of the chunking strategy")
 
 
 class VectorDbSchema(BaseModel):
-    id: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    search_types: Optional[List[str]] = None
+    id: str = Field(..., description="Unique identifier for the vector database")
+    name: Optional[str] = Field(None, description="Name of the vector database")
+    description: Optional[str] = Field(None, description="Description of the vector database")
+    search_types: Optional[List[str]] = Field(
+        None, description="List of supported search types (vector, keyword, hybrid)"
+    )
 
 
 class VectorSearchResult(BaseModel):
     """Schema for search result documents."""
 
-    id: str
-    content: str
-    name: Optional[str] = None
-    meta_data: Optional[Dict[str, Any]] = None
-    usage: Optional[Dict[str, Any]] = None
-    reranking_score: Optional[float] = None
-    content_id: Optional[str] = None
-    content_origin: Optional[str] = None
-    size: Optional[int] = None
+    id: str = Field(..., description="Unique identifier for the search result document")
+    content: str = Field(..., description="Content text of the document")
+    name: Optional[str] = Field(None, description="Name of the document")
+    meta_data: Optional[Dict[str, Any]] = Field(None, description="Metadata associated with the document")
+    usage: Optional[Dict[str, Any]] = Field(None, description="Usage statistics (e.g., token counts)")
+    reranking_score: Optional[float] = Field(None, description="Reranking score for relevance", ge=0.0, le=1.0)
+    content_id: Optional[str] = Field(None, description="ID of the source content")
+    content_origin: Optional[str] = Field(None, description="Origin URL or source of the content")
+    size: Optional[int] = Field(None, description="Size of the content in bytes", ge=0)
 
     @classmethod
     def from_document(cls, document) -> "VectorSearchResult":
@@ -153,23 +155,23 @@ class VectorSearchRequestSchema(BaseModel):
     class Meta(BaseModel):
         """Inline metadata schema for pagination."""
 
-        limit: Optional[int] = Field(20, description="Number of results per page", ge=1, le=100)
-        page: Optional[int] = Field(1, description="Page number", ge=1)
+        limit: int = Field(20, description="Number of results per page", ge=1, le=100)
+        page: int = Field(1, description="Page number", ge=1)
 
-    query: str = Field(..., description="The search query")
-    db_id: Optional[str] = Field(None, description="The content database id")
-    vector_db_ids: Optional[List[str]] = Field(None, description="List of vector database ids to search in")
-    search_type: Optional[str] = Field(None, description="The type of search to perform")
-    max_results: Optional[int] = Field(None, description="The maximum number of results to return")
-    filters: Optional[Dict[str, Any]] = Field(None, description="The filters to apply to the search")
+    query: str = Field(..., description="The search query text")
+    db_id: Optional[str] = Field(None, description="The content database ID to search in")
+    vector_db_ids: Optional[List[str]] = Field(None, description="List of vector database IDs to search in")
+    search_type: Optional[str] = Field(None, description="The type of search to perform (vector, keyword, hybrid)")
+    max_results: Optional[int] = Field(None, description="The maximum number of results to return", ge=1, le=1000)
+    filters: Optional[Dict[str, Any]] = Field(None, description="Filters to apply to the search results")
     meta: Optional[Meta] = Field(
         None, description="Pagination metadata. Limit and page number to return a subset of results."
     )
 
 
 class ConfigResponseSchema(BaseModel):
-    readers: Optional[Dict[str, ReaderSchema]] = None
-    readersForType: Optional[Dict[str, List[str]]] = None
-    chunkers: Optional[Dict[str, ChunkerSchema]] = None
-    filters: Optional[List[str]] = None
-    vector_dbs: Optional[List[VectorDbSchema]] = None
+    readers: Optional[Dict[str, ReaderSchema]] = Field(None, description="Available content readers")
+    readersForType: Optional[Dict[str, List[str]]] = Field(None, description="Mapping of content types to reader IDs")
+    chunkers: Optional[Dict[str, ChunkerSchema]] = Field(None, description="Available chunking strategies")
+    filters: Optional[List[str]] = Field(None, description="Available filter tags")
+    vector_dbs: Optional[List[VectorDbSchema]] = Field(None, description="Configured vector databases")

agno/os/routers/memory/schemas.py

@@ -1,24 +1,24 @@
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class DeleteMemoriesRequest(BaseModel):
-    memory_ids: List[str]
-    user_id: Optional[str] = None
+    memory_ids: List[str] = Field(..., description="List of memory IDs to delete", min_length=1)
+    user_id: Optional[str] = Field(None, description="User ID to filter memories for deletion")
 
 
 class UserMemorySchema(BaseModel):
-    memory_id: str
-    memory: str
-    topics: Optional[List[str]]
+    memory_id: str = Field(..., description="Unique identifier for the memory")
+    memory: str = Field(..., description="Memory content text", min_length=1)
+    topics: Optional[List[str]] = Field(None, description="Topics or tags associated with the memory")
 
-    agent_id: Optional[str]
-    team_id: Optional[str]
-    user_id: Optional[str]
+    agent_id: Optional[str] = Field(None, description="Agent ID associated with this memory")
+    team_id: Optional[str] = Field(None, description="Team ID associated with this memory")
+    user_id: Optional[str] = Field(None, description="User ID who owns this memory")
 
-    updated_at: Optional[datetime]
+    updated_at: Optional[datetime] = Field(None, description="Timestamp when memory was last updated")
 
     @classmethod
     def from_dict(cls, memory_dict: Dict[str, Any]) -> "UserMemorySchema":
@@ -36,17 +36,17 @@ class UserMemorySchema(BaseModel):
 class UserMemoryCreateSchema(BaseModel):
     """Define the payload expected for creating a new user memory"""
 
-    memory: str
-    user_id: Optional[str] = None
-    topics: Optional[List[str]] = None
+    memory: str = Field(..., description="Memory content text", min_length=1, max_length=5000)
+    user_id: Optional[str] = Field(None, description="User ID who owns this memory")
+    topics: Optional[List[str]] = Field(None, description="Topics or tags to categorize the memory")
 
 
 class UserStatsSchema(BaseModel):
     """Schema for user memory statistics"""
 
-    user_id: str
-    total_memories: int
-    last_memory_updated_at: Optional[datetime] = None
+    user_id: str = Field(..., description="User ID")
+    total_memories: int = Field(..., description="Total number of memories for this user", ge=0)
+    last_memory_updated_at: Optional[datetime] = Field(None, description="Timestamp of the most recent memory update")
 
     @classmethod
     def from_dict(cls, user_stats_dict: Dict[str, Any]) -> "UserStatsSchema":

agno/os/routers/metrics/schemas.py

@@ -1,27 +1,27 @@
 from datetime import datetime
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class DayAggregatedMetrics(BaseModel):
     """Aggregated metrics for a given day"""
 
-    id: str
+    id: str = Field(..., description="Unique identifier for the metrics record")
 
-    agent_runs_count: int
-    agent_sessions_count: int
-    team_runs_count: int
-    team_sessions_count: int
-    workflow_runs_count: int
-    workflow_sessions_count: int
-    users_count: int
-    token_metrics: Dict[str, Any]
-    model_metrics: List[Dict[str, Any]]
+    agent_runs_count: int = Field(..., description="Total number of agent runs", ge=0)
+    agent_sessions_count: int = Field(..., description="Total number of agent sessions", ge=0)
+    team_runs_count: int = Field(..., description="Total number of team runs", ge=0)
+    team_sessions_count: int = Field(..., description="Total number of team sessions", ge=0)
+    workflow_runs_count: int = Field(..., description="Total number of workflow runs", ge=0)
+    workflow_sessions_count: int = Field(..., description="Total number of workflow sessions", ge=0)
+    users_count: int = Field(..., description="Total number of unique users", ge=0)
+    token_metrics: Dict[str, Any] = Field(..., description="Token usage metrics (input, output, cached, etc.)")
+    model_metrics: List[Dict[str, Any]] = Field(..., description="Metrics grouped by model (model_id, provider, count)")
 
-    date: datetime
-    created_at: int
-    updated_at: int
+    date: datetime = Field(..., description="Date for which these metrics are aggregated")
+    created_at: int = Field(..., description="Unix timestamp when metrics were created", ge=0)
+    updated_at: int = Field(..., description="Unix timestamp when metrics were last updated", ge=0)
 
     @classmethod
     def from_dict(cls, metrics_dict: Dict[str, Any]) -> "DayAggregatedMetrics":
@@ -43,5 +43,5 @@ class DayAggregatedMetrics(BaseModel):
 
 
 class MetricsResponse(BaseModel):
-    metrics: List[DayAggregatedMetrics]
-    updated_at: Optional[datetime]
+    metrics: List[DayAggregatedMetrics] = Field(..., description="List of daily aggregated metrics")
+    updated_at: Optional[datetime] = Field(None, description="Timestamp of the most recent metrics update")