agno 2.0.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

agno/tools/dalle.py

@@ -1,10 +1,8 @@
 from os import getenv
-from typing import Any, List, Literal, Optional, Union
+from typing import Any, List, Literal, Optional
 from uuid import uuid4
 
-from agno.agent import Agent
 from agno.media import Image
-from agno.team.team import Team
 from agno.tools import Toolkit
 from agno.tools.function import ToolResult
 from agno.utils.log import log_debug, logger
@@ -64,7 +62,7 @@ class DalleTools(Toolkit):
         # - Add support for saving images
         # - Add support for editing images
 
-    def create_image(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
+    def create_image(self, prompt: str) -> ToolResult:
         """Use this function to generate an image for a prompt.
 
         Args:

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/duckduckgo.py

@@ -12,14 +12,16 @@ except ImportError:
 
 class DuckDuckGoTools(Toolkit):
     """
-    DuckDuckGo is a toolkit for searching DuckDuckGo easily.
+    DuckDuckGo is a toolkit for searching using DuckDuckGo easily.
+    It uses the meta-search library DDGS, so it also has access to other backends.
     Args:
-        search (bool): Enable DuckDuckGo search function.
-        news (bool): Enable DuckDuckGo news function.
+        enable_search (bool): Enable DDGS search function.
+        enable_news (bool): Enable DDGS news function.
         modifier (Optional[str]): A modifier to be used in the search request.
         fixed_max_results (Optional[int]): A fixed number of maximum results.
         proxy (Optional[str]): Proxy to be used in the search request.
         timeout (Optional[int]): The maximum number of seconds to wait for a response.
+        backend (Optional[str]): The backend to be used in the search request.
 
     """
 
@@ -28,6 +30,7 @@ class DuckDuckGoTools(Toolkit):
         enable_search: bool = True,
         enable_news: bool = True,
         all: bool = False,
+        backend: str = "duckduckgo",
         modifier: Optional[str] = None,
         fixed_max_results: Optional[int] = None,
         proxy: Optional[str] = None,
@@ -40,6 +43,7 @@ class DuckDuckGoTools(Toolkit):
         self.fixed_max_results: Optional[int] = fixed_max_results
         self.modifier: Optional[str] = modifier
         self.verify_ssl: bool = verify_ssl
+        self.backend: str = backend
 
         tools: List[Any] = []
         if all or enable_search:
@@ -50,38 +54,38 @@ class DuckDuckGoTools(Toolkit):
         super().__init__(name="duckduckgo", tools=tools, **kwargs)
 
     def duckduckgo_search(self, query: str, max_results: int = 5) -> str:
-        """Use this function to search DuckDuckGo for a query.
+        """Use this function to search DDGS for a query.
 
         Args:
             query(str): The query to search for.
             max_results (optional, default=5): The maximum number of results to return.
 
         Returns:
-            The result from DuckDuckGo.
+            The result from DDGS.
         """
         actual_max_results = self.fixed_max_results or max_results
         search_query = f"{self.modifier} {query}" if self.modifier else query
 
-        log_debug(f"Searching DDG for: {search_query}")
+        log_debug(f"Searching DDG for: {search_query} using backend: {self.backend}")
         with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
-            results = ddgs.text(query=search_query, max_results=actual_max_results)
+            results = ddgs.text(query=search_query, max_results=actual_max_results, backend=self.backend)
 
         return json.dumps(results, indent=2)
 
     def duckduckgo_news(self, query: str, max_results: int = 5) -> str:
-        """Use this function to get the latest news from DuckDuckGo.
+        """Use this function to get the latest news from DDGS.
 
         Args:
             query(str): The query to search for.
             max_results (optional, default=5): The maximum number of results to return.
 
         Returns:
-            The latest news from DuckDuckGo.
+            The latest news from DDGS.
         """
         actual_max_results = self.fixed_max_results or max_results
 
-        log_debug(f"Searching DDG news for: {query}")
+        log_debug(f"Searching DDG news for: {query} using backend: {self.backend}")
         with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
-            results = ddgs.news(query=query, max_results=actual_max_results)
+            results = ddgs.news(query=query, max_results=actual_max_results, backend=self.backend)
 
         return json.dumps(results, indent=2)

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/eleven_labs.py

@@ -1,4 +1,3 @@
-from base64 import b64encode
 from io import BytesIO
 from os import getenv, path
 from pathlib import Path
@@ -10,7 +9,7 @@ from agno.media import Audio
 from agno.team.team import Team
 from agno.tools import Toolkit
 from agno.tools.function import ToolResult
-from agno.utils.log import logger
+from agno.utils.log import log_error, log_info
 
 try:
     from elevenlabs import ElevenLabs  # type: ignore
@@ -48,7 +47,7 @@ class ElevenLabsTools(Toolkit):
     ):
         self.api_key = api_key or getenv("ELEVEN_LABS_API_KEY")
         if not self.api_key:
-            logger.error("ELEVEN_LABS_API_KEY not set. Please set the ELEVEN_LABS_API_KEY environment variable.")
+            log_error("ELEVEN_LABS_API_KEY not set. Please set the ELEVEN_LABS_API_KEY environment variable.")
 
         self.target_directory = target_directory
         self.voice_id = voice_id
@@ -73,7 +72,7 @@ class ElevenLabsTools(Toolkit):
 
     def get_voices(self) -> str:
         """
-        Use this function to get all the voices available.
+        Get all the voices available.
 
         Returns:
             result (list): A list of voices that have an ID, name and description.
@@ -94,20 +93,19 @@ class ElevenLabsTools(Toolkit):
             return str(response)
 
         except Exception as e:
-            logger.error(f"Failed to fetch voices: {e}")
+            log_error(f"Failed to fetch voices: {e}")
             return f"Error: {e}"
 
-    def _process_audio(self, audio_generator: Iterator[bytes]) -> str:
-        # Step 1: Write audio data to BytesIO
+    def _process_audio(self, audio_generator: Iterator[bytes]) -> bytes:
         audio_bytes = BytesIO()
         for chunk in audio_generator:
             audio_bytes.write(chunk)
-        audio_bytes.seek(0)  # Rewind the stream
 
-        # Step 2: Encode as Base64
-        base64_audio = b64encode(audio_bytes.read()).decode("utf-8")
+        # Read bytes
+        audio_bytes.seek(0)
+        audio_data = audio_bytes.read()
 
-        # Step 3: Optionally save to disk if target_directory exists
+        # Save to disk if target_directory exists
         if self.target_directory:
             # Determine file extension based on output format
             if self.output_format.startswith("mp3"):
@@ -122,19 +120,19 @@ class ElevenLabsTools(Toolkit):
             output_filename = f"{uuid4()}.{extension}"
             output_path = path.join(self.target_directory, output_filename)
 
-            # Write from BytesIO to disk
-            audio_bytes.seek(0)  # Reset the BytesIO stream again
             with open(output_path, "wb") as f:
-                f.write(audio_bytes.read())
+                f.write(audio_data)
 
-        return base64_audio
+            log_info(f"Audio saved to: {output_path}")
+
+        return audio_data
 
     def generate_sound_effect(self, prompt: str, duration_seconds: Optional[float] = None) -> ToolResult:
         """
-        Use this function to generate sound effect audio from a text prompt.
+        Generate a sound effect from a text description.
 
         Args:
-            prompt (str): Text to generate audio from.
+            prompt (str): Description of the sound effect
             duration_seconds (Optional[float]): Duration in seconds to generate audio from. Has to be between 0.5 and 22.
         Returns:
             ToolResult: A ToolResult containing the generated audio or error message.
@@ -144,27 +142,27 @@ class ElevenLabsTools(Toolkit):
                 text=prompt, duration_seconds=duration_seconds
             )
 
-            base64_audio = self._process_audio(audio_generator)
+            audio_data = self._process_audio(audio_generator)
 
             # Create AudioArtifact
             audio_artifact = Audio(
                 id=str(uuid4()),
-                base64_audio=base64_audio,
+                content=audio_data,
                 mime_type="audio/mpeg",
             )
 
             return ToolResult(
-                content="Audio generated successfully",
+                content="Sound effect generated successfully",
                 audios=[audio_artifact],
             )
 
         except Exception as e:
-            logger.error(f"Failed to generate audio: {e}")
+            log_error(f"Failed to generate sound effect: {e}")
             return ToolResult(content=f"Error: {e}")
 
     def text_to_speech(self, agent: Union[Agent, Team], prompt: str) -> ToolResult:
         """
-        Use this function to convert text to speech audio.
+        Convert text to speech.
 
         Args:
             prompt (str): Text to generate audio from.
@@ -179,12 +177,12 @@ class ElevenLabsTools(Toolkit):
                 output_format=self.output_format,
             )
 
