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

agno/playground/sync_router.py

@@ -1,405 +0,0 @@
-import json
-from dataclasses import asdict
-from io import BytesIO
-from typing import Generator, List, Optional, cast
-
-from fastapi import APIRouter, File, Form, HTTPException, Query, UploadFile
-from fastapi.responses import JSONResponse, StreamingResponse
-
-from agno.agent.agent import Agent, RunResponse
-from agno.media import Image
-from agno.playground.operator import (
-    format_tools,
-    get_agent_by_id,
-    get_session_title,
-    get_session_title_from_workflow_session,
-    get_workflow_by_id,
-)
-from agno.playground.schemas import (
-    AgentGetResponse,
-    AgentModel,
-    AgentRenameRequest,
-    AgentSessionsResponse,
-    WorkflowGetResponse,
-    WorkflowRenameRequest,
-    WorkflowRunRequest,
-    WorkflowSessionResponse,
-    WorkflowsGetResponse,
-)
-from agno.storage.agent.session import AgentSession
-from agno.storage.workflow.session import WorkflowSession
-from agno.utils.log import logger
-from agno.workflow.workflow import Workflow
-
-
-def get_sync_playground_router(
-    agents: Optional[List[Agent]] = None, workflows: Optional[List[Workflow]] = None
-) -> APIRouter:
-    playground_router = APIRouter(prefix="/playground", tags=["Playground"])
-    if agents is None and workflows is None:
-        raise ValueError("Either agents or workflows must be provided.")
-
-    @playground_router.get("/status")
-    def playground_status():
-        return {"playground": "available"}
-
-    @playground_router.get("/agents", response_model=List[AgentGetResponse])
-    def get_agents():
-        agent_list: List[AgentGetResponse] = []
-        if agents is None:
-            return agent_list
-
-        for agent in agents:
-            agent_tools = agent.get_tools()
-            formatted_tools = format_tools(agent_tools)
-
-            name = agent.model.name or agent.model.__class__.__name__ if agent.model else None
-            provider = agent.model.provider or agent.model.__class__.__name__ if agent.model else None
-            model_id = agent.model.id if agent.model else None
-
-            if provider and model_id:
-                provider = f"{provider} {model_id}"
-            elif name and model_id:
-                provider = f"{name} {model_id}"
-            elif model_id:
-                provider = model_id
-            else:
-                provider = ""
-
-            agent_list.append(
-                AgentGetResponse(
-                    agent_id=agent.agent_id,
-                    name=agent.name,
-                    model=AgentModel(
-                        name=name,
-                        model=model_id,
-                        provider=provider,
-                    ),
-                    add_context=agent.add_context,
-                    tools=formatted_tools,
-                    memory={"name": agent.memory.db.__class__.__name__} if agent.memory and agent.memory.db else None,
-                    storage={"name": agent.storage.__class__.__name__} if agent.storage else None,
-                    knowledge={"name": agent.knowledge.__class__.__name__} if agent.knowledge else None,
-                    description=agent.description,
-                    instructions=agent.instructions,
-                )
-            )
-
-        return agent_list
-
-    def chat_response_streamer(agent: Agent, message: str, images: Optional[List[Image]] = None) -> Generator:
-        run_response = agent.run(message=message, images=images, stream=True, stream_intermediate_steps=True)
-        for run_response_chunk in run_response:
-            run_response_chunk = cast(RunResponse, run_response_chunk)
-            yield run_response_chunk.to_json()
-
-    def process_image(file: UploadFile) -> Image:
-        content = file.file.read()
-
-        return Image(content=content)
-
-    @playground_router.post("/agents/{agent_id}/runs")
-    def create_agent_run(
-        agent_id: str,
-        message: str = Form(...),
-        stream: bool = Form(True),
-        monitor: bool = Form(False),
-        session_id: Optional[str] = Form(None),
-        user_id: Optional[str] = Form(None),
-        files: Optional[List[UploadFile]] = File(None),
-        image: Optional[UploadFile] = File(None),
-    ):
-        logger.debug(f"AgentRunRequest: {message} {agent_id} {stream} {monitor} {session_id} {user_id} {files}")
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            raise HTTPException(status_code=404, detail="Agent not found")
-
-        if files:
-            if agent.knowledge is None:
-                raise HTTPException(status_code=404, detail="KnowledgeBase not found")
-
-        if session_id is not None:
-            logger.debug(f"Continuing session: {session_id}")
-        else:
-            logger.debug("Creating new session")
-
-        # Create a new instance of this agent
-        new_agent_instance = agent.deep_copy(update={"session_id": session_id})
-        new_agent_instance.session_name = None
-
-        if user_id is not None:
-            new_agent_instance.user_id = user_id
-
-        if monitor:
-            new_agent_instance.monitoring = True
-        else:
-            new_agent_instance.monitoring = False
-
-        base64_image: Optional[Image] = None
-        if image:
-            base64_image = process_image(image)
-
-        if files:
-            for file in files:
-                if file.content_type == "application/pdf":
-                    from agno.document.reader.pdf_reader import PDFReader
-
-                    contents = file.file.read()
-                    pdf_file = BytesIO(contents)
-                    pdf_file.name = file.filename
-                    file_content = PDFReader().read(pdf_file)
-                    if agent.knowledge is not None:
-                        agent.knowledge.load_documents(file_content)
-                elif file.content_type == "text/csv":
-                    from agno.document.reader.csv_reader import CSVReader
-
-                    contents = file.file.read()
-                    csv_file = BytesIO(contents)
-                    csv_file.name = file.filename
-                    file_content = CSVReader().read(csv_file)
-                    if agent.knowledge is not None:
-                        agent.knowledge.load_documents(file_content)
-                elif file.content_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
-                    from agno.document.reader.docx_reader import DocxReader
-
-                    contents = file.file.read()
-                    docx_file = BytesIO(contents)
-                    docx_file.name = file.filename
-                    file_content = DocxReader().read(docx_file)
-                    if agent.knowledge is not None:
-                        agent.knowledge.load_documents(file_content)
-                elif file.content_type == "text/plain":
-                    from agno.document.reader.text_reader import TextReader
-
-                    contents = file.file.read()
-                    text_file = BytesIO(contents)
-                    text_file.name = file.filename
-                    file_content = TextReader().read(text_file)
-                    if agent.knowledge is not None:
-                        agent.knowledge.load_documents(file_content)
-                else:
-                    raise HTTPException(status_code=400, detail="Unsupported file type")
-
-        if stream:
-            return StreamingResponse(
-                chat_response_streamer(new_agent_instance, message, images=[base64_image] if base64_image else None),
-                media_type="text/event-stream",
-            )
-        else:
-            run_response = cast(
-                RunResponse,
-                new_agent_instance.run(
-                    message,
-                    images=[base64_image] if base64_image else None,
-                    stream=False,
-                ),
-            )
-            return run_response
-
-    @playground_router.get("/agents/{agent_id}/sessions")
-    def get_user_agent_sessions(agent_id: str, user_id: str = Query(..., min_length=1)):
-        logger.debug(f"AgentSessionsRequest: {agent_id} {user_id}")
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            return JSONResponse(status_code=404, content="Agent not found.")
-
-        if agent.storage is None:
-            return JSONResponse(status_code=404, content="Agent does not have storage enabled.")
-
-        agent_sessions: List[AgentSessionsResponse] = []
-        all_agent_sessions: List[AgentSession] = agent.storage.get_all_sessions(user_id=user_id)
-        for session in all_agent_sessions:
-            title = get_session_title(session)
-            agent_sessions.append(
-                AgentSessionsResponse(
-                    title=title,
-                    session_id=session.session_id,
-                    session_name=session.session_data.get("session_name") if session.session_data else None,
-                    created_at=session.created_at,
-                )
-            )
-        return agent_sessions
-
-    @playground_router.get("/agents/{agent_id}/sessions/{session_id}")
-    def get_user_agent_session(agent_id: str, session_id: str, user_id: str = Query(..., min_length=1)):
-        logger.debug(f"AgentSessionsRequest: {agent_id} {user_id} {session_id}")
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            return JSONResponse(status_code=404, content="Agent not found.")
-
-        if agent.storage is None:
-            return JSONResponse(status_code=404, content="Agent does not have storage enabled.")
-
-        agent_session: Optional[AgentSession] = agent.storage.read(session_id)
-        if agent_session is None:
-            return JSONResponse(status_code=404, content="Session not found.")
-
-        return agent_session
-
-    @playground_router.post("/agents/{agent_id}/sessions/{session_id}/rename")
-    def rename_agent_session(agent_id: str, session_id: str, body: AgentRenameRequest):
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            return JSONResponse(status_code=404, content=f"couldn't find agent with {agent_id}")
-
-        if agent.storage is None:
-            return JSONResponse(status_code=404, content="Agent does not have storage enabled.")
-
-        all_agent_sessions: List[AgentSession] = agent.storage.get_all_sessions(user_id=body.user_id)
-        for session in all_agent_sessions:
-            if session.session_id == session_id:
-                agent.session_id = session_id
-                agent.rename_session(body.name)
-                return JSONResponse(content={"message": f"successfully renamed agent {agent.name}"})
-
-        return JSONResponse(status_code=404, content="Session not found.")
-
-    @playground_router.delete("/agents/{agent_id}/sessions/{session_id}")
-    def delete_agent_session(agent_id: str, session_id: str, user_id: str = Query(..., min_length=1)):
-        agent = get_agent_by_id(agent_id, agents)
-        if agent is None:
-            return JSONResponse(status_code=404, content="Agent not found.")
-
-        if agent.storage is None:
-            return JSONResponse(status_code=404, content="Agent does not have storage enabled.")
-
-        all_agent_sessions: List[AgentSession] = agent.storage.get_all_sessions(user_id=user_id)
-        for session in all_agent_sessions:
-            if session.session_id == session_id:
-                agent.delete_session(session_id)
-                return JSONResponse(content={"message": f"successfully deleted agent {agent.name}"})
-
-        return JSONResponse(status_code=404, content="Session not found.")
-
-    @playground_router.get("/workflows", response_model=List[WorkflowsGetResponse])
-    def get_workflows():
-        if workflows is None:
-            return []
-
-        return [
-            WorkflowsGetResponse(
-                workflow_id=str(workflow.workflow_id),
-                name=workflow.name,
-                description=workflow.description,
-            )
-            for workflow in workflows
-        ]
-
-    @playground_router.get("/workflows/{workflow_id}", response_model=WorkflowGetResponse)
-    def get_workflow(workflow_id: str):
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        return WorkflowGetResponse(
-            workflow_id=workflow.workflow_id,
-            name=workflow.name,
-            description=workflow.description,
-            parameters=workflow._run_parameters or {},
-            storage=workflow.storage.__class__.__name__ if workflow.storage else None,
-        )
-
-    @playground_router.post("/workflows/{workflow_id}/runs")
-    def create_workflow_run(workflow_id: str, body: WorkflowRunRequest):
-        # Retrieve the workflow by ID
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        # Create a new instance of this workflow
-        new_workflow_instance = workflow.deep_copy(update={"workflow_id": workflow_id})
-        new_workflow_instance.user_id = body.user_id
-        new_workflow_instance.session_name = None
-
-        # Return based on the response type
-        try:
-            if new_workflow_instance._run_return_type == "RunResponse":
-                # Return as a normal response
-                return new_workflow_instance.run(**body.input)
-            else:
-                # Return as a streaming response
-                return StreamingResponse(
-                    (json.dumps(asdict(result)) for result in new_workflow_instance.run(**body.input)),
-                    media_type="text/event-stream",
-                )
-        except Exception as e:
-            # Handle unexpected runtime errors
-            raise HTTPException(status_code=500, detail=f"Error running workflow: {str(e)}")
-
-    @playground_router.get("/workflows/{workflow_id}/sessions", response_model=List[WorkflowSessionResponse])
-    def get_all_workflow_sessions(workflow_id: str, user_id: str = Query(..., min_length=1)):
-        # Retrieve the workflow by ID
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if not workflow:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        # Ensure storage is enabled for the workflow
-        if not workflow.storage:
-            raise HTTPException(status_code=404, detail="Workflow does not have storage enabled")
-
-        # Retrieve all sessions for the given workflow and user
-        try:
-            all_workflow_sessions: List[WorkflowSession] = workflow.storage.get_all_sessions(
-                user_id=user_id, workflow_id=workflow_id
-            )
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Error retrieving sessions: {str(e)}")
-
-        # Return the sessions
-        return [
-            WorkflowSessionResponse(
-                title=get_session_title_from_workflow_session(session),
-                session_id=session.session_id,
-                session_name=session.session_data.get("session_name") if session.session_data else None,
-                created_at=session.created_at,
-            )
-            for session in all_workflow_sessions
-        ]
-
-    @playground_router.get("/workflows/{workflow_id}/sessions/{session_id}", response_model=WorkflowSession)
-    def get_workflow_session(workflow_id: str, session_id: str, user_id: str = Query(..., min_length=1)):
-        # Retrieve the workflow by ID
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if not workflow:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        # Ensure storage is enabled for the workflow
-        if not workflow.storage:
-            raise HTTPException(status_code=404, detail="Workflow does not have storage enabled")
-
-        # Retrieve the specific session
-        try:
-            workflow_session: Optional[WorkflowSession] = workflow.storage.read(session_id, user_id)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Error retrieving session: {str(e)}")
-
-        if not workflow_session:
-            raise HTTPException(status_code=404, detail="Session not found")
-
-        # Return the session
-        return workflow_session
-
-    @playground_router.post("/workflows/{workflow_id}/sessions/{session_id}/rename")
-    def rename_workflow_session(
-        workflow_id: str,
-        session_id: str,
-        body: WorkflowRenameRequest,
-    ):
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        workflow.session_id = session_id
-        workflow.rename_session(body.name)
-        return JSONResponse(content={"message": f"successfully renamed workflow {workflow.name}"})
-
-    @playground_router.delete("/workflows/{workflow_id}/sessions/{session_id}")
-    def delete_workflow_session(workflow_id: str, session_id: str):
-        workflow = get_workflow_by_id(workflow_id, workflows)
-        if workflow is None:
-            raise HTTPException(status_code=404, detail="Workflow not found")
-
-        workflow.delete_session(session_id)
-        return JSONResponse(content={"message": f"successfully deleted workflow {workflow.name}"})
-
-    return playground_router

