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

agno/os/routers/session/session.py

@@ -1,9 +1,9 @@
 import logging
-from typing import List, Optional, Union
+from typing import List, Optional, Union, cast
 
 from fastapi import APIRouter, Body, Depends, HTTPException, Path, Query, Request
 
-from agno.db.base import BaseDb, SessionType
+from agno.db.base import AsyncBaseDb, BaseDb, SessionType
 from agno.os.auth import get_authentication_dependency
 from agno.os.schema import (
     AgentSessionDetailSchema,
@@ -29,7 +29,9 @@ from agno.os.utils import get_db
 logger = logging.getLogger(__name__)
 
 
-def get_session_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoAPISettings()) -> APIRouter:
+def get_session_router(
+    dbs: dict[str, Union[BaseDb, AsyncBaseDb]], settings: AgnoAPISettings = AgnoAPISettings()
+) -> APIRouter:
     """Create session router with comprehensive OpenAPI documentation for session management endpoints."""
     session_router = APIRouter(
         dependencies=[Depends(get_authentication_dependency(settings))],
@@ -45,7 +47,7 @@ def get_session_router(dbs: dict[str, BaseDb], settings: AgnoAPISettings = AgnoA
     return attach_routes(router=session_router, dbs=dbs)
 
 
-def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
+def attach_routes(router: APIRouter, dbs: dict[str, Union[BaseDb, AsyncBaseDb]]) -> APIRouter:
     @router.get(
         "/sessions",
         response_model=PaginatedResponse[SessionSchema],
@@ -108,17 +110,31 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         if hasattr(request.state, "user_id"):
             user_id = request.state.user_id
 
-        sessions, total_count = db.get_sessions(
-            session_type=session_type,
-            component_id=component_id,
-            user_id=user_id,
-            session_name=session_name,
-            limit=limit,
-            page=page,
-            sort_by=sort_by,
-            sort_order=sort_order,
-            deserialize=False,
-        )
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            sessions, total_count = await db.get_sessions(
+                session_type=session_type,
+                component_id=component_id,
+                user_id=user_id,
+                session_name=session_name,
+                limit=limit,
+                page=page,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
+        else:
+            sessions, total_count = db.get_sessions(  # type: ignore
+                session_type=session_type,
+                component_id=component_id,
+                user_id=user_id,
+                session_name=session_name,
+                limit=limit,
+                page=page,
+                sort_by=sort_by,
+                sort_order=sort_order,
+                deserialize=False,
+            )
 
         return PaginatedResponse(
             data=[SessionSchema.from_dict(session) for session in sessions],  # type: ignore
@@ -231,7 +247,11 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         if hasattr(request.state, "user_id"):
             user_id = request.state.user_id
 
-        session = db.get_session(session_id=session_id, session_type=session_type, user_id=user_id)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            session = await db.get_session(session_id=session_id, session_type=session_type, user_id=user_id)
+        else:
+            session = db.get_session(session_id=session_id, session_type=session_type, user_id=user_id)
         if not session:
             raise HTTPException(
                 status_code=404, detail=f"{session_type.value.title()} Session with id '{session_id}' not found"
@@ -373,7 +393,16 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         if hasattr(request.state, "user_id"):
             user_id = request.state.user_id
 
-        session = db.get_session(session_id=session_id, session_type=session_type, user_id=user_id, deserialize=False)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            session = await db.get_session(
+                session_id=session_id, session_type=session_type, user_id=user_id, deserialize=False
+            )
+        else:
+            session = db.get_session(
+                session_id=session_id, session_type=session_type, user_id=user_id, deserialize=False
+            )
+
         if not session:
             raise HTTPException(status_code=404, detail=f"Session with ID {session_id} not found")
 
@@ -381,11 +410,12 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         if not runs:
             raise HTTPException(status_code=404, detail=f"Session with ID {session_id} has no runs")
 
+        run_responses: List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]] = []
+
         if session_type == SessionType.AGENT:
             return [RunSchema.from_dict(run) for run in runs]
 
         elif session_type == SessionType.TEAM:
-            run_responses: List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]] = []
             for run in runs:
                 if run.get("agent_id") is not None:
                     run_responses.append(RunSchema.from_dict(run))
@@ -394,7 +424,6 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
             return run_responses
 
         elif session_type == SessionType.WORKFLOW:
-            run_responses: List[Union[RunSchema, TeamRunSchema, WorkflowRunSchema]] = []  # type: ignore
             for run in runs:
                 if run.get("workflow_id") is not None:
                     run_responses.append(WorkflowRunSchema.from_dict(run))
@@ -425,7 +454,11 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         db_id: Optional[str] = Query(default=None, description="Database ID to use for deletion"),
     ) -> None:
         db = get_db(dbs, db_id)
-        db.delete_session(session_id=session_id)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            await db.delete_session(session_id=session_id)
+        else:
+            db.delete_session(session_id=session_id)
 
     @router.delete(
         "/sessions",
@@ -456,7 +489,11 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
             raise HTTPException(status_code=400, detail="Session IDs and session types must have the same length")
 
         db = get_db(dbs, db_id)
-        db.delete_sessions(session_ids=request.session_ids)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            await db.delete_sessions(session_ids=request.session_ids)
+        else:
+            db.delete_sessions(session_ids=request.session_ids)
 
     @router.post(
         "/sessions/{session_id}/rename",
@@ -555,7 +592,13 @@ def attach_routes(router: APIRouter, dbs: dict[str, BaseDb]) -> APIRouter:
         db_id: Optional[str] = Query(default=None, description="Database ID to use for rename operation"),
     ) -> Union[AgentSessionDetailSchema, TeamSessionDetailSchema, WorkflowSessionDetailSchema]:
         db = get_db(dbs, db_id)
-        session = db.rename_session(session_id=session_id, session_type=session_type, session_name=session_name)
+        if isinstance(db, AsyncBaseDb):
+            db = cast(AsyncBaseDb, db)
+            session = await db.rename_session(
+                session_id=session_id, session_type=session_type, session_name=session_name
+            )
+        else:
+            session = db.rename_session(session_id=session_id, session_type=session_type, session_name=session_name)
         if not session:
             raise HTTPException(status_code=404, detail=f"Session with id '{session_id}' not found")
 

agno/os/schema.py

@@ -10,6 +10,7 @@ from agno.db.base import SessionType
 from agno.models.message import Message
 from agno.os.config import ChatConfig, EvalsConfig, KnowledgeConfig, MemoryConfig, MetricsConfig, SessionConfig
 from agno.os.utils import (
+    extract_input_media,
     format_team_tools,
     format_tools,
     get_run_input,
@@ -841,6 +842,12 @@ class RunSchema(BaseModel):
     created_at: Optional[datetime]
     references: Optional[List[dict]]
     reasoning_messages: Optional[List[dict]]
+    images: Optional[List[dict]]
+    videos: Optional[List[dict]]
+    audio: Optional[List[dict]]
+    files: Optional[List[dict]]
+    response_audio: Optional[List[dict]]
+    input_media: Optional[Dict[str, Any]]
 
     @classmethod
     def from_dict(cls, run_dict: Dict[str, Any]) -> "RunSchema":
@@ -862,6 +869,12 @@ class RunSchema(BaseModel):
             events=[event for event in run_dict["events"]] if run_dict.get("events") else None,
             references=run_dict.get("references", []),
             reasoning_messages=run_dict.get("reasoning_messages", []),
+            images=run_dict.get("images", []),
+            videos=run_dict.get("videos", []),
+            audio=run_dict.get("audio", []),
+            files=run_dict.get("files", []),
+            response_audio=run_dict.get("response_audio", []),
+            input_media=extract_input_media(run_dict),
             created_at=datetime.fromtimestamp(run_dict.get("created_at", 0), tz=timezone.utc)
             if run_dict.get("created_at") is not None
             else None,
@@ -884,6 +897,12 @@ class TeamRunSchema(BaseModel):
     created_at: Optional[datetime]
     references: Optional[List[dict]]
     reasoning_messages: Optional[List[dict]]
+    input_media: Optional[Dict[str, Any]]
+    images: Optional[List[dict]]
+    videos: Optional[List[dict]]
+    audio: Optional[List[dict]]
+    files: Optional[List[dict]]
+    response_audio: Optional[List[dict]]
 
     @classmethod
     def from_dict(cls, run_dict: Dict[str, Any]) -> "TeamRunSchema":
@@ -907,6 +926,12 @@ class TeamRunSchema(BaseModel):
             else None,
             references=run_dict.get("references", []),
             reasoning_messages=run_dict.get("reasoning_messages", []),
+            images=run_dict.get("images", []),
+            videos=run_dict.get("videos", []),
+            audio=run_dict.get("audio", []),
+            files=run_dict.get("files", []),
+            response_audio=run_dict.get("response_audio", []),
+            input_media=extract_input_media(run_dict),
         )
 
 
@@ -927,6 +952,11 @@ class WorkflowRunSchema(BaseModel):
     reasoning_steps: Optional[List[dict]]
     references: Optional[List[dict]]
     reasoning_messages: Optional[List[dict]]
+    images: Optional[List[dict]]
+    videos: Optional[List[dict]]
+    audio: Optional[List[dict]]
+    files: Optional[List[dict]]
+    response_audio: Optional[List[dict]]
 
     @classmethod
     def from_dict(cls, run_response: Dict[str, Any]) -> "WorkflowRunSchema":
@@ -948,6 +978,11 @@ class WorkflowRunSchema(BaseModel):
             reasoning_steps=run_response.get("reasoning_steps", []),
             references=run_response.get("references", []),
             reasoning_messages=run_response.get("reasoning_messages", []),
+            images=run_response.get("images", []),
+            videos=run_response.get("videos", []),
+            audio=run_response.get("audio", []),
+            files=run_response.get("files", []),
+            response_audio=run_response.get("response_audio", []),
         )
 
 
@@ -964,6 +999,7 @@ class PaginationInfo(BaseModel):
     limit: Optional[int] = 20
     total_pages: Optional[int] = 0
     total_count: Optional[int] = 0
+    search_time_ms: Optional[float] = 0
 
 
 class PaginatedResponse(BaseModel, Generic[T]):

agno/os/utils.py

@@ -3,9 +3,11 @@ from typing import Any, Callable, Dict, List, Optional, Set, Union
 from fastapi import FastAPI, HTTPException, UploadFile
 from fastapi.routing import APIRoute, APIRouter
 from starlette.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
 
+from agno.models.message import Message
 from agno.agent.agent import Agent
-from agno.db.base import BaseDb
+from agno.db.base import AsyncBaseDb, BaseDb
 from agno.knowledge.knowledge import Knowledge
 from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
@@ -17,7 +19,7 @@ from agno.utils.log import logger
 from agno.workflow.workflow import Workflow
 
 
-def get_db(dbs: dict[str, BaseDb], db_id: Optional[str] = None) -> BaseDb:
+def get_db(dbs: dict[str, Union[BaseDb, AsyncBaseDb]], db_id: Optional[str] = None) -> Union[BaseDb, AsyncBaseDb]:
     """Return the database with the given ID, or the first database if no ID is provided."""
 
     # Raise if multiple databases are provided but no db_id is provided
@@ -54,23 +56,31 @@ def get_knowledge_instance_by_db_id(knowledge_instances: List[Knowledge], db_id:
 
 
 def get_run_input(run_dict: Dict[str, Any], is_workflow_run: bool = False) -> str:
-    """Get the run input from the given run dictionary"""
+    """Get the run input from the given run dictionary
+    
+    Uses the RunInput/TeamRunInput object which stores the original user input.
+    """
+
+    # For agent or team runs, use the stored input_content
+    if not is_workflow_run and run_dict.get("input") is not None:
+        input_data = run_dict.get("input")
+        if isinstance(input_data, dict) and input_data.get("input_content") is not None:
+            return stringify_input_content(input_data["input_content"])
 
-    if is_workflow_run:
+    if is_workflow_run: 
+        # Check the input field directly
+        if run_dict.get("input") is not None:
+            input_value = run_dict.get("input")
+            return str(input_value)
+        
+        # Check the step executor runs for fallback
         step_executor_runs = run_dict.get("step_executor_runs", [])
         if step_executor_runs:
             for message in reversed(step_executor_runs[0].get("messages", [])):
                 if message.get("role") == "user":
                     return message.get("content", "")
 
-        # Check the input field directly as final fallback
-        if run_dict.get("input") is not None:
-            input_value = run_dict.get("input")
-            if isinstance(input_value, str):
-                return input_value
-            else:
-                return str(input_value)
-
+    # Final fallback: scan messages
     if run_dict.get("messages") is not None:
         for message in reversed(run_dict["messages"]):
             if message.get("role") == "user":
@@ -140,6 +150,25 @@ def get_session_name(session: Dict[str, Any]) -> str:
     return ""
 
 
+
+
+def extract_input_media(run_dict: Dict[str, Any]) -> Dict[str, Any]:
+    input_media: Dict[str, List[Any]] = {
+        "images": [],
+        "videos": [],
+        "audios": [],
+        "files": [],
+    }
+
+    input = run_dict.get("input", [])
+    input_media["images"].extend(input.get("images", []))
+    input_media["videos"].extend(input.get("videos", []))
+    input_media["audios"].extend(input.get("audios", []))
+    input_media["files"].extend(input.get("files", []))
+    
+    return input_media
+
+
 def process_image(file: UploadFile) -> Image:
     content = file.file.read()
     if not content:
@@ -495,3 +524,29 @@ def collect_mcp_tools_from_workflow_step(step: Any, mcp_tools: List[Any]) -> Non
     elif isinstance(step, Workflow):
         # Nested workflow
         collect_mcp_tools_from_workflow(step, mcp_tools)
+
+
+def stringify_input_content(input_content: Union[str, Dict[str, Any], List[Any], BaseModel]) -> str:
+    """Convert any given input_content into its string representation.
+    
+    This handles both serialized (dict) and live (object) input_content formats.
+    """
+    import json
+
+    if isinstance(input_content, str):
+        return input_content
+    elif isinstance(input_content, Message):
+        return json.dumps(input_content.to_dict())
+    elif isinstance(input_content, dict):
+        return json.dumps(input_content, indent=2, default=str)
+    elif isinstance(input_content, list):
+        if input_content:
+            # Handle live Message objects
+            if isinstance(input_content[0], Message):
+                return json.dumps([m.to_dict() for m in input_content])
+            # Handle serialized Message dicts
+            elif isinstance(input_content[0], dict) and input_content[0].get("role") == "user":
+                return input_content[0].get("content", str(input_content))
+        return str(input_content)
+    else:
+        return str(input_content)

agno/reasoning/anthropic.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.utils.log import logger
+
+
+def is_anthropic_reasoning_model(reasoning_model: Model) -> bool:
+    """Check if the model is an Anthropic Claude model with thinking support."""
+    is_claude = reasoning_model.__class__.__name__ == "Claude"
+    if not is_claude:
+        return False
+
+    # Check if provider is Anthropic (not VertexAI)
+    is_anthropic_provider = hasattr(reasoning_model, "provider") and reasoning_model.provider == "Anthropic"
+
+    # Check if thinking parameter is set
+    has_thinking = hasattr(reasoning_model, "thinking") and reasoning_model.thinking is not None
+
+    return is_claude and is_anthropic_provider and has_thinking
+
+
+def get_anthropic_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    """Get reasoning from an Anthropic Claude model."""
+    from agno.run.agent import RunOutput
+
+    try:
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    redacted_reasoning_content: Optional[str] = None
+
+    if reasoning_agent_response.messages is not None:
+        for msg in reasoning_agent_response.messages:
+            if msg.reasoning_content is not None:
+                reasoning_content = msg.reasoning_content
+            if hasattr(msg, "redacted_reasoning_content") and msg.redacted_reasoning_content is not None:
+                redacted_reasoning_content = msg.redacted_reasoning_content
+                break
+
+    return Message(
+        role="assistant",
+        content=f"<thinking>\n{reasoning_content}\n</thinking>",
+        reasoning_content=reasoning_content,
+        redacted_reasoning_content=redacted_reasoning_content,
+    )
+
+
+async def aget_anthropic_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    """Get reasoning from an Anthropic Claude model asynchronously."""
+    from agno.run.agent import RunOutput
+
+    try:
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    redacted_reasoning_content: Optional[str] = None
+
+    if reasoning_agent_response.messages is not None:
+        for msg in reasoning_agent_response.messages:
+            if msg.reasoning_content is not None:
+                reasoning_content = msg.reasoning_content
+            if hasattr(msg, "redacted_reasoning_content") and msg.redacted_reasoning_content is not None:
+                redacted_reasoning_content = msg.redacted_reasoning_content
+                break
+
+    return Message(
+        role="assistant",
+        content=f"<thinking>\n{reasoning_content}\n</thinking>",
+        reasoning_content=reasoning_content,
+        redacted_reasoning_content=redacted_reasoning_content,
+    )

agno/reasoning/gemini.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.utils.log import logger
+
+
+def is_gemini_reasoning_model(reasoning_model: Model) -> bool:
+    """Check if the model is a Gemini model with thinking support."""
+    is_gemini_class = reasoning_model.__class__.__name__ == "Gemini"
+    if not is_gemini_class:
+        return False
+
+    # Check if it's a Gemini 2.5+ model (supports thinking)
+    model_id = reasoning_model.id.lower()
+    has_thinking_support = "2.5" in model_id
+
+    # Also check if thinking parameters are set
+    # Note: thinking_budget=0 explicitly disables thinking mode per Google's API docs
+    has_thinking_budget = (
+        hasattr(reasoning_model, "thinking_budget")
+        and reasoning_model.thinking_budget is not None
+        and reasoning_model.thinking_budget > 0
+    )
+    has_include_thoughts = hasattr(reasoning_model, "include_thoughts") and reasoning_model.include_thoughts is not None
+
+    return is_gemini_class and (has_thinking_support or has_thinking_budget or has_include_thoughts)
+
+
+def get_gemini_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    """Get reasoning from a Gemini model."""
+    from agno.run.agent import RunOutput
+
+    try:
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    if reasoning_agent_response.messages is not None:
+        for msg in reasoning_agent_response.messages:
+            if msg.reasoning_content is not None:
+                reasoning_content = msg.reasoning_content
+                break
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )
+
+
+async def aget_gemini_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    """Get reasoning from a Gemini model asynchronously."""
+    from agno.run.agent import RunOutput
+
+    try:
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    if reasoning_agent_response.messages is not None:
+        for msg in reasoning_agent_response.messages:
+            if msg.reasoning_content is not None:
+                reasoning_content = msg.reasoning_content
+                break
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )

agno/reasoning/openai.py

@@ -28,6 +28,11 @@ def is_openai_reasoning_model(reasoning_model: Model) -> bool:
 def get_openai_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
     from agno.run.agent import RunOutput
 
+    # Update system message role to "system"
+    for message in messages:
+        if message.role == "developer":
+            message.role = "system"
+
     try:
         reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
     except Exception as e:

agno/reasoning/vertexai.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.utils.log import logger
+
+
+def is_vertexai_reasoning_model(reasoning_model: Model) -> bool:
+    """Check if the model is a VertexAI model with thinking support."""
+    # Check if provider is VertexAI
+    is_vertexai_provider = hasattr(reasoning_model, "provider") and reasoning_model.provider == "VertexAI"
+
+    # Check if thinking parameter is set
+    has_thinking = hasattr(reasoning_model, "thinking") and reasoning_model.thinking is not None
+
+    return is_vertexai_provider and has_thinking
+
+
+def get_vertexai_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    """Get reasoning from a VertexAI Claude model."""
+    from agno.run.agent import RunOutput
+
+    try:
+        reasoning_agent_response: RunOutput = reasoning_agent.run(input=messages)
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    redacted_reasoning_content: Optional[str] = None
+
+    if reasoning_agent_response.messages is not None:
+        for msg in reasoning_agent_response.messages:
+            if msg.reasoning_content is not None:
+                reasoning_content = msg.reasoning_content
+            if hasattr(msg, "redacted_reasoning_content") and msg.redacted_reasoning_content is not None:
+                redacted_reasoning_content = msg.redacted_reasoning_content
+                break
+
+    return Message(
+        role="assistant",
+        content=f"<thinking>\n{reasoning_content}\n</thinking>",
+        reasoning_content=reasoning_content,
+        redacted_reasoning_content=redacted_reasoning_content,
+    )
+
+
+async def aget_vertexai_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    """Get reasoning from a VertexAI Claude model asynchronously."""
+    from agno.run.agent import RunOutput
+
+    try:
+        reasoning_agent_response: RunOutput = await reasoning_agent.arun(input=messages)
+    except Exception as e:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    redacted_reasoning_content: Optional[str] = None
+
+    if reasoning_agent_response.messages is not None:
+        for msg in reasoning_agent_response.messages:
+            if msg.reasoning_content is not None:
+                reasoning_content = msg.reasoning_content
+            if hasattr(msg, "redacted_reasoning_content") and msg.redacted_reasoning_content is not None:
+                redacted_reasoning_content = msg.redacted_reasoning_content
+                break
+
+    return Message(
+        role="assistant",
+        content=f"<thinking>\n{reasoning_content}\n</thinking>",
+        reasoning_content=reasoning_content,
+        redacted_reasoning_content=redacted_reasoning_content,
+    )

agno/session/workflow.py

@@ -77,7 +77,7 @@ class WorkflowSession:
 
     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.
         """
@@ -88,7 +88,7 @@ class WorkflowSession:
 
         # 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:
@@ -116,7 +116,7 @@ class WorkflowSession:
 
     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.
         """