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

agno/models/vertexai/claude.py

@@ -0,0 +1,74 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, Optional
+
+from agno.models.anthropic import Claude as AnthropicClaude
+
+try:
+    from anthropic import AnthropicVertex as AnthropicClient
+    from anthropic import (
+        AsyncAnthropicVertex as AsyncAnthropicClient,
+    )
+except ImportError as e:
+    raise ImportError("`anthropic` not installed. Please install it with `pip install anthropic`") from e
+
+
+@dataclass
+class Claude(AnthropicClaude):
+    """
+    A class representing Anthropic Claude model.
+
+    For more information, see: https://docs.anthropic.com/en/api/messages
+    """
+
+    id: str = "claude-sonnet-4@20250514"
+    name: str = "Claude"
+    provider: str = "VertexAI"
+
+    # Client parameters
+    region: Optional[str] = None
+    project_id: Optional[str] = None
+    base_url: Optional[str] = None
+
+    # Anthropic clients
+    client: Optional[AnthropicClient] = None
+    async_client: Optional[AsyncAnthropicClient] = None
+
+    def _get_client_params(self) -> Dict[str, Any]:
+        client_params: Dict[str, Any] = {}
+
+        # Add API key to client parameters
+        client_params["region"] = self.region or getenv("CLOUD_ML_REGION")
+        client_params["project_id"] = self.project_id or getenv("ANTHROPIC_VERTEX_PROJECT_ID")
+        client_params["base_url"] = self.base_url or getenv("ANTHROPIC_VERTEX_BASE_URL")
+        if self.timeout is not None:
+            client_params["timeout"] = self.timeout
+
+        # Add additional client parameters
+        if self.client_params is not None:
+            client_params.update(self.client_params)
+        if self.default_headers is not None:
+            client_params["default_headers"] = self.default_headers
+        return client_params
+
+    def get_client(self) -> AnthropicClient:
+        """
+        Returns an instance of the Anthropic client.
+        """
+        if self.client and not self.client.is_closed():
+            return self.client
+
+        _client_params = self._get_client_params()
+        self.client = AnthropicClient(**_client_params)
+        return self.client
+
+    def get_async_client(self) -> AsyncAnthropicClient:
+        """
+        Returns an instance of the async Anthropic client.
+        """
+        if self.async_client:
+            return self.async_client
+
+        _client_params = self._get_client_params()
+        self.async_client = AsyncAnthropicClient(**_client_params)
+        return self.async_client

agno/os/app.py

@@ -64,6 +64,30 @@ async def mcp_lifespan(_, mcp_tools):
         await tool.close()
 
 
+def _combine_app_lifespans(lifespans: list) -> Any:
+    """Combine multiple FastAPI app lifespan context managers into one."""
+    if len(lifespans) == 1:
+        return lifespans[0]
+
+    from contextlib import asynccontextmanager
+
+    @asynccontextmanager
+    async def combined_lifespan(app):
+        async def _run_nested(index: int):
+            if index >= len(lifespans):
+                yield
+                return
+
+            async with lifespans[index](app):
+                async for _ in _run_nested(index + 1):
+                    yield
+
+        async for _ in _run_nested(0):
+            yield
+
+    return combined_lifespan
+
+
 class AgentOS:
     def __init__(
         self,
@@ -183,9 +207,6 @@ class AgentOS:
 
                 team.initialize_team()
 
-                # Required for the built-in routes to work
-                team.store_events = True
-
                 for member in team.members:
                     if isinstance(member, Agent):
                         member.team_id = None
@@ -193,13 +214,20 @@ class AgentOS:
                     elif isinstance(member, Team):
                         member.initialize_team()
 
+                # Required for the built-in routes to work
+                team.store_events = True
+
         if self.workflows:
             for workflow in self.workflows:
                 # Track MCP tools recursively in workflow members
                 collect_mcp_tools_from_workflow(workflow, self.mcp_tools)
+
                 if not workflow.id:
                     workflow.id = generate_id_from_name(workflow.name)
 
+                # Required for the built-in routes to work
+                workflow.store_events = True
+
         if self.telemetry:
             from agno.api.os import OSLaunch, log_os_telemetry
 
@@ -220,7 +248,7 @@ class AgentOS:
                         async with mcp_tools_lifespan(app):  # type: ignore
                             yield
 
-                app_lifespan = combined_lifespan  # type: ignore
+                app_lifespan = combined_lifespan
             else:
                 app_lifespan = mcp_tools_lifespan
 
@@ -237,6 +265,32 @@ class AgentOS:
     def get_app(self) -> FastAPI:
         if self.base_app:
             fastapi_app = self.base_app
+
+            # Initialize MCP server if enabled
+            if self.enable_mcp_server:
+                from agno.os.mcp import get_mcp_server
+
+                self._mcp_app = get_mcp_server(self)
+
+            # Collect all lifespans that need to be combined
+            lifespans = []
+
+            if fastapi_app.router.lifespan_context:
+                lifespans.append(fastapi_app.router.lifespan_context)
+
+            if self.mcp_tools:
+                lifespans.append(partial(mcp_lifespan, mcp_tools=self.mcp_tools))
+
+            if self.enable_mcp_server and self._mcp_app:
+                lifespans.append(self._mcp_app.lifespan)
+
+            if self.lifespan:
+                lifespans.append(self.lifespan)
+
+            # Combine lifespans and set them in the app
+            if lifespans:
+                fastapi_app.router.lifespan_context = _combine_app_lifespans(lifespans)
+
         else:
             if self.enable_mcp_server:
                 from contextlib import asynccontextmanager
@@ -255,7 +309,7 @@ class AgentOS:
                             async with self._mcp_app.lifespan(app):  # type: ignore
                                 yield
 
-                    final_lifespan = combined_lifespan  # type: ignore
+                    final_lifespan = combined_lifespan
 
                 fastapi_app = self._make_app(lifespan=final_lifespan)
             else:

agno/os/interfaces/agui/utils.py

@@ -8,6 +8,7 @@ from typing import AsyncIterator, List, Set, Tuple, Union
 
 from ag_ui.core import (
     BaseEvent,
+    CustomEvent,
     EventType,
     RunFinishedEvent,
     StepFinishedEvent,
@@ -261,6 +262,11 @@ 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:
+        custom_event = CustomEvent(name=chunk.event, value=chunk.content)
+        events_to_emit.append(custom_event)
+
     return events_to_emit, message_started, message_id
 
 

agno/os/mcp.py

@@ -78,21 +78,21 @@ def get_mcp_server(
         agent = get_agent_by_id(agent_id, os.agents)
         if agent is None:
             raise Exception(f"Agent {agent_id} not found")
-        return agent.run(message)
+        return await agent.arun(message)
 
     @mcp.tool(name="run_team", description="Run a team", tags={"core"})  # type: ignore
     async def run_team(team_id: str, message: str) -> TeamRunOutput:
         team = get_team_by_id(team_id, os.teams)
         if team is None:
             raise Exception(f"Team {team_id} not found")
-        return team.run(message)
+        return await team.arun(message)
 
     @mcp.tool(name="run_workflow", description="Run a workflow", tags={"core"})  # type: ignore
     async def run_workflow(workflow_id: str, message: str) -> WorkflowRunOutput:
         workflow = get_workflow_by_id(workflow_id, os.workflows)
         if workflow is None:
             raise Exception(f"Workflow {workflow_id} not found")
-        return workflow.run(message)
+        return await workflow.arun(message)
 
     # Session Management Tools
     @mcp.tool(name="get_sessions_for_agent", description="Get list of sessions for an agent", tags={"session"})  # type: ignore

agno/os/schema.py

@@ -913,6 +913,7 @@ class TeamRunSchema(BaseModel):
 class WorkflowRunSchema(BaseModel):
     run_id: str
     run_input: Optional[str]
+    events: Optional[List[dict]]
     workflow_id: Optional[str]
     user_id: Optional[str]
     content: Optional[Union[str, dict]]
@@ -933,6 +934,7 @@ class WorkflowRunSchema(BaseModel):
         return cls(
             run_id=run_response.get("run_id", ""),
             run_input=run_input,
+            events=run_response.get("events", []),
             workflow_id=run_response.get("workflow_id", ""),
             user_id=run_response.get("user_id", ""),
             content=run_response.get("content", ""),

agno/os/utils.py

@@ -89,16 +89,17 @@ def get_session_name(session: Dict[str, Any]) -> str:
 
     # Otherwise use the original user message
     else:
-        runs = session.get("runs", [])
+        runs = session.get("runs", []) or []
 
         # For teams, identify the first Team run and avoid using the first member's run
         if session.get("session_type") == "team":
             run = None
             for r in runs:
                 # If agent_id is not present, it's a team run
-                if not r.get("agent_id"):  
+                if not r.get("agent_id"):
                     run = r
                     break
+
             # Fallback to first run if no team run found
             if run is None and runs:
                 run = runs[0]
@@ -112,6 +113,7 @@ def get_session_name(session: Dict[str, Any]) -> str:
                 elif isinstance(workflow_input, dict):
                     try:
                         import json
+
                         return json.dumps(workflow_input)
                     except (TypeError, ValueError):
                         pass

agno/session/workflow.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, List, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
 from agno.run.workflow import WorkflowRunOutput
 from agno.utils.log import logger
@@ -75,6 +75,74 @@ class WorkflowSession:
         else:
             self.runs.append(run)
 
+    def get_workflow_history(self, num_runs: Optional[int] = None) -> List[Tuple[str, str]]:
+        """Get workflow history as structured data (input, response pairs)
+        
+        Args:
+            num_runs: Number of recent runs to include. If None, returns all available history.
+        """
+        if not self.runs:
+            return []
+
+        from agno.run.base import RunStatus
+
+        # Get completed runs only (exclude current/pending run)
+        completed_runs = [run for run in self.runs if run.status == RunStatus.completed]
+        
+        if num_runs is not None and len(completed_runs) > num_runs:
+            recent_runs = completed_runs[-num_runs:]
+        else:
+            recent_runs = completed_runs
+
+        if not recent_runs:
+            return []
+
+        # Return structured data as list of (input, response) tuples
+        history_data = []
+        for run in recent_runs:
+            # Get input
+            input_str = ""
+            if run.input:
+                input_str = str(run.input) if not isinstance(run.input, str) else run.input
+
+            # Get response
+            response_str = ""
+            if run.content:
+                response_str = str(run.content) if not isinstance(run.content, str) else run.content
+
+            history_data.append((input_str, response_str))
+
+        return history_data
+
+    def get_workflow_history_context(self, num_runs: Optional[int] = None) -> Optional[str]:
+        """Get formatted workflow history context for steps
+        
+        Args:
+            num_runs: Number of recent runs to include. If None, returns all available history.
+        """
+        history_data = self.get_workflow_history(num_runs)
+
+        if not history_data:
+            return None
+
+        # Format as workflow context using the structured data
+        context_parts = ["<workflow_history_context>"]
+
+        for i, (input_str, response_str) in enumerate(history_data, 1):
+            context_parts.append(f"[run-{i}]")
+
+            if input_str:
+                context_parts.append(f"input: {input_str}")
+            if response_str:
+                context_parts.append(f"response: {response_str}")
+
+            context_parts.append("")  # Empty line between runs
+
+        context_parts.append("</workflow_history_context>")
+        context_parts.append("")  # Empty line before current input
+
+        return "\n".join(context_parts)
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for storage, serializing runs to dicts"""