agno 2.0.0rc1__py3-none-any.whl → 2.0.1__py3-none-any.whl

agno/models/base.py

@@ -21,11 +21,11 @@ from uuid import uuid4
 from pydantic import BaseModel
 
 from agno.exceptions import AgentRunException
-from agno.media import Audio, AudioArtifact, AudioResponse, Image, ImageArtifact, Video, VideoArtifact
+from agno.media import Audio, Image, Video
 from agno.models.message import Citations, Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse, ModelResponseEvent, ToolExecution
-from agno.run.agent import RunContentEvent, RunOutput, RunOutputEvent
+from agno.run.agent import CustomEvent, RunContentEvent, RunOutput, RunOutputEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunOutputEvent
 from agno.tools.function import Function, FunctionCall, FunctionExecutionResult, UserInputField
@@ -43,9 +43,9 @@ class MessageData:
     response_citations: Optional[Citations] = None
     response_tool_calls: List[Dict[str, Any]] = field(default_factory=list)
 
-    response_audio: Optional[AudioResponse] = None
-    response_image: Optional[ImageArtifact] = None
-    response_video: Optional[VideoArtifact] = None
+    response_audio: Optional[Audio] = None
+    response_image: Optional[Image] = None
+    response_video: Optional[Video] = None
 
     # Data from the provider that we might need on subsequent messages
     response_provider_data: Optional[Dict[str, Any]] = None
@@ -502,9 +502,7 @@ class Model(ABC):
         if assistant_message.citations is not None:
             model_response.citations = assistant_message.citations
         if assistant_message.audio_output is not None:
-            if isinstance(assistant_message.audio_output, AudioArtifact):
-                model_response.audios = [assistant_message.audio_output]
-            elif isinstance(assistant_message.audio_output, AudioResponse):
+            if isinstance(assistant_message.audio_output, Audio):
                 model_response.audio = assistant_message.audio_output
         if assistant_message.image_output is not None:
             model_response.images = [assistant_message.image_output]
@@ -557,9 +555,7 @@ class Model(ABC):
         if assistant_message.citations is not None:
             model_response.citations = assistant_message.citations
         if assistant_message.audio_output is not None:
-            if isinstance(assistant_message.audio_output, AudioArtifact):
-                model_response.audios = [assistant_message.audio_output]
-            elif isinstance(assistant_message.audio_output, AudioResponse):
+            if isinstance(assistant_message.audio_output, Audio):
                 model_response.audio = assistant_message.audio_output
         if assistant_message.image_output is not None:
             model_response.images = [assistant_message.image_output]
@@ -993,13 +989,13 @@ class Model(ABC):
             stream_data.response_tool_calls.extend(model_response_delta.tool_calls)
             should_yield = True
 
-        if model_response_delta.audio is not None and isinstance(model_response_delta.audio, AudioResponse):
+        if model_response_delta.audio is not None and isinstance(model_response_delta.audio, Audio):
             if stream_data.response_audio is None:
-                stream_data.response_audio = AudioResponse(id=str(uuid4()), content="", transcript="")
+                stream_data.response_audio = Audio(id=str(uuid4()), content="", transcript="")
 
             from typing import cast
 
-            audio_response = cast(AudioResponse, model_response_delta.audio)
+            audio_response = cast(Audio, model_response_delta.audio)
 
             # Update the stream data with audio information
             if audio_response.id is not None:
@@ -1104,41 +1100,10 @@ class Model(ABC):
         audios = None
 
         if success and function_execution_result:
-            # Convert ImageArtifacts to Images for message compatibility
-            if function_execution_result.images:
-                from agno.media import Image
-
-                images = []
-                for img_artifact in function_execution_result.images:
-                    if img_artifact.url:
-                        images.append(Image(url=img_artifact.url))
-                    elif img_artifact.content:
-                        images.append(Image(content=img_artifact.content))
-
-            # Convert VideoArtifacts to Videos for message compatibility
-            if function_execution_result.videos:
-                from agno.media import Video
-
-                videos = []
-                for vid_artifact in function_execution_result.videos:
-                    if vid_artifact.url:
-                        videos.append(Video(url=vid_artifact.url))
-                    elif vid_artifact.content:
-                        videos.append(Video(content=vid_artifact.content))
-
-            # Convert AudioArtifacts to Audio for message compatibility
-            if function_execution_result.audios:
-                from agno.media import Audio
-
-                audios = []
-                for aud_artifact in function_execution_result.audios:
-                    if aud_artifact.url:
-                        audios.append(Audio(url=aud_artifact.url))
-                    elif aud_artifact.base64_audio:
-                        import base64
-
-                        audio_bytes = base64.b64decode(aud_artifact.base64_audio)
-                        audios.append(Audio(content=audio_bytes))
+            # With unified classes, no conversion needed - use directly
+            images = function_execution_result.images
+            videos = function_execution_result.videos
+            audios = function_execution_result.audios
 
         return Message(
             role=self.tool_message_role,
@@ -1223,6 +1188,9 @@ class Model(ABC):
                         if function_call.function.show_result:
                             yield ModelResponse(content=item.content)
 
+                        if isinstance(item, CustomEvent):
+                            function_call_output += str(item)
+
                     # Yield the event itself to bubble it up
                     yield item
 
@@ -1389,7 +1357,7 @@ class Model(ABC):
     async def arun_function_call(
         self,
         function_call: FunctionCall,
-    ) -> Tuple[Union[bool, AgentRunException], Timer, FunctionCall, Optional[Dict[str, Any]]]:
+    ) -> Tuple[Union[bool, AgentRunException], Timer, FunctionCall, FunctionExecutionResult]:
         """Run a single function call and return its success status, timer, and the FunctionCall object."""
         from inspect import isasyncgenfunction, iscoroutine, iscoroutinefunction
 
@@ -1423,7 +1391,7 @@ class Model(ABC):
             raise e
 
         function_call_timer.stop()
-        return success, function_call_timer, function_call, result.updated_session_state
+        return success, function_call_timer, function_call, result
 
     async def arun_function_calls(
         self,
@@ -1569,7 +1537,9 @@ class Model(ABC):
                 raise result
 
             # Unpack result
-            function_call_success, function_call_timer, function_call, updated_session_state = result
+            function_call_success, function_call_timer, function_call, function_execution_result = result
+
+            updated_session_state = function_execution_result.updated_session_state
 
             # Handle AgentRunException
             if isinstance(function_call_success, AgentRunException):
@@ -1623,20 +1593,43 @@ class Model(ABC):
                                 yield ModelResponse(content=item.content)
                                 continue
 
+                            if isinstance(item, CustomEvent):
+                                function_call_output += str(item)
+
                         # Yield the event itself to bubble it up
                         yield item
+
+                    # Yield custom events emitted by the tool
                     else:
                         function_call_output += str(item)
                         if function_call.function.show_result:
                             yield ModelResponse(content=str(item))
             else:
-                function_call_output = str(function_call.result)
+                from agno.tools.function import ToolResult
+
+                if isinstance(function_execution_result.result, ToolResult):
+                    tool_result = function_execution_result.result
+                    function_call_output = tool_result.content
+
+                    if tool_result.images:
+                        function_execution_result.images = tool_result.images
+                    if tool_result.videos:
+                        function_execution_result.videos = tool_result.videos
+                    if tool_result.audios:
+                        function_execution_result.audios = tool_result.audios
+                else:
+                    function_call_output = str(function_call.result)
+
                 if function_call.function.show_result:
                     yield ModelResponse(content=function_call_output)
 
             # Create and yield function call result
             function_call_result = self.create_function_call_result(
-                function_call, success=function_call_success, output=function_call_output, timer=function_call_timer
+                function_call,
+                success=function_call_success,
+                output=function_call_output,
+                timer=function_call_timer,
+                function_execution_result=function_execution_result,
             )
             yield ModelResponse(
                 content=f"{function_call.get_call_str()} completed in {function_call_timer.elapsed:.4f}s.",
@@ -1653,6 +1646,9 @@ class Model(ABC):
                 ],
                 event=ModelResponseEvent.tool_call_completed.value,
                 updated_session_state=updated_session_state,
+                images=function_execution_result.images,
+                videos=function_execution_result.videos,
+                audios=function_execution_result.audios,
             )
 
             # Add function call result to function call results

