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

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")