agno 2.2.10__py3-none-any.whl → 2.2.12__py3-none-any.whl

agno/knowledge/utils.py

@@ -129,12 +129,32 @@ def get_chunker_info(chunker_key: str) -> Dict:
             class_name = chunker_class.__name__
             docstring = chunker_class.__doc__ or f"{class_name} chunking strategy"
 
+            # Check class __init__ signature for chunk_size and overlap parameters
+            metadata = {}
+            import inspect
+
+            try:
+                sig = inspect.signature(chunker_class.__init__)
+                param_names = set(sig.parameters.keys())
+
+                # If class has chunk_size or max_chunk_size parameter, set default chunk_size
+                if "chunk_size" in param_names or "max_chunk_size" in param_names:
+                    metadata["chunk_size"] = 5000
+
+                # If class has overlap parameter, set default overlap
+                if "overlap" in param_names:
+                    metadata["chunk_overlap"] = 0
+            except Exception:
+                # If we can't inspect, skip metadata
+                pass
+
             return {
                 "key": chunker_key,
                 "class_name": class_name,
                 "name": chunker_key,
                 "description": docstring.strip(),
                 "strategy_type": strategy_type.value,
+                "metadata": metadata,
             }
         except ValueError:
             raise ValueError(f"Unknown chunker key: {chunker_key}")

agno/models/anthropic/claude.py

@@ -45,6 +45,8 @@ except ImportError as e:
 # Import Beta types
 try:
     from anthropic.types.beta import BetaRawContentBlockDeltaEvent, BetaTextDelta
+    from anthropic.types.beta.beta_message import BetaMessage
+    from anthropic.types.beta.beta_usage import BetaUsage
 except ImportError as e:
     raise ImportError(
         "`anthropic` not installed or missing beta components. Please install with `pip install anthropic`"
@@ -84,13 +86,14 @@ class Claude(Model):
     cache_system_prompt: Optional[bool] = False
     extended_cache_time: Optional[bool] = False
     request_params: Optional[Dict[str, Any]] = None
-    mcp_servers: Optional[List[MCPServerConfiguration]] = None
 
-    # Skills configuration
+    # Anthropic beta and experimental features
+    betas: Optional[List[str]] = None  # Enables specific experimental or newly released features.
+    context_management: Optional[Dict[str, Any]] = None
+    mcp_servers: Optional[List[MCPServerConfiguration]] = None
     skills: Optional[List[Dict[str, str]]] = (
         None  # e.g., [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
     )
-    betas: Optional[List[str]] = None  # Enables specific experimental or newly released features.
 
     # Client parameters
     api_key: Optional[str] = None
@@ -129,6 +132,15 @@ class Claude(Model):
             client_params["default_headers"] = self.default_headers
         return client_params
 
+    def _has_beta_features(self) -> bool:
+        """Check if the model has any Anthropic beta features enabled."""
+        return (
+            self.mcp_servers is not None
+            or self.context_management is not None
+            or self.skills is not None
+            or self.betas is not None
+        )
+
     def get_client(self) -> AnthropicClient:
         """
         Returns an instance of the Anthropic client.
@@ -208,6 +220,10 @@ class Claude(Model):
             _request_params["top_p"] = self.top_p
         if self.top_k:
             _request_params["top_k"] = self.top_k
+        if self.betas:
+            _request_params["betas"] = self.betas
+        if self.context_management:
+            _request_params["context_management"] = self.context_management
         if self.mcp_servers:
             _request_params["mcp_servers"] = [
                 {k: v for k, v in asdict(server).items() if v is not None} for server in self.mcp_servers
@@ -279,7 +295,7 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None or self.skills is not None:
+            if self._has_beta_features():
                 assistant_message.metrics.start_timer()
                 provider_response = self.get_client().beta.messages.create(
                     model=self.id,
@@ -346,7 +362,8 @@ class Claude(Model):
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
-            if self.mcp_servers is not None or self.skills is not None:
+            # Beta features
+            if self._has_beta_features():
                 assistant_message.metrics.start_timer()
                 with self.get_client().beta.messages.stream(
                     model=self.id,
@@ -401,7 +418,8 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None or self.skills is not None:
+            # Beta features
+            if self._has_beta_features():
                 assistant_message.metrics.start_timer()
                 provider_response = await self.get_async_client().beta.messages.create(
                     model=self.id,
@@ -465,7 +483,7 @@ class Claude(Model):
             chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message, tools)
 
-            if self.mcp_servers is not None or self.skills is not None:
+            if self._has_beta_features():
                 assistant_message.metrics.start_timer()
                 async with self.get_async_client().beta.messages.stream(
                     model=self.id,
@@ -507,7 +525,7 @@ class Claude(Model):
             return tool_call_prompt
         return None
 
-    def _parse_provider_response(self, response: AnthropicMessage, **kwargs) -> ModelResponse:
+    def _parse_provider_response(self, response: Union[AnthropicMessage, BetaMessage], **kwargs) -> ModelResponse:
         """
         Parse the Claude response into a ModelResponse.
 
@@ -582,6 +600,14 @@ class Claude(Model):
         if response.usage is not None:
             model_response.response_usage = self._get_metrics(response.usage)
 
+        # Capture context management information if present
+        if self.context_management is not None and hasattr(response, "context_management"):
+            if response.context_management is not None:  # type: ignore
+                model_response.provider_data = model_response.provider_data or {}
+                if hasattr(response.context_management, "model_dump"):
+                    model_response.provider_data["context_management"] = response.context_management.model_dump()  # type: ignore
+                else:
+                    model_response.provider_data["context_management"] = response.context_management  # type: ignore
         # Extract file IDs if skills are enabled
         if self.skills and response.content:
             file_ids: List[str] = []
@@ -676,6 +702,16 @@ class Claude(Model):
                             DocumentCitation(document_title=citation.document_title, cited_text=citation.cited_text)
                         )
 
+            # Capture context management information if present
+            if self.context_management is not None and hasattr(response.message, "context_management"):  # type: ignore
+                context_mgmt = response.message.context_management  # type: ignore
+                if context_mgmt is not None:
+                    model_response.provider_data = model_response.provider_data or {}
+                    if hasattr(context_mgmt, "model_dump"):
+                        model_response.provider_data["context_management"] = context_mgmt.model_dump()
+                    else:
+                        model_response.provider_data["context_management"] = context_mgmt
+
         if hasattr(response, "message") and hasattr(response.message, "usage") and response.message.usage is not None:  # type: ignore
             model_response.response_usage = self._get_metrics(response.message.usage)  # type: ignore
 
@@ -692,7 +728,7 @@ class Claude(Model):
 
         return model_response
 
-    def _get_metrics(self, response_usage: Union[Usage, MessageDeltaUsage]) -> Metrics:
+    def _get_metrics(self, response_usage: Union[Usage, MessageDeltaUsage, BetaUsage]) -> Metrics:
         """
         Parse the given Anthropic-specific usage into an Agno Metrics object.
 

agno/models/base.py

@@ -692,6 +692,8 @@ class Model(ABC):
             if model_response.extra is None:
                 model_response.extra = {}
             model_response.extra.update(provider_response.extra)
+        if provider_response.provider_data is not None:
+            model_response.provider_data = provider_response.provider_data
 
     async def _aprocess_model_response(
         self,
@@ -745,6 +747,8 @@ class Model(ABC):
             if model_response.extra is None:
                 model_response.extra = {}
             model_response.extra.update(provider_response.extra)
+        if provider_response.provider_data is not None:
+            model_response.provider_data = provider_response.provider_data
 
     def _populate_assistant_message(
         self,

agno/os/app.py

@@ -232,6 +232,12 @@ class AgentOS:
         self._initialize_workflows()
         self._auto_discover_databases()
         self._auto_discover_knowledge_instances()
+
+        if self.enable_mcp_server:
+            from agno.os.mcp import get_mcp_server
+
+            self._mcp_app = get_mcp_server(self)
+
         self._reprovision_routers(app=app)
 
     def _reprovision_routers(self, app: FastAPI) -> None:
@@ -248,7 +254,9 @@ class AgentOS:
         app.router.routes = [
             route
             for route in app.router.routes
-            if hasattr(route, "path") and route.path in ["/docs", "/redoc", "/openapi.json", "/docs/oauth2-redirect"]  # type: ignore
+            if hasattr(route, "path")
+            and route.path in ["/docs", "/redoc", "/openapi.json", "/docs/oauth2-redirect"]
+            or route.path.startswith("/mcp")  # type: ignore
         ]
 
         # Add the built-in routes
@@ -258,13 +266,17 @@ class AgentOS:
         for router in updated_routers:
             self._add_router(app, router)
 
+        # Mount MCP if needed
+        if self.enable_mcp_server and self._mcp_app:
+            app.mount("/", self._mcp_app)
+
     def _add_built_in_routes(self, app: FastAPI) -> None:
         """Add all AgentOSbuilt-in routes to the given app."""
         # Add the home router if MCP server is not enabled
         if not self.enable_mcp_server:
             self._add_router(app, get_home_router(self))
 
-        self._add_router(app, get_health_router())
+        self._add_router(app, get_health_router(health_endpoint="/health"))
         self._add_router(app, get_base_router(self, settings=self.settings))
         self._add_router(app, get_websocket_router(self, settings=self.settings))
 
@@ -381,20 +393,24 @@ class AgentOS:
             # Collect all lifespans that need to be combined
             lifespans = []
 
+            # The user provided lifespan
+            if self.lifespan:
+                # Wrap the user lifespan with agent_os parameter
+                wrapped_lifespan = self._add_agent_os_to_lifespan_function(self.lifespan)
+                lifespans.append(wrapped_lifespan)
+
+            # The provided app's existing lifespan
             if fastapi_app.router.lifespan_context:
                 lifespans.append(fastapi_app.router.lifespan_context)
 
+            # The MCP tools lifespan
             if self.mcp_tools:
                 lifespans.append(partial(mcp_lifespan, mcp_tools=self.mcp_tools))
 
+            # The /mcp server lifespan
             if self.enable_mcp_server and self._mcp_app:
                 lifespans.append(self._mcp_app.lifespan)
 
-            if self.lifespan:
-                # Wrap the user lifespan with agent_os parameter
-                wrapped_lifespan = self._add_agent_os_to_lifespan_function(self.lifespan)
-                lifespans.append(wrapped_lifespan)
-
             # Combine lifespans and set them in the app
             if lifespans:
                 fastapi_app.router.lifespan_context = _combine_app_lifespans(lifespans)

agno/os/interfaces/slack/router.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Union
 
 from fastapi import APIRouter, BackgroundTasks, HTTPException, Request
 from pydantic import BaseModel, Field
@@ -24,7 +24,11 @@ class SlackChallengeResponse(BaseModel):
 
 
 def attach_routes(
-    router: APIRouter, agent: Optional[Agent] = None, team: Optional[Team] = None, workflow: Optional[Workflow] = None
+    router: APIRouter,
+    agent: Optional[Agent] = None,
+    team: Optional[Team] = None,
+    workflow: Optional[Workflow] = None,
+    reply_to_mentions_only: bool = True,
 ) -> APIRouter:
     # Determine entity type for documentation
     entity_type = "agent" if agent else "team" if team else "workflow" if workflow else "unknown"
@@ -34,7 +38,7 @@ def attach_routes(
         operation_id=f"slack_events_{entity_type}",
         name="slack_events",
         description="Process incoming Slack events",
-        response_model=SlackEventResponse,
+        response_model=Union[SlackChallengeResponse, SlackEventResponse],
         response_model_exclude_none=True,
         responses={
             200: {"description": "Event processed successfully"},
@@ -71,36 +75,52 @@ def attach_routes(
         return SlackEventResponse(status="ok")
 
     async def _process_slack_event(event: dict):
-        if event.get("type") == "message":
-            user = None
-            message_text = event.get("text", "")
-            channel_id = event.get("channel", "")
-            user = event.get("user")
-            if event.get("thread_ts"):
-                ts = event.get("thread_ts", "")
-            else:
-                ts = event.get("ts", "")
-
-            # Use the timestamp as the session id, so that each thread is a separate session
-            session_id = ts
-
-            if agent:
-                response = await agent.arun(message_text, user_id=user if user else None, session_id=session_id)
-            elif team:
-                response = await team.arun(message_text, user_id=user if user else None, session_id=session_id)  # type: ignore
-            elif workflow:
-                response = await workflow.arun(message_text, user_id=user if user else None, session_id=session_id)  # type: ignore
-
-            if response:
-                if hasattr(response, "reasoning_content") and response.reasoning_content:
-                    _send_slack_message(
-                        channel=channel_id,
-                        message=f"Reasoning: \n{response.reasoning_content}",
-                        thread_ts=ts,
-                        italics=True,
-                    )
-
-                _send_slack_message(channel=channel_id, message=response.content or "", thread_ts=ts)
+        event_type = event.get("type")
+
+        # Only handle app_mention and message events
+        if event_type not in ("app_mention", "message"):
+            return
+
+        channel_type = event.get("channel_type", "")
+
+        # Handle duplicate replies
+        if not reply_to_mentions_only and event_type == "app_mention":
+            return
+
+        # If reply_to_mentions_only is True, ignore every message that is not a DM
+        if reply_to_mentions_only and event_type == "message" and channel_type != "im":
+            return
+
+        # Extract event data
+        user = None
+        message_text = event.get("text", "")
+        channel_id = event.get("channel", "")
+        user = event.get("user")
+        if event.get("thread_ts"):
+            ts = event.get("thread_ts", "")
+        else:
+            ts = event.get("ts", "")
+
+        # Use the timestamp as the session id, so that each thread is a separate session
+        session_id = ts
+
+        if agent:
+            response = await agent.arun(message_text, user_id=user, session_id=session_id)
+        elif team:
+            response = await team.arun(message_text, user_id=user, session_id=session_id)  # type: ignore
+        elif workflow:
+            response = await workflow.arun(message_text, user_id=user, session_id=session_id)  # type: ignore
+
+        if response:
+            if hasattr(response, "reasoning_content") and response.reasoning_content:
+                _send_slack_message(
+                    channel=channel_id,
+                    message=f"Reasoning: \n{response.reasoning_content}",
+                    thread_ts=ts,
+                    italics=True,
+                )
+
+            _send_slack_message(channel=channel_id, message=response.content or "", thread_ts=ts)
 
     def _send_slack_message(channel: str, thread_ts: str, message: str, italics: bool = False):
         if len(message) <= 40000:

agno/os/interfaces/slack/slack.py

@@ -21,12 +21,14 @@ class Slack(BaseInterface):
         workflow: Optional[Workflow] = None,
         prefix: str = "/slack",
         tags: Optional[List[str]] = None,
+        reply_to_mentions_only: bool = True,
     ):
         self.agent = agent
         self.team = team
         self.workflow = workflow
         self.prefix = prefix
         self.tags = tags or ["Slack"]
+        self.reply_to_mentions_only = reply_to_mentions_only
 
         if not (self.agent or self.team or self.workflow):
             raise ValueError("Slack requires an agent, team or workflow")
@@ -34,6 +36,12 @@ class Slack(BaseInterface):
     def get_router(self) -> APIRouter:
         self.router = APIRouter(prefix=self.prefix, tags=self.tags)  # type: ignore
 
-        self.router = attach_routes(router=self.router, agent=self.agent, team=self.team, workflow=self.workflow)
+        self.router = attach_routes(
+            router=self.router,
+            agent=self.agent,
+            team=self.team,
+            workflow=self.workflow,
+            reply_to_mentions_only=self.reply_to_mentions_only,
+        )
 
         return self.router

agno/os/router.py

@@ -106,10 +106,34 @@ async def _get_request_kwargs(request: Request, endpoint_func: Callable) -> Dict
         try:
             if isinstance(knowledge_filters, str):
                 knowledge_filters_dict = json.loads(knowledge_filters)  # type: ignore
-                kwargs["knowledge_filters"] = knowledge_filters_dict
+
+                # Try to deserialize FilterExpr objects
+                from agno.filters import from_dict
+
+                # Check if it's a single FilterExpr dict or a list of FilterExpr dicts
+                if isinstance(knowledge_filters_dict, dict) and "op" in knowledge_filters_dict:
+                    # Single FilterExpr - convert to list format
+                    kwargs["knowledge_filters"] = [from_dict(knowledge_filters_dict)]
+                elif isinstance(knowledge_filters_dict, list):
+                    # List of FilterExprs or mixed content
+                    deserialized = []
+                    for item in knowledge_filters_dict:
+                        if isinstance(item, dict) and "op" in item:
+                            deserialized.append(from_dict(item))
+                        else:
+                            # Keep non-FilterExpr items as-is
+                            deserialized.append(item)
+                    kwargs["knowledge_filters"] = deserialized
+                else:
+                    # Regular dict filter
+                    kwargs["knowledge_filters"] = knowledge_filters_dict
         except json.JSONDecodeError:
             kwargs.pop("knowledge_filters")
             log_warning(f"Invalid knowledge_filters parameter couldn't be loaded: {knowledge_filters}")
+        except ValueError as e:
+            # Filter deserialization failed
+            kwargs.pop("knowledge_filters")
+            log_warning(f"Invalid FilterExpr in knowledge_filters: {e}")
 
     # Parse boolean and null values
     for key, value in kwargs.items():

agno/os/routers/health.py

@@ -5,13 +5,13 @@ from fastapi import APIRouter
 from agno.os.schema import HealthResponse
 
 
-def get_health_router() -> APIRouter:
+def get_health_router(health_endpoint: str = "/health") -> APIRouter:
     router = APIRouter(tags=["Health"])
 
     started_time_stamp = datetime.now(timezone.utc).timestamp()
 
     @router.get(
-        "/health",
+        health_endpoint,
         operation_id="health_check",
         summary="Health Check",
         description="Check the health status of the AgentOS API. Returns a simple status indicator.",
@@ -19,7 +19,9 @@ def get_health_router() -> APIRouter:
         responses={
             200: {
                 "description": "API is healthy and operational",
-                "content": {"application/json": {"example": {"status": "ok", "instantiated_at": "1760169236.778903"}}},
+                "content": {
+                    "application/json": {"example": {"status": "ok", "instantiated_at": str(started_time_stamp)}}
+                },
             }
         },
     )

agno/os/routers/knowledge/knowledge.py

@@ -102,6 +102,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         text_content: Optional[str] = Form(None, description="Raw text content to process"),
         reader_id: Optional[str] = Form(None, description="ID of the reader to use for content processing"),
         chunker: Optional[str] = Form(None, description="Chunking strategy to apply during processing"),
+        chunk_size: Optional[int] = Form(None, description="Chunk size to use for processing"),
+        chunk_overlap: Optional[int] = Form(None, description="Chunk overlap to use for processing"),
         db_id: Optional[str] = Query(default=None, description="Database ID to use for content storage"),
     ):
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
@@ -172,7 +174,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         content.content_hash = content_hash
         content.id = generate_id(content_hash)
 
-        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker)
+        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker, chunk_size, chunk_overlap)
 
         response = ContentResponseSchema(
             id=content.id,
@@ -801,36 +803,55 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
                                     "key": "AgenticChunker",
                                     "name": "AgenticChunker",
                                     "description": "Chunking strategy that uses an LLM to determine natural breakpoints in the text",
+                                    "metadata": {"chunk_size": 5000},
                                 },
                                 "DocumentChunker": {
                                     "key": "DocumentChunker",
                                     "name": "DocumentChunker",
                                     "description": "A chunking strategy that splits text based on document structure like paragraphs and sections",
-                                },
-                                "RecursiveChunker": {
-                                    "key": "RecursiveChunker",
-                                    "name": "RecursiveChunker",
-                                    "description": "Chunking strategy that recursively splits text into chunks by finding natural break points",
-                                },
-                                "SemanticChunker": {
-                                    "key": "SemanticChunker",
-                                    "name": "SemanticChunker",
-                                    "description": "Chunking strategy that splits text into semantic chunks using chonkie",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
                                 },
                                 "FixedSizeChunker": {
                                     "key": "FixedSizeChunker",
                                     "name": "FixedSizeChunker",
                                     "description": "Chunking strategy that splits text into fixed-size chunks with optional overlap",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
+                                },
+                                "MarkdownChunker": {
+                                    "key": "MarkdownChunker",
+                                    "name": "MarkdownChunker",
+                                    "description": "A chunking strategy that splits markdown based on structure like headers, paragraphs and sections",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
+                                },
+                                "RecursiveChunker": {
+                                    "key": "RecursiveChunker",
+                                    "name": "RecursiveChunker",
+                                    "description": "Chunking strategy that recursively splits text into chunks by finding natural break points",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
                                 },
                                 "RowChunker": {
                                     "key": "RowChunker",
                                     "name": "RowChunker",
                                     "description": "RowChunking chunking strategy",
+                                    "metadata": {},
                                 },
-                                "MarkdownChunker": {
-                                    "key": "MarkdownChunker",
-                                    "name": "MarkdownChunker",
-                                    "description": "A chunking strategy that splits markdown based on structure like headers, paragraphs and sections",
+                                "SemanticChunker": {
+                                    "key": "SemanticChunker",
+                                    "name": "SemanticChunker",
+                                    "description": "Chunking strategy that splits text into semantic chunks using chonkie",
+                                    "metadata": {"chunk_size": 5000},
                                 },
                             },
                             "vector_dbs": [
@@ -896,7 +917,10 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             chunker_key = chunker_info.get("key")
             if chunker_key:
                 chunkers_dict[chunker_key] = ChunkerSchema(
-                    key=chunker_key, name=chunker_info.get("name"), description=chunker_info.get("description")
+                    key=chunker_key,
+                    name=chunker_info.get("name"),
+                    description=chunker_info.get("description"),
+                    metadata=chunker_info.get("metadata", {}),
                 )
 
         vector_dbs = []
@@ -929,6 +953,8 @@ async def process_content(
     content: Content,
     reader_id: Optional[str] = None,
     chunker: Optional[str] = None,
+    chunk_size: Optional[int] = None,
+    chunk_overlap: Optional[int] = None,
 ):
     """Background task to process the content"""
 
@@ -951,7 +977,7 @@ async def process_content(
                 content.reader = reader
         if chunker and content.reader:
             # Set the chunker name on the reader - let the reader handle it internally
-            content.reader.set_chunking_strategy_from_string(chunker)
+            content.reader.set_chunking_strategy_from_string(chunker, chunk_size=chunk_size, overlap=chunk_overlap)
             log_debug(f"Set chunking strategy: {chunker}")
 
         log_debug(f"Using reader: {content.reader.__class__.__name__}")

agno/os/routers/knowledge/schemas.py

@@ -106,9 +106,10 @@ class ReaderSchema(BaseModel):
 
 
 class ChunkerSchema(BaseModel):
-    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")
+    key: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
 
 
 class VectorDbSchema(BaseModel):

agno/run/agent.py

@@ -696,7 +696,17 @@ class RunOutput:
             data = data.pop("run")
 
         events = data.pop("events", None)
-        events = [run_output_event_from_dict(event) for event in events] if events else None
+        final_events = []
+        for event in events or []:
+            if "agent_id" in event:
+                event = run_output_event_from_dict(event)
+            else:
+                # Use the factory from response.py for agent events
+                from agno.run.team import team_run_output_event_from_dict
+
+                event = team_run_output_event_from_dict(event)
+            final_events.append(event)
+        events = final_events
 
         messages = data.pop("messages", None)
         messages = [Message.from_dict(message) for message in messages] if messages else None

agno/run/base.py

@@ -1,9 +1,10 @@
 from dataclasses import asdict, dataclass
 from enum import Enum
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
+from agno.filters import FilterExpr
 from agno.media import Audio, Image, Video
 from agno.models.message import Citations, Message, MessageReferences
 from agno.models.metrics import Metrics
@@ -18,7 +19,7 @@ class RunContext:
     user_id: Optional[str] = None
 
     dependencies: Optional[Dict[str, Any]] = None
-    knowledge_filters: Optional[Dict[str, Any]] = None
+    knowledge_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]] = None
     metadata: Optional[Dict[str, Any]] = None
     session_state: Optional[Dict[str, Any]] = None