agno 2.0.5__py3-none-any.whl → 2.0.7__py3-none-any.whl

agno/team/team.py

@@ -829,6 +829,7 @@ class Team:
             functions=self._functions_for_model,
             tool_choice=self.tool_choice,
             tool_call_limit=self.tool_call_limit,
+            send_media_to_model=self.send_media_to_model,
         )
 
         # Check for cancellation after model call
@@ -1121,13 +1122,17 @@ class Team:
         # Initialize Team
         self.initialize_team(debug_mode=debug_mode)
 
-        image_artifacts, video_artifacts, audio_artifacts = self._validate_media_object_id(
-            images=images, videos=videos, audios=audio
+        image_artifacts, video_artifacts, audio_artifacts, file_artifacts = self._validate_media_object_id(
+            images=images, videos=videos, audios=audio, files=files
         )
 
         # Create RunInput to capture the original user input
         run_input = TeamRunInput(
-            input_content=input, images=image_artifacts, videos=video_artifacts, audios=audio_artifacts, files=files
+            input_content=input,
+            images=image_artifacts,
+            videos=video_artifacts,
+            audios=audio_artifacts,
+            files=file_artifacts,
         )
 
         # Read existing session from database
@@ -1411,6 +1416,7 @@ class Team:
             tool_choice=self.tool_choice,
             tool_call_limit=self.tool_call_limit,
             response_format=response_format,
+            send_media_to_model=self.send_media_to_model,
         )  # type: ignore
 
         # Check for cancellation after model call
@@ -1739,13 +1745,17 @@ class Team:
         # Initialize Team
         self.initialize_team(debug_mode=debug_mode)
 
-        image_artifacts, video_artifacts, audio_artifacts = self._validate_media_object_id(
-            images=images, videos=videos, audios=audio
+        image_artifacts, video_artifacts, audio_artifacts, file_artifacts = self._validate_media_object_id(
+            images=images, videos=videos, audios=audio, files=files
         )
 
         # Create RunInput to capture the original user input
         run_input = TeamRunInput(
-            input_content=input, images=image_artifacts, videos=video_artifacts, audios=audio_artifacts, files=files
+            input_content=input,
+            images=image_artifacts,
+            videos=video_artifacts,
+            audios=audio_artifacts,
+            files=file_artifacts,
         )
 
         team_session = self._read_or_create_session(session_id=session_id, user_id=user_id)
@@ -1963,6 +1973,10 @@ class Team:
             for audio in model_response.audios:
                 self._add_audio(audio, run_response)  # Generated audio go to run_response.audio
 
+        if model_response.files is not None:
+            for file in model_response.files:
+                self._add_file(file, run_response)  # Generated files go to run_response.files
+
     def _update_run_response(
         self, model_response: ModelResponse, run_response: TeamRunOutput, run_messages: RunMessages
     ):
@@ -1985,7 +1999,9 @@ class Team:
                 run_response.reasoning_content = model_response.reasoning_content
             else:
                 run_response.reasoning_content += model_response.reasoning_content
-
+        # Update provider data
+        if model_response.provider_data is not None:
+            run_response.model_provider_data = model_response.provider_data
         # Update citations
         if model_response.citations is not None:
             run_response.citations = model_response.citations
@@ -2049,6 +2065,7 @@ class Team:
             tool_choice=self.tool_choice,
             tool_call_limit=self.tool_call_limit,
             stream_model_response=stream_model_response,
+            send_media_to_model=self.send_media_to_model,
         ):
             yield from self._handle_model_response_chunk(
                 session=session,
@@ -2071,6 +2088,8 @@ class Team:
             run_response.response_audio = full_model_response.audio
         if full_model_response.citations is not None:
             run_response.citations = full_model_response.citations
+        if full_model_response.provider_data is not None:
+            run_response.model_provider_data = full_model_response.provider_data
 
         if stream_intermediate_steps and reasoning_state["reasoning_started"]:
             all_reasoning_steps: List[ReasoningStep] = []
@@ -2129,6 +2148,7 @@ class Team:
             tool_choice=self.tool_choice,
             tool_call_limit=self.tool_call_limit,
             stream_model_response=stream_model_response,
+            send_media_to_model=self.send_media_to_model,
         )  # type: ignore
         async for model_response_event in model_stream:
             for event in self._handle_model_response_chunk(
@@ -2158,6 +2178,8 @@ class Team:
             run_response.response_audio = full_model_response.audio
         if full_model_response.citations is not None:
             run_response.citations = full_model_response.citations
+        if full_model_response.provider_data is not None:
+            run_response.model_provider_data = full_model_response.provider_data
 
         # Build a list of messages that should be added to the RunOutput
         messages_for_run_response = [m for m in run_messages.messages if m.add_to_agent_memory]
@@ -2297,6 +2319,7 @@ class Team:
                                 redacted_reasoning_content=model_response_event.redacted_reasoning_content,
                                 response_audio=full_model_response.audio,
                                 citations=model_response_event.citations,
+                                model_provider_data=model_response_event.provider_data,
                                 image=model_response_event.images[-1] if model_response_event.images else None,
                             ),
                             run_response,
