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

agno/os/auth.py

@@ -1,6 +1,9 @@
-from fastapi import Depends, HTTPException
+from typing import List, Set
+
+from fastapi import Depends, HTTPException, Request
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
 
+from agno.os.scopes import get_accessible_resource_ids
 from agno.os.settings import AgnoAPISettings
 
 # Create a global HTTPBearer instance
@@ -18,7 +21,7 @@ def get_authentication_dependency(settings: AgnoAPISettings):
         A dependency function that can be used with FastAPI's Depends()
     """
 
-    def auth_dependency(credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
+    async def auth_dependency(credentials: HTTPAuthorizationCredentials = Depends(security)) -> bool:
         # If no security key is set, skip authentication entirely
         if not settings or not settings.os_security_key:
             return True
@@ -40,7 +43,7 @@ def get_authentication_dependency(settings: AgnoAPISettings):
 
 def validate_websocket_token(token: str, settings: AgnoAPISettings) -> bool:
     """
-    Validate a bearer token for WebSocket authentication.
+    Validate a bearer token for WebSocket authentication (legacy os_security_key method).
 
     Args:
         token: The bearer token to validate
@@ -55,3 +58,187 @@ def validate_websocket_token(token: str, settings: AgnoAPISettings) -> bool:
 
     # Verify the token matches the configured security key
     return token == settings.os_security_key
+
+
+def get_accessible_resources(request: Request, resource_type: str) -> Set[str]:
+    """
+    Get the set of resource IDs the user has access to based on their scopes.
+
+    This function is used to filter lists of resources (agents, teams, workflows)
+    based on the user's scopes from their JWT token.
+
+    Args:
+        request: The FastAPI request object (contains request.state.scopes)
+        resource_type: Type of resource ("agents", "teams", "workflows")
+
+    Returns:
+        Set of resource IDs the user can access. Returns {"*"} for wildcard access.
+
+    Usage:
+        accessible_ids = get_accessible_resources(request, "agents")
+        if "*" not in accessible_ids:
+            agents = [a for a in agents if a.id in accessible_ids]
+
+    Examples:
+        >>> # User with specific agent access
+        >>> # Token scopes: ["agent-os:my-os:agents:my-agent:read"]
+        >>> get_accessible_resources(request, "agents")
+        {'my-agent'}
+
+        >>> # User with wildcard access
+        >>> # Token scopes: ["agent-os:my-os:agents:*:read"] or ["admin"]
+        >>> get_accessible_resources(request, "agents")
+        {'*'}
+
+        >>> # User with agent-os level access (global resource scope)
+        >>> # Token scopes: ["agent-os:my-os:agents:read"]
+        >>> get_accessible_resources(request, "agents")
+        {'*'}
+    """
+    # Check if accessible_resource_ids is already cached in request state (set by JWT middleware)
+    # This happens when user doesn't have global scope but has specific resource scopes
+    cached_ids = getattr(request.state, "accessible_resource_ids", None)
+    if cached_ids is not None:
+        return cached_ids
+
+    # Get user's scopes from request state (set by JWT middleware)
+    user_scopes = getattr(request.state, "scopes", [])
+
+    # Get accessible resource IDs
+    accessible_ids = get_accessible_resource_ids(user_scopes=user_scopes, resource_type=resource_type)
+
+    return accessible_ids
+
+
+def filter_resources_by_access(request: Request, resources: List, resource_type: str) -> List:
+    """
+    Filter a list of resources based on user's access permissions.
+
+    Args:
+        request: The FastAPI request object
+        resources: List of resource objects (agents, teams, or workflows) with 'id' attribute
+        resource_type: Type of resource ("agents", "teams", "workflows")
+
+    Returns:
+        Filtered list of resources the user has access to
+
+    Usage:
+        agents = filter_resources_by_access(request, all_agents, "agents")
+        teams = filter_resources_by_access(request, all_teams, "teams")
+        workflows = filter_resources_by_access(request, all_workflows, "workflows")
+
+    Examples:
+        >>> # User with specific access
+        >>> agents = [Agent(id="agent-1"), Agent(id="agent-2"), Agent(id="agent-3")]
+        >>> # Token scopes: ["agent-os:my-os:agents:agent-1:read", "agent-os:my-os:agents:agent-2:read"]
+        >>> filter_resources_by_access(request, agents, "agents")
+        [Agent(id="agent-1"), Agent(id="agent-2")]
+
+        >>> # User with wildcard access
+        >>> # Token scopes: ["admin"]
+        >>> filter_resources_by_access(request, agents, "agents")
+        [Agent(id="agent-1"), Agent(id="agent-2"), Agent(id="agent-3")]
+    """
+    accessible_ids = get_accessible_resources(request, resource_type)
+
+    # Wildcard access - return all resources
+    if "*" in accessible_ids:
+        return resources
+
+    # Filter to only accessible resources
+    return [r for r in resources if r.id in accessible_ids]
+
+
+def check_resource_access(request: Request, resource_id: str, resource_type: str, action: str = "read") -> bool:
+    """
+    Check if user has access to a specific resource.
+
+    Args:
+        request: The FastAPI request object
+        resource_id: ID of the resource to check
+        resource_type: Type of resource ("agents", "teams", "workflows")
+        action: Action to check ("read", "run", etc.)
+
+    Returns:
+        True if user has access, False otherwise
+
+    Usage:
+        if not check_resource_access(request, agent_id, "agents", "run"):
+            raise HTTPException(status_code=403, detail="Access denied")
+
+    Examples:
+        >>> # Token scopes: ["agent-os:my-os:agents:my-agent:read", "agent-os:my-os:agents:my-agent:run"]
+        >>> check_resource_access(request, "my-agent", "agents", "run")
+        True
+
+        >>> check_resource_access(request, "other-agent", "agents", "run")
+        False
+    """
+    accessible_ids = get_accessible_resources(request, resource_type)
+
+    # Wildcard access grants all permissions
+    if "*" in accessible_ids:
+        return True
+
+    # Check if user has access to this specific resource
+    return resource_id in accessible_ids
+
+
+def require_resource_access(resource_type: str, action: str, resource_id_param: str):
+    """
+    Create a dependency that checks if the user has access to a specific resource.
+
+    This dependency factory creates a FastAPI dependency that automatically checks
+    authorization when authorization is enabled. It extracts the resource ID from
+    the path parameters and verifies the user has the required access.
+
+    Args:
+        resource_type: Type of resource ("agents", "teams", "workflows")
+        action: Action to check ("read", "run")
+        resource_id_param: Name of the path parameter containing the resource ID
+
+    Returns:
+        A dependency function for use with FastAPI's Depends()
+
+    Usage:
+        @router.post("/agents/{agent_id}/runs")
+        async def create_agent_run(
+            agent_id: str,
+            request: Request,
+            _: None = Depends(require_resource_access("agents", "run", "agent_id")),
+        ):
+            ...
+
+        @router.get("/agents/{agent_id}")
+        async def get_agent(
+            agent_id: str,
+            request: Request,
+            _: None = Depends(require_resource_access("agents", "read", "agent_id")),
+        ):
+            ...
+
+    Examples:
+        >>> # Creates dependency for checking agent run access
+        >>> dep = require_resource_access("agents", "run", "agent_id")
+
+        >>> # Creates dependency for checking team read access
+        >>> dep = require_resource_access("teams", "read", "team_id")
+    """
+    # Map resource_type to singular form for error messages
+    resource_singular = {
+        "agents": "agent",
+        "teams": "team",
+        "workflows": "workflow",
+    }.get(resource_type, resource_type.rstrip("s"))
+
+    async def dependency(request: Request):
+        # Only check authorization if it's enabled
+        if not getattr(request.state, "authorization_enabled", False):
+            return
+
+        # Get the resource_id from path parameters
+        resource_id = request.path_params.get(resource_id_param)
+        if resource_id and not check_resource_access(request, resource_id, resource_type, action):
+            raise HTTPException(status_code=403, detail=f"Access denied to {action} this {resource_singular}")
+
+    return dependency

agno/os/config.py

@@ -5,6 +5,15 @@ from typing import Generic, List, Optional, TypeVar
 from pydantic import BaseModel, field_validator
 
 
+class AuthorizationConfig(BaseModel):
+    """Configuration for the JWT middleware"""
+
+    verification_keys: Optional[List[str]] = None
+    jwks_file: Optional[str] = None
+    algorithm: Optional[str] = None
+    verify_audience: Optional[bool] = None
+
+
 class EvalsDomainConfig(BaseModel):
     """Configuration for the Evals domain of the AgentOS"""
 
@@ -36,6 +45,12 @@ class MemoryDomainConfig(BaseModel):
     display_name: Optional[str] = None
 
 
+class TracesDomainConfig(BaseModel):
+    """Configuration for the Traces domain of the AgentOS"""
+
+    display_name: Optional[str] = None
+
+
 DomainConfigType = TypeVar("DomainConfigType")
 
 
@@ -44,6 +59,7 @@ class DatabaseConfig(BaseModel, Generic[DomainConfigType]):
 
     db_id: str
     domain_config: Optional[DomainConfigType] = None
+    tables: Optional[List[str]] = None
 
 
 class EvalsConfig(EvalsDomainConfig):
@@ -76,6 +92,12 @@ class MetricsConfig(MetricsDomainConfig):
     dbs: Optional[List[DatabaseConfig[MetricsDomainConfig]]] = None
 
 
+class TracesConfig(TracesDomainConfig):
+    """Configuration for the Traces domain of the AgentOS"""
+
+    dbs: Optional[List[DatabaseConfig[TracesDomainConfig]]] = None
+
+
 class ChatConfig(BaseModel):
     """Configuration for the Chat page of the AgentOS"""
 
@@ -101,3 +123,4 @@ class AgentOSConfig(BaseModel):
     memory: Optional[MemoryConfig] = None
     session: Optional[SessionConfig] = None
     metrics: Optional[MetricsConfig] = None
+    traces: Optional[TracesConfig] = None

agno/os/interfaces/a2a/router.py

@@ -11,7 +11,7 @@ from typing_extensions import List
 try:
     from a2a.types import SendMessageSuccessResponse, Task, TaskState, TaskStatus
 except ImportError as e:
-    raise ImportError("`a2a` not installed. Please install it with `pip install -U a2a`") from e
+    raise ImportError("`a2a` not installed. Please install it with `pip install -U a2a-sdk`") from e
 
 from agno.agent import Agent
 from agno.os.interfaces.a2a.utils import (
@@ -19,8 +19,7 @@ from agno.os.interfaces.a2a.utils import (
     map_run_output_to_a2a_task,
     stream_a2a_response_with_error_handling,
 )
-from agno.os.router import _get_request_kwargs
-from agno.os.utils import get_agent_by_id, get_team_by_id, get_workflow_by_id
+from agno.os.utils import get_agent_by_id, get_request_kwargs, get_team_by_id, get_workflow_by_id
 from agno.team import Team
 from agno.workflow import Workflow
 
@@ -36,9 +35,8 @@ def attach_routes(
 
     @router.post(
         "/message/send",
-        tags=["A2A"],
         operation_id="send_message",
-        summary="Send message to Agent, Team, or Workflow (A2A Protocol)",
+        name="send_message",
         description="Send a message to an Agno Agent, Team, or Workflow. "
         "The Agent, Team or Workflow is identified via the 'agentId' field in params.message or X-Agent-ID header. "
         "Optional: Pass user ID via X-User-ID header (recommended) or 'userId' in params.message.metadata.",
@@ -76,7 +74,7 @@ def attach_routes(
     )
     async def a2a_send_message(request: Request):
         request_body = await request.json()
-        kwargs = await _get_request_kwargs(request, a2a_send_message)
+        kwargs = await get_request_kwargs(request, a2a_send_message)
 
         # 1. Get the Agent, Team, or Workflow to run
         agent_id = request_body.get("params", {}).get("message", {}).get("agentId") or request.headers.get("X-Agent-ID")
@@ -159,9 +157,8 @@ def attach_routes(
 
     @router.post(
         "/message/stream",
-        tags=["A2A"],
         operation_id="stream_message",
-        summary="Stream message to Agent, Team, or Workflow (A2A Protocol)",
+        name="stream_message",
         description="Stream a message to an Agno Agent, Team, or Workflow."
         "The Agent, Team or Workflow is identified via the 'agentId' field in params.message or X-Agent-ID header. "
         "Optional: Pass user ID via X-User-ID header (recommended) or 'userId' in params.message.metadata. "
@@ -183,7 +180,7 @@ def attach_routes(
     )
     async def a2a_stream_message(request: Request):
         request_body = await request.json()
-        kwargs = await _get_request_kwargs(request, a2a_stream_message)
+        kwargs = await get_request_kwargs(request, a2a_stream_message)
 
         # 1. Get the Agent, Team, or Workflow to run
         agent_id = request_body.get("params", {}).get("message", {}).get("agentId")
@@ -223,7 +220,7 @@ def attach_routes(
                     session_id=context_id,
                     user_id=user_id,
                     stream=True,
-                    stream_intermediate_steps=True,
+                    stream_events=True,
                     **kwargs,
                 )
             else:
@@ -236,7 +233,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/a2a/utils.py

@@ -110,7 +110,7 @@ async def map_a2a_request_to_run_input(request_body: dict, stream: bool = True)
 
     Returns:
         RunInput: The Agno RunInput
-        stream: Wheter we are in stream mode
+        stream: Whether we are in stream mode
     """
 
     # 1. Validate the request

agno/os/interfaces/agui/router.py

@@ -19,6 +19,7 @@ from agno.agent.agent import Agent
 from agno.os.interfaces.agui.utils import (
     async_stream_agno_response_as_agui_events,
     convert_agui_messages_to_agno_messages,
+    validate_agui_state,
 )
 from agno.team.team import Team
 
@@ -32,6 +33,7 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
     try:
         # Preparing the input for the Agent and emitting the run started event
         messages = convert_agui_messages_to_agno_messages(run_input.messages or [])
+
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
 
         # Look for user_id in run_input.forwarded_props
@@ -39,13 +41,18 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
         if run_input.forwarded_props and isinstance(run_input.forwarded_props, dict):
             user_id = run_input.forwarded_props.get("user_id")
 
+        # Validating the session state is of the expected type (dict)
+        session_state = validate_agui_state(run_input.state, run_input.thread_id)
+
         # Request streaming response from agent
         response_stream = agent.arun(
             input=messages,
             session_id=run_input.thread_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_events=True,
             user_id=user_id,
+            session_state=session_state,
+            run_id=run_id,
         )
 
         # Stream the response content in AG-UI format
@@ -75,13 +82,18 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
         if input.forwarded_props and isinstance(input.forwarded_props, dict):
             user_id = input.forwarded_props.get("user_id")
 
+        # Validating the session state is of the expected type (dict)
+        session_state = validate_agui_state(input.state, input.thread_id)
+
         # Request streaming response from team
         response_stream = team.arun(
             input=messages,
             session_id=input.thread_id,
             stream=True,
-            stream_intermediate_steps=True,
+            stream_steps=True,
             user_id=user_id,
+            session_state=session_state,
+            run_id=run_id,
         )
 
         # Stream the response content in AG-UI format
@@ -101,7 +113,10 @@ def attach_routes(router: APIRouter, agent: Optional[Agent] = None, team: Option
 
     encoder = EventEncoder()
 
-    @router.post("/agui")
+    @router.post(
+        "/agui",
+        name="run_agent",
+    )
     async def run_agent_agui(run_input: RunAgentInput):
         async def event_generator():
             if agent:

agno/os/interfaces/agui/utils.py

@@ -3,11 +3,12 @@
 import json
 import uuid
 from collections.abc import Iterator
-from dataclasses import dataclass
-from typing import AsyncIterator, List, Set, Tuple, Union
+from dataclasses import asdict, dataclass, is_dataclass
+from typing import Any, AsyncIterator, Dict, List, Optional, Set, Tuple, Union
 
 from ag_ui.core import (
     BaseEvent,
+    CustomEvent,
     EventType,
     RunFinishedEvent,
     StepFinishedEvent,
@@ -21,14 +22,48 @@ from ag_ui.core import (
     ToolCallStartEvent,
 )
 from ag_ui.core.types import Message as AGUIMessage
+from pydantic import BaseModel
 
 from agno.models.message import Message
 from agno.run.agent import RunContentEvent, RunEvent, RunOutputEvent, RunPausedEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunEvent, TeamRunOutputEvent
+from agno.utils.log import log_debug, log_warning
 from agno.utils.message import get_text_from_message
 
 
+def validate_agui_state(state: Any, thread_id: str) -> Optional[Dict[str, Any]]:
+    """Validate the given AGUI state is of the expected type (dict)."""
+    if state is None:
+        return None
+
+    if isinstance(state, dict):
+        return state
+
+    if isinstance(state, BaseModel):
+        try:
+            return state.model_dump()
+        except Exception:
+            pass
+
+    if is_dataclass(state):
+        try:
+            return asdict(state)  # type: ignore
+        except Exception:
+            pass
+
+    if hasattr(state, "to_dict") and callable(getattr(state, "to_dict")):
+        try:
+            result = state.to_dict()  # type: ignore
+            if isinstance(result, dict):
+                return result
+        except Exception:
+            pass
+
+    log_warning(f"AGUI state must be a dict, got {type(state).__name__}. State will be ignored. Thread: {thread_id}")
+    return None
+
+
 @dataclass
 class EventBuffer:
     """Buffer to manage event ordering constraints, relevant when mapping Agno responses to AG-UI events."""
@@ -81,23 +116,43 @@ class EventBuffer:
 
 def convert_agui_messages_to_agno_messages(messages: List[AGUIMessage]) -> List[Message]:
     """Convert AG-UI messages to Agno messages."""
-    result = []
+    # First pass: collect all tool_call_ids that have results
+    tool_call_ids_with_results: Set[str] = set()
+    for msg in messages:
+        if msg.role == "tool" and msg.tool_call_id:
+            tool_call_ids_with_results.add(msg.tool_call_id)
+
+    # Second pass: convert messages
+    result: List[Message] = []
+    seen_tool_call_ids: Set[str] = set()
+
     for msg in messages:
         if msg.role == "tool":
+            # Deduplicate tool results - keep only first occurrence
+            if msg.tool_call_id in seen_tool_call_ids:
+                log_debug(f"Skipping duplicate AGUI tool result: {msg.tool_call_id}")
+                continue
+            seen_tool_call_ids.add(msg.tool_call_id)
             result.append(Message(role="tool", tool_call_id=msg.tool_call_id, content=msg.content))
+
         elif msg.role == "assistant":
             tool_calls = None
             if msg.tool_calls:
-                tool_calls = [call.model_dump() for call in msg.tool_calls]
-            result.append(
-                Message(
-                    role="assistant",
-                    content=msg.content,
-                    tool_calls=tool_calls,
-                )
-            )
+                # Filter tool_calls to only those with results in this message sequence
+                filtered_calls = [call for call in msg.tool_calls if call.id in tool_call_ids_with_results]
+                if filtered_calls:
+                    tool_calls = [call.model_dump() for call in filtered_calls]
+            result.append(Message(role="assistant", content=msg.content, tool_calls=tool_calls))
+
         elif msg.role == "user":
             result.append(Message(role="user", content=msg.content))
+
+        elif msg.role == "system":
+            pass  # Skip - agent builds its own system message from configuration
+
+        else:
+            log_warning(f"Unknown AGUI message role: {msg.role}")
+
     return result
 
 
@@ -215,7 +270,25 @@ def _create_events_from_chunk(
             parent_message_id = event_buffer.get_parent_message_id_for_tool_call()
 
             if not parent_message_id:
-                parent_message_id = current_message_id
+                # Create parent message for tool calls without preceding assistant message
+                parent_message_id = str(uuid.uuid4())
+
+                # Emit a text message to serve as the parent
+                text_start = TextMessageStartEvent(
+                    type=EventType.TEXT_MESSAGE_START,
+                    message_id=parent_message_id,
+                    role="assistant",
+                )
+                events_to_emit.append(text_start)
+
+                text_end = TextMessageEndEvent(
+                    type=EventType.TEXT_MESSAGE_END,
+                    message_id=parent_message_id,
+                )
+                events_to_emit.append(text_end)
+
+                # Set this as the pending parent for subsequent tool calls in this batch
+                event_buffer.set_pending_tool_calls_parent_id(parent_message_id)
 
             start_event = ToolCallStartEvent(
                 type=EventType.TOOL_CALL_START,
@@ -261,6 +334,23 @@ def _create_events_from_chunk(
         step_finished_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
         events_to_emit.append(step_finished_event)
 
+    # Handle custom events
+    elif chunk.event == RunEvent.custom_event:
+        # Use the name of the event class if available, otherwise default to the CustomEvent
+        try:
+            custom_event_name = chunk.__class__.__name__
+        except Exception:
+            custom_event_name = chunk.event
+
+        # Use the complete Agno event as value if parsing it works, else the event content field
+        try:
+            custom_event_value = chunk.to_dict()
+        except Exception:
+            custom_event_value = chunk.content  # type: ignore
+
+        custom_event = CustomEvent(name=custom_event_name, value=custom_event_value)
+        events_to_emit.append(custom_event)
+
     return events_to_emit, message_started, message_id
 
 
@@ -289,37 +379,60 @@ def _create_completion_events(
         end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=message_id)
         events_to_emit.append(end_message_event)
 
-    # emit frontend tool calls, i.e. external_execution=True
-    if isinstance(chunk, RunPausedEvent) and chunk.tools is not None:
-        for tool in chunk.tools:
-            if tool.tool_call_id is None or tool.tool_name is None:
-                continue
-
-            # Use the current text message ID from event buffer as parent
-            parent_message_id = event_buffer.get_parent_message_id_for_tool_call()
-            if not parent_message_id:
-                parent_message_id = message_id  # Fallback to the passed message_id
-
-            start_event = ToolCallStartEvent(
-                type=EventType.TOOL_CALL_START,
-                tool_call_id=tool.tool_call_id,
-                tool_call_name=tool.tool_name,
-                parent_message_id=parent_message_id,
+    # Emit external execution tools
+    if isinstance(chunk, RunPausedEvent):
+        external_tools = chunk.tools_awaiting_external_execution
+        if external_tools:
+            # First, emit an assistant message for external tool calls
+            assistant_message_id = str(uuid.uuid4())
+            assistant_start_event = TextMessageStartEvent(
+                type=EventType.TEXT_MESSAGE_START,
+                message_id=assistant_message_id,
+                role="assistant",
             )
-            events_to_emit.append(start_event)
+            events_to_emit.append(assistant_start_event)
+
+            # Add any text content if present for the assistant message
+            if chunk.content:
+                content_event = TextMessageContentEvent(
+                    type=EventType.TEXT_MESSAGE_CONTENT,
+                    message_id=assistant_message_id,
+                    delta=str(chunk.content),
+                )
+                events_to_emit.append(content_event)
 
-            args_event = ToolCallArgsEvent(
-                type=EventType.TOOL_CALL_ARGS,
-                tool_call_id=tool.tool_call_id,
-                delta=json.dumps(tool.tool_args),
+            # End the assistant message
+            assistant_end_event = TextMessageEndEvent(
+                type=EventType.TEXT_MESSAGE_END,
+                message_id=assistant_message_id,
             )
-            events_to_emit.append(args_event)
+            events_to_emit.append(assistant_end_event)
+
+            # Emit tool call events for external execution
+            for tool in external_tools:
+                if tool.tool_call_id is None or tool.tool_name is None:
+                    continue
+
+                start_event = ToolCallStartEvent(
+                    type=EventType.TOOL_CALL_START,
+                    tool_call_id=tool.tool_call_id,
+                    tool_call_name=tool.tool_name,
+                    parent_message_id=assistant_message_id,  # Use the assistant message as parent
+                )
+                events_to_emit.append(start_event)
 
-            end_event = ToolCallEndEvent(
-                type=EventType.TOOL_CALL_END,
-                tool_call_id=tool.tool_call_id,
-            )
-            events_to_emit.append(end_event)
+                args_event = ToolCallArgsEvent(
+                    type=EventType.TOOL_CALL_ARGS,
+                    tool_call_id=tool.tool_call_id,
+                    delta=json.dumps(tool.tool_args),
+                )
+                events_to_emit.append(args_event)
+
+                end_event = ToolCallEndEvent(
+                    type=EventType.TOOL_CALL_END,
+                    tool_call_id=tool.tool_call_id,
+                )
+                events_to_emit.append(end_event)
 
     run_finished_event = RunFinishedEvent(type=EventType.RUN_FINISHED, thread_id=thread_id, run_id=run_id)
     events_to_emit.append(run_finished_event)