agno 2.2.4__py3-none-any.whl → 2.2.6__py3-none-any.whl

agno/team/team.py

@@ -45,6 +45,7 @@ from agno.models.base import Model
 from agno.models.message import Message, MessageReferences
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse, ModelResponseEvent
+from agno.models.utils import get_model
 from agno.reasoning.step import NextAction, ReasoningStep, ReasoningSteps
 from agno.run.agent import RunEvent, RunOutput, RunOutputEvent
 from agno.run.base import RunStatus
@@ -437,7 +438,7 @@ class Team:
         self,
         members: List[Union[Agent, "Team"]],
         id: Optional[str] = None,
-        model: Optional[Model] = None,
+        model: Optional[Union[Model, str]] = None,
         name: Optional[str] = None,
         role: Optional[str] = None,
         respond_directly: bool = False,
@@ -498,9 +499,9 @@ class Team:
         post_hooks: Optional[Union[List[Callable[..., Any]], List[BaseGuardrail]]] = None,
         input_schema: Optional[Type[BaseModel]] = None,
         output_schema: Optional[Type[BaseModel]] = None,
-        parser_model: Optional[Model] = None,
+        parser_model: Optional[Union[Model, str]] = None,
         parser_model_prompt: Optional[str] = None,
-        output_model: Optional[Model] = None,
+        output_model: Optional[Union[Model, str]] = None,
         output_model_prompt: Optional[str] = None,
         use_json_mode: bool = False,
         parse_response: bool = True,
@@ -514,7 +515,7 @@ class Team:
         add_session_summary_to_context: Optional[bool] = None,
         metadata: Optional[Dict[str, Any]] = None,
         reasoning: bool = False,
-        reasoning_model: Optional[Model] = None,
+        reasoning_model: Optional[Union[Model, str]] = None,
         reasoning_agent: Optional[Agent] = None,
         reasoning_min_steps: int = 1,
         reasoning_max_steps: int = 10,
@@ -535,7 +536,7 @@ class Team:
     ):
         self.members = members
 
-        self.model = model
+        self.model = model  # type: ignore[assignment]
 
         self.name = name
         self.id = id
@@ -618,9 +619,9 @@ class Team:
 
         self.input_schema = input_schema
         self.output_schema = output_schema
-        self.parser_model = parser_model
+        self.parser_model = parser_model  # type: ignore[assignment]
         self.parser_model_prompt = parser_model_prompt
-        self.output_model = output_model
+        self.output_model = output_model  # type: ignore[assignment]
         self.output_model_prompt = output_model_prompt
         self.use_json_mode = use_json_mode
         self.parse_response = parse_response
@@ -637,7 +638,7 @@ class Team:
         self.metadata = metadata
 
         self.reasoning = reasoning
-        self.reasoning_model = reasoning_model
+        self.reasoning_model = reasoning_model  # type: ignore[assignment]
         self.reasoning_agent = reasoning_agent
         self.reasoning_min_steps = reasoning_min_steps
         self.reasoning_max_steps = reasoning_max_steps
@@ -694,6 +695,8 @@ class Team:
         # Lazy-initialized shared thread pool executor for background tasks (memory, cultural knowledge, etc.)
         self._background_executor: Optional[Any] = None
 
+        self._resolve_models()
+
     @property
     def background_executor(self) -> Any:
         """Lazy initialization of shared thread pool executor for background tasks.
@@ -902,6 +905,17 @@ class Team:
         """Return True if the db the team is equipped with is an Async implementation"""
         return self.db is not None and isinstance(self.db, AsyncBaseDb)
 
+    def _resolve_models(self) -> None:
+        """Resolve model strings to Model instances."""
+        if self.model is not None:
+            self.model = get_model(self.model)
+        if self.reasoning_model is not None:
+            self.reasoning_model = get_model(self.reasoning_model)
+        if self.parser_model is not None:
+            self.parser_model = get_model(self.parser_model)
+        if self.output_model is not None:
+            self.output_model = get_model(self.output_model)
+
     def initialize_team(self, debug_mode: Optional[bool] = None) -> None:
         # Make sure for the team, we are using the team logger
         use_team_logger()
@@ -1593,6 +1607,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
+                    session_state=session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -1604,6 +1619,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
+                    session_state=session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     from agno.run.team import IntermediateRunContentEvent, RunContentEvent
@@ -1932,6 +1948,7 @@ class Team:
             team_id=self.id,
             team_name=self.name,
             metadata=metadata,
+            session_state=session_state,
             input=run_input,
         )
 
@@ -2439,6 +2456,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
+                    session_state=session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     yield event
@@ -2450,6 +2468,7 @@ class Team:
                     tools=_tools,
                     response_format=response_format,
                     stream_events=stream_events,
+                    session_state=session_state,
                 ):
                     raise_if_cancelled(run_response.run_id)  # type: ignore
                     from agno.run.team import IntermediateRunContentEvent, RunContentEvent
@@ -2771,6 +2790,7 @@ class Team:
             team_id=self.id,
             team_name=self.name,
             metadata=metadata,
+            session_state=session_state,
             input=run_input,
         )
 
@@ -2930,6 +2950,12 @@ class Team:
         if model_response.audio is not None:
             run_response.response_audio = model_response.audio
 
+        # Update session_state with changes from model response
+        if model_response.updated_session_state is not None and run_response.session_state is not None:
+            from agno.utils.merge_dict import merge_dictionaries
+
+            merge_dictionaries(run_response.session_state, model_response.updated_session_state)
+
         # 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]
 
@@ -2954,6 +2980,7 @@ class Team:
         tools: Optional[List[Union[Function, dict]]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
+        session_state: Optional[Dict[str, Any]] = None,
     ) -> Iterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         self.model = cast(Model, self.model)
 
@@ -2985,6 +3012,7 @@ class Team:
                 reasoning_state=reasoning_state,
                 stream_events=stream_events,
                 parse_structured_output=self.should_parse_structured_output,
+                session_state=session_state,
             )
 
         # 3. Update TeamRunOutput
@@ -3036,6 +3064,7 @@ class Team:
         tools: Optional[List[Union[Function, dict]]] = None,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
         stream_events: bool = False,
+        session_state: Optional[Dict[str, Any]] = None,
     ) -> AsyncIterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         self.model = cast(Model, self.model)
 
@@ -3068,6 +3097,7 @@ class Team:
                 reasoning_state=reasoning_state,
                 stream_events=stream_events,
                 parse_structured_output=self.should_parse_structured_output,
+                session_state=session_state,
             ):
                 yield event
 
@@ -3122,6 +3152,7 @@ class Team:
         reasoning_state: Optional[Dict[str, Any]] = None,
         stream_events: bool = False,
         parse_structured_output: bool = False,
+        session_state: Optional[Dict[str, Any]] = None,
     ) -> Iterator[Union[TeamRunOutputEvent, RunOutputEvent]]:
         if isinstance(model_response_event, tuple(get_args(RunOutputEvent))) or isinstance(
             model_response_event, tuple(get_args(TeamRunOutputEvent))
@@ -3299,10 +3330,15 @@ class Team:
 
             # If the model response is a tool_call_completed, update the existing tool call in the run_response
             elif model_response_event.event == ModelResponseEvent.tool_call_completed.value:
-                if model_response_event.updated_session_state is not None and session.session_data is not None:
-                    merge_dictionaries(
-                        session.session_data["session_state"], model_response_event.updated_session_state
-                    )
+                if model_response_event.updated_session_state is not None:
+                    # Update the session_state variable that TeamRunOutput references
+                    if session_state is not None:
+                        merge_dictionaries(session_state, model_response_event.updated_session_state)
+                    # Also update the DB session object
+                    if session.session_data is not None:
+                        merge_dictionaries(
+                            session.session_data["session_state"], model_response_event.updated_session_state
+                        )
 
                 if model_response_event.images is not None:
                     for image in model_response_event.images:
@@ -4498,7 +4534,7 @@ class Team:
                         store_events=self.store_events,
                     )
             else:
-                log_warning(
+                log_info(
                     f"Reasoning model: {reasoning_model.__class__.__name__} is not a native reasoning model, defaulting to manual Chain-of-Thought reasoning"
                 )
                 use_default_reasoning = True
@@ -4779,7 +4815,7 @@ class Team:
                         store_events=self.store_events,
                     )
             else:
-                log_warning(
+                log_info(
                     f"Reasoning model: {reasoning_model.__class__.__name__} is not a native reasoning model, defaulting to manual Chain-of-Thought reasoning"
                 )
                 use_default_reasoning = True

agno/tools/file.py

@@ -1,9 +1,9 @@
 import json
 from pathlib import Path
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Tuple
 
 from agno.tools import Toolkit
-from agno.utils.log import log_debug, log_error, log_info
+from agno.utils.log import log_debug, log_error
 
 
 class FileTools(Toolkit):
@@ -12,14 +12,26 @@ class FileTools(Toolkit):
         base_dir: Optional[Path] = None,
         enable_save_file: bool = True,
         enable_read_file: bool = True,
+        enable_delete_file: bool = False,
         enable_list_files: bool = True,
         enable_search_files: bool = True,
+        enable_read_file_chunk: bool = True,
+        enable_replace_file_chunk: bool = True,
+        expose_base_directory: bool = False,
+        max_file_length: int = 10000000,
+        max_file_lines: int = 100000,
+        line_separator: str = "\n",
         all: bool = False,
         **kwargs,
     ):
         self.base_dir: Path = base_dir or Path.cwd()
+        self.base_dir = self.base_dir.resolve()
 
         tools: List[Any] = []
+        self.max_file_length = max_file_length
+        self.max_file_lines = max_file_lines
+        self.line_separator = line_separator
+        self.expose_base_directory = expose_base_directory
         if all or enable_save_file:
             tools.append(self.save_file)
         if all or enable_read_file:
@@ -28,10 +40,16 @@ class FileTools(Toolkit):
             tools.append(self.list_files)
         if all or enable_search_files:
             tools.append(self.search_files)
+        if all or enable_delete_file:
+            tools.append(self.delete_file)
+        if all or enable_read_file_chunk:
+            tools.append(self.read_file_chunk)
+        if all or enable_replace_file_chunk:
+            tools.append(self.replace_file_chunk)
 
         super().__init__(name="file_tools", tools=tools, **kwargs)
 
-    def save_file(self, contents: str, file_name: str, overwrite: bool = True) -> str:
+    def save_file(self, contents: str, file_name: str, overwrite: bool = True, encoding: str = "utf-8") -> str:
         """Saves the contents to a file called `file_name` and returns the file name if successful.
 
         :param contents: The contents to save.
@@ -40,44 +58,146 @@ class FileTools(Toolkit):
         :return: The file name if successful, otherwise returns an error message.
         """
         try:
-            file_path = self.base_dir.joinpath(file_name)
+            safe, file_path = self.check_escape(file_name)
+            if not (safe):
+                log_error(f"Attempted to save file: {file_name}")
+                return "Error saving file"
             log_debug(f"Saving contents to {file_path}")
             if not file_path.parent.exists():
                 file_path.parent.mkdir(parents=True, exist_ok=True)
             if file_path.exists() and not overwrite:
                 return f"File {file_name} already exists"
-            file_path.write_text(contents)
-            log_info(f"Saved: {file_path}")
+            file_path.write_text(contents, encoding=encoding)
+            log_debug(f"Saved: {file_path}")
             return str(file_name)
         except Exception as e:
             log_error(f"Error saving to file: {e}")
             return f"Error saving to file: {e}"
 
-    def read_file(self, file_name: str) -> str:
+    def read_file_chunk(self, file_name: str, start_line: int, end_line: int, encoding: str = "utf-8") -> str:
+        """Reads the contents of the file `file_name` and returns lines from start_line to end_line.
+
+        :param file_name: The name of the file to read.
+        :param start_line: Number of first line in the returned chunk
+        :param end_line: Number of the last line in the returned chunk
+        :param encoding: Encoding to use, default - utf-8
+
+        :return: The contents of the selected chunk
+        """
+        try:
+            log_debug(f"Reading file: {file_name}")
+            safe, file_path = self.check_escape(file_name)
+            if not (safe):
+                log_error(f"Attempted to read file: {file_name}")
+                return "Error reading file"
+            contents = file_path.read_text(encoding=encoding)
+            lines = contents.split(self.line_separator)
+            return self.line_separator.join(lines[start_line : end_line + 1])
+        except Exception as e:
+            log_error(f"Error reading file: {e}")
+            return f"Error reading file: {e}"
+
+    def replace_file_chunk(
+        self, file_name: str, start_line: int, end_line: int, chunk: str, encoding: str = "utf-8"
+    ) -> str:
+        """Reads the contents of the file, replaces lines
+        between start_line and end_line with chunk and writes the file
+
+        :param file_name: The name of the file to process.
+        :param start_line: Number of first line in the replaced chunk
+        :param end_line: Number of the last line in the replaced chunk
+        :param chunk: String to be inserted instead of lines from start_line to end_line. Can have multiple lines.
+        :param encoding: Encoding to use, default - utf-8
+
+        :return: file name if successfull, error message otherwise
+        """
+        try:
+            log_debug(f"Patching file: {file_name}")
+            safe, file_path = self.check_escape(file_name)
+            if not (safe):
+                log_error(f"Attempted to read file: {file_name}")
+                return "Error reading file"
+            contents = file_path.read_text(encoding=encoding)
+            lines = contents.split(self.line_separator)
+            start = lines[0:start_line]
+            end = lines[end_line + 1 :]
+            return self.save_file(
+                file_name=file_name, contents=self.line_separator.join(start + [chunk] + end), encoding=encoding
+            )
+        except Exception as e:
+            log_error(f"Error patching file: {e}")
+            return f"Error patching file: {e}"
+
+    def read_file(self, file_name: str, encoding: str = "utf-8") -> str:
         """Reads the contents of the file `file_name` and returns the contents if successful.
 
         :param file_name: The name of the file to read.
+        :param encoding: Encoding to use, default - utf-8
         :return: The contents of the file if successful, otherwise returns an error message.
         """
         try:
-            log_info(f"Reading file: {file_name}")
-            file_path = self.base_dir.joinpath(file_name)
-            contents = file_path.read_text(encoding="utf-8")
+            log_debug(f"Reading file: {file_name}")
+            safe, file_path = self.check_escape(file_name)
+            if not (safe):
+                log_error(f"Attempted to read file: {file_name}")
+                return "Error reading file"
+            contents = file_path.read_text(encoding=encoding)
+            if len(contents) > self.max_file_length:
+                return "Error reading file: file too long. Use read_file_chunk instead"
+            if len(contents.split(self.line_separator)) > self.max_file_lines:
+                return "Error reading file: file too long. Use read_file_chunk instead"
+
             return str(contents)
         except Exception as e:
             log_error(f"Error reading file: {e}")
             return f"Error reading file: {e}"
 
-    def list_files(self) -> str:
-        """Returns a list of files in the base directory
+    def delete_file(self, file_name: str) -> str:
+        """Deletes a file
+        :param file_name: Name of the file to delete
+
+        :return: Empty string, if operation succeeded, otherwise returns an error message
+        """
+        safe, path = self.check_escape(file_name)
+        try:
+            if safe:
+                if path.is_dir():
+                    path.rmdir()
+                    return ""
+                path.unlink()
+                return ""
+            else:
+                log_error(f"Attempt to delete file outside {self.base_dir}: {file_name}")
+                return "Incorrect file_name"
+        except Exception as e:
+            log_error(f"Error removing {file_name}: {e}")
+            return f"Error removing file: {e}"
+
+    def check_escape(self, relative_path: str) -> Tuple[bool, Path]:
+        d = self.base_dir.joinpath(Path(relative_path)).resolve()
+        if self.base_dir == d:
+            return True, d
+        try:
+            d.relative_to(self.base_dir)
+        except ValueError:
+            log_error("Attempted to escape base_dir")
+            return False, self.base_dir
+        return True, d
+
+    def list_files(self, **kwargs) -> str:
+        """Returns a list of files in directory
+        :param directory: (Optional) name of directory to list.
 
         :return: The contents of the file if successful, otherwise returns an error message.
         """
+        directory = kwargs.get("directory", ".")
         try:
-            log_info(f"Reading files in : {self.base_dir}")
-            return json.dumps(
-                [str(file_path.relative_to(self.base_dir)) for file_path in self.base_dir.iterdir()], indent=4
-            )
+            log_debug(f"Reading files in : {self.base_dir}/{directory}")
+            safe, d = self.check_escape(directory)
+            if safe:
+                return json.dumps([str(file_path.relative_to(self.base_dir)) for file_path in d.iterdir()], indent=4)
+            else:
+                return "{}"
         except Exception as e:
             log_error(f"Error reading files: {e}")
             return f"Error reading files: {e}"
@@ -94,15 +214,23 @@ class FileTools(Toolkit):
 
             log_debug(f"Searching files in {self.base_dir} with pattern {pattern}")
             matching_files = list(self.base_dir.glob(pattern))
-
-            file_paths = [str(file_path.relative_to(self.base_dir)) for file_path in matching_files]
-
-            result = {
-                "pattern": pattern,
-                "base_directory": str(self.base_dir),
-                "matches_found": len(file_paths),
-                "files": file_paths,
-            }
+            result = None
+            if self.expose_base_directory:
+                file_paths = [str(file_path) for file_path in matching_files]
+                result = {
+                    "pattern": pattern,
+                    "matches_found": len(file_paths),
+                    "base_directory": str(self.base_dir),
+                    "files": file_paths,
+                }
+            else:
+                file_paths = [str(file_path.relative_to(self.base_dir)) for file_path in matching_files]
+
+                result = {
+                    "pattern": pattern,
+                    "matches_found": len(file_paths),
+                    "files": file_paths,
+                }
             log_debug(f"Found {len(file_paths)} files matching pattern {pattern}")
             return json.dumps(result, indent=2)
 

agno/tools/function.py

@@ -440,7 +440,7 @@ class Function(BaseModel):
     @staticmethod
     def _wrap_callable(func: Callable) -> Callable:
         """Wrap a callable with Pydantic's validate_call decorator, if relevant"""
-        from inspect import isasyncgenfunction, iscoroutinefunction
+        from inspect import isasyncgenfunction, iscoroutinefunction, signature
 
         pydantic_version = Version(version("pydantic"))
 
@@ -458,6 +458,10 @@ class Function(BaseModel):
         # Don't wrap callables that are already wrapped with validate_call
         elif getattr(func, "_wrapped_for_validation", False):
             return func
+        # Don't wrap functions with session_state parameter
+        # session_state needs to be passed by reference, not copied by pydantic's validation
+        elif "session_state" in signature(func).parameters:
+            return func
         # Wrap the callable with validate_call
         else:
             wrapped = validate_call(func, config=dict(arbitrary_types_allowed=True))  # type: ignore