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

agno/playground/operator.py

@@ -1,92 +0,0 @@
-from typing import List, Optional
-
-from agno.agent.agent import Agent, AgentRun, Function, Toolkit
-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 format_tools(agent_tools):
-    formatted_tools = []
-    if agent_tools is not None:
-        for tool in agent_tools:
-            if isinstance(tool, dict):
-                formatted_tools.append(tool)
-            elif isinstance(tool, Toolkit):
-                for f_name, f in tool.functions.items():
-                    formatted_tools.append(f.to_dict())
-            elif isinstance(tool, Function):
-                formatted_tools.append(tool.to_dict())
-            elif callable(tool):
-                func = Function.from_callable(tool)
-                formatted_tools.append(func.to_dict())
-            else:
-                logger.warning(f"Unknown tool type: {type(tool)}")
-    return formatted_tools
-
-
-def get_agent_by_id(agent_id: str, agents: Optional[List[Agent]] = None) -> Optional[Agent]:
-    if agent_id is None or agents is None:
-        return None
-
-    for agent in agents:
-        if agent.agent_id == agent_id:
-            return agent
-    return None
-
-
-def get_session_title(session: AgentSession) -> str:
-    if session is None:
-        return "Unnamed session"
-    session_name = session.session_data.get("session_name") if session.session_data is not None else None
-    if session_name is not None:
-        return session_name
-    memory = session.memory
-    if memory is not None:
-        runs = memory.get("runs") or memory.get("chats")
-        if isinstance(runs, list):
-            for _run in runs:
-                try:
-                    run_parsed = AgentRun.model_validate(_run)
-                    if run_parsed.message is not None and run_parsed.message.role == "user":
-                        content = run_parsed.message.get_content_string()
-                        if content:
-                            return content
-                        else:
-                            return "No title"
-                except Exception as e:
-                    logger.error(f"Error parsing chat: {e}")
-    return "Unnamed session"
-
-
-def get_session_title_from_workflow_session(workflow_session: WorkflowSession) -> str:
-    if workflow_session is None:
-        return "Unnamed session"
-    session_name = (
-        workflow_session.session_data.get("session_name") if workflow_session.session_data is not None else None
-    )
-    if session_name is not None:
-        return session_name
-    memory = workflow_session.memory
-    if memory is not None:
-        runs = memory.get("runs")
-        if isinstance(runs, list):
-            for _run in runs:
-                try:
-                    response = _run.get("response")
-                    content = response.get("content") if response else None
-                    return content.split("\n")[0] if content else "No title"
-                except Exception as e:
-                    logger.error(f"Error parsing chat: {e}")
-    return "Unnamed session"
-
-
-def get_workflow_by_id(workflow_id: str, workflows: Optional[List[Workflow]] = None) -> Optional[Workflow]:
-    if workflows is None or workflow_id is None:
-        return None
-
-    for workflow in workflows:
-        if workflow.workflow_id == workflow_id:
-            return workflow
-    return None

agno/playground/playground.py

@@ -1,91 +0,0 @@
-from typing import List, Optional, Set
-
-from fastapi import FastAPI
-from fastapi.routing import APIRouter
-
-from agno.agent.agent import Agent
-from agno.api.playground import PlaygroundEndpointCreate, create_playground_endpoint
-from agno.playground.async_router import get_async_playground_router
-from agno.playground.settings import PlaygroundSettings
-from agno.playground.sync_router import get_sync_playground_router
-from agno.utils.log import logger
-from agno.workflow.workflow import Workflow
-
-
-class Playground:
-    def __init__(
-        self,
-        agents: Optional[List[Agent]] = None,
-        workflows: Optional[List[Workflow]] = None,
-        settings: Optional[PlaygroundSettings] = None,
-        api_app: Optional[FastAPI] = None,
-        router: Optional[APIRouter] = None,
-    ):
-        if not agents and not workflows:
-            raise ValueError("Either agents or workflows must be provided.")
-
-        self.agents: Optional[List[Agent]] = agents
-        self.workflows: Optional[List[Workflow]] = workflows
-        self.settings: PlaygroundSettings = settings or PlaygroundSettings()
-        self.api_app: Optional[FastAPI] = api_app
-        self.router: Optional[APIRouter] = router
-        self.endpoints_created: Set[str] = set()
-
-    def get_router(self) -> APIRouter:
-        return get_sync_playground_router(self.agents, self.workflows)
-
-    def get_async_router(self) -> APIRouter:
-        return get_async_playground_router(self.agents, self.workflows)
-
-    def get_app(self, use_async: bool = True, prefix: str = "/v1") -> FastAPI:
-        from starlette.middleware.cors import CORSMiddleware
-
-        if not self.api_app:
-            self.api_app = FastAPI(
-                title=self.settings.title,
-                docs_url="/docs" if self.settings.docs_enabled else None,
-                redoc_url="/redoc" if self.settings.docs_enabled else None,
-                openapi_url="/openapi.json" if self.settings.docs_enabled else None,
-            )
-
-        if not self.api_app:
-            raise Exception("API App could not be created.")
-
-        if not self.router:
-            self.router = APIRouter(prefix=prefix)
-
-        if not self.router:
-            raise Exception("API Router could not be created.")
-
-        if use_async:
-            self.router.include_router(self.get_async_router())
-        else:
-            self.router.include_router(self.get_router())
-        self.api_app.include_router(self.router)
-
-        self.api_app.add_middleware(
-            CORSMiddleware,
-            allow_origins=self.settings.cors_origin_list,
-            allow_credentials=True,
-            allow_methods=["*"],
-            allow_headers=["*"],
-            expose_headers=["*"],
-        )
-
-        return self.api_app
-
-    def create_endpoint(self, endpoint: str, prefix: str = "/v1") -> None:
-        if endpoint in self.endpoints_created:
-            return
-
-        try:
-            logger.info(f"Creating playground endpoint: {endpoint}")
-            create_playground_endpoint(
-                playground=PlaygroundEndpointCreate(endpoint=endpoint, playground_data={"prefix": prefix})
-            )
-        except Exception as e:
-            logger.error(f"Could not create playground endpoint: {e}")
-            logger.error("Please try again.")
-            return
-
-        self.endpoints_created.add(endpoint)

agno/playground/schemas.py

@@ -1,76 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-from fastapi import UploadFile
-from pydantic import BaseModel
-
-
-class AgentModel(BaseModel):
-    name: Optional[str] = None
-    model: Optional[str] = None
-    provider: Optional[str] = None
-
-
-class AgentGetResponse(BaseModel):
-    agent_id: str
-    name: Optional[str] = None
-    model: Optional[AgentModel] = None
-    add_context: Optional[bool] = None
-    tools: Optional[List[Dict[str, Any]]] = None
-    memory: Optional[Dict[str, Any]] = None
-    storage: Optional[Dict[str, Any]] = None
-    knowledge: Optional[Dict[str, Any]] = None
-    description: Optional[str] = None
-    instructions: Optional[List[str]] = None
-
-
-class AgentRunRequest(BaseModel):
-    message: str
-    agent_id: str
-    stream: bool = True
-    monitor: bool = False
-    session_id: Optional[str] = None
-    user_id: Optional[str] = None
-    files: Optional[List[UploadFile]] = None
-
-
-class AgentRenameRequest(BaseModel):
-    name: str
-    user_id: str
-
-
-class AgentSessionsResponse(BaseModel):
-    title: Optional[str] = None
-    session_id: Optional[str] = None
-    session_name: Optional[str] = None
-    created_at: Optional[int] = None
-
-
-class WorkflowRenameRequest(BaseModel):
-    name: str
-
-
-class WorkflowRunRequest(BaseModel):
-    input: Dict[str, Any]
-    user_id: Optional[str] = None
-    session_id: Optional[str] = None
-
-
-class WorkflowSessionResponse(BaseModel):
-    title: Optional[str] = None
-    session_id: Optional[str] = None
-    session_name: Optional[str] = None
-    created_at: Optional[int] = None
-
-
-class WorkflowGetResponse(BaseModel):
-    workflow_id: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    parameters: Optional[Dict[str, Any]] = None
-    storage: Optional[str] = None
-
-
-class WorkflowsGetResponse(BaseModel):
-    workflow_id: str
-    name: str
-    description: Optional[str] = None

agno/playground/serve.py

@@ -1,55 +0,0 @@
-from typing import Union
-from urllib.parse import quote
-
-from fastapi import FastAPI
-from rich import box
-from rich.panel import Panel
-
-from agno.api.playground import PlaygroundEndpointCreate, create_playground_endpoint
-from agno.cli.console import console
-from agno.cli.settings import agno_cli_settings
-from agno.utils.log import logger
-
-
-def serve_playground_app(
-    app: Union[str, FastAPI],
-    *,
-    scheme: str = "http",
-    host: str = "localhost",
-    port: int = 7777,
-    reload: bool = False,
-    prefix="/v1",
-    **kwargs,
-):
-    import uvicorn
-
-    try:
-        create_playground_endpoint(
-            playground=PlaygroundEndpointCreate(
-                endpoint=f"{scheme}://{host}:{port}", playground_data={"prefix": prefix}
-            ),
-        )
-    except Exception as e:
-        logger.error(f"Could not create playground endpoint: {e}")
-        logger.error("Please try again.")
-        return
-
-    logger.info(f"Starting playground on {scheme}://{host}:{port}")
-    # Encode the full endpoint (host:port)
-    encoded_endpoint = quote(f"{host}:{port}")
-
-    # Create a panel with the playground URL
-    url = f"{agno_cli_settings.playground_url}?endpoint={encoded_endpoint}"
-    panel = Panel(
-        f"[bold green]Playground URL:[/bold green] [link={url}]{url}[/link]",
-        title="Agent Playground",
-        expand=False,
-        border_style="cyan",
-        box=box.HEAVY,
-        padding=(2, 2),
-    )
-
-    # Print the panel
-    console.print(panel)
-
-    uvicorn.run(app=app, host=host, port=port, reload=reload, **kwargs)