agno/models/google/gemini.py

@@ -10,7 +10,7 @@ from uuid import uuid4
 from pydantic import BaseModel
 
 from agno.exceptions import ModelProviderError
-from agno.media import Audio, File, ImageArtifact, Video
+from agno.media import Audio, File, Image, Video
 from agno.models.base import Model
 from agno.models.message import Citations, Message, UrlCitation
 from agno.models.metrics import Metrics
@@ -559,9 +559,14 @@ class Gemini(Model):
             return Part.from_bytes(mime_type=mime_type, data=audio.content)
 
         # Case 2: Audio is an url
-        elif audio.url is not None and audio.audio_url_content is not None:
-            mime_type = f"audio/{audio.format}" if audio.format else "audio/mp3"
-            return Part.from_bytes(mime_type=mime_type, data=audio.audio_url_content)
+        elif audio.url is not None:
+            audio_bytes = audio.get_content_bytes()  # type: ignore
+            if audio_bytes is not None:
+                mime_type = f"audio/{audio.format}" if audio.format else "audio/mp3"
+                return Part.from_bytes(mime_type=mime_type, data=audio_bytes)
+            else:
+                log_warning(f"Failed to download audio from {audio}")
+                return None
 
         # Case 3: Audio is a local file path
         elif audio.filepath is not None:
@@ -815,9 +820,7 @@ class Gemini(Model):
                     if model_response.images is None:
                         model_response.images = []
                     model_response.images.append(
-                        ImageArtifact(
-                            id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type
-                        )
+                        Image(id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type)
                     )
 
                 # Extract function call if present
@@ -929,9 +932,7 @@ class Gemini(Model):
                         if model_response.images is None:
                             model_response.images = []
                         model_response.images.append(
-                            ImageArtifact(
-                                id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type
-                            )
+                            Image(id=str(uuid4()), content=part.inline_data.data, mime_type=part.inline_data.mime_type)
                         )
 
                     # Extract function call if present

agno/models/message.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Sequence, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from agno.media import Audio, AudioArtifact, AudioResponse, File, Image, ImageArtifact, Video, VideoArtifact
+from agno.media import Audio, File, Image, Video
 from agno.models.metrics import Metrics
 from agno.utils.log import log_debug, log_error, log_info, log_warning
 
@@ -71,9 +71,9 @@ class Message(BaseModel):
     files: Optional[Sequence[File]] = None
 
     # Output from the models
-    audio_output: Optional[Union[AudioResponse, AudioArtifact]] = None
-    image_output: Optional[ImageArtifact] = None
-    video_output: Optional[VideoArtifact] = None
+    audio_output: Optional[Audio] = None
+    image_output: Optional[Image] = None
+    video_output: Optional[Video] = None
 
     # The thinking content from the model
     redacted_reasoning_content: Optional[str] = None

agno/models/ollama/chat.py

@@ -149,7 +149,7 @@ class Ollama(Model):
                 message_images = []
                 for image in message.images:
                     if image.url is not None:
-                        message_images.append(image.image_url_content)
+                        message_images.append(image.get_content_bytes())
                     if image.filepath is not None:
                         message_images.append(image.filepath)  # type: ignore
                     if image.content is not None and isinstance(image.content, bytes):

agno/models/openai/chat.py

@@ -2,12 +2,13 @@ from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from os import getenv
 from typing import Any, Dict, Iterator, List, Literal, Optional, Type, Union
+from uuid import uuid4
 
 import httpx
 from pydantic import BaseModel
 
 from agno.exceptions import ModelProviderError
-from agno.media import AudioResponse
+from agno.media import Audio
 from agno.models.base import Model
 from agno.models.message import Message
 from agno.models.metrics import Metrics
@@ -729,14 +730,14 @@ class OpenAIChat(Model):
             # If the audio output modality is requested, we can extract an audio response
             try:
                 if isinstance(response_message.audio, dict):
-                    model_response.audio = AudioResponse(
+                    model_response.audio = Audio(
                         id=response_message.audio.get("id"),
                         content=response_message.audio.get("data"),
                         expires_at=response_message.audio.get("expires_at"),
                         transcript=response_message.audio.get("transcript"),
                     )
                 else:
-                    model_response.audio = AudioResponse(
+                    model_response.audio = Audio(
                         id=response_message.audio.id,
                         content=response_message.audio.data,
                         expires_at=response_message.audio.expires_at,
@@ -783,21 +784,39 @@ class OpenAIChat(Model):
                 # Add audio if present
                 if hasattr(choice_delta, "audio") and choice_delta.audio is not None:
                     try:
+                        audio_data = None
+                        audio_id = None
+                        audio_expires_at = None
+                        audio_transcript = None
+
                         if isinstance(choice_delta.audio, dict):
-                            model_response.audio = AudioResponse(
-                                id=choice_delta.audio.get("id"),
-                                content=choice_delta.audio.get("data"),
-                                expires_at=choice_delta.audio.get("expires_at"),
-                                transcript=choice_delta.audio.get("transcript"),
+                            audio_data = choice_delta.audio.get("data")
+                            audio_id = choice_delta.audio.get("id")
+                            audio_expires_at = choice_delta.audio.get("expires_at")
+                            audio_transcript = choice_delta.audio.get("transcript")
+                        else:
+                            audio_data = choice_delta.audio.data
+                            audio_id = choice_delta.audio.id
+                            audio_expires_at = choice_delta.audio.expires_at
+                            audio_transcript = choice_delta.audio.transcript
+
+                        # Only create Audio object if there's actual content
+                        if audio_data is not None:
+                            model_response.audio = Audio(
+                                id=audio_id,
+                                content=audio_data,
+                                expires_at=audio_expires_at,
+                                transcript=audio_transcript,
                                 sample_rate=24000,
                                 mime_type="pcm16",
                             )
-                        else:
-                            model_response.audio = AudioResponse(
-                                id=choice_delta.audio.id,
-                                content=choice_delta.audio.data,
-                                expires_at=choice_delta.audio.expires_at,
-                                transcript=choice_delta.audio.transcript,
+                        # If no content but there's transcript/metadata, create minimal Audio object
+                        elif audio_transcript is not None or audio_id is not None:
+                            model_response.audio = Audio(
+                                id=audio_id or str(uuid4()),
+                                content=b"",
+                                expires_at=audio_expires_at,
+                                transcript=audio_transcript,
                                 sample_rate=24000,
                                 mime_type="pcm16",
                             )

agno/models/response.py

@@ -3,7 +3,7 @@ from enum import Enum
 from time import time
 from typing import Any, Dict, List, Optional
 
-from agno.media import AudioArtifact, AudioResponse, ImageArtifact, VideoArtifact
+from agno.media import Audio, Image, Video
 from agno.models.message import Citations
 from agno.models.metrics import Metrics
 from agno.tools.function import UserInputField
@@ -87,12 +87,12 @@ class ModelResponse:
 
     content: Optional[Any] = None
     parsed: Optional[Any] = None
-    audio: Optional[AudioResponse] = None
+    audio: Optional[Audio] = None
 
     # Unified media fields for LLM-generated and tool-generated media artifacts
-    images: Optional[List[ImageArtifact]] = None
-    videos: Optional[List[VideoArtifact]] = None
-    audios: Optional[List[AudioArtifact]] = None
+    images: Optional[List[Image]] = None
+    videos: Optional[List[Video]] = None
+    audios: Optional[List[Audio]] = None
 
     # Model tool calls
     tool_calls: List[Dict[str, Any]] = field(default_factory=list)

agno/os/app.py

@@ -36,12 +36,11 @@ from agno.os.routers.session import get_session_router
 from agno.os.settings import AgnoAPISettings
 from agno.os.utils import generate_id
 from agno.team.team import Team
-from agno.tools.mcp import MCPTools, MultiMCPTools
 from agno.workflow.workflow import Workflow
 
 
 @asynccontextmanager
-async def mcp_lifespan(app, mcp_tools: List[Union[MCPTools, MultiMCPTools]]):
+async def mcp_lifespan(app, mcp_tools):
     """Manage MCP connection lifecycle inside a FastAPI app"""
     # Startup logic: connect to all contextual MCP servers
     for tool in mcp_tools:
@@ -83,7 +82,12 @@ class AgentOS:
         self.interfaces = interfaces or []
 
         self.settings: AgnoAPISettings = settings or AgnoAPISettings()
-        self.fastapi_app: Optional[FastAPI] = fastapi_app
+
+        self._app_set = False
+        self.fastapi_app: Optional[FastAPI] = None
+        if fastapi_app:
+            self.fastapi_app = fastapi_app
+            self._app_set = True
 
         self.interfaces = interfaces or []
 
@@ -98,14 +102,16 @@ class AgentOS:
         self.lifespan = lifespan
 
         # List of all MCP tools used inside the AgentOS
-        self.mcp_tools: List[Union[MCPTools, MultiMCPTools]] = []
+        self.mcp_tools = []
 
         if self.agents:
             for agent in self.agents:
                 # Track all MCP tools to later handle their connection
                 if agent.tools:
                     for tool in agent.tools:
-                        if isinstance(tool, MCPTools) or isinstance(tool, MultiMCPTools):
+                        # Checking if the tool is a MCPTools or MultiMCPTools instance
+                        type_name = type(tool).__name__
+                        if type_name in ("MCPTools", "MultiMCPTools"):
                             self.mcp_tools.append(tool)
 
                 agent.initialize_agent()
@@ -118,7 +124,9 @@ class AgentOS:
                 # Track all MCP tools to later handle their connection
                 if team.tools:
                     for tool in team.tools:
-                        if isinstance(tool, MCPTools) or isinstance(tool, MultiMCPTools):
+                        # Checking if the tool is a MCPTools or MultiMCPTools instance
+                        type_name = type(tool).__name__
+                        if type_name in ("MCPTools", "MultiMCPTools"):
                             self.mcp_tools.append(tool)
 
                 team.initialize_team()
@@ -213,33 +221,35 @@ class AgentOS:
         if self.enable_mcp and self.mcp_app:
             self.fastapi_app.mount("/", self.mcp_app)
 
-        # Add middleware
-        @self.fastapi_app.exception_handler(HTTPException)
-        async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
-            return JSONResponse(
-                status_code=exc.status_code,
-                content={"detail": str(exc.detail)},
-            )
+        # Add middleware (only if app is not set)
+        if not self._app_set:
 
-        async def general_exception_handler(request: Request, call_next):
-            try:
-                return await call_next(request)
-            except Exception as e:
+            @self.fastapi_app.exception_handler(HTTPException)
+            async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
                 return JSONResponse(
-                    status_code=e.status_code if hasattr(e, "status_code") else 500,  # type: ignore
-                    content={"detail": str(e)},
+                    status_code=exc.status_code,
+                    content={"detail": str(exc.detail)},
                 )
 
-        self.fastapi_app.middleware("http")(general_exception_handler)
+            async def general_exception_handler(request: Request, call_next):
+                try:
+                    return await call_next(request)
+                except Exception as e:
+                    return JSONResponse(
+                        status_code=e.status_code if hasattr(e, "status_code") else 500,  # type: ignore
+                        content={"detail": str(e)},
+                    )
+
+            self.fastapi_app.middleware("http")(general_exception_handler)
 
-        self.fastapi_app.add_middleware(
-            CORSMiddleware,
-            allow_origins=self.settings.cors_origin_list,  # type: ignore
-            allow_credentials=True,
-            allow_methods=["*"],
-            allow_headers=["*"],
-            expose_headers=["*"],
-        )
+            self.fastapi_app.add_middleware(
+                CORSMiddleware,
+                allow_origins=self.settings.cors_origin_list,  # type: ignore
+                allow_credentials=True,
+                allow_methods=["*"],
+                allow_headers=["*"],
+                expose_headers=["*"],
+            )
 
         return self.fastapi_app
 
@@ -458,6 +468,7 @@ class AgentOS:
         host: str = "localhost",
         port: int = 7777,
         reload: bool = False,
+        workers: Optional[int] = None,
         **kwargs,
     ):
         import uvicorn
@@ -486,4 +497,4 @@ class AgentOS:
             )
         )
 
-        uvicorn.run(app=app, host=host, port=port, reload=reload, **kwargs)
+        uvicorn.run(app=app, host=host, port=port, reload=reload, workers=workers, **kwargs)