@@ -3118,6 +3141,7 @@ class Team:
         images: Optional[Sequence[Image]] = None,
         videos: Optional[Sequence[Video]] = None,
         audios: Optional[Sequence[Audio]] = None,
+        files: Optional[Sequence[File]] = None,
     ) -> tuple:
         image_list = None
         if images:
@@ -3149,7 +3173,17 @@ class Team:
                     aud.id = str(uuid4())
                 audio_list.append(aud)
 
-        return image_list, video_list, audio_list
+        file_list = None
+        if files:
+            file_list = []
+            for file in files:
+                if not file.id:
+                    from uuid import uuid4
+
+                    file.id = str(uuid4())
+                file_list.append(file)
+
+        return image_list, video_list, audio_list, file_list
 
     def cli_app(
         self,
@@ -5056,20 +5090,19 @@ class Team:
             import json
 
             history: List[Dict[str, Any]] = []
-            if session is not None:
-                all_chats = self.get_messages_for_session(session_id=session.session_id)
 
-                if len(all_chats) == 0:
-                    return ""
+            all_chats = session.get_messages_from_last_n_runs(
+                team_id=self.id,
+            )
 
-                for chat in all_chats[::-1]:  # type: ignore
-                    history.insert(0, chat.to_dict())  # type: ignore
+            if len(all_chats) == 0:
+                return ""
 
-                if num_chats is not None:
-                    history = history[:num_chats]
+            for chat in all_chats[::-1]:  # type: ignore
+                history.insert(0, chat.to_dict())  # type: ignore
 
-            else:
-                return ""
+            if num_chats is not None:
+                history = history[:num_chats]
 
             return json.dumps(history)
 
@@ -6259,6 +6292,13 @@ class Team:
             run_response.audio = []
         run_response.audio.append(audio)
 
+    def _add_file(self, file: File, run_response: TeamRunOutput) -> None:
+        """Add file to both the agent's stateful storage and the current run response"""
+        # Add to run response
+        if run_response.files is None:
+            run_response.files = []
+        run_response.files.append(file)
+
     def _update_reasoning_content_from_tool_call(
         self, run_response: TeamRunOutput, tool_name: str, tool_args: Dict[str, Any]
     ) -> Optional[ReasoningStep]:

agno/tools/decorator.py

@@ -250,8 +250,10 @@ def tool(*args, **kwargs) -> Union[Function, Callable[[F], Function]]:
         if kwargs.get("stop_after_tool_call") is True:
             if "show_result" not in kwargs or kwargs.get("show_result") is None:
                 tool_config["show_result"] = True
-
-        return Function(**tool_config)
+        function = Function(**tool_config)
+        # Determine parameters for the function
+        function.process_entrypoint()
+        return function
 
     # Handle both @tool and @tool() cases
     if len(args) == 1 and callable(args[0]) and not kwargs:

agno/tools/e2b.py

@@ -464,7 +464,7 @@ class E2BTools(Toolkit):
 
             result = f"Contents of {directory_path}:\n"
             for file in files:
-                file_type = "Directory" if file.is_dir else "File"
+                file_type = "Directory" if file.type == "directory" else "File"
                 size = f"{file.size} bytes" if file.size is not None else "Unknown size"
                 result += f"- {file.name} ({file_type}, {size})\n"
 
@@ -486,12 +486,19 @@ class E2BTools(Toolkit):
         try:
             content = self.sandbox.files.read(file_path)
 
-            # Try to decode as text if encoding is provided
-            try:
-                text_content = content.decode(encoding)
-                return text_content
-            except UnicodeDecodeError:
-                return f"File read successfully but contains binary data ({len(content)} bytes). Use download_file_from_sandbox to save it."
+            # Check if content is already a string or if it's bytes that need decoding
+            if isinstance(content, str):
+                return content
+            elif isinstance(content, bytes):
+                # Try to decode as text if encoding is provided
+                try:
+                    text_content = content.decode(encoding)
+                    return text_content
+                except UnicodeDecodeError:
+                    return f"File read successfully but contains binary data ({len(content)} bytes). Use download_file_from_sandbox to save it."
+            else:
+                # Handle unexpected content type
+                return f"Unexpected content type: {type(content)}. Expected str or bytes."
 
         except Exception as e:
             return json.dumps({"status": "error", "message": f"Error reading file: {str(e)}"})

agno/tools/file_generation.py

@@ -0,0 +1,350 @@
+import csv
+import io
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from uuid import uuid4
+
+from agno.media import File
+from agno.tools import Toolkit
+from agno.tools.function import ToolResult
+from agno.utils.log import log_debug, logger
+
+try:
+    from reportlab.lib.pagesizes import letter
+    from reportlab.lib.styles import getSampleStyleSheet
+    from reportlab.lib.units import inch
+    from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer
+
+    PDF_AVAILABLE = True
+except ImportError:
+    PDF_AVAILABLE = False
+    logger.warning("reportlab not installed. PDF generation will not be available. Install with: pip install reportlab")
+
+
+class FileGenerationTools(Toolkit):
+    def __init__(
+        self,
+        enable_json_generation: bool = True,
+        enable_csv_generation: bool = True,
+        enable_pdf_generation: bool = True,
+        enable_txt_generation: bool = True,
+        output_directory: Optional[str] = None,
+        all: bool = False,
+        **kwargs,
+    ):
+        self.enable_json_generation = enable_json_generation
+        self.enable_csv_generation = enable_csv_generation
+        self.enable_pdf_generation = enable_pdf_generation and PDF_AVAILABLE
+        self.enable_txt_generation = enable_txt_generation
+        self.output_directory = Path(output_directory) if output_directory else None
+
+        # Create output directory if specified
+        if self.output_directory:
+            self.output_directory.mkdir(parents=True, exist_ok=True)
+            log_debug(f"Files will be saved to: {self.output_directory}")
+
+        if enable_pdf_generation and not PDF_AVAILABLE:
+            logger.warning("PDF generation requested but reportlab is not installed. Disabling PDF generation.")
+            self.enable_pdf_generation = False
+
+        tools: List[Any] = []
+        if all or enable_json_generation:
+            tools.append(self.generate_json_file)
+        if all or enable_csv_generation:
+            tools.append(self.generate_csv_file)
+        if all or (enable_pdf_generation and PDF_AVAILABLE):
+            tools.append(self.generate_pdf_file)
+        if all or enable_txt_generation:
+            tools.append(self.generate_text_file)
+
+        super().__init__(name="file_generation", tools=tools, **kwargs)
+
+    def _save_file_to_disk(self, content: Union[str, bytes], filename: str) -> Optional[str]:
+        """Save file to disk if output_directory is set. Return file path or None."""
+        if not self.output_directory:
+            return None
+
+        file_path = self.output_directory / filename
+
+        if isinstance(content, str):
+            file_path.write_text(content, encoding="utf-8")
+        else:
+            file_path.write_bytes(content)
+
+        log_debug(f"File saved to: {file_path}")
+        return str(file_path)
+
+    def generate_json_file(self, data: Union[Dict, List, str], filename: Optional[str] = None) -> ToolResult:
+        """Generate a JSON file from the provided data.
+
+        Args:
+            data: The data to write to the JSON file. Can be a dictionary, list, or JSON string.
+            filename: Optional filename for the generated file. If not provided, a UUID will be used.
+
+        Returns:
+            ToolResult: Result containing the generated JSON file as a FileArtifact.
+        """
+        try:
+            log_debug(f"Generating JSON file with data: {type(data)}")
+
+            # Handle different input types
+            if isinstance(data, str):
+                try:
+                    json.loads(data)
+                    json_content = data  # Use the original string if it's valid JSON
+                except json.JSONDecodeError:
+                    # If it's not valid JSON, treat as plain text and wrap it
+                    json_content = json.dumps({"content": data}, indent=2)
+            else:
+                json_content = json.dumps(data, indent=2, ensure_ascii=False)
+
+            # Generate filename if not provided
+            if not filename:
+                filename = f"generated_file_{str(uuid4())[:8]}.json"
+            elif not filename.endswith(".json"):
+                filename += ".json"
+
+            # Save file to disk (if output_directory is set)
+            file_path = self._save_file_to_disk(json_content, filename)
+
+            # Create FileArtifact
+            file_artifact = File(
+                id=str(uuid4()),
+                content=json_content,
+                mime_type="application/json",
+                file_type="json",
+                filename=filename,
+                size=len(json_content.encode("utf-8")),
+                url=f"file://{file_path}" if file_path else None,
+            )
+
+            log_debug("JSON file generated successfully")
+            success_msg = f"JSON file '{filename}' has been generated successfully with {len(json_content)} characters."
+            if file_path:
+                success_msg += f" File saved to: {file_path}"
+            else:
+                success_msg += " File is available in response."
+
+            return ToolResult(content=success_msg, files=[file_artifact])
+
+        except Exception as e:
+            logger.error(f"Failed to generate JSON file: {e}")
+            return ToolResult(content=f"Error generating JSON file: {e}")
+
+    def generate_csv_file(
+        self,
+        data: Union[List[List], List[Dict], str],
+        filename: Optional[str] = None,
+        headers: Optional[List[str]] = None,
+    ) -> ToolResult:
+        """Generate a CSV file from the provided data.
+
+        Args:
+            data: The data to write to the CSV file. Can be a list of lists, list of dictionaries, or CSV string.
+            filename: Optional filename for the generated file. If not provided, a UUID will be used.
+            headers: Optional headers for the CSV. Used when data is a list of lists.
+
+        Returns:
+            ToolResult: Result containing the generated CSV file as a FileArtifact.
+        """
+        try:
+            log_debug(f"Generating CSV file with data: {type(data)}")
+
+            # Create CSV content
+            output = io.StringIO()
+
+            if isinstance(data, str):
+                # If it's already a CSV string, use it directly
+                csv_content = data
+            elif isinstance(data, list) and len(data) > 0:
+                writer = csv.writer(output)
+
+                if isinstance(data[0], dict):
+                    # List of dictionaries - use keys as headers
+                    if data:
+                        fieldnames = list(data[0].keys())
+                        writer.writerow(fieldnames)
+                        for row in data:
+                            if isinstance(row, dict):
+                                writer.writerow([row.get(field, "") for field in fieldnames])
+                            else:
+                                writer.writerow([str(row)] + [""] * (len(fieldnames) - 1))
+                elif isinstance(data[0], list):
+                    # List of lists
+                    if headers:
+                        writer.writerow(headers)
+                    writer.writerows(data)
+                else:
+                    # List of other types
+                    if headers:
+                        writer.writerow(headers)
+                    for item in data:
+                        writer.writerow([str(item)])
+
+                csv_content = output.getvalue()
+            else:
+                csv_content = ""
+
+            # Generate filename if not provided
+            if not filename:
+                filename = f"generated_file_{str(uuid4())[:8]}.csv"
+            elif not filename.endswith(".csv"):
+                filename += ".csv"
+
+            # Save file to disk (if output_directory is set)
+            file_path = self._save_file_to_disk(csv_content, filename)
+
+            # Create FileArtifact
+            file_artifact = File(
+                id=str(uuid4()),
+                content=csv_content,
+                mime_type="text/csv",
+                file_type="csv",
+                filename=filename,
+                size=len(csv_content.encode("utf-8")),
+                url=f"file://{file_path}" if file_path else None,
+            )
+
+            log_debug("CSV file generated successfully")
+            success_msg = f"CSV file '{filename}' has been generated successfully with {len(csv_content)} characters."
+            if file_path:
+                success_msg += f" File saved to: {file_path}"
+            else:
+                success_msg += " File is available in response."
+
+            return ToolResult(content=success_msg, files=[file_artifact])
+
+        except Exception as e:
+            logger.error(f"Failed to generate CSV file: {e}")
+            return ToolResult(content=f"Error generating CSV file: {e}")
+
+    def generate_pdf_file(
+        self, content: str, filename: Optional[str] = None, title: Optional[str] = None
+    ) -> ToolResult:
+        """Generate a PDF file from the provided content.
+
+        Args:
+            content: The text content to write to the PDF file.
+            filename: Optional filename for the generated file. If not provided, a UUID will be used.
+            title: Optional title for the PDF document.
+
+        Returns:
+            ToolResult: Result containing the generated PDF file as a FileArtifact.
+        """
+        if not PDF_AVAILABLE:
+            return ToolResult(
+                content="PDF generation is not available. Please install reportlab: pip install reportlab"
+            )
+
+        try:
+            log_debug(f"Generating PDF file with content length: {len(content)}")
+
+            # Create PDF content in memory
+            buffer = io.BytesIO()
+            doc = SimpleDocTemplate(buffer, pagesize=letter, topMargin=1 * inch)
+
+            # Get styles
+            styles = getSampleStyleSheet()
+            title_style = styles["Title"]
+            normal_style = styles["Normal"]
+
+            # Build story (content elements)
+            story = []
+
+            if title:
+                story.append(Paragraph(title, title_style))
+                story.append(Spacer(1, 20))
+
+            # Split content into paragraphs and add to story
+            paragraphs = content.split("\n\n")
+            for para in paragraphs:
+                if para.strip():
+                    # Clean the paragraph text for PDF
+                    clean_para = para.strip().replace("<", "&lt;").replace(">", "&gt;")
+                    story.append(Paragraph(clean_para, normal_style))
+                    story.append(Spacer(1, 10))
+
+            # Build PDF
+            doc.build(story)
+            pdf_content = buffer.getvalue()
+            buffer.close()
+
+            # Generate filename if not provided
+            if not filename:
+                filename = f"generated_file_{str(uuid4())[:8]}.pdf"
+            elif not filename.endswith(".pdf"):
+                filename += ".pdf"
+
+            # Save file to disk (if output_directory is set)
+            file_path = self._save_file_to_disk(pdf_content, filename)
+
+            # Create FileArtifact
+            file_artifact = File(
+                id=str(uuid4()),
+                content=pdf_content,
+                mime_type="application/pdf",
+                file_type="pdf",
+                filename=filename,
+                size=len(pdf_content),
+                url=f"file://{file_path}" if file_path else None,
+            )
+
+            log_debug("PDF file generated successfully")
+            success_msg = f"PDF file '{filename}' has been generated successfully with {len(pdf_content)} bytes."
+            if file_path:
+                success_msg += f" File saved to: {file_path}"
+            else:
+                success_msg += " File is available in response."
+
+            return ToolResult(content=success_msg, files=[file_artifact])
+
+        except Exception as e:
+            logger.error(f"Failed to generate PDF file: {e}")
+            return ToolResult(content=f"Error generating PDF file: {e}")
+
+    def generate_text_file(self, content: str, filename: Optional[str] = None) -> ToolResult:
+        """Generate a text file from the provided content.
+
+        Args:
+            content: The text content to write to the file.
+            filename: Optional filename for the generated file. If not provided, a UUID will be used.
+
+        Returns:
+            ToolResult: Result containing the generated text file as a FileArtifact.
+        """
+        try:
+            log_debug(f"Generating text file with content length: {len(content)}")
+
+            # Generate filename if not provided
+            if not filename:
+                filename = f"generated_file_{str(uuid4())[:8]}.txt"
+            elif not filename.endswith(".txt"):
+                filename += ".txt"
+
+            # Save file to disk (if output_directory is set)
+            file_path = self._save_file_to_disk(content, filename)
+
+            # Create FileArtifact
+            file_artifact = File(
+                id=str(uuid4()),
+                content=content,
+                mime_type="text/plain",
+                file_type="txt",
+                filename=filename,
+                size=len(content.encode("utf-8")),
+                url=f"file://{file_path}" if file_path else None,
+            )
+
+            log_debug("Text file generated successfully")
+            success_msg = f"Text file '{filename}' has been generated successfully with {len(content)} characters."
+            if file_path:
+                success_msg += f" File saved to: {file_path}"
+            else:
+                success_msg += " File is available in response."
+
+            return ToolResult(content=success_msg, files=[file_artifact])
+
+        except Exception as e:
+            logger.error(f"Failed to generate text file: {e}")
+            return ToolResult(content=f"Error generating text file: {e}")

agno/tools/function.py

@@ -485,6 +485,7 @@ class FunctionExecutionResult(BaseModel):
     images: Optional[List[Image]] = None
     videos: Optional[List[Video]] = None
     audios: Optional[List[Audio]] = None
+    files: Optional[List[File]] = None
 
 
 class FunctionCall(BaseModel):
@@ -965,3 +966,4 @@ class ToolResult(BaseModel):
     images: Optional[List[Image]] = None
     videos: Optional[List[Video]] = None
     audios: Optional[List[Audio]] = None
+    files: Optional[List[File]] = None

agno/tools/mcp.py

@@ -102,7 +102,7 @@ class MCPTools(Toolkit):
         transport: Literal["stdio", "sse", "streamable-http"] = "stdio",
         server_params: Optional[Union[StdioServerParameters, SSEClientParams, StreamableHTTPClientParams]] = None,
         session: Optional[ClientSession] = None,
-        timeout_seconds: int = 5,
+        timeout_seconds: int = 10,
         client=None,
         include_tools: Optional[list[str]] = None,
         exclude_tools: Optional[list[str]] = None,