agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/os/routers/agents/schema.py

@@ -0,0 +1,261 @@
+from typing import Any, Dict, Optional
+from uuid import uuid4
+
+from pydantic import BaseModel
+
+from agno.agent import Agent
+from agno.models.message import Message
+from agno.os.schema import ModelResponse
+from agno.os.utils import (
+    format_tools,
+    get_agent_input_schema_dict,
+)
+from agno.run import RunContext
+from agno.run.agent import RunOutput
+from agno.session import AgentSession
+from agno.utils.agent import aexecute_instructions, aexecute_system_message
+
+
+class AgentResponse(BaseModel):
+    id: Optional[str] = None
+    name: Optional[str] = None
+    db_id: Optional[str] = None
+    model: Optional[ModelResponse] = None
+    tools: Optional[Dict[str, Any]] = None
+    sessions: Optional[Dict[str, Any]] = None
+    knowledge: Optional[Dict[str, Any]] = None
+    memory: Optional[Dict[str, Any]] = None
+    reasoning: Optional[Dict[str, Any]] = None
+    default_tools: Optional[Dict[str, Any]] = None
+    system_message: Optional[Dict[str, Any]] = None
+    extra_messages: Optional[Dict[str, Any]] = None
+    response_settings: Optional[Dict[str, Any]] = None
+    introduction: Optional[str] = None
+    streaming: Optional[Dict[str, Any]] = None
+    metadata: Optional[Dict[str, Any]] = None
+    input_schema: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    async def from_agent(cls, agent: Agent) -> "AgentResponse":
+        def filter_meaningful_config(d: Dict[str, Any], defaults: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+            """Filter out fields that match their default values, keeping only meaningful user configurations"""
+            filtered = {}
+            for key, value in d.items():
+                if value is None:
+                    continue
+                # Skip if value matches the default exactly
+                if key in defaults and value == defaults[key]:
+                    continue
+                # Keep non-default values
+                filtered[key] = value
+            return filtered if filtered else None
+
+        # Define default values for filtering
+        agent_defaults = {
+            # Sessions defaults
+            "add_history_to_context": False,
+            "num_history_runs": 3,
+            "enable_session_summaries": False,
+            "search_session_history": False,
+            "cache_session": False,
+            # Knowledge defaults
+            "add_references": False,
+            "references_format": "json",
+            "enable_agentic_knowledge_filters": False,
+            # Memory defaults
+            "enable_agentic_memory": False,
+            "enable_user_memories": False,
+            # Reasoning defaults
+            "reasoning": False,
+            "reasoning_min_steps": 1,
+            "reasoning_max_steps": 10,
+            # Default tools defaults
+            "read_chat_history": False,
+            "search_knowledge": True,
+            "update_knowledge": False,
+            "read_tool_call_history": False,
+            # System message defaults
+            "system_message_role": "system",
+            "build_context": True,
+            "markdown": False,
+            "add_name_to_context": False,
+            "add_datetime_to_context": False,
+            "add_location_to_context": False,
+            "resolve_in_context": True,
+            # Extra messages defaults
+            "user_message_role": "user",
+            "build_user_context": True,
+            # Response settings defaults
+            "retries": 0,
+            "delay_between_retries": 1,
+            "exponential_backoff": False,
+            "parse_response": True,
+            "use_json_mode": False,
+            # Streaming defaults
+            "stream_events": False,
+            "stream_intermediate_steps": False,
+        }
+
+        session_id = str(uuid4())
+        run_id = str(uuid4())
+        agent_tools = await agent.aget_tools(
+            session=AgentSession(session_id=session_id, session_data={}),
+            run_response=RunOutput(run_id=run_id, session_id=session_id),
+            run_context=RunContext(run_id=run_id, session_id=session_id, user_id=agent.user_id),
+            check_mcp_tools=False,
+        )
+        formatted_tools = format_tools(agent_tools) if agent_tools else None
+
+        additional_input = agent.additional_input
+        if additional_input and isinstance(additional_input[0], Message):
+            additional_input = [message.to_dict() for message in additional_input]  # type: ignore
+
+        # Build model only if it has at least one non-null field
+        model_name = agent.model.name if (agent.model and agent.model.name) else None
+        model_provider = agent.model.provider if (agent.model and agent.model.provider) else None
+        model_id = agent.model.id if (agent.model and agent.model.id) else None
+        _agent_model_data: Dict[str, Any] = {}
+        if model_name is not None:
+            _agent_model_data["name"] = model_name
+        if model_id is not None:
+            _agent_model_data["model"] = model_id
+        if model_provider is not None:
+            _agent_model_data["provider"] = model_provider
+
+        session_table = agent.db.session_table_name if agent.db else None
+        knowledge_table = agent.db.knowledge_table_name if agent.db and agent.knowledge else None
+
+        tools_info = {
+            "tools": formatted_tools,
+            "tool_call_limit": agent.tool_call_limit,
+            "tool_choice": agent.tool_choice,
+        }
+
+        sessions_info = {
+            "session_table": session_table,
+            "add_history_to_context": agent.add_history_to_context,
+            "enable_session_summaries": agent.enable_session_summaries,
+            "num_history_runs": agent.num_history_runs,
+            "search_session_history": agent.search_session_history,
+            "num_history_sessions": agent.num_history_sessions,
+            "cache_session": agent.cache_session,
+        }
+
+        knowledge_info = {
+            "knowledge_table": knowledge_table,
+            "enable_agentic_knowledge_filters": agent.enable_agentic_knowledge_filters,
+            "knowledge_filters": agent.knowledge_filters,
+            "references_format": agent.references_format,
+        }
+
+        memory_info: Optional[Dict[str, Any]] = None
+        if agent.memory_manager is not None:
+            memory_info = {
+                "enable_agentic_memory": agent.enable_agentic_memory,
+                "enable_user_memories": agent.enable_user_memories,
+                "metadata": agent.metadata,
+                "memory_table": agent.db.memory_table_name if agent.db and agent.enable_user_memories else None,
+            }
+
+            if agent.memory_manager.model is not None:
+                memory_info["model"] = ModelResponse(
+                    name=agent.memory_manager.model.name,
+                    model=agent.memory_manager.model.id,
+                    provider=agent.memory_manager.model.provider,
+                ).model_dump()
+
+        reasoning_info: Dict[str, Any] = {
+            "reasoning": agent.reasoning,
+            "reasoning_agent_id": agent.reasoning_agent.id if agent.reasoning_agent else None,
+            "reasoning_min_steps": agent.reasoning_min_steps,
+            "reasoning_max_steps": agent.reasoning_max_steps,
+        }
+
+        if agent.reasoning_model:
+            reasoning_info["reasoning_model"] = ModelResponse(
+                name=agent.reasoning_model.name,
+                model=agent.reasoning_model.id,
+                provider=agent.reasoning_model.provider,
+            ).model_dump()
+
+        default_tools_info = {
+            "read_chat_history": agent.read_chat_history,
+            "search_knowledge": agent.search_knowledge,
+            "update_knowledge": agent.update_knowledge,
+            "read_tool_call_history": agent.read_tool_call_history,
+        }
+
+        instructions = agent.instructions if agent.instructions else None
+        if instructions and callable(instructions):
+            instructions = await aexecute_instructions(instructions=instructions, agent=agent)
+
+        system_message = agent.system_message if agent.system_message else None
+        if system_message and callable(system_message):
+            system_message = await aexecute_system_message(system_message=system_message, agent=agent)
+
+        system_message_info = {
+            "system_message": str(system_message) if system_message else None,
+            "system_message_role": agent.system_message_role,
+            "build_context": agent.build_context,
+            "description": agent.description,
+            "instructions": instructions,
+            "expected_output": agent.expected_output,
+            "additional_context": agent.additional_context,
+            "markdown": agent.markdown,
+            "add_name_to_context": agent.add_name_to_context,
+            "add_datetime_to_context": agent.add_datetime_to_context,
+            "add_location_to_context": agent.add_location_to_context,
+            "timezone_identifier": agent.timezone_identifier,
+            "resolve_in_context": agent.resolve_in_context,
+        }
+
+        extra_messages_info = {
+            "additional_input": additional_input,  # type: ignore
+            "user_message_role": agent.user_message_role,
+            "build_user_context": agent.build_user_context,
+        }
+
+        response_settings_info: Dict[str, Any] = {
+            "retries": agent.retries,
+            "delay_between_retries": agent.delay_between_retries,
+            "exponential_backoff": agent.exponential_backoff,
+            "output_schema_name": agent.output_schema.__name__ if agent.output_schema else None,
+            "parser_model_prompt": agent.parser_model_prompt,
+            "parse_response": agent.parse_response,
+            "structured_outputs": agent.structured_outputs,
+            "use_json_mode": agent.use_json_mode,
+            "save_response_to_file": agent.save_response_to_file,
+        }
+
+        if agent.parser_model:
+            response_settings_info["parser_model"] = ModelResponse(
+                name=agent.parser_model.name,
+                model=agent.parser_model.id,
+                provider=agent.parser_model.provider,
+            ).model_dump()
+
+        streaming_info = {
+            "stream": agent.stream,
+            "stream_events": agent.stream_events,
+            "stream_intermediate_steps": agent.stream_intermediate_steps,
+        }
+
+        return AgentResponse(
+            id=agent.id,
+            name=agent.name,
+            db_id=agent.db.id if agent.db else None,
+            model=ModelResponse(**_agent_model_data) if _agent_model_data else None,
+            tools=filter_meaningful_config(tools_info, {}),
+            sessions=filter_meaningful_config(sessions_info, agent_defaults),
+            knowledge=filter_meaningful_config(knowledge_info, agent_defaults),
+            memory=filter_meaningful_config(memory_info, agent_defaults) if memory_info else None,
+            reasoning=filter_meaningful_config(reasoning_info, agent_defaults),
+            default_tools=filter_meaningful_config(default_tools_info, agent_defaults),
+            system_message=filter_meaningful_config(system_message_info, agent_defaults),
+            extra_messages=filter_meaningful_config(extra_messages_info, agent_defaults),
+            response_settings=filter_meaningful_config(response_settings_info, agent_defaults),
+            streaming=filter_meaningful_config(streaming_info, agent_defaults),
+            introduction=agent.introduction,
+            metadata=agent.metadata,
+            input_schema=get_agent_input_schema_dict(agent),
+        )

agno/os/routers/evals/evals.py

@@ -1,11 +1,11 @@
 import logging
 from copy import deepcopy
-from typing import List, Optional
+from typing import List, Optional, Union, cast
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 
 from agno.agent.agent import Agent
-from agno.db.base import BaseDb
+from agno.db.base import AsyncBaseDb, BaseDb
 from agno.db.schemas.evals import EvalFilterType, EvalType
 from agno.models.utils import get_model
 from agno.os.auth import get_authentication_dependency
@@ -15,7 +15,12 @@ from agno.os.routers.evals.schemas import (
     EvalSchema,
     UpdateEvalRunRequest,
 )
-from agno.os.routers.evals.utils import run_accuracy_eval, run_performance_eval, run_reliability_eval
+from agno.os.routers.evals.utils import (
+    run_accuracy_eval,
+    run_agent_as_judge_eval,
+    run_performance_eval,
+    run_reliability_eval,
+)
 from agno.os.schema import (
     BadRequestResponse,
     InternalServerErrorResponse,
@@ -34,7 +39,7 @@ logger = logging.getLogger(__name__)
 
 
 def get_eval_router(
-    dbs: dict[str, BaseDb],
+    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]],
     agents: Optional[List[Agent]] = None,
     teams: Optional[List[Team]] = None,
     settings: AgnoAPISettings = AgnoAPISettings(),
@@ -55,7 +60,10 @@ def get_eval_router(
 
 
 def attach_routes(
-    router: APIRouter, dbs: dict[str, BaseDb], agents: Optional[List[Agent]] = None, teams: Optional[List[Team]] = None
+    router: APIRouter,
+    dbs: dict[str, list[Union[BaseDb, AsyncBaseDb]]],
+    agents: Optional[List[Agent]] = None,
+    teams: Optional[List[Team]] = None,
 ) -> APIRouter:
     @router.get(
         "/eval-runs",
@@ -112,21 +120,48 @@ def attach_routes(
         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"),
+        table: Optional[str] = Query(default=None, description="The database table to use"),
     ) -> PaginatedResponse[EvalSchema]:
-        db = get_db(dbs, db_id)
-        eval_runs, total_count = db.get_eval_runs(
-            limit=limit,
-            page=page,
-            sort_by=sort_by,
-            sort_order=sort_order,
-            agent_id=agent_id,
-            team_id=team_id,
-            workflow_id=workflow_id,
-            model_id=model_id,
-            eval_type=eval_types,
-            filter_type=filter_type,
-            deserialize=False,
-        )
+        db = await get_db(dbs, db_id, table)
+
+        # TODO: Delete me:
+        # Filtering out agent-as-judge by default for now,
+        # as they are not supported yet in the AgentOS UI.
+        eval_types = eval_types or [
+            EvalType.ACCURACY,
+            EvalType.PERFORMANCE,
+            EvalType.RELIABILITY,
+        ]
+
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            eval_runs, total_count = await db.get_eval_runs(
+                limit=limit,
+                page=page,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                agent_id=agent_id,
+                team_id=team_id,
+                workflow_id=workflow_id,
+                model_id=model_id,
+                eval_type=eval_types,
+                filter_type=filter_type,
+                deserialize=False,
+            )
+        else:
+            eval_runs, total_count = db.get_eval_runs(  # type: ignore
+                limit=limit,
+                page=page,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                agent_id=agent_id,
+                team_id=team_id,
+                workflow_id=workflow_id,
+                model_id=model_id,
+                eval_type=eval_types,
+                filter_type=filter_type,
+                deserialize=False,
+            )
 
         return PaginatedResponse(
             data=[EvalSchema.from_dict(eval_run) for eval_run in eval_runs],  # type: ignore
@@ -178,9 +213,14 @@ def attach_routes(
     async def get_eval_run(
         eval_run_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+        table: Optional[str] = Query(default=None, description="Table to query eval run from"),
     ) -> EvalSchema:
-        db = get_db(dbs, db_id)
-        eval_run = db.get_eval_run(eval_run_id=eval_run_id, deserialize=False)
+        db = await get_db(dbs, db_id, table)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            eval_run = await db.get_eval_run(eval_run_id=eval_run_id, deserialize=False)
+        else:
+            eval_run = db.get_eval_run(eval_run_id=eval_run_id, deserialize=False)
         if not eval_run:
             raise HTTPException(status_code=404, detail=f"Eval run with id '{eval_run_id}' not found")
 
@@ -200,10 +240,15 @@ def attach_routes(
     async def delete_eval_runs(
         request: DeleteEvalRunsRequest,
         db_id: Optional[str] = Query(default=None, description="Database ID to use for deletion"),
+        table: Optional[str] = Query(default=None, description="Table to use for deletion"),
     ) -> None:
         try:
-            db = get_db(dbs, db_id)
-            db.delete_eval_runs(eval_run_ids=request.eval_run_ids)
+            db = await get_db(dbs, db_id, table)
+            if isinstance(db, AsyncBaseDb):
+                db = cast(AsyncBaseDb, db)
+                await db.delete_eval_runs(eval_run_ids=request.eval_run_ids)
+            else:
+                db.delete_eval_runs(eval_run_ids=request.eval_run_ids)
         except Exception as e:
             raise HTTPException(status_code=500, detail=f"Failed to delete eval runs: {e}")
 
@@ -249,10 +294,15 @@ def attach_routes(
         eval_run_id: str,
         request: UpdateEvalRunRequest,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
+        table: Optional[str] = Query(default=None, description="Table to use for rename operation"),
     ) -> EvalSchema:
         try:
-            db = get_db(dbs, db_id)
-            eval_run = db.rename_eval_run(eval_run_id=eval_run_id, name=request.name, deserialize=False)
+            db = await get_db(dbs, db_id, table)
+            if isinstance(db, AsyncBaseDb):
+                db = cast(AsyncBaseDb, db)
+                eval_run = await db.rename_eval_run(eval_run_id=eval_run_id, name=request.name, deserialize=False)
+            else:
+                eval_run = db.rename_eval_run(eval_run_id=eval_run_id, name=request.name, deserialize=False)
         except Exception as e:
             raise HTTPException(status_code=500, detail=f"Failed to rename eval run: {e}")
 
@@ -268,7 +318,7 @@ def attach_routes(
         operation_id="run_eval",
         summary="Execute Evaluation",
         description=(
-            "Run evaluation tests on agents or teams. Supports accuracy, performance, and reliability evaluations. "
+            "Run evaluation tests on agents or teams. Supports accuracy, agent-as-judge, performance, and reliability evaluations. "
             "Requires either agent_id or team_id, but not both."
         ),
         responses={
@@ -304,8 +354,9 @@ def attach_routes(
     async def run_eval(
         eval_run_input: EvalRunInput,
         db_id: Optional[str] = Query(default=None, description="Database ID to use for evaluation"),
+        table: Optional[str] = Query(default=None, description="Table to use for evaluation"),
     ) -> Optional[EvalSchema]:
-        db = get_db(dbs, db_id)
+        db = await get_db(dbs, db_id, table)
 
         if eval_run_input.agent_id and eval_run_input.team_id:
             raise HTTPException(status_code=400, detail="Only one of agent_id or team_id must be provided")
@@ -324,10 +375,10 @@ def attach_routes(
             ):
                 default_model = deepcopy(agent.model)
                 if eval_run_input.model_id != agent.model.id or eval_run_input.model_provider != agent.model.provider:
-                    model = get_model(
-                        model_id=eval_run_input.model_id.lower(),
-                        model_provider=eval_run_input.model_provider.lower(),
-                    )
+                    model_provider = eval_run_input.model_provider.lower()
+                    model_id = eval_run_input.model_id.lower()
+                    model_string = f"{model_provider}:{model_id}"
+                    model = get_model(model_string)
                     agent.model = model
 
             team = None
@@ -337,6 +388,7 @@ def attach_routes(
             if not team:
                 raise HTTPException(status_code=404, detail=f"Team with id '{eval_run_input.team_id}' not found")
 
+            # If model_id/model_provider specified, override team's model temporarily
             default_model = None
             if (
                 hasattr(team, "model")
@@ -344,13 +396,13 @@ def attach_routes(
                 and eval_run_input.model_id is not None
                 and eval_run_input.model_provider is not None
             ):
-                default_model = deepcopy(team.model)
+                default_model = deepcopy(team.model)  # Save original
                 if eval_run_input.model_id != team.model.id or eval_run_input.model_provider != team.model.provider:
-                    model = get_model(
-                        model_id=eval_run_input.model_id.lower(),
-                        model_provider=eval_run_input.model_provider.lower(),
-                    )
-                    team.model = model
+                    model_provider = eval_run_input.model_provider.lower()
+                    model_id = eval_run_input.model_id.lower()
+                    model_string = f"{model_provider}:{model_id}"
+                    model = get_model(model_string)
+                    team.model = model  # Override temporarily
 
             agent = None
 
@@ -363,6 +415,11 @@ def attach_routes(
                 eval_run_input=eval_run_input, db=db, agent=agent, team=team, default_model=default_model
             )
 
+        elif eval_run_input.eval_type == EvalType.AGENT_AS_JUDGE:
+            return await run_agent_as_judge_eval(
+                eval_run_input=eval_run_input, db=db, agent=agent, team=team, default_model=default_model
+            )
+
         elif eval_run_input.eval_type == EvalType.PERFORMANCE:
             return await run_performance_eval(
                 eval_run_input=eval_run_input, db=db, agent=agent, team=team, default_model=default_model
@@ -379,8 +436,8 @@ def attach_routes(
 def parse_eval_types_filter(
     eval_types: Optional[str] = Query(
         default=None,
-        description="Comma-separated eval types (accuracy,performance,reliability)",
-        examples=["accuracy,performance"],
+        description="Comma-separated eval types (accuracy,agent_as_judge,performance,reliability)",
+        examples=["accuracy,agent_as_judge,performance,reliability"],
     ),
 ) -> Optional[List[EvalType]]:
     """Parse comma-separated eval types into EvalType enums for filtering evaluation runs."""

agno/os/routers/evals/schemas.py

@@ -1,54 +1,64 @@
 from dataclasses import asdict
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Literal, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from agno.db.schemas.evals import EvalType
-from agno.eval import AccuracyResult, PerformanceResult, ReliabilityResult
+from agno.eval import AccuracyResult, AgentAsJudgeResult, PerformanceResult, ReliabilityResult
 from agno.eval.accuracy import AccuracyEval
+from agno.eval.agent_as_judge import AgentAsJudgeEval
 from agno.eval.performance import PerformanceEval
 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")
+
+    # AgentAsJudge eval specific fields
+    criteria: Optional[str] = Field(None, description="Evaluation criteria for agent-as-judge evaluation")
+    scoring_strategy: Optional[Literal["numeric", "binary"]] = Field(
+        "binary", description="Scoring strategy: 'numeric' (1-10 with threshold) or 'binary' (PASS/FAIL)"
+    )
+    threshold: Optional[int] = Field(
+        7, description="Score threshold for pass/fail (1-10), only used with numeric scoring", ge=1, le=10
+    )
 
     # 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":
@@ -89,6 +99,28 @@ class EvalSchema(BaseModel):
             eval_data=asdict(result),
         )
 
+    @classmethod
+    def from_agent_as_judge_eval(
+        cls,
+        agent_as_judge_eval: AgentAsJudgeEval,
+        result: AgentAsJudgeResult,
+        model_id: Optional[str] = None,
+        model_provider: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        team_id: Optional[str] = None,
+    ) -> "EvalSchema":
+        return cls(
+            id=result.run_id,
+            name=agent_as_judge_eval.name,
+            agent_id=agent_id,
+            team_id=team_id,
+            workflow_id=None,
+            model_id=model_id,
+            model_provider=model_provider,
+            eval_type=EvalType.AGENT_AS_JUDGE,
+            eval_data=asdict(result),
+        )
+
     @classmethod
     def from_performance_eval(
         cls,
@@ -135,8 +167,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)