agno 2.0.0a1__tar.gz → 2.0.0rc1__tar.gz

{agno-2.0.0a1 → agno-2.0.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.0.0a1
+Version: 2.0.0rc1
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com

{agno-2.0.0a1 → agno-2.0.0rc1}/agno/agent/agent.py

@@ -23,7 +23,7 @@ from typing import (
     get_args,
     overload,
 )
-from uuid import NAMESPACE_DNS, uuid4, uuid5
+from uuid import uuid4
 
 from pydantic import BaseModel
 
@@ -39,6 +39,7 @@ from agno.models.response import ModelResponse, ModelResponseEvent, ToolExecutio
 from agno.reasoning.step import NextAction, ReasoningStep, ReasoningSteps
 from agno.run.agent import (
     RunEvent,
+    RunInput,
     RunOutput,
     RunOutputEvent,
 )
@@ -222,6 +223,10 @@ class Agent:
     update_knowledge: bool = False
     # Add a tool that allows the Model to get the tool call history.
     read_tool_call_history: bool = False
+    # If False, media (images, videos, audio, files) is only available to tools and not sent to the LLM
+    send_media_to_model: bool = True
+    # If True, store media in run output
+    store_media: bool = True
 
     # --- System message settings ---
     # Provide the system message as a string or function
@@ -360,6 +365,7 @@ class Agent:
         session_summary_manager: Optional[SessionSummaryManager] = None,
         add_history_to_context: bool = False,
         num_history_runs: int = 3,
+        store_media: bool = True,
         knowledge: Optional[Knowledge] = None,
         knowledge_filters: Optional[Dict[str, Any]] = None,
         enable_agentic_knowledge_filters: Optional[bool] = None,
@@ -380,6 +386,7 @@ class Agent:
         search_knowledge: bool = True,
         update_knowledge: bool = False,
         read_tool_call_history: bool = False,
+        send_media_to_model: bool = True,
         system_message: Optional[Union[str, Callable, Message]] = None,
         system_message_role: str = "system",
         build_context: bool = True,
@@ -450,6 +457,8 @@ class Agent:
         self.add_history_to_context = add_history_to_context
         self.num_history_runs = num_history_runs
 
+        self.store_media = store_media
+
         self.knowledge = knowledge
         self.knowledge_filters = knowledge_filters
         self.enable_agentic_knowledge_filters = enable_agentic_knowledge_filters
@@ -474,7 +483,7 @@ class Agent:
         self.search_knowledge = search_knowledge
         self.update_knowledge = update_knowledge
         self.read_tool_call_history = read_tool_call_history
-
+        self.send_media_to_model = send_media_to_model
         self.system_message = system_message
         self.system_message_role = system_message_role
         self.build_context = build_context
@@ -539,7 +548,7 @@ class Agent:
     def set_id(self) -> None:
         if self.id is None:
             if self.name is not None:
-                self.id = str(uuid5(NAMESPACE_DNS, self.name))
+                self.id = self.name.lower().replace(" ", "-")
             else:
                 self.id = str(uuid4())
 
@@ -760,6 +769,11 @@ class Agent:
         # 3. Update the RunOutput with the model response
         self._update_run_response(model_response=model_response, run_response=run_response, run_messages=run_messages)
 
+        if self.store_media:
+            self._store_media(run_response, model_response)
+        else:
+            self._scrub_media_from_run_output(run_response)
+
         # We should break out of the run function
         if any(tool_call.is_paused for tool_call in run_response.tools or []):
             return self._handle_agent_run_paused(
@@ -1059,6 +1073,15 @@ class Agent:
         # Initialize the Agent
         self.initialize_agent(debug_mode=debug_mode)
 
+        image_artifacts, video_artifacts, audio_artifacts = self._convert_media_to_artifacts(
+            images=images, videos=videos, audios=audio
+        )
+
+        # Create RunInput to capture the original user input
+        run_input = RunInput(
+            input_content=input, images=image_artifacts, videos=video_artifacts, audios=audio_artifacts, files=files
+        )
+
         # Read existing session from database
         agent_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
         self._update_metadata(session=agent_session)
@@ -1128,6 +1151,7 @@ class Agent:
             agent_id=self.id,
             agent_name=self.name,
             metadata=metadata,
+            input=run_input,
         )
 
         run_response.model = self.model.id if self.model is not None else None
@@ -1305,6 +1329,11 @@ class Agent:
         # 3. Update the RunOutput with the model response
         self._update_run_response(model_response=model_response, run_response=run_response, run_messages=run_messages)
 
+        if self.store_media:
+            self._store_media(run_response, model_response)
+        else:
+            self._scrub_media_from_run_output(run_response)
+
         # We should break out of the run function
         if any(tool_call.is_paused for tool_call in run_response.tools or []):
             return self._handle_agent_run_paused(
@@ -1613,6 +1642,15 @@ class Agent:
         # Initialize the Agent
         self.initialize_agent(debug_mode=debug_mode)
 
+        image_artifacts, video_artifacts, audio_artifacts = self._convert_media_to_artifacts(
+            images=images, videos=videos, audios=audio
+        )
+
+        # Create RunInput to capture the original user input
+        run_input = RunInput(
+            input_content=input, images=image_artifacts, videos=video_artifacts, audios=audio_artifacts, files=files
+        )
+
         # Read existing session from storage
         agent_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
         self._update_metadata(session=agent_session)
@@ -1679,6 +1717,7 @@ class Agent:
             agent_id=self.id,
             agent_name=self.name,
             metadata=metadata,
+            input=run_input,
         )
 
         run_response.model = self.model.id if self.model is not None else None
@@ -2942,6 +2981,21 @@ class Agent:
                 _t.requires_user_input = False
                 _t.answered = True
 
+    def _store_media(self, run_response: RunOutput, model_response: ModelResponse):
+        """Store media from model response in run_response for persistence"""
+        # Handle generated media fields from ModelResponse (generated media)
+        if model_response.images is not None:
+            for image in model_response.images:
+                self._add_image(image, run_response)  # Generated images go to run_response.images
+
+        if model_response.videos is not None:
+            for video in model_response.videos:
+                self._add_video(video, run_response)  # Generated videos go to run_response.videos
+
+        if model_response.audios is not None:
+            for audio in model_response.audios:
+                self._add_audio(audio, run_response)  # Generated audio go to run_response.audio
+
     def _update_run_response(self, model_response: ModelResponse, run_response: RunOutput, run_messages: RunMessages):
         # Handle structured outputs
         if self.output_schema is not None and model_response.parsed is not None:
@@ -2984,19 +3038,6 @@ class Agent:
                         run_response=run_response, tool_name=tool_name, tool_args=tool_args
                     )
 