-            base64_audio = self._process_audio(audio_generator)
+            audio_data = self._process_audio(audio_generator)
 
             # Create AudioArtifact
             audio_artifact = Audio(
                 id=str(uuid4()),
-                base64_audio=base64_audio,
+                content=audio_data,
                 mime_type="audio/mpeg",
             )
 
@@ -194,5 +192,5 @@ class ElevenLabsTools(Toolkit):
             )
 
         except Exception as e:
-            logger.error(f"Failed to generate audio: {e}")
+            log_error(f"Failed to generate audio: {e}")
             return ToolResult(content=f"Error: {e}")

agno/tools/exa.py

@@ -27,14 +27,14 @@ class ExaTools(Toolkit):
         all (bool): Enable all tools. Overrides individual flags when True. Default is False.
         text (bool): Retrieve text content from results. Default is True.
         text_length_limit (int): Max length of text content per result. Default is 1000.
-        highlights (bool): Include highlighted snippets. Default is True.
+        highlights (bool): Include highlighted snippets. Deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.
         api_key (Optional[str]): Exa API key. Retrieved from `EXA_API_KEY` env variable if not provided.
         num_results (Optional[int]): Default number of search results. Overrides individual searches if set.
         start_crawl_date (Optional[str]): Include results crawled on/after this date (`YYYY-MM-DD`).
         end_crawl_date (Optional[str]): Include results crawled on/before this date (`YYYY-MM-DD`).
         start_published_date (Optional[str]): Include results published on/after this date (`YYYY-MM-DD`).
         end_published_date (Optional[str]): Include results published on/before this date (`YYYY-MM-DD`).
-        use_autoprompt (Optional[bool]): Enable autoprompt features in queries.
+        use_autoprompt (Optional[bool]): Enable autoprompt features in queries. Deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.
         type (Optional[str]): Specify content type (e.g., article, blog, video).
         category (Optional[str]): Filter results by category. Options are "company", "research paper", "news", "pdf", "github", "tweet", "personal site", "linkedin profile", "financial report".
         include_domains (Optional[List[str]]): Restrict results to these domains.
@@ -54,7 +54,7 @@ class ExaTools(Toolkit):
         all: bool = False,
         text: bool = True,
         text_length_limit: int = 1000,
-        highlights: bool = True,
+        highlights: Optional[bool] = None,  # Deprecated
         summary: bool = False,
         api_key: Optional[str] = None,
         num_results: Optional[int] = None,
@@ -84,7 +84,24 @@ class ExaTools(Toolkit):
 
         self.text: bool = text
         self.text_length_limit: int = text_length_limit
-        self.highlights: bool = highlights
+
+        if highlights:
+            import warnings
+
+            warnings.warn(
+                "The 'highlights' parameter is deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        if use_autoprompt:
+            import warnings
+
+            warnings.warn(
+                "The 'use_autoprompt' parameter is deprecated since it was removed in the Exa API. It will be removed from Agno in a future release.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         self.summary: bool = summary
         self.num_results: Optional[int] = num_results
         self.livecrawl: str = livecrawl
@@ -92,7 +109,6 @@ class ExaTools(Toolkit):
         self.end_crawl_date: Optional[str] = end_crawl_date
         self.start_published_date: Optional[str] = start_published_date
         self.end_published_date: Optional[str] = end_published_date
-        self.use_autoprompt: Optional[bool] = use_autoprompt
         self.type: Optional[str] = type
         self.category: Optional[str] = category
         self.include_domains: Optional[List[str]] = include_domains
@@ -140,13 +156,6 @@ class ExaTools(Toolkit):
                 if self.text_length_limit:
                     _text = _text[: self.text_length_limit]
                 result_dict["text"] = _text
-            if self.highlights:
-                try:
-                    if result.highlights:  # type: ignore
-                        result_dict["highlights"] = result.highlights  # type: ignore
-                except Exception as e:
-                    log_debug(f"Failed to get highlights {e}")
-                    result_dict["highlights"] = f"Failed to get highlights {e}"
             exa_results_parsed.append(result_dict)
         return json.dumps(exa_results_parsed, indent=4, ensure_ascii=False)
 
@@ -168,14 +177,12 @@ class ExaTools(Toolkit):
                 log_info(f"Searching exa for: {query}")
             search_kwargs: Dict[str, Any] = {
                 "text": self.text,
-                "highlights": self.highlights,
                 "summary": self.summary,
                 "num_results": self.num_results or num_results,
                 "start_crawl_date": self.start_crawl_date,
                 "end_crawl_date": self.end_crawl_date,
                 "start_published_date": self.start_published_date,
                 "end_published_date": self.end_published_date,
-                "use_autoprompt": self.use_autoprompt,
                 "type": self.type,
                 "category": self.category or category,  # Prefer a user-set category
                 "include_domains": self.include_domains,
@@ -212,7 +219,6 @@ class ExaTools(Toolkit):
 
         query_kwargs: Dict[str, Any] = {
             "text": self.text,
-            "highlights": self.highlights,
             "summary": self.summary,
         }
 
@@ -249,7 +255,6 @@ class ExaTools(Toolkit):
 
         query_kwargs: Dict[str, Any] = {
             "text": self.text,
-            "highlights": self.highlights,
             "summary": self.summary,
             "include_domains": self.include_domains,
             "exclude_domains": self.exclude_domains,

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,42 +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) 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}"
@@ -92,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) 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)