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

agno/run/agent.py

@@ -337,6 +337,8 @@ class RunInput:
             result["videos"] = [vid.to_dict() for vid in self.videos]
         if self.audios:
             result["audios"] = [aud.to_dict() for aud in self.audios]
+        if self.files:
+            result["files"] = [file.to_dict() for file in self.files]
 
         return result
 
@@ -392,6 +394,7 @@ class RunOutput:
     images: Optional[List[Image]] = None  # Images attached to the response
     videos: Optional[List[Video]] = None  # Videos attached to the response
     audio: Optional[List[Audio]] = None  # Audio attached to the response
+    files: Optional[List[File]] = None  # Files attached to the response
     response_audio: Optional[Audio] = None  # Model audio response
 
     # Input media and messages from user
@@ -446,6 +449,7 @@ class RunOutput:
                 "images",
                 "videos",
                 "audio",
+                "files",
                 "response_audio",
                 "input",
                 "citations",
@@ -508,6 +512,14 @@ class RunOutput:
                 else:
                     _dict["audio"].append(aud)
 
+        if self.files is not None:
+            _dict["files"] = []
+            for file in self.files:
+                if isinstance(file, File):
+                    _dict["files"].append(file.to_dict())
+                else:
+                    _dict["files"].append(file)
+
         if self.response_audio is not None:
             if isinstance(self.response_audio, Audio):
                 _dict["response_audio"] = self.response_audio.to_dict()
@@ -576,6 +588,9 @@ class RunOutput:
         audio = data.pop("audio", [])
         audio = [Audio.model_validate(audio) for audio in audio] if audio else None
 
+        files = data.pop("files", [])
+        files = [File.model_validate(file) for file in files] if files else None
+
         response_audio = data.pop("response_audio", None)
         response_audio = Audio.model_validate(response_audio) if response_audio else None
 
@@ -613,6 +628,7 @@ class RunOutput:
             images=images,
             audio=audio,
             videos=videos,
+            files=files,
             response_audio=response_audio,
             input=input_obj,
             events=events,

agno/run/team.py

@@ -321,6 +321,8 @@ class TeamRunInput:
             result["videos"] = [vid.to_dict() for vid in self.videos]
         if self.audios:
             result["audios"] = [aud.to_dict() for aud in self.audios]
+        if self.files:
+            result["files"] = [file.to_dict() for file in self.files]
 
         return result
 
@@ -370,6 +372,7 @@ class TeamRunOutput:
     images: Optional[List[Image]] = None  # Images from member runs
     videos: Optional[List[Video]] = None  # Videos from member runs
     audio: Optional[List[Audio]] = None  # Audio from member runs
+    files: Optional[List[File]] = None  # Files from member runs
 
     response_audio: Optional[Audio] = None  # Model audio response
 
@@ -419,6 +422,7 @@ class TeamRunOutput:
                 "images",
                 "videos",
                 "audio",
+                "files",
                 "response_audio",
                 "citations",
                 "events",
@@ -461,6 +465,9 @@ class TeamRunOutput:
         if self.audio is not None:
             _dict["audio"] = [aud.to_dict() for aud in self.audio]
 
+        if self.files is not None:
+            _dict["files"] = [file.to_dict() for file in self.files]
+
         if self.response_audio is not None:
             _dict["response_audio"] = self.response_audio.to_dict()
 
@@ -555,6 +562,9 @@ class TeamRunOutput:
         audio = data.pop("audio", [])
         audio = [Audio.model_validate(audio) for audio in audio] if audio else None
 
+        files = data.pop("files", [])
+        files = [File.model_validate(file) for file in files] if files else None
+
         tools = data.pop("tools", [])
         tools = [ToolExecution.from_dict(tool) for tool in tools] if tools else None
 
@@ -584,6 +594,7 @@ class TeamRunOutput:
             images=images,
             videos=videos,
             audio=audio,
+            files=files,
             response_audio=response_audio,
             input=input_obj,
             citations=citations,
@@ -618,3 +629,7 @@ class TeamRunOutput:
             if self.audio is None:
                 self.audio = []
             self.audio.extend(run_response.audio)
+        if run_response.files is not None:
+            if self.files is None:
+                self.files = []
+            self.files.extend(run_response.files)

agno/run/workflow.py

@@ -462,6 +462,7 @@ def workflow_run_output_event_from_dict(data: dict) -> BaseWorkflowRunOutputEven
 class WorkflowRunOutput:
     """Response returned by Workflow.run() functions - kept for backwards compatibility"""
 
+    input: Optional[Union[str, Dict[str, Any], List[Any], BaseModel]] = None
     content: Optional[Union[str, Dict[str, Any], List[Any], BaseModel, Any]] = None
     content_type: str = "str"
 
@@ -553,6 +554,12 @@ class WorkflowRunOutput:
         if self.metrics is not None:
             _dict["metrics"] = self.metrics.to_dict()
 
+        if self.input is not None:
+            if isinstance(self.input, BaseModel):
+                _dict["input"] = self.input.model_dump(exclude_none=True)
+            else:
+                _dict["input"] = self.input
+
         if self.content and isinstance(self.content, BaseModel):
             _dict["content"] = self.content.model_dump(exclude_none=True)
 
@@ -624,6 +631,8 @@ class WorkflowRunOutput:
             final_events.append(event)
         events = final_events
 
+        input_data = data.pop("input", None)
+
         return cls(
             step_results=parsed_step_results,
             metadata=metadata,
@@ -634,6 +643,7 @@ class WorkflowRunOutput:
             events=events,
             metrics=workflow_metrics,
             step_executor_runs=step_executor_runs,
+            input=input_data,
             **data,
         )
 

agno/team/team.py

@@ -1121,13 +1121,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
@@ -1739,13 +1743,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 +1971,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
     ):
@@ -3118,6 +3130,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 +3162,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,
@@ -6259,6 +6282,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/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