-        # Handle unified media fields from ModelResponse
-        if model_response.images is not None:
-            for image in model_response.images:
-                self._add_image(image, run_response)
-
-        if model_response.videos is not None:
-            for video in model_response.videos:
-                self._add_video(video, run_response)
-
-        if model_response.audios is not None:
-            for audio in model_response.audios:
-                self._add_audio(audio, run_response)
-
         # Update the run_response audio with the model response audio
         if model_response.audio is not None:
             run_response.response_audio = model_response.audio
@@ -3704,6 +3745,209 @@ class Agent:
 
         return agent_tools
 
+    def _collect_joint_images(
+        self,
+        run_input: Optional[RunInput] = None,
+        session: Optional[AgentSession] = None,
+    ) -> Optional[Sequence[Image]]:
+        """Collect images from input, session history, and current run response."""
+        joint_images = []
+
+        # 1. Add images from current input
+        if run_input and run_input.images:
+            for artifact in run_input.images:
+                try:
+                    if artifact.url:
+                        joint_images.append(Image(url=artifact.url))
+                    elif artifact.content:
+                        joint_images.append(Image(content=artifact.content))
+                except Exception as e:
+                    log_warning(f"Error converting ImageArtifact to Image: {e}")
+                    continue
+            log_debug(f"Added {len(run_input.images)} input images to joint list")
+
+        # 2. Add images from session history (from both input and generated sources)
+        try:
+            if session and session.runs:
+                for historical_run in session.runs:
+                    # Add generated images from previous runs
+                    if historical_run.images:
+                        for artifact in historical_run.images:
+                            try:
+                                if artifact.url:
+                                    joint_images.append(Image(url=artifact.url))
+                                elif artifact.content:
+                                    joint_images.append(Image(content=artifact.content))
+                            except Exception as e:
+                                log_warning(f"Error converting historical ImageArtifact to Image: {e}")
+                                continue
+                        log_debug(
+                            f"Added {len(historical_run.images)} generated images from historical run {historical_run.run_id}"
+                        )
+
+                    # Add input images from previous runs
+                    if historical_run.input and historical_run.input.images:
+                        for artifact in historical_run.input.images:
+                            try:
+                                if artifact.url:
+                                    joint_images.append(Image(url=artifact.url))
+                                elif artifact.content:
+                                    joint_images.append(Image(content=artifact.content))
+                            except Exception as e:
+                                log_warning(f"Error converting input ImageArtifact to Image: {e}")
+                                continue
+                        log_debug(
+                            f"Added {len(historical_run.input.images)} input images from historical run {historical_run.run_id}"
+                        )
+        except Exception as e:
+            log_debug(f"Could not access session history for images: {e}")
+
+        if joint_images:
+            log_debug(f"Images Available to Model: {len(joint_images)} images")
+        return joint_images if joint_images else None
+
+    def _collect_joint_videos(
+        self,
+        run_input: Optional[RunInput] = None,
+        session: Optional[AgentSession] = None,
+    ) -> Optional[Sequence[Video]]:
+        """Collect videos from input, session history, and current run response."""
+        joint_videos = []
+
+        # 1. Add videos from current input
+        if run_input and run_input.videos:
+            for artifact in run_input.videos:
+                try:
+                    if artifact.url:
+                        joint_videos.append(Video(url=artifact.url))
+                    elif artifact.content:
+                        joint_videos.append(Video(content=artifact.content))
+                except Exception as e:
+                    log_warning(f"Error converting VideoArtifact to Video: {e}")
+                    continue
+            log_debug(f"Added {len(run_input.videos)} input videos to joint list")
+
+        # 2. Add videos from session history (from both input and generated sources)
+        try:
+            if session and session.runs:
+                for historical_run in session.runs:
+                    # Add generated videos from previous runs
+                    if historical_run.videos:
+                        for artifact in historical_run.videos:
+                            try:
+                                if artifact.url:
+                                    joint_videos.append(Video(url=artifact.url))
+                                elif artifact.content:
+                                    joint_videos.append(Video(content=artifact.content))
+                            except Exception as e:
+                                log_warning(f"Error converting historical VideoArtifact to Video: {e}")
+                                continue
+                        log_debug(
+                            f"Added {len(historical_run.videos)} generated videos from historical run {historical_run.run_id}"
+                        )
+
+                    # Add input videos from previous runs
+                    if historical_run.input and historical_run.input.videos:
+                        for artifact in historical_run.input.videos:
+                            try:
+                                if artifact.url:
+                                    joint_videos.append(Video(url=artifact.url))
+                                elif artifact.content:
+                                    joint_videos.append(Video(content=artifact.content))
+                            except Exception as e:
+                                log_warning(f"Error converting input VideoArtifact to Video: {e}")
+                                continue
+                        log_debug(
+                            f"Added {len(historical_run.input.videos)} input videos from historical run {historical_run.run_id}"
+                        )
+        except Exception as e:
+            log_debug(f"Could not access session history for videos: {e}")
+
+        if joint_videos:
+            log_debug(f"Videos Available to Model: {len(joint_videos)} videos")
+        return joint_videos if joint_videos else None
+
+    def _collect_joint_audios(
+        self,
+        run_input: Optional[RunInput] = None,
+        session: Optional[AgentSession] = None,
+    ) -> Optional[Sequence[Audio]]:
+        """Collect audios from input, session history, and current run response."""
+        joint_audios = []
+
+        # 1. Add audios from current input
+        if run_input and run_input.audios:
+            for artifact in run_input.audios:
+                try:
+                    if artifact.url:
+                        joint_audios.append(Audio(url=artifact.url))
+                    elif artifact.base64_audio:
+                        joint_audios.append(Audio(content=artifact.base64_audio))
+                except Exception as e:
+                    log_warning(f"Error converting AudioArtifact to Audio: {e}")
+                    continue
+            log_debug(f"Added {len(run_input.audios)} input audios to joint list")
+
+        # 2. Add audios from session history (from both input and generated sources)
+        try:
+            if session and session.runs:
+                for historical_run in session.runs:
+                    # Add generated audios from previous runs
+                    if historical_run.audio:
+                        for artifact in historical_run.audio:
+                            try:
+                                if artifact.url:
+                                    joint_audios.append(Audio(url=artifact.url))
+                                elif artifact.base64_audio:
+                                    joint_audios.append(Audio(content=artifact.base64_audio))
+                            except Exception as e:
+                                log_warning(f"Error converting historical AudioArtifact to Audio: {e}")
+                                continue
+                        log_debug(
+                            f"Added {len(historical_run.audio)} generated audios from historical run {historical_run.run_id}"
+                        )
+
+                    # Add input audios from previous runs
+                    if historical_run.input and historical_run.input.audios:
+                        for artifact in historical_run.input.audios:
+                            try:
+                                if artifact.url:
+                                    joint_audios.append(Audio(url=artifact.url))
+                                elif artifact.base64_audio:
+                                    joint_audios.append(Audio(content=artifact.base64_audio))
+                            except Exception as e:
+                                log_warning(f"Error converting input AudioArtifact to Audio: {e}")
+                                continue
+                        log_debug(
+                            f"Added {len(historical_run.input.audios)} input audios from historical run {historical_run.run_id}"
+                        )
+        except Exception as e:
+            log_debug(f"Could not access session history for audios: {e}")
+
+        if joint_audios:
+            log_debug(f"Audios Available to Model: {len(joint_audios)} audios")
+        return joint_audios if joint_audios else None
+
+    def _collect_joint_files(
+        self,
+        run_input: Optional[RunInput] = None,
+    ) -> Optional[Sequence[File]]:
+        """Collect files from input and session history."""
+        from agno.utils.log import log_debug
+
+        joint_files: List[File] = []
+
+        # 1. Add files from current input
+        if run_input and run_input.files:
+            joint_files.extend(run_input.files)
+
+        # TODO: Files aren't stored in session history yet and dont have a FileArtifact
+
+        if joint_files:
+            log_debug(f"Files Available to Model: {len(joint_files)} files")
+
+        return joint_files if joint_files else None
+
     def _determine_tools_for_model(
         self,
         model: Model,
@@ -3802,8 +4046,27 @@ class Agent:
 
         # Update the session state for the functions
         if self._functions_for_model:
+            from inspect import signature
+
+            # Check if any functions need media before collecting
+            needs_media = any(
+                any(param in signature(func.entrypoint).parameters for param in ["images", "videos", "audios", "files"])
+                for func in self._functions_for_model.values()
+                if func.entrypoint is not None
+            )
+
+            # Only collect media if functions actually need them
+            joint_images = self._collect_joint_images(run_response.input, session) if needs_media else None
+            joint_files = self._collect_joint_files(run_response.input) if needs_media else None
+            joint_audios = self._collect_joint_audios(run_response.input, session) if needs_media else None
+            joint_videos = self._collect_joint_videos(run_response.input, session) if needs_media else None
+
             for func in self._functions_for_model.values():
                 func._session_state = session_state
+                func._images = joint_images
+                func._files = joint_files
+                func._audios = joint_audios
+                func._videos = joint_videos
 
     def _model_should_return_structured_output(self):
         self.model = cast(Model, self.model)
@@ -4656,10 +4919,10 @@ class Agent:
             return Message(
                 role=self.user_message_role,
                 content=input,
-                images=images,
-                audio=audio,
-                videos=videos,
-                files=files,
+                images=None if not self.send_media_to_model else images,
+                audio=None if not self.send_media_to_model else audio,
+                videos=None if not self.send_media_to_model else videos,
+                files=None if not self.send_media_to_model else files,
                 **kwargs,
             )
         # 2. Build the user message for the Agent
@@ -4669,10 +4932,10 @@ class Agent:
                 return Message(
                     role=self.user_message_role,
                     content="",
-                    images=images,
-                    audio=audio,
-                    videos=videos,
-                    files=files,
+                    images=None if not self.send_media_to_model else images,
+                    audio=None if not self.send_media_to_model else audio,
+                    videos=None if not self.send_media_to_model else videos,
+                    files=None if not self.send_media_to_model else files,
                     **kwargs,
                 )
             else:
@@ -4691,10 +4954,10 @@ class Agent:
                 return Message(
                     role=self.user_message_role,
                     content=message_content,
-                    images=images,
-                    audio=audio,
-                    videos=videos,
-                    files=files,
+                    images=None if not self.send_media_to_model else images,
+                    audio=None if not self.send_media_to_model else audio,
+                    videos=None if not self.send_media_to_model else videos,
+                    files=None if not self.send_media_to_model else files,
                     **kwargs,
                 )
 
@@ -4785,10 +5048,10 @@ class Agent:
                 return Message(
                     role=self.user_message_role,
                     content=user_msg_content,
-                    audio=audio,
-                    images=images,
-                    videos=videos,
-                    files=files,
+                    audio=None if not self.send_media_to_model else audio,
+                    images=None if not self.send_media_to_model else images,
+                    videos=None if not self.send_media_to_model else videos,
+                    files=None if not self.send_media_to_model else files,
                     **kwargs,
                 )
 
@@ -4836,7 +5099,7 @@ class Agent:
         )
         """
 
-        # Initialize the RunMessages object
+        # Initialize the RunMessages object (no media here - that's in RunInput now)
         run_messages = RunMessages()
 
         # 1. Add system message to run_messages
@@ -6851,6 +7114,100 @@ class Agent:
 
         return effective_filters
 
+    def _scrub_media_from_run_output(self, run_response: RunOutput) -> None:
+        """
+        Completely remove all media from RunOutput when store_media=False.
+        This includes media in input, output artifacts, and all messages.
+        """
+        # 1. Scrub RunInput media
+        if run_response.input is not None:
+            run_response.input.images = []
+            run_response.input.videos = []
+            run_response.input.audios = []
+            run_response.input.files = []
+
+        # 2. RunOutput artifact media are skipped since we don't store them when store_media=False
+
+        # 3. Scrub media from all messages
+        if run_response.messages:
+            for message in run_response.messages:
+                self._scrub_media_from_message(message)
+
+        # 4. Scrub media from additional_input messages if any
+        if run_response.additional_input:
+            for message in run_response.additional_input:
+                self._scrub_media_from_message(message)
+
+        # 5. Scrub media from reasoning_messages if any
+        if run_response.reasoning_messages:
+            for message in run_response.reasoning_messages:
+                self._scrub_media_from_message(message)
+
+    def _scrub_media_from_message(self, message: Message) -> None:
+        """Remove all media from a Message object."""
+        # Input media
+        message.images = None
+        message.videos = None
+        message.audio = None
+        message.files = None
+
+        # Output media
+        message.audio_output = None
+        message.image_output = None
+        message.video_output = None
+
+    def _convert_media_to_artifacts(
+        self,
+        images: Optional[Sequence[Image]] = None,
+        videos: Optional[Sequence[Video]] = None,
+        audios: Optional[Sequence[Audio]] = None,
+    ) -> tuple:
+        """Convert raw Image/Video/Audio objects to ImageArtifact/VideoArtifact/AudioArtifact objects."""
+        from uuid import uuid4
+
+        from agno.media import AudioArtifact, ImageArtifact, VideoArtifact
+
+        image_artifacts = None
+        if images:
+            image_artifacts = []
+            for img in images:
+                try:
+                    if img.url:
+                        image_artifacts.append(ImageArtifact(id=str(uuid4()), url=img.url))
+                    elif img.content:
+                        image_artifacts.append(ImageArtifact(id=str(uuid4()), content=img.content))
+                except Exception as e:
+                    log_warning(f"Error creating ImageArtifact: {e}")
+                    continue
+
+        video_artifacts = None
+        if videos:
+            video_artifacts = []
+            for vid in videos:
+                try:
+                    if vid.url:
+                        video_artifacts.append(VideoArtifact(id=str(uuid4()), url=vid.url))
+                    elif vid.content:
+                        video_artifacts.append(VideoArtifact(id=str(uuid4()), content=vid.content))
+                except Exception as e:
+                    log_warning(f"Error creating VideoArtifact: {e}")
+                    continue
+
+        audio_artifacts = None
+        if audios:
+            audio_artifacts = []
+            for aud in audios:
+                try:
+                    if aud.url:
+                        audio_artifacts.append(AudioArtifact(id=str(uuid4()), url=aud.url))
+                    elif aud.content:
+                        audio_artifacts.append(AudioArtifact(id=str(uuid4()), content=aud.content))
+                except Exception as e:
+                    log_warning(f"Error creating AudioArtifact: {e}")
+                    continue
+
+        return image_artifacts, video_artifacts, audio_artifacts
+
     def cli_app(
         self,
         input: Optional[str] = None,

{agno-2.0.0a1 → agno-2.0.0rc1}/agno/api/agent.py

@@ -10,7 +10,7 @@ def create_agent_run(run: AgentRunCreate) -> None:
         try:
             api_client.post(
                 ApiRoutes.RUN_CREATE,
-                json={"run": run.model_dump(exclude_none=True)},
+                json=run.model_dump(exclude_none=True),
             )
         except Exception as e:
             log_debug(f"Could not create Agent run: {e}")
@@ -22,7 +22,7 @@ async def acreate_agent_run(run: AgentRunCreate) -> None:
         try:
             await api_client.post(
                 ApiRoutes.RUN_CREATE,
-                json={"run": run.model_dump(exclude_none=True)},
+                json=run.model_dump(exclude_none=True),
             )
         except Exception as e:
             log_debug(f"Could not create Agent run: {e}")

{agno-2.0.0a1 → agno-2.0.0rc1}/agno/api/evals.py

@@ -8,7 +8,7 @@ def create_eval_run_telemetry(eval_run: EvalRunCreate) -> None:
     """Telemetry recording for Eval runs"""
     with api.Client() as api_client:
         try:
-            api_client.post(ApiRoutes.EVAL_RUN_CREATE, json={"eval_run": eval_run.model_dump(exclude_none=True)})
+            api_client.post(ApiRoutes.EVAL_RUN_CREATE, json=eval_run.model_dump(exclude_none=True))
         except Exception as e:
             log_debug(f"Could not create evaluation run: {e}")
 
@@ -17,6 +17,6 @@ async def async_create_eval_run_telemetry(eval_run: EvalRunCreate) -> None:
     """Telemetry recording for async Eval runs"""
     async with api.AsyncClient() as api_client:
         try:
-            await api_client.post(ApiRoutes.EVAL_RUN_CREATE, json={"eval_run": eval_run.model_dump(exclude_none=True)})
+            await api_client.post(ApiRoutes.EVAL_RUN_CREATE, json=eval_run.model_dump(exclude_none=True))
         except Exception as e:
             log_debug(f"Could not create evaluation run: {e}")

{agno-2.0.0a1 → agno-2.0.0rc1}/agno/api/os.py

@@ -10,7 +10,7 @@ def log_os_telemetry(launch: OSLaunch) -> None:
         try:
             response = api_client.post(
                 ApiRoutes.AGENT_OS_LAUNCH,
-                json={"launch": launch.model_dump(exclude_none=True)},
+                json=launch.model_dump(exclude_none=True),
             )
             response.raise_for_status()
         except Exception as e:

{agno-2.0.0a1 → agno-2.0.0rc1}/agno/api/settings.py

@@ -16,7 +16,7 @@ class AgnoAPISettings(BaseSettings):
     api_runtime: str = "prd"
     alpha_features: bool = False
 
-    api_url: str = "https://api.agno.com"
+    api_url: str = "https://os-api.agno.com"
 
     model_config = SettingsConfigDict(env_prefix="AGNO_")
 
@@ -42,7 +42,7 @@ class AgnoAPISettings(BaseSettings):
         elif api_runtime == "stg":
             return "https://api-stg.agno.com"
         else:
-            return "https://api.agno.com"
+            return "https://os-api.agno.com"
 
     def gate_alpha_feature(self):
         if not self.alpha_features:

{agno-2.0.0a1 → agno-2.0.0rc1}/agno/api/team.py

@@ -10,7 +10,7 @@ def create_team_run(run: TeamRunCreate) -> None:
         try:
             response = api_client.post(
                 ApiRoutes.RUN_CREATE,
-                json={"run": run.model_dump(exclude_none=True)},
+                json=run.model_dump(exclude_none=True),
             )
             response.raise_for_status()
         except Exception as e:
@@ -23,7 +23,7 @@ async def acreate_team_run(run: TeamRunCreate) -> None:
         try:
             response = await api_client.post(
                 ApiRoutes.RUN_CREATE,
-                json={"run": run.model_dump(exclude_none=True)},
+                json=run.model_dump(exclude_none=True),
             )
             response.raise_for_status()
         except Exception as e: