agno 2.2.13__py3-none-any.whl

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/azure_ai_foundry.py

@@ -0,0 +1,67 @@
+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_ai_foundry_reasoning_model(reasoning_model: Model) -> bool:
+    return reasoning_model.__class__.__name__ == "AzureAIFoundry" and (
+        ("deepseek" in reasoning_model.id.lower())
+        or ("o1" in reasoning_model.id.lower())
+        or ("o3" in reasoning_model.id.lower())
+        or ("o4" in reasoning_model.id.lower())
+    )
+
+
+def get_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    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 = ""
+    # We use the normal content as no reasoning content is returned
+    if reasoning_agent_response.content is not None:
+        # Extract content between <think> tags if present
+        content = reasoning_agent_response.content
+        if "<think>" in content and "</think>" in content:
+            start_idx = content.find("<think>") + len("<think>")
+            end_idx = content.find("</think>")
+            reasoning_content = content[start_idx:end_idx].strip()
+        else:
+            reasoning_content = content
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )
+
+
+async def aget_ai_foundry_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    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.content is not None:
+        # Extract content between <think> tags if present
+        content = reasoning_agent_response.content
+        if "<think>" in content and "</think>" in content:
+            start_idx = content.find("<think>") + len("<think>")
+            end_idx = content.find("</think>")
+            reasoning_content = content[start_idx:end_idx].strip()
+        else:
+            reasoning_content = content
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )

agno/reasoning/deepseek.py

@@ -0,0 +1,63 @@
+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_deepseek_reasoning_model(reasoning_model: Model) -> bool:
+    return reasoning_model.__class__.__name__ == "DeepSeek" and reasoning_model.id.lower() == "deepseek-reasoner"
+
+
+def get_deepseek_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:
+        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_deepseek_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 = 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/default.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
+
+from agno.models.base import Model
+from agno.reasoning.step import ReasoningSteps
+from agno.tools import Toolkit
+from agno.tools.function import Function
+
+
+def get_default_reasoning_agent(
+    reasoning_model: Model,
+    min_steps: int,
+    max_steps: int,
+    tools: Optional[List[Union[Toolkit, Callable, Function, Dict]]] = None,
+    tool_call_limit: Optional[int] = None,
+    use_json_mode: bool = False,
+    telemetry: bool = True,
+    debug_mode: bool = False,
+    debug_level: Literal[1, 2] = 1,
+    session_state: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+) -> Optional["Agent"]:  # type: ignore  # noqa: F821
+    from agno.agent import Agent
+
+    agent = Agent(
+        model=reasoning_model,
+        description="You are a meticulous, thoughtful, and logical Reasoning Agent who solves complex problems through clear, structured, step-by-step analysis.",
+        instructions=dedent(f"""\
+        Step 1 - Problem Analysis:
+        - Restate the user's task clearly in your own words to ensure full comprehension.
+        - Identify explicitly what information is required and what tools or resources might be necessary.
+
+        Step 2 - Decompose and Strategize:
+        - Break down the problem into clearly defined subtasks.
+        - Develop at least two distinct strategies or approaches to solving the problem to ensure thoroughness.
+
+        Step 3 - Intent Clarification and Planning:
+        - Clearly articulate the user's intent behind their request.
+        - Select the most suitable strategy from Step 2, clearly justifying your choice based on alignment with the user's intent and task constraints.
+        - Formulate a detailed step-by-step action plan outlining the sequence of actions needed to solve the problem.
+
+        Step 4 - Execute the Action Plan:
+        For each planned step, document:
+        1. **Title**: Concise title summarizing the step.
+        2. **Action**: Explicitly state your next action in the first person ('I will...').
+        3. **Result**: Execute your action using necessary tools and provide a concise summary of the outcome.
+        4. **Reasoning**: Clearly explain your rationale, covering:
+            - Necessity: Why this action is required.
+            - Considerations: Highlight key considerations, potential challenges, and mitigation strategies.
+            - Progression: How this step logically follows from or builds upon previous actions.
+            - Assumptions: Explicitly state any assumptions made and justify their validity.
+        5. **Next Action**: Clearly select your next step from:
+            - **continue**: If further steps are needed.
+            - **validate**: When you reach a potential answer, signaling it's ready for validation.
+            - **final_answer**: Only if you have confidently validated the solution.
+            - **reset**: Immediately restart analysis if a critical error or incorrect result is identified.
+        6. **Confidence Score**: Provide a numeric confidence score (0.0–1.0) indicating your certainty in the step's correctness and its outcome.
+
+        Step 5 - Validation (mandatory before finalizing an answer):
+        - Explicitly validate your solution by:
+            - Cross-verifying with alternative approaches (developed in Step 2).
+            - Using additional available tools or methods to independently confirm accuracy.
+        - Clearly document validation results and reasoning behind the validation method chosen.
+        - If validation fails or discrepancies arise, explicitly identify errors, reset your analysis, and revise your plan accordingly.
+
+        Step 6 - Provide the Final Answer:
+        - Once thoroughly validated and confident, deliver your solution clearly and succinctly.
+        - Restate briefly how your answer addresses the user's original intent and resolves the stated task.
+
+        General Operational Guidelines:
+        - Ensure your analysis remains:
+            - **Complete**: Address all elements of the task.
+            - **Comprehensive**: Explore diverse perspectives and anticipate potential outcomes.
+            - **Logical**: Maintain coherence between all steps.
+            - **Actionable**: Present clearly implementable steps and actions.
+            - **Insightful**: Offer innovative and unique perspectives where applicable.
+        - Always explicitly handle errors and mistakes by resetting or revising steps immediately.
+        - Adhere strictly to a minimum of {min_steps} and maximum of {max_steps} steps to ensure effective task resolution.
+        - Execute necessary tools proactively and without hesitation, clearly documenting tool usage.
+        - Only create a single instance of ReasoningSteps for your response.\
+        """),
+        tools=tools,
+        tool_call_limit=tool_call_limit,
+        output_schema=ReasoningSteps,
+        use_json_mode=use_json_mode,
+        telemetry=telemetry,
+        debug_mode=debug_mode,
+        debug_level=debug_level,
+        session_state=session_state,
+        dependencies=dependencies,
+        metadata=metadata,
+    )
+
+    return agent

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/groq.py

@@ -0,0 +1,71 @@
+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_groq_reasoning_model(reasoning_model: Model) -> bool:
+    return reasoning_model.__class__.__name__ == "Groq" and "deepseek" in reasoning_model.id.lower()
+
+
+def get_groq_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:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    if reasoning_agent_response.content is not None:
+        # Extract content between <think> tags if present
+        content = reasoning_agent_response.content
+        if "<think>" in content and "</think>" in content:
+            start_idx = content.find("<think>") + len("<think>")
+            end_idx = content.find("</think>")
+            reasoning_content = content[start_idx:end_idx].strip()
+        else:
+            reasoning_content = content
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )
+
+
+async def aget_groq_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 = 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.content is not None:
+        # Extract content between <think> tags if present
+        content = reasoning_agent_response.content
+        if "<think>" in content and "</think>" in content:
+            start_idx = content.find("<think>") + len("<think>")
+            end_idx = content.find("</think>")
+            reasoning_content = content[start_idx:end_idx].strip()
+        else:
+            reasoning_content = content
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )

agno/reasoning/helpers.py

@@ -0,0 +1,63 @@
+from typing import Any, Dict, List, Literal, Optional
+
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.reasoning.step import NextAction, ReasoningStep
+from agno.run.messages import RunMessages
+from agno.utils.log import logger
+
+
+def get_reasoning_agent(
+    reasoning_model: Model,
+    telemetry: bool = False,
+    debug_mode: bool = False,
+    debug_level: Literal[1, 2] = 1,
+    session_state: Optional[Dict[str, Any]] = None,
+    dependencies: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+) -> "Agent":  # type: ignore  # noqa: F821
+    from agno.agent import Agent
+
+    return Agent(
+        model=reasoning_model,
+        telemetry=telemetry,
+        debug_mode=debug_mode,
+        debug_level=debug_level,
+        session_state=session_state,
+        dependencies=dependencies,
+        metadata=metadata,
+    )
+
+
+def get_next_action(reasoning_step: ReasoningStep) -> NextAction:
+    next_action = reasoning_step.next_action or NextAction.FINAL_ANSWER
+    if isinstance(next_action, str):
+        try:
+            return NextAction(next_action)
+        except ValueError:
+            logger.warning(f"Reasoning error. Invalid next action: {next_action}")
+            return NextAction.FINAL_ANSWER
+    return next_action
+
+
+def update_messages_with_reasoning(
+    run_messages: RunMessages,
+    reasoning_messages: List[Message],
+) -> None:
+    run_messages.messages.append(
+        Message(
+            role="assistant",
+            content="I have worked through this problem in-depth, running all necessary tools and have included my raw, step by step research. ",
+            add_to_agent_memory=False,
+        )
+    )
+    for message in reasoning_messages:
+        message.add_to_agent_memory = False
+    run_messages.messages.extend(reasoning_messages)
+    run_messages.messages.append(
+        Message(
+            role="assistant",
+            content="Now I will summarize my reasoning and provide a final answer. I will skip any tool calls already executed and steps that are not relevant to the final answer.",
+            add_to_agent_memory=False,
+        )
+    )

agno/reasoning/ollama.py

@@ -0,0 +1,67 @@
+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_ollama_reasoning_model(reasoning_model: Model) -> bool:
+    return reasoning_model.__class__.__name__ == "Ollama" and (
+        "qwq" in reasoning_model.id
+        or "deepseek-r1" in reasoning_model.id
+        or "qwen2.5-coder" in reasoning_model.id
+        or "openthinker" in reasoning_model.id
+    )
+
+
+def get_ollama_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    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 = ""
+    # We use the normal content as no reasoning content is returned
+    if reasoning_agent_response.content is not None:
+        # Extract content between <think> tags if present
+        content = reasoning_agent_response.content
+        if "<think>" in content and "</think>" in content:
+            start_idx = content.find("<think>") + len("<think>")
+            end_idx = content.find("</think>")
+            reasoning_content = content[start_idx:end_idx].strip()
+        else:
+            reasoning_content = content
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )
+
+
+async def aget_ollama_reasoning(reasoning_agent: "Agent", messages: List[Message]) -> Optional[Message]:  # type: ignore  # noqa: F821
+    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.content is not None:
+        # Extract content between <think> tags if present
+        content = reasoning_agent_response.content
+        if "<think>" in content and "</think>" in content:
+            start_idx = content.find("<think>") + len("<think>")
+            end_idx = content.find("</think>")
+            reasoning_content = content[start_idx:end_idx].strip()
+        else:
+            reasoning_content = content
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )

agno/reasoning/openai.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.models.openai.like import OpenAILike
+from agno.utils.log import logger
+
+
+def is_openai_reasoning_model(reasoning_model: Model) -> bool:
+    return (
+        (
+            reasoning_model.__class__.__name__ == "OpenAIChat"
+            or reasoning_model.__class__.__name__ == "OpenAIResponses"
+            or reasoning_model.__class__.__name__ == "AzureOpenAI"
+        )
+        and (
+            ("o4" in reasoning_model.id)
+            or ("o3" in reasoning_model.id)
+            or ("o1" in reasoning_model.id)
+            or ("4.1" in reasoning_model.id)
+            or ("4.5" in reasoning_model.id)
+        )
+    ) or (isinstance(reasoning_model, OpenAILike) and "deepseek-r1" in reasoning_model.id.lower())
+
+
+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:
+        logger.warning(f"Reasoning error: {e}")
+        return None
+
+    reasoning_content: str = ""
+    # We use the normal content as no reasoning content is returned
+    if reasoning_agent_response.content is not None:
+        # Extract content between <think> tags if present
+        content = reasoning_agent_response.content
+        if "<think>" in content and "</think>" in content:
+            start_idx = content.find("<think>") + len("<think>")
+            end_idx = content.find("</think>")
+            reasoning_content = content[start_idx:end_idx].strip()
+        else:
+            reasoning_content = content
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )
+
+
+async def aget_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 = 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.content is not None:
+        # Extract content between <think> tags if present
+        content = reasoning_agent_response.content
+        if "<think>" in content and "</think>" in content:
+            start_idx = content.find("<think>") + len("<think>")
+            end_idx = content.find("</think>")
+            reasoning_content = content[start_idx:end_idx].strip()
+        else:
+            reasoning_content = content
+
+    return Message(
+        role="assistant", content=f"<thinking>\n{reasoning_content}\n</thinking>", reasoning_content=reasoning_content
+    )