agno/reasoning/agent.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-from typing import Callable, Dict, List, Optional, Union
-
-from agno.models.base import Model
-from agno.reasoning.step import ReasoningSteps
-from agno.tools.function import Function
-from agno.tools.toolkit import Toolkit
-
-
-def get_reasoning_agent(
-    reasoning_model: Model,
-    min_steps: int,
-    max_steps: int,
-    tools: Optional[List[Union[Toolkit, Callable, Function, Dict]]] = None,
-    structured_outputs: bool = False,
-    monitoring: bool = False,
-) -> Optional["Agent"]:  # type: ignore  # noqa: F821
-    from agno.agent import Agent
-
-    return Agent(
-        model=reasoning_model,
-        description="You are a meticulous and thoughtful assistant that solves a problem by thinking through it step-by-step.",
-        instructions=[
-            "First - Carefully analyze the task by spelling it out loud.",
-            "Then, break down the problem by thinking through it step by step and develop multiple strategies to solve the problem."
-            "Then, examine the users intent develop a step by step plan to solve the problem.",
-            "Work through your plan step-by-step, executing any tools as needed. For each step, provide:\n"
-            "  1. Title: A clear, concise title that encapsulates the step's main focus or objective.\n"
-            "  2. Action: Describe the action you will take in the first person (e.g., 'I will...').\n"
-            "  3. Result: Execute the action by running any necessary tools or providing an answer. Summarize the outcome.\n"
-            "  4. Reasoning: Explain the logic behind this step in the first person, including:\n"
-            "     - Necessity: Why this action is necessary.\n"
-            "     - Considerations: Key considerations and potential challenges.\n"
-            "     - Progression: How it builds upon previous steps (if applicable).\n"
-            "     - Assumptions: Any assumptions made and their justifications.\n"
-            "  5. Next Action: Decide on the next step:\n"
-            "     - continue: If more steps are needed to reach an answer.\n"
-            "     - validate: If you have reached an answer and should validate the result.\n"
-            "     - final_answer: If the answer is validated and is the final answer.\n"
-            "     Note: you must always validate the answer before providing the final answer.\n"
-            "  6. Confidence score: A score from 0.0 to 1.0 reflecting your certainty about the action and its outcome.",
-            "Handling Next Actions:\n"
-            "  - If next_action is continue, proceed to the next step in your analysis.\n"
-            "  - If next_action is validate, validate the result and provide the final answer.\n"
-            "  - If next_action is final_answer, stop reasoning.",
-            "Remember - If next_action is validate, you must validate your result\n"
-            "  - Ensure the answer resolves the original request.\n"
-            "  - Validate your result using any necessary tools or methods.\n"
-            "  - If there is another method to solve the task, use that to validate the result.\n"
-            "Ensure your analysis is:\n"
-            "  - Complete: Validate results and run all necessary tools.\n"
-            "  - Comprehensive: Consider multiple angles and potential outcomes.\n"
-            "  - Logical: Ensure each step coherently follows from the previous one.\n"
-            "  - Actionable: Provide clear, implementable steps or solutions.\n"
-            "  - Insightful: Offer unique perspectives or innovative approaches when appropriate.",
-            "Additional Guidelines:\n"
-            "  - Remember to run any tools you need to solve the problem.\n"
-            f"  - Take at least {min_steps} steps to solve the problem.\n"
-            "  - If you have all the information you need, provide the final answer.\n"
-            "  - IMPORTANT: IF AT ANY TIME THE RESULT IS WRONG, RESET AND START OVER.",
-        ],
-        tools=tools,
-        show_tool_calls=False,
-        response_model=ReasoningSteps,
-        structured_outputs=structured_outputs,
-        monitoring=monitoring,
-    )

agno/run/response.py

@@ -1,112 +0,0 @@
-from dataclasses import asdict, dataclass, field
-from enum import Enum
-from time import time
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel
-
-from agno.media import AudioArtifact, AudioOutput, ImageArtifact, VideoArtifact
-from agno.models.message import Message, MessageReferences
-from agno.reasoning.step import ReasoningStep
-
-
-class RunEvent(str, Enum):
-    """Events that can be sent by the run() functions"""
-
-    run_started = "RunStarted"
-    run_response = "RunResponse"
-    run_completed = "RunCompleted"
-    tool_call_started = "ToolCallStarted"
-    tool_call_completed = "ToolCallCompleted"
-    reasoning_started = "ReasoningStarted"
-    reasoning_step = "ReasoningStep"
-    reasoning_completed = "ReasoningCompleted"
-    updating_memory = "UpdatingMemory"
-    workflow_started = "WorkflowStarted"
-    workflow_completed = "WorkflowCompleted"
-
-
-@dataclass
-class RunResponseExtraData:
-    references: Optional[List[MessageReferences]] = None
-    add_messages: Optional[List[Message]] = None
-    history: Optional[List[Message]] = None
-    reasoning_steps: Optional[List[ReasoningStep]] = None
-    reasoning_messages: Optional[List[Message]] = None
-
-    def to_dict(self) -> Dict[str, Any]:
-        _dict = {}
-        if self.add_messages is not None:
-            _dict["add_messages"] = [m.to_dict() for m in self.add_messages]
-        if self.history is not None:
-            _dict["history"] = [m.to_dict() for m in self.history]
-        if self.reasoning_messages is not None:
-            _dict["reasoning_messages"] = [m.to_dict() for m in self.reasoning_messages]
-        if self.reasoning_steps is not None:
-            _dict["reasoning_steps"] = [rs.model_dump() for rs in self.reasoning_steps]
-        if self.references is not None:
-            _dict["references"] = [r.model_dump() for r in self.references]
-        return _dict
-
-
-@dataclass
-class RunResponse:
-    """Response returned by Agent.run() or Workflow.run() functions"""
-
-    content: Optional[Any] = None
-    content_type: str = "str"
-    event: str = RunEvent.run_response.value
-    messages: Optional[List[Message]] = None
-    metrics: Optional[Dict[str, Any]] = None
-    model: Optional[str] = None
-    run_id: Optional[str] = None
-    agent_id: Optional[str] = None
-    session_id: Optional[str] = None
-    workflow_id: Optional[str] = None
-    tools: Optional[List[Dict[str, Any]]] = None
-    images: Optional[List[ImageArtifact]] = None  # Images attached to the response
-    videos: Optional[List[VideoArtifact]] = None  # Videos attached to the response
-    audio: Optional[List[AudioArtifact]] = None  # AudioArtifact attached to the response
-    response_audio: Optional[AudioOutput] = None  # Model audio response
-    extra_data: Optional[RunResponseExtraData] = None
-    created_at: int = field(default_factory=lambda: int(time()))
-
-    def to_dict(self) -> Dict[str, Any]:
-        _dict = {k: v for k, v in asdict(self).items() if v is not None and k != "messages"}
-        if self.messages is not None:
-            _dict["messages"] = [m.to_dict() for m in self.messages]
-
-        if self.extra_data is not None:
-            _dict["extra_data"] = self.extra_data.to_dict()
-
-        if self.images is not None:
-            _dict["images"] = [img.model_dump() for img in self.images]
-
-        if self.videos is not None:
-            _dict["videos"] = [vid.model_dump() for vid in self.videos]
-
-        if self.audio is not None:
-            _dict["audio"] = [aud.model_dump() for aud in self.audio]
-
-        if isinstance(self.content, BaseModel):
-            _dict["content"] = self.content.model_dump(exclude_none=True)
-        return _dict
-
-    def to_json(self) -> str:
-        import json
-
-        _dict = self.to_dict()
-
-        return json.dumps(_dict, indent=2)
-
-    def get_content_as_string(self, **kwargs) -> str:
-        import json
-
-        from pydantic import BaseModel
-
-        if isinstance(self.content, str):
-            return self.content
-        elif isinstance(self.content, BaseModel):
-            return self.content.model_dump_json(exclude_none=True, **kwargs)
-        else:
-            return json.dumps(self.content, **kwargs)

agno/storage/agent/base.py

@@ -1,38 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Optional
-
-from agno.storage.agent.session import AgentSession
-
-
-class AgentStorage(ABC):
-    @abstractmethod
-    def create(self) -> None:
-        raise NotImplementedError
-
-    @abstractmethod
-    def read(self, session_id: str, user_id: Optional[str] = None) -> Optional[AgentSession]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_all_session_ids(self, user_id: Optional[str] = None, agent_id: Optional[str] = None) -> List[str]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_all_sessions(self, user_id: Optional[str] = None, agent_id: Optional[str] = None) -> List[AgentSession]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def upsert(self, session: AgentSession) -> Optional[AgentSession]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def delete_session(self, session_id: Optional[str] = None):
-        raise NotImplementedError
-
-    @abstractmethod
-    def drop(self) -> None:
-        raise NotImplementedError
-
-    @abstractmethod
-    def upgrade_schema(self) -> None:
-        raise NotImplementedError