From fd4ef4f47a17d12c17c6ee203fce99f2096d01d9 Mon Sep 17 00:00:00 2001 From: Lucas Gomide Date: Mon, 5 May 2025 15:15:50 -0300 Subject: [PATCH] fix: Remove kwargs from all RagTools (#285) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: remove kwargs from all (except mysql & pg) RagTools The agent uses the tool description to decide what to propagate when a tool with **kwargs is found, but this often leads to failures during the tool invocation step. This happens because the final description ends up like this: ``` CrewStructuredTool(name='Knowledge base', description='Tool Name: Knowledge base Tool Arguments: {'query': {'description': None, 'type': 'str'}, 'kwargs': {'description': None, 'type': 'Any'}} Tool Description: A knowledge base that can be used to answer questions.') ``` The agent then tries to infer and pass a kwargs parameter, which isn’t supported by the schema at all. * feat: adding test to search tools * feat: add db (chromadb folder) to .gitignore * fix: fix github search integration A few attributes were missing when calling the .add method: data_type and loader. Also, update the query search according to the EmbedChain documentation, the query must include the type and repo keys * fix: rollback YoutubeChannel paramenter * chore: fix type hinting for CodeDocs search * fix: ensure proper configuration when call `add` According to the documentation, some search methods must be defined as either a loader or a data_type. This commit ensures that. * build: add optional-dependencies for github and xml search * test: mocking external requests from search_tool tests * build: add pytest-recording as devDependencie --- .../code_docs_search_tool.py | 25 +- .../tools/csv_search_tool/csv_search_tool.py | 25 +- .../directory_search_tool.py | 30 +- .../docx_search_tool/docx_search_tool.py | 27 +- .../github_search_tool/github_search_tool.py | 59 +- .../json_search_tool/json_search_tool.py | 24 +- .../tools/mdx_search_tool/mdx_search_tool.py | 25 +- .../tools/pdf_search_tool/pdf_search_tool.py | 36 +- .../pdf_text_writing_tool.py | 5 +- src/crewai_tools/tools/rag/rag_tool.py | 8 +- .../serply_api_tool/serply_job_search_tool.py | 13 +- .../serply_webpage_to_markdown_tool.py | 10 +- .../tools/txt_search_tool/txt_search_tool.py | 27 +- .../website_search/website_search_tool.py | 29 +- .../tools/xml_search_tool/xml_search_tool.py | 24 +- .../youtube_channel_search_tool.py | 24 +- .../youtube_video_search_tool.py | 29 +- .../test_csv_search_tool.yaml | 251 ++++++++ .../test_directory_search_tool.yaml | 544 ++++++++++++++++++ .../test_json_search_tool.yaml | 300 ++++++++++ .../test_mdx_search_tool.yaml | 255 ++++++++ .../test_txt_search_tool.yaml | 251 ++++++++ tests/tools/test_search_tools.py | 309 ++++++++++ 23 files changed, 2051 insertions(+), 279 deletions(-) create mode 100644 tests/tools/cassettes/test_search_tools/test_csv_search_tool.yaml create mode 100644 tests/tools/cassettes/test_search_tools/test_directory_search_tool.yaml create mode 100644 tests/tools/cassettes/test_search_tools/test_json_search_tool.yaml create mode 100644 tests/tools/cassettes/test_search_tools/test_mdx_search_tool.yaml create mode 100644 tests/tools/cassettes/test_search_tools/test_txt_search_tool.yaml create mode 100644 tests/tools/test_search_tools.py diff --git a/src/crewai_tools/tools/code_docs_search_tool/code_docs_search_tool.py b/src/crewai_tools/tools/code_docs_search_tool/code_docs_search_tool.py index ae51adf54..05711d7bc 100644 --- a/src/crewai_tools/tools/code_docs_search_tool/code_docs_search_tool.py +++ b/src/crewai_tools/tools/code_docs_search_tool/code_docs_search_tool.py @@ -31,30 +31,19 @@ class CodeDocsSearchTool(RagTool): def __init__(self, docs_url: Optional[str] = None, **kwargs): super().__init__(**kwargs) if docs_url is not None: - kwargs["data_type"] = DataType.DOCS_SITE self.add(docs_url) self.description = f"A tool that can be used to semantic search a query the {docs_url} Code Docs content." self.args_schema = FixedCodeDocsSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "docs_url" in kwargs: - self.add(kwargs["docs_url"]) + def add(self, docs_url: str) -> None: + super().add(docs_url, data_type=DataType.DOCS_SITE) def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + docs_url: Optional[str] = None, + ) -> str: + if docs_url is not None: + self.add(docs_url) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/csv_search_tool/csv_search_tool.py b/src/crewai_tools/tools/csv_search_tool/csv_search_tool.py index e255df6b5..4567df201 100644 --- a/src/crewai_tools/tools/csv_search_tool/csv_search_tool.py +++ b/src/crewai_tools/tools/csv_search_tool/csv_search_tool.py @@ -31,30 +31,19 @@ class CSVSearchTool(RagTool): def __init__(self, csv: Optional[str] = None, **kwargs): super().__init__(**kwargs) if csv is not None: - kwargs["data_type"] = DataType.CSV self.add(csv) self.description = f"A tool that can be used to semantic search a query the {csv} CSV's content." self.args_schema = FixedCSVSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "csv" in kwargs: - self.add(kwargs["csv"]) + def add(self, csv: str) -> None: + super().add(csv, data_type=DataType.CSV) def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + csv: Optional[str] = None, + ) -> str: + if csv is not None: + self.add(csv) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/directory_search_tool/directory_search_tool.py b/src/crewai_tools/tools/directory_search_tool/directory_search_tool.py index ffd132c0e..20d21731a 100644 --- a/src/crewai_tools/tools/directory_search_tool/directory_search_tool.py +++ b/src/crewai_tools/tools/directory_search_tool/directory_search_tool.py @@ -1,4 +1,4 @@ -from typing import Any, Optional, Type +from typing import Optional, Type from embedchain.loaders.directory_loader import DirectoryLoader from pydantic import BaseModel, Field @@ -31,30 +31,22 @@ class DirectorySearchTool(RagTool): def __init__(self, directory: Optional[str] = None, **kwargs): super().__init__(**kwargs) if directory is not None: - kwargs["loader"] = DirectoryLoader(config=dict(recursive=True)) self.add(directory) self.description = f"A tool that can be used to semantic search a query the {directory} directory's content." self.args_schema = FixedDirectorySearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "directory" in kwargs: - self.add(kwargs["directory"]) + def add(self, directory: str) -> None: + super().add( + directory, + loader=DirectoryLoader(config=dict(recursive=True)), + ) def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + directory: Optional[str] = None, + ) -> str: + if directory is not None: + self.add(directory) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/docx_search_tool/docx_search_tool.py b/src/crewai_tools/tools/docx_search_tool/docx_search_tool.py index 9f6c49df7..cdd76c29d 100644 --- a/src/crewai_tools/tools/docx_search_tool/docx_search_tool.py +++ b/src/crewai_tools/tools/docx_search_tool/docx_search_tool.py @@ -37,36 +37,19 @@ class DOCXSearchTool(RagTool): def __init__(self, docx: Optional[str] = None, **kwargs): super().__init__(**kwargs) if docx is not None: - kwargs["data_type"] = DataType.DOCX self.add(docx) self.description = f"A tool that can be used to semantic search a query the {docx} DOCX's content." self.args_schema = FixedDOCXSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "docx" in kwargs: - self.add(kwargs["docx"]) + def add(self, docx: str) -> None: + super().add(docx, data_type=DataType.DOCX) def _run( self, - **kwargs: Any, + search_query: str, + docx: Optional[str] = None, ) -> Any: - search_query = kwargs.get("search_query") - if search_query is None: - search_query = kwargs.get("query") - - docx = kwargs.get("docx") if docx is not None: self.add(docx) - return super()._run(query=search_query, **kwargs) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/github_search_tool/github_search_tool.py b/src/crewai_tools/tools/github_search_tool/github_search_tool.py index 6ba7b919c..51fe4033c 100644 --- a/src/crewai_tools/tools/github_search_tool/github_search_tool.py +++ b/src/crewai_tools/tools/github_search_tool/github_search_tool.py @@ -1,7 +1,7 @@ -from typing import Any, List, Optional, Type +from typing import List, Optional, Type from embedchain.loaders.github import GithubLoader -from pydantic import BaseModel, Field +from pydantic import BaseModel, Field, PrivateAttr from ..rag.rag_tool import RagTool @@ -27,19 +27,29 @@ class GithubSearchToolSchema(FixedGithubSearchToolSchema): class GithubSearchTool(RagTool): name: str = "Search a github repo's content" - description: str = "A tool that can be used to semantic search a query from a github repo's content. This is not the GitHub API, but instead a tool that can provide semantic search capabilities." + description: str = ( + "A tool that can be used to semantic search a query from a github repo's content. This is not the GitHub API, but instead a tool that can provide semantic search capabilities." + ) summarize: bool = False gh_token: str args_schema: Type[BaseModel] = GithubSearchToolSchema - content_types: List[str] + content_types: List[str] = Field( + default_factory=lambda: ["code", "repo", "pr", "issue"], + description="Content types you want to be included search, options: [code, repo, pr, issue]", + ) + _loader: GithubLoader | None = PrivateAttr(default=None) - def __init__(self, github_repo: Optional[str] = None, **kwargs): + def __init__( + self, + github_repo: Optional[str] = None, + content_types: Optional[List[str]] = None, + **kwargs, + ): super().__init__(**kwargs) - if github_repo is not None: - kwargs["data_type"] = "github" - kwargs["loader"] = GithubLoader(config={"token": self.gh_token}) + self._loader = GithubLoader(config={"token": self.gh_token}) - self.add(repo=github_repo) + if github_repo and content_types: + self.add(repo=github_repo, content_types=content_types) self.description = f"A tool that can be used to semantic search a query the {github_repo} github repo's content. This is not the GitHub API, but instead a tool that can provide semantic search capabilities." self.args_schema = FixedGithubSearchToolSchema self._generate_description() @@ -47,26 +57,25 @@ class GithubSearchTool(RagTool): def add( self, repo: str, - content_types: List[str] | None = None, - **kwargs: Any, + content_types: Optional[List[str]] = None, ) -> None: content_types = content_types or self.content_types - super().add(f"repo:{repo} type:{','.join(content_types)}", **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "github_repo" in kwargs: - self.add( - repo=kwargs["github_repo"], content_types=kwargs.get("content_types") - ) + super().add( + f"repo:{repo} type:{','.join(content_types)}", + data_type="github", + loader=self._loader, + ) def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + github_repo: Optional[str] = None, + content_types: Optional[List[str]] = None, + ) -> str: + if github_repo: + self.add( + repo=github_repo, + content_types=content_types, + ) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/json_search_tool/json_search_tool.py b/src/crewai_tools/tools/json_search_tool/json_search_tool.py index 422f2f175..5d832c6b9 100644 --- a/src/crewai_tools/tools/json_search_tool/json_search_tool.py +++ b/src/crewai_tools/tools/json_search_tool/json_search_tool.py @@ -31,30 +31,16 @@ class JSONSearchTool(RagTool): def __init__(self, json_path: Optional[str] = None, **kwargs): super().__init__(**kwargs) if json_path is not None: - kwargs["data_type"] = DataType.JSON self.add(json_path) self.description = f"A tool that can be used to semantic search a query the {json_path} JSON's content." self.args_schema = FixedJSONSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "json_path" in kwargs: - self.add(kwargs["json_path"]) - def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + json_path: Optional[str] = None, + ) -> str: + if json_path is not None: + self.add(json_path) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/mdx_search_tool/mdx_search_tool.py b/src/crewai_tools/tools/mdx_search_tool/mdx_search_tool.py index dd1c2bb9d..dfab255b0 100644 --- a/src/crewai_tools/tools/mdx_search_tool/mdx_search_tool.py +++ b/src/crewai_tools/tools/mdx_search_tool/mdx_search_tool.py @@ -31,30 +31,19 @@ class MDXSearchTool(RagTool): def __init__(self, mdx: Optional[str] = None, **kwargs): super().__init__(**kwargs) if mdx is not None: - kwargs["data_type"] = DataType.MDX self.add(mdx) self.description = f"A tool that can be used to semantic search a query the {mdx} MDX's content." self.args_schema = FixedMDXSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "mdx" in kwargs: - self.add(kwargs["mdx"]) + def add(self, mdx: str) -> None: + super().add(mdx, data_type=DataType.MDX) def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + mdx: Optional[str] = None, + ) -> str: + if mdx is not None: + self.add(mdx) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/pdf_search_tool/pdf_search_tool.py b/src/crewai_tools/tools/pdf_search_tool/pdf_search_tool.py index fc11306ce..d56219785 100644 --- a/src/crewai_tools/tools/pdf_search_tool/pdf_search_tool.py +++ b/src/crewai_tools/tools/pdf_search_tool/pdf_search_tool.py @@ -30,39 +30,19 @@ class PDFSearchTool(RagTool): def __init__(self, pdf: Optional[str] = None, **kwargs): super().__init__(**kwargs) if pdf is not None: - kwargs["data_type"] = DataType.PDF_FILE self.add(pdf) self.description = f"A tool that can be used to semantic search a query the {pdf} PDF's content." self.args_schema = FixedPDFSearchToolSchema self._generate_description() - @model_validator(mode="after") - def _set_default_adapter(self): - if isinstance(self.adapter, RagTool._AdapterPlaceholder): - from embedchain import App + def add(self, pdf: str) -> None: + super().add(pdf, data_type=DataType.PDF_FILE) - from crewai_tools.adapters.pdf_embedchain_adapter import ( - PDFEmbedchainAdapter, - ) - - app = App.from_config(config=self.config) if self.config else App() - self.adapter = PDFEmbedchainAdapter( - embedchain_app=app, summarize=self.summarize - ) - - return self - - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( + def _run( self, query: str, - **kwargs: Any, - ) -> Any: - if "pdf" in kwargs: - self.add(kwargs["pdf"]) + pdf: Optional[str] = None, + ) -> str: + if pdf is not None: + self.add(pdf) + return super()._run(query=query) diff --git a/src/crewai_tools/tools/pdf_text_writing_tool/pdf_text_writing_tool.py b/src/crewai_tools/tools/pdf_text_writing_tool/pdf_text_writing_tool.py index ad4d847b6..1d8f3ffd8 100644 --- a/src/crewai_tools/tools/pdf_text_writing_tool/pdf_text_writing_tool.py +++ b/src/crewai_tools/tools/pdf_text_writing_tool/pdf_text_writing_tool.py @@ -32,7 +32,9 @@ class PDFTextWritingTool(RagTool): """A tool to add text to specific positions in a PDF, with custom font support.""" name: str = "PDF Text Writing Tool" - description: str = "A tool that can write text to a specific position in a PDF document, with optional custom font embedding." + description: str = ( + "A tool that can write text to a specific position in a PDF document, with optional custom font embedding." + ) args_schema: Type[BaseModel] = PDFTextWritingToolSchema def run( @@ -45,7 +47,6 @@ class PDFTextWritingTool(RagTool): font_name: str = "F1", font_file: Optional[str] = None, page_number: int = 0, - **kwargs, ) -> str: reader = PdfReader(pdf_path) writer = PdfWriter() diff --git a/src/crewai_tools/tools/rag/rag_tool.py b/src/crewai_tools/tools/rag/rag_tool.py index 6d0320c0c..900a6ef36 100644 --- a/src/crewai_tools/tools/rag/rag_tool.py +++ b/src/crewai_tools/tools/rag/rag_tool.py @@ -59,11 +59,5 @@ class RagTool(BaseTool): def _run( self, query: str, - **kwargs: Any, - ) -> Any: - self._before_run(query, **kwargs) - + ) -> str: return f"Relevant Content:\n{self.adapter.query(query)}" - - def _before_run(self, query, **kwargs): - pass diff --git a/src/crewai_tools/tools/serply_api_tool/serply_job_search_tool.py b/src/crewai_tools/tools/serply_api_tool/serply_job_search_tool.py index b0474262a..1c0c665b5 100644 --- a/src/crewai_tools/tools/serply_api_tool/serply_job_search_tool.py +++ b/src/crewai_tools/tools/serply_api_tool/serply_job_search_tool.py @@ -41,14 +41,15 @@ class SerplyJobSearchTool(RagTool): def _run( self, - **kwargs: Any, - ) -> Any: + query: Optional[str] = None, + search_query: Optional[str] = None, + ) -> str: query_payload = {} - if "query" in kwargs: - query_payload["q"] = kwargs["query"] - elif "search_query" in kwargs: - query_payload["q"] = kwargs["search_query"] + if query is not None: + query_payload["q"] = query + elif search_query is not None: + query_payload["q"] = search_query # build the url url = f"{self.request_url}{urlencode(query_payload)}" diff --git a/src/crewai_tools/tools/serply_api_tool/serply_webpage_to_markdown_tool.py b/src/crewai_tools/tools/serply_api_tool/serply_webpage_to_markdown_tool.py index 4010236cc..c7678f852 100644 --- a/src/crewai_tools/tools/serply_api_tool/serply_webpage_to_markdown_tool.py +++ b/src/crewai_tools/tools/serply_api_tool/serply_webpage_to_markdown_tool.py @@ -18,7 +18,9 @@ class SerplyWebpageToMarkdownToolSchema(BaseModel): class SerplyWebpageToMarkdownTool(RagTool): name: str = "Webpage to Markdown" - description: str = "A tool to perform convert a webpage to markdown to make it easier for LLMs to understand" + description: str = ( + "A tool to perform convert a webpage to markdown to make it easier for LLMs to understand" + ) args_schema: Type[BaseModel] = SerplyWebpageToMarkdownToolSchema request_url: str = "https://api.serply.io/v1/request" proxy_location: Optional[str] = "US" @@ -39,9 +41,9 @@ class SerplyWebpageToMarkdownTool(RagTool): def _run( self, - **kwargs: Any, - ) -> Any: - data = {"url": kwargs["url"], "method": "GET", "response_type": "markdown"} + url: str, + ) -> str: + data = {"url": url, "method": "GET", "response_type": "markdown"} response = requests.request( "POST", self.request_url, headers=self.headers, json=data ) diff --git a/src/crewai_tools/tools/txt_search_tool/txt_search_tool.py b/src/crewai_tools/tools/txt_search_tool/txt_search_tool.py index 95b353f45..ebbde1223 100644 --- a/src/crewai_tools/tools/txt_search_tool/txt_search_tool.py +++ b/src/crewai_tools/tools/txt_search_tool/txt_search_tool.py @@ -1,6 +1,5 @@ -from typing import Any, Optional, Type +from typing import Optional, Type -from embedchain.models.data_type import DataType from pydantic import BaseModel, Field from ..rag.rag_tool import RagTool @@ -31,30 +30,16 @@ class TXTSearchTool(RagTool): def __init__(self, txt: Optional[str] = None, **kwargs): super().__init__(**kwargs) if txt is not None: - kwargs["data_type"] = DataType.TEXT_FILE self.add(txt) self.description = f"A tool that can be used to semantic search a query the {txt} txt's content." self.args_schema = FixedTXTSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "txt" in kwargs: - self.add(kwargs["txt"]) - def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + txt: Optional[str] = None, + ) -> str: + if txt is not None: + self.add(txt) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/website_search/website_search_tool.py b/src/crewai_tools/tools/website_search/website_search_tool.py index 842462546..b89af6656 100644 --- a/src/crewai_tools/tools/website_search/website_search_tool.py +++ b/src/crewai_tools/tools/website_search/website_search_tool.py @@ -25,36 +25,27 @@ class WebsiteSearchToolSchema(FixedWebsiteSearchToolSchema): class WebsiteSearchTool(RagTool): name: str = "Search in a specific website" - description: str = "A tool that can be used to semantic search a query from a specific URL content." + description: str = ( + "A tool that can be used to semantic search a query from a specific URL content." + ) args_schema: Type[BaseModel] = WebsiteSearchToolSchema def __init__(self, website: Optional[str] = None, **kwargs): super().__init__(**kwargs) if website is not None: - kwargs["data_type"] = DataType.WEB_PAGE self.add(website) self.description = f"A tool that can be used to semantic search a query from {website} website content." self.args_schema = FixedWebsiteSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "website" in kwargs: - self.add(kwargs["website"]) + def add(self, website: str) -> None: + super().add(website, data_type=DataType.WEB_PAGE) def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + website: Optional[str] = None, + ) -> str: + if website is not None: + self.add(website) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/xml_search_tool/xml_search_tool.py b/src/crewai_tools/tools/xml_search_tool/xml_search_tool.py index 95a382299..2e0d26a88 100644 --- a/src/crewai_tools/tools/xml_search_tool/xml_search_tool.py +++ b/src/crewai_tools/tools/xml_search_tool/xml_search_tool.py @@ -31,30 +31,16 @@ class XMLSearchTool(RagTool): def __init__(self, xml: Optional[str] = None, **kwargs): super().__init__(**kwargs) if xml is not None: - kwargs["data_type"] = DataType.XML self.add(xml) self.description = f"A tool that can be used to semantic search a query the {xml} XML's content." self.args_schema = FixedXMLSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "xml" in kwargs: - self.add(kwargs["xml"]) - def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + xml: Optional[str] = None, + ) -> str: + if xml is not None: + self.add(xml) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/youtube_channel_search_tool/youtube_channel_search_tool.py b/src/crewai_tools/tools/youtube_channel_search_tool/youtube_channel_search_tool.py index 81ecc30c3..9de4b568f 100644 --- a/src/crewai_tools/tools/youtube_channel_search_tool/youtube_channel_search_tool.py +++ b/src/crewai_tools/tools/youtube_channel_search_tool/youtube_channel_search_tool.py @@ -25,13 +25,14 @@ class YoutubeChannelSearchToolSchema(FixedYoutubeChannelSearchToolSchema): class YoutubeChannelSearchTool(RagTool): name: str = "Search a Youtube Channels content" - description: str = "A tool that can be used to semantic search a query from a Youtube Channels content." + description: str = ( + "A tool that can be used to semantic search a query from a Youtube Channels content." + ) args_schema: Type[BaseModel] = YoutubeChannelSearchToolSchema def __init__(self, youtube_channel_handle: Optional[str] = None, **kwargs): super().__init__(**kwargs) if youtube_channel_handle is not None: - kwargs["data_type"] = DataType.YOUTUBE_CHANNEL self.add(youtube_channel_handle) self.description = f"A tool that can be used to semantic search a query the {youtube_channel_handle} Youtube Channels content." self.args_schema = FixedYoutubeChannelSearchToolSchema @@ -40,23 +41,16 @@ class YoutubeChannelSearchTool(RagTool): def add( self, youtube_channel_handle: str, - **kwargs: Any, ) -> None: if not youtube_channel_handle.startswith("@"): youtube_channel_handle = f"@{youtube_channel_handle}" - super().add(youtube_channel_handle, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "youtube_channel_handle" in kwargs: - self.add(kwargs["youtube_channel_handle"]) + super().add(youtube_channel_handle, data_type=DataType.YOUTUBE_CHANNEL) def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + youtube_channel_handle: Optional[str] = None, + ) -> str: + if youtube_channel_handle is not None: + self.add(youtube_channel_handle) + return super()._run(query=search_query) diff --git a/src/crewai_tools/tools/youtube_video_search_tool/youtube_video_search_tool.py b/src/crewai_tools/tools/youtube_video_search_tool/youtube_video_search_tool.py index 1ad8434c8..639f1a266 100644 --- a/src/crewai_tools/tools/youtube_video_search_tool/youtube_video_search_tool.py +++ b/src/crewai_tools/tools/youtube_video_search_tool/youtube_video_search_tool.py @@ -25,36 +25,27 @@ class YoutubeVideoSearchToolSchema(FixedYoutubeVideoSearchToolSchema): class YoutubeVideoSearchTool(RagTool): name: str = "Search a Youtube Video content" - description: str = "A tool that can be used to semantic search a query from a Youtube Video content." + description: str = ( + "A tool that can be used to semantic search a query from a Youtube Video content." + ) args_schema: Type[BaseModel] = YoutubeVideoSearchToolSchema def __init__(self, youtube_video_url: Optional[str] = None, **kwargs): super().__init__(**kwargs) if youtube_video_url is not None: - kwargs["data_type"] = DataType.YOUTUBE_VIDEO self.add(youtube_video_url) self.description = f"A tool that can be used to semantic search a query the {youtube_video_url} Youtube Video content." self.args_schema = FixedYoutubeVideoSearchToolSchema self._generate_description() - def add( - self, - *args: Any, - **kwargs: Any, - ) -> None: - super().add(*args, **kwargs) - - def _before_run( - self, - query: str, - **kwargs: Any, - ) -> Any: - if "youtube_video_url" in kwargs: - self.add(kwargs["youtube_video_url"]) + def add(self, youtube_video_url: str) -> None: + super().add(youtube_video_url, data_type=DataType.YOUTUBE_VIDEO) def _run( self, search_query: str, - **kwargs: Any, - ) -> Any: - return super()._run(query=search_query, **kwargs) + youtube_video_url: Optional[str] = None, + ) -> str: + if youtube_video_url is not None: + self.add(youtube_video_url) + return super()._run(query=search_query) diff --git a/tests/tools/cassettes/test_search_tools/test_csv_search_tool.yaml b/tests/tools/cassettes/test_search_tools/test_csv_search_tool.yaml new file mode 100644 index 000000000..4247ba7bb --- /dev/null +++ b/tests/tools/cassettes/test_search_tools/test_csv_search_tool.yaml @@ -0,0 +1,251 @@ +interactions: +- request: + body: '{"input": ["name: test, description: This is a test CSV file"], "model": + "text-embedding-ada-002", "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '127' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 12,\n \"total_tokens\": 12\n }\n}\n" + headers: + CF-RAY: + - 936f9362dc5e7e01-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:57 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=8J2Cz0gyk5BpRSYbzjWETqMiyphlW8TAe7802MlHMe0-1745770077-1.0.1.1-qbyKIgJQJDS2wWDKC1x0RrxzJk5mcE4wDunq25j.sNSe_EMvVEIQTJR6t4Jmrknve3lSxXTsW4VL_3EYYk6ehiq6yIQDVzVkqNfU_xlwris; + path=/; expires=Sun, 27-Apr-25 16:37:57 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=r11uIiVDOWdkeX_FkCjMMnH.Z9zcvp4ptrKi3luIa9s-1745770077165-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '170' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-56c4dc8986-59htf + x-envoy-upstream-service-time: + - '96' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999987' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_4953e9919d74fabb02f89c587d38ea30 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"batch": [{"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35168, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true}, "timestamp": "2025-04-27T16:07:52.864741+00:00", "context": {}, "distinct_id": + "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "query"}], "historical_migration": + false, "sentAt": "2025-04-27T16:07:56.879642+00:00", "api_key": "phc_PHQDA5KwztijnSojsxJ2c1DuJd52QCzJzT2xnSGvjN2"}' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate, zstd + Connection: + - keep-alive + Content-Length: + - '454' + Content-Type: + - application/json + User-Agent: + - posthog-python/3.9.3 + method: POST + uri: https://us.i.posthog.com/batch/ + response: + body: + string: '{"status":"Ok"}' + headers: + Connection: + - keep-alive + Content-Length: + - '15' + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:57 GMT + access-control-allow-credentials: + - 'true' + server: + - envoy + vary: + - origin, access-control-request-method, access-control-request-headers + x-envoy-upstream-service-time: + - '52' + status: + code: 200 + message: OK +- request: + body: '{"input": ["test CSV"], "model": "text-embedding-ada-002", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '87' + content-type: + - application/json + cookie: + - __cf_bm=8J2Cz0gyk5BpRSYbzjWETqMiyphlW8TAe7802MlHMe0-1745770077-1.0.1.1-qbyKIgJQJDS2wWDKC1x0RrxzJk5mcE4wDunq25j.sNSe_EMvVEIQTJR6t4Jmrknve3lSxXTsW4VL_3EYYk6ehiq6yIQDVzVkqNfU_xlwris; + _cfuvid=r11uIiVDOWdkeX_FkCjMMnH.Z9zcvp4ptrKi3luIa9s-1745770077165-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 2,\n \"total_tokens\": 2\n }\n}\n" + headers: + CF-RAY: + - 936f93666e9d7e01-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:57 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '59' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-787f678775-4x2zc + x-envoy-upstream-service-time: + - '39' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999998' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_9bb18ff3e7da9b6d8406f6361cbf5497 + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/tools/cassettes/test_search_tools/test_directory_search_tool.yaml b/tests/tools/cassettes/test_search_tools/test_directory_search_tool.yaml new file mode 100644 index 000000000..6f3fd2d58 --- /dev/null +++ b/tests/tools/cassettes/test_search_tools/test_directory_search_tool.yaml @@ -0,0 +1,544 @@ +interactions: +- request: + body: '{"input": ["This is a test file for directory search"], "model": "text-embedding-ada-002", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '119' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 8,\n \"total_tokens\": 8\n }\n}\n" + headers: + CF-RAY: + - 936f92b30c267df3-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:28 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=nFZbdbFah.LWbzeW.glnLPLT8LbiE2gQXhAnfko3dOM-1745770048-1.0.1.1-6X7_GmSlrhT2JDG3UI.GdG197sz4YerSq59cGRFhchAip2X4Az27dMYcavJW.noLsarkBrxKgf7B5SZg7354p8ZOH9VBHq35KlZ6QavVyJ8; + path=/; expires=Sun, 27-Apr-25 16:37:28 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=.vAWcVjI11dzJOYj038IwLPbCQXQ1.tBpWmDu6Xt46k-1745770048727-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '78' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-97cfd68d4-7qqkm + x-envoy-upstream-service-time: + - '51' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999989' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_b2ab62724f2840722a52cfed5dd64580 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"batch": [{"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35099, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true}, "timestamp": "2025-04-27T16:07:28.073953+00:00", "context": {}, "distinct_id": + "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "init"}], "historical_migration": + false, "sentAt": "2025-04-27T16:07:28.576735+00:00", "api_key": "phc_PHQDA5KwztijnSojsxJ2c1DuJd52QCzJzT2xnSGvjN2"}' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate, zstd + Connection: + - keep-alive + Content-Length: + - '453' + Content-Type: + - application/json + User-Agent: + - posthog-python/3.9.3 + method: POST + uri: https://us.i.posthog.com/batch/ + response: + body: + string: '{"status":"Ok"}' + headers: + Connection: + - keep-alive + Content-Length: + - '15' + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:29 GMT + access-control-allow-credentials: + - 'true' + server: + - envoy + vary: + - origin, access-control-request-method, access-control-request-headers + x-envoy-upstream-service-time: + - '37' + status: + code: 200 + message: OK +- request: + body: '{"batch": [{"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35099, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true}, "timestamp": "2025-04-27T16:07:28.073953+00:00", "context": {}, "distinct_id": + "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "init"}], "historical_migration": + false, "sentAt": "2025-04-27T16:07:29.624095+00:00", "api_key": "phc_PHQDA5KwztijnSojsxJ2c1DuJd52QCzJzT2xnSGvjN2"}' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate, zstd + Connection: + - keep-alive + Content-Length: + - '453' + Content-Type: + - application/json + User-Agent: + - posthog-python/3.9.3 + method: POST + uri: https://us.i.posthog.com/batch/ + response: + body: + string: '{"status":"Ok"}' + headers: + Connection: + - keep-alive + Content-Length: + - '15' + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:30 GMT + access-control-allow-credentials: + - 'true' + server: + - envoy + vary: + - origin, access-control-request-method, access-control-request-headers + x-envoy-upstream-service-time: + - '28' + status: + code: 200 + message: OK +- request: + body: '{"batch": [{"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35099, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true}, "timestamp": "2025-04-27T16:07:28.073953+00:00", "context": {}, "distinct_id": + "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "init"}], "historical_migration": + false, "sentAt": "2025-04-27T16:07:30.646962+00:00", "api_key": "phc_PHQDA5KwztijnSojsxJ2c1DuJd52QCzJzT2xnSGvjN2"}' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate, zstd + Connection: + - keep-alive + Content-Length: + - '453' + Content-Type: + - application/json + User-Agent: + - posthog-python/3.9.3 + method: POST + uri: https://us.i.posthog.com/batch/ + response: + body: + string: '{"status":"Ok"}' + headers: + Connection: + - keep-alive + Content-Length: + - '15' + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:31 GMT + access-control-allow-credentials: + - 'true' + server: + - envoy + vary: + - origin, access-control-request-method, access-control-request-headers + x-envoy-upstream-service-time: + - '28' + status: + code: 200 + message: OK +- request: + body: '{"input": ["test file"], "model": "text-embedding-ada-002", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '88' + content-type: + - application/json + cookie: + - __cf_bm=nFZbdbFah.LWbzeW.glnLPLT8LbiE2gQXhAnfko3dOM-1745770048-1.0.1.1-6X7_GmSlrhT2JDG3UI.GdG197sz4YerSq59cGRFhchAip2X4Az27dMYcavJW.noLsarkBrxKgf7B5SZg7354p8ZOH9VBHq35KlZ6QavVyJ8; + _cfuvid=.vAWcVjI11dzJOYj038IwLPbCQXQ1.tBpWmDu6Xt46k-1745770048727-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 2,\n \"total_tokens\": 2\n }\n}\n" + headers: + CF-RAY: + - 936f92b4cd887df3-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:33 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '162' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-7bbfccd4b9-5rlz8 + x-envoy-upstream-service-time: + - '98' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999998' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_5414bfd96cbd16d84a01f68e994a38f2 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["This is a test file for directory search"], "model": "text-embedding-ada-002", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '119' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 8,\n \"total_tokens\": 8\n }\n}\n" + headers: + CF-RAY: + - 936f9336cc417e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:49 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=EO3qaPuy2laM3xDGRwHtVhJMUVrBq0C4x5BxYYC8dT0-1745770069-1.0.1.1-kOylsOMvWlUF5owqqiIUziYDoC1f8vVA4C7C9em_s1Gdawqe_C0R5yIfCxJzf9.q9LZJQyCGp8L2rJaFzDF0Nk2pkv2v.tT.uQTRlmCgzwY; + path=/; expires=Sun, 27-Apr-25 16:37:49 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=52fi4.4bJilzZrvgAS3YttTnBjtEe8pVmM0VbBM5jis-1745770069782-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '39' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-97cfd68d4-nw6rt + x-envoy-upstream-service-time: + - '28' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999989' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_f9ca57dbb69b376529e9c874f44dba39 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"input": ["test file"], "model": "text-embedding-ada-002", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '88' + content-type: + - application/json + cookie: + - __cf_bm=EO3qaPuy2laM3xDGRwHtVhJMUVrBq0C4x5BxYYC8dT0-1745770069-1.0.1.1-kOylsOMvWlUF5owqqiIUziYDoC1f8vVA4C7C9em_s1Gdawqe_C0R5yIfCxJzf9.q9LZJQyCGp8L2rJaFzDF0Nk2pkv2v.tT.uQTRlmCgzwY; + _cfuvid=52fi4.4bJilzZrvgAS3YttTnBjtEe8pVmM0VbBM5jis-1745770069782-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"MriavBo/HbyzL4C8J0aGvA0LObyTrcU8NvT2vLBR6ryxjEi8dTacvMRTrTwGPdo6DkYXOwUCfLonc4G7WAsGPG+VODyUyQu8k9rAPHzJnLxQECy8+yQ8PDnSjLwOoI07kp9ivEp9q7zbg2k8lMkLvdYMr7v6vGK7iMKiPAels7w3qOO8UC/EvCGzBbxzOe66GTE6O3CEA70Fie08b3YgvEPOZDzc60K7+TVxPKEciLxcKMq8Mz+MuRgjVzz0Csq8mcc3vDYh8jxRS4o7q1M+un+MarzdJiG8jtyUu9BMMzyxq+C71oU9vACq2TsOc5I7Xb0evYjCortCR3O8kzQ3PNEAoDuOKKi8KijsO8lRWTxPqFI7GCPXu6WTwjwdTn48pZPCuxq4KzzJnWw8jaG2ux4C67zQ8ry75wNhPGqXDLvV8Gg84Y94vPli7LuTNLc7V9CnPLITujsRKP07vErwPBQGk7vLQKQ7Q1VWPONAkzwr3Ng8egfNO2N9GrwtBgI7XUSQPMM35zyIo4q8T07cvH+M6rsI4JG8oIezu9DyPLwb8wm9ZNeQO4yT0ztnjPu7LdmGOwWJ7TseAmu81ZZyPHaQkry/zo+8yOn/O7cfSTx2F4Q8iByZvCuvXbxzDHO79iYQPGOqlTwee/k8j5ABvTKqNzwZBD88e5whvG6H1bwxQl47lLsovBMXSD048aQ8bi1fPLmVBTxPe1e8E0RDPMmd7Lz72Kg8OGqzvMjpf7yxuUM8i1j1PAhng7pYC4a83tqNvNdmJTy4ALE8JVe7Oj0cTDztPGu8mi8RPKeviLxnjPs8B9Iuu+85Gbv5NXE8jXS7O+mmGLs5pZG8DEnpu3wjkzyzAoU8EpBWPOpaBb2UFR88IeAAPYcONjxvoxs8mtUavHtCq7wlSVg6RAnDPBsgBb2kd/w7WAuGu+7DXDw31V66bdNoPJJy5zsAXka8sPfzvJ/TRjzKjDc9cznuPNh0iLyw93M7wxhPPPk1cbxJQs27DVdMvEWeFz2CXJ064Y94PBKCc7wBPy6/sYxIvPZTi7pjqhW8reiSPAE/Lj1YCwY9jMBOO0Mo27xP9OW6sea+uzZ76DyZxze84+acvFCJOjvFraO8gBNcPK1CibxiFUG88GYUPVAvRDzFYZA8SvY5u2qXDDzt4nS71gwvPO08a7vJney8dO3aPO7RP7q5tJ28GuWmuw2Ex7se1e+7V/0iPfAagTtnbWO84UNlvEkV0jzttXk8LEQyvD07ZLogHrE8GYuwOw1XTDqYX167Ks51PNQ8fLsfEE66lMkLPIijCjxRxBi8emHDu2m2JLyOVSO8z11ovH/Y/TwNCzm8e7s5PLnCgDwOGRy8BYltuQVccjyHWkm80S2bvEk0ajxqapG8pZPCPA6/pbvwGoG8Vu+/PHYXBLyHaKy80PI8vIDm4Dzq0xM97Yj+O5RCmrz0ZEC73jQEuypV57qNzjE6Z4z7vHtvprt7b6Y8ULa1u1dXmbxbR+K7ytjKvKXAvTt2FwQ9jq+ZPLnCgLzXZqU4YrtKPJn0srtWlUm83Z8vPD9lDT2TrUW8Ks71O28cqjsIhpu8n0xVu0S9r7samRM8SY7gO8+3Xjwsca08jjaLOmIVQbzpeZ28h1pJu0LtfLwUUqa8Y8ktvXz2FzyScuc77zmZO/wyH7zRLRs9oA6lO1uT9TxbR2I8dEfRO24tXzwGEF877Q/wvFYcO7yaAha81itHuj3C1TsqzvU8ghAKvWqXDDy5DpS8EoLzPMMYz7vq05M82HSIvGOqlbwlV7u7yyEMu4jvHTwILKU7je3JvDFv2bxibzc81Gn3uojQBTxENr68pHf8u4ZM5ryScmc7/F+avCoobLzwwAo6IYYKvbhaJ7uaTqm859bluj3vUDz0KWK8NwLaO3AqjbwrvcC5JmWevIK2EzyIdo+6JmUevdBrS7qw9/O7J3OBvOg+vzwGl1A8UFy/u7zDfrxpLzM7mW1BPJUjgrzFYRC8iEmUPB57+bs5pZE8hh/rOrHY2zx6rda7vu0nOqtyVrz8Mp88bxwqvNV3WjxkMYe8qr5pujOZArsIZ4M8j5CBu8nKZzv6Q9Q8hgDTOwx25Dz2zJk7c5NkO2rxgrvjXys8V6MsvXqt1jtaZnq84iTNO3BXiDwxnNQ7293fvEvXIb2BezU8DuwgPHZjlzyL/v66JdDJO7D3c7xC7fw7pigXO595ULvoMNy64GL9u6evCLoT+C887ZZhPLimOj10wN88lMmLOXtCK7xzZmk8Tm30O+85GbvFrSM9ZAQMvCaENjw+/bO8SY7gPAWJbTzXkyA7AvMaPDeo4zzjQJO80dMkO+Gd2zuUnJA877KnPEwSgLzeB4k83fklvILjjjxb7Wu8amqRPPzmCz2khV+87sNcvFHxEzwrNs88nh/aPIHVqzyCiZg8XnGLu+8MHroMo188yX5UvBoSorlLuIk8jAxivCr7cLxYCwa8f19vuytjSjyYBWi6MVDBPFyvOzxY3oo82HQIPW92oDxXV5m6m1yMvOGP+Lwlo048m7aCuu/+ujqxX027w2TivHM5bjwBi0E8V4SUPHR0zLsdTn67Qhp4PF2Qo7yymqs71+2WPN2fLzx1gq+7sJ19PB62V7xRPac80GtLvENV1rxw0Ja8oA6lPGrxgrzvOZm87bV5vOotijx62lE7ps4gPSfsj7pQAkm8Z+ZxPA04NDp/X288YyOkvIjCortaZvo8aYkpPFYcO7wUJau87h3TvLnhGDzdU5y6Jr8UPXAqjTy+DEA8Ks51vMRTLbzXZqW8DhmcvB6odDwIOgi5vma2O4e0v7zXOao8rIC5O2/CMzwTREM8H+NSPAhZILy/VYG77bX5u/oWWTpc3La7+hZZPHyqhDw5S5s8lLsovJQVHzz5rn887wyePPt+Mrob84m8jGbYPDb0djyyQLU86cWwPNxyND3UaXc8RcuSPGQxBzzJflS8sm2wPKZ0qrusjhy8Mriau3z2F7y8SvA7PiovPFEejzxENj48nh/avIJcHTzLxxU7cFcIvLHmPjq3TMQ8LVKVPLgtrLyTNLe7HgLru7MvAL3XGpK8Q87kvNLhhztLqia8rLsXvPaABr0mvxS96aaYvKDCkbzqWgU6gagwOyBLLLybtgK9XnELvGTXkDwhWY+7V1eZOr7ArLsg/5i7GarIPCGGCrwZMbq8AH1eOjhqs7kaEiK80MXBPNwYvjwSr+67jGbYO+Bi/bvkbQ4712alPCVJWDvDkd28UALJPA0LObxEkLQ6lJwQPJkTS7yzL4A83Bi+uB8QTrygDqU774WsvC1SFTx89hc7Hqj0O2ghUDxpL7O8SiM1vAbEyzyYjFm8q3JWO+O5IbxzDHM8mH72O6A7ILyIdg89V9AnvJ8AQrxq8YI6/OYLvZOOrTs2Tu06e0IrPAiGmzyyIR28M5mCvFWH5ruy9CG8rK00vJLM3TvE+ba87Q9wvNbfs7yG09e8FNkXvB57eTxjyS087TxrvMttn7xL16E7VpVJvMoFRrzt4nS81XfavNh0CLzuw9w6yZ3svN3MKjyzL4A7Vnaxu4GoML0VjYS8yuatuvtRN73DkV28pP7tO10XFTz1Rag8nh/aPC0Ggrv8QAI8bdNoOk4T/rs+hCU8nwDCu+g+P7yU6KO8qybDOksEHTzpeZ08fKoEPU97V7g2Tm284GJ9PLDK+Drh6W67nsVju9XwaLwYb2q64vfRO+fWZbxwKg08cISDvI0axbsCTRE9+rziu4ECJzyfpku5gdWrPKUM0bzwGgE8yl+8vMNk4rsYb+o6AKpZPKWTwryybbC8fFCOPHXcJTviUcg82wpbvNDyPDvj5pw57tG/PA5zkryUbxU7Jf1Eu+l5nTuhHAi7COCRvDgeIDtXsY85EtxpPHbqiDvgYn28B0s9u3xQDrwrkEW5CLMWO1ZJtrsf8TU9Ya1nPMW7Bj0gLBQ9Griru2e5drw+dkK6OBA9u3x9ibzF2p48qybDPLMChbzccrS8v0eePJ8tvTysrTQ8gdUrvGnjn7sYb+o8dr2NPFE9p7zEcsU6etpRvfxfGjuCEAq8mgIWvAG4vLx62tG7JmWevKVmxzynrwi9Hi/mPEmOYDw+/bO8ZNeQO/kIdrzUPHy80bQMPOeparx0wN88y8cVu9AfOLyIdg88Ak0RvPt+srwCeow61+2WN3qA2zzud0m9aRCbvEJ07jsVYIk89N1OO2OqlTsOoI28AnqMvMhw8bnQxcE7mZo8PA04NDqmRy88qr5pvFU7U7xutFC8P96bvNuw5Ls/vwO7UZcdvEk0aryl7Tg7H5c/PFejrDtdkCM8iyv6vOmmmDy5aAo9OB6gvFyvuzve2g08uACxO0JHc7wHeDg8VmjOu1HEmLygh7M86tMTvbc+YbwC8xq9vu0nvBic5TzvWLG7VnaxuxKv7rsZMbo7ThP+Oo6CHjxq8YI2joKeO/atgbwHSz26cP2RO3sVMLthNFm77h3TOuep6jvFBxo7WDgBvdQ8fLw2e+g7LCWauquf0bsgHjE7Er3RvO+yp7z0Vl285wNhPNwYvrlWHLu8rK00vFUOWLxeywG9H/E1PO8rtrz03U483HK0vMx7grl7nKG8PZVavGN9mjyxMlI89b62O2kvM7x1Npy8tz7hu4LjDr290eG6gmqAO/Qp4jvdrZI8DTg0vGN9GruAx8g8Z4x7uxpsmDygtC68Q6/MvLeY17s9wlU8Hi9mO3WvqrsFXPK8CCwlPO/+ujvkmok7jAxiPOHpbjx/jGo6jXQ7vPYmELwbIIU8uHm/uxl9Tby5woC8k1NPvAAxS7wRKH08zz7QvOrTEzm90eG8IKUiOzb0drxRSwo7n1o4vSVXO7zJney7b6Mbvb7ArDzgYv27BQL8OfVFqDxWaE48+dv6u7nCgLvRAKA8CLOWvD0cTLwgHrG67Q/wvO8MnrxnbWO6pnSqPPsFpLy3xdK7bxyqvB7Vb7zK2Eo8UZedOxNxvjw4xCm81R3kvBoSIrrn1uU7s9WJPGlcrrsOv6U8DNBavJScED3vK7Y87eJ0u1FLirsamZO4vbJJPOmmmLziq748+kNUPvRWXTzpTCK8aQI4PR7V77v8jBW8cFcIPGk9Frit6JK77qTEPDHJzzwT+K88dHRMO44oqDogpaK7RAlDPAf/Kb2IHJm8jUdAvMNFyrx6rVY87/66vLFfzbvQTDO78O0FPcW7BrwzEhG8s9WJvBKC8zx8yRy56Gu6vLPVibw9aN87gG1SPGReAr04ajM43EW5O/SDWDwhswU9iKOKuis2Tzz5CPa8LHGtO2m2pLxPe1c8SRXSPO2W4Ts+0Li84RbquwfxxjwlKkC8aVwuu8NFSjyTrcW5T3vXO4YtTjt0wN883HI0vKeCDTvqWoW8+TXxu/vYqDy88Pm8zHsCPR9qxLw2Tm07IVmPvKoY4LvIcPE7v3QZvHx9iTy5lQW8lLsoOpjY7Dt1r6q8ZASMvBVgCT0T+C88b5W4PGpqkTzQTDO8ZxNtOwLUAjyMhfC8XILAvLD387xXsY+73OvCO88RVbx/BXm6LVIVvdAfuLw5LIO8RBemvHvotLvhcGA89UWovF1EkDyYMmM8xCYyPKtTvrwBP647wzdnPNcaEjuCiZi7uIciu2dtYzun3IO7RXGcu9BrS7yzAoU89q0BvfwynztVh2a8Qu18PD8Llzxp4x+04zKwvDhqMzw2x/u7DkaXPIyya7qMwM676Gu6O59MVTmzAgW89iaQvLgtLLvUPHw8/F8avUwSALxzOW65ps4gPT6jPTzcRTm79INYvOqHADsgeCc7rRWOvFzcNji4eb88/DIfvCr7cLxRPSc8yfdiPDOZAruzAgU9XRcVOtEtm7xLi4669RitvCBLrLwMKlG8duoIPL1YUz17byY7w0XKvLN7E73Q8jw8XNy2vGeM+7wSr268DbFCPRIJZbylwD28K2PKu25oPb6rn9E8vaTmPHucoTtd6hk8xTSVO/Q3xTzkmom8mfQyPEVSBDxvwjM8EVX4u+otiryqGGA8sCTvOsshDDx7u7k7COCRvEMo2zxhrec8yhOpPD79M7ysB6s7yZ3su1dXmTsVjQS63HK0vD1o3zwa5Sa7aKhBvC2si7sMo188v84PPCQcXTz7fjI8AFDjutGmqTsYb2q8BS93OxlQ0jsr3Fg7XeoZPVyCwDppAji7sH5lPErJPjwAMcs80S0bPHyqBD3ifsO8ejTIPD5XqrxaOX+8sYxIvFuTdTwtUpU72KGDvNEAILx/MvQ7fH2JOhgjV7ysYaG8YuhFO0uLDjx/MnS8ANdUvHwjk7yCiZg8JpKZvFFLijxXhJS8SbvbvO08azzeNAS8dTacPGEHXrwC8xq9aKhBPFtHYryGLc47h4fEu+7wVz10occ7XChKPPk1cTwO7CC6ZDGHvJoCFjt1Nhy8aS8zvAhnAz2kK2m8YkI8vOoAj7wM/VU7UqUAO2e5drxnE+07sPdzvJ7FY7y938S7ThN+vO0PcLxQ1c07v84PPe9YsTzuHVM8OaURPSBLLD2U6CM8FWAJvVejrLsH/6k7vjk7PF0JMjykWOQ83cwqvLBR6rxk15C8AtSCO8hwcTxpAri7sPdzuQUCfDz2zBm7sm2wu0uLjr0tBoK81XfaPHaQkj3pphi84vfRPMshDDv7fjI9yVHZO5u2gjw+V6q7htNXvI2htrymoaW8avECu+gRxDvKXzy8pKT3u/sFpLxJFdI8cP2RvNzrQrxwKo08dM7CvB1OfrxuaL07JSrAvPmu/zz1vjY8Mqq3vBNEQzkUBpO8bmi9PICazbx8IxO8iNAFO91THL2MZti84RbqPA/6g7ykpHc8piiXPLLHprt7Qqu8bmi9O9dHjbw3tsa51itHPCaxMbwmZZ68GdfDOkJH8zqbXAy80B+4ukk0ajw5/4e7BQL8PC1SlTx/BXm8AH3evFHxk7wg/xg74xOYvGfm8TwHpbO7H5c/u17LgbwlV7u7fCOTPIDHSDuIHJk51ivHPAz9VbxRaiK7E/ivvFt0XTvWK0e9fH0JvRQzjjxpXC683a2SvNG0jLxKfau8ULY1OsO+2Dy9WFO4ddylu11jKLuMhXA8CDqIvCcZizoxnNQ8hkxmPKYatLy/KAa9aT2WPACq2TvRpik8Z4z7u2e5djy+GqO81Dz8vAJ6jL1E3Mc8RUQhO+hd17sfakQ70MXBPIdayTtVDli6GyAFvIH0QzxMEoC83HI0O+otCr3qAA+8YdpivA3ePbygwhE92KEDPW4ORzyGTOY7xa2jPHu7ubxpArg7BYntO1vta7wf8bU81ivHu61CCT08Dmm8ARKzvJp7pLlw/RG9K+o7vNLhhzz0Cko7ycpnvCB4p7vQHzg8CA0NPHZjF7vW/ku8RZ4XvZ95UDtEF6a8FDMOvNvdXzyCtpO8buHLu/nbejwSY1u7DCrROyX9xDtq8YK8kp9ivORtjjqngo28ps6gPHa9jbweidw7MZxUvHUJoTwORpc7Vkm2PBmqyDzYdAi8CA2NPIhJFDtOQHm8418rPB6o9LzVd9q8rIA5vDjEKTwldtM8YdriPIKJGDwGatW8avGCPCoobLvWWMI8H2rEPLHY2zwHHkK9RfiNPPWfnjy4ALE8ucKAuzH2yjrXRw26RGO5OEu4Cb2CL6I7S+WEO+SaCbugh7O8ejRIPC0Ggjt0dEw8lOijPLjTtTz0g1g8abaku43OsTsrY8q8vdHhuwFsKbzIQ/a8lG8VveLYubpJFdI8s04YPNQ8fLsOcxK8LBe3PIK2k7weqPQ7CA0NvBlQ0rstBgK9da+qPPpwTzxFUoQ8Yo7PPAIgFryfAMI8ZAQMO5gy47v7q627y8cVPI42Czz1RSi8gi8iO5L5WLnu0T+8+9govIHVK7vpH6e5Xb0ePCXQSbz1n549RXGcPMjp/7tpXK470VoWPD/eGzya1Ro86Zi1PAceQrynVZK8v3SZPDnSjLutQgm8c2ZpvIyy67wHSz08b3YgvKEciDz8Mp+7ROqqPBmLsDt6gFs7ExfIPN2tkjw5eJY6sMp4Oh57+Tu8HfU6v1WBu0OvzLzVHWQ7Wjl/POOMprvc68K8w+vTPMl+VLwYI9e6ucIAveSaCTxjnDK4iNCFPIFOOjzFrSO9yyGMvEu4ibtWlUm7Ks71vL+hFDxnjPu7\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 2,\n \"total_tokens\": 2\n }\n}\n" + headers: + CF-RAY: + - 936f93388d697e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:50 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '132' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-75c844b786-xxzqk + x-envoy-upstream-service-time: + - '61' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999998' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_5d278e154a0358a46c53ec740679883c + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/tools/cassettes/test_search_tools/test_json_search_tool.yaml b/tests/tools/cassettes/test_search_tools/test_json_search_tool.yaml new file mode 100644 index 000000000..2e509ef4a --- /dev/null +++ b/tests/tools/cassettes/test_search_tools/test_json_search_tool.yaml @@ -0,0 +1,300 @@ +interactions: +- request: + body: '{"input": ["\"test\": \"This is a test JSON file\""], "model": "text-embedding-ada-002", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '117' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 11,\n \"total_tokens\": 11\n }\n}\n" + headers: + CF-RAY: + - 936f93430d8e7df5-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:51 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=ZWmwH7qy_Do2gMLxa1sSsrEo.85HbT2vglvD1Dwg1Zs-1745770071-1.0.1.1-WFNWy52G66A4oGmHOWFAlhnFBFbZJ31LnUNvi7bwKg2R2anwH7wnxAc.zA9GMIYExcRah3uIl5KRt723DyGt5EZ60XcQksxVd2co80t2i.g; + path=/; expires=Sun, 27-Apr-25 16:37:51 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=u7YNKY8LlLPo_cstP53bpHP1eV7pP._t2QByCJYNkyk-1745770071796-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '93' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5f4895bd76-796jv + x-envoy-upstream-service-time: + - '61' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999991' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_69bfa1db5b89ca60293896c5f37d0d8f + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"batch": [{"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35168, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true}, "timestamp": "2025-04-27T16:07:50.287520+00:00", "context": {}, "distinct_id": + "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "init"}], "historical_migration": + false, "sentAt": "2025-04-27T16:07:51.445161+00:00", "api_key": "phc_PHQDA5KwztijnSojsxJ2c1DuJd52QCzJzT2xnSGvjN2"}' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate, zstd + Connection: + - keep-alive + Content-Length: + - '453' + Content-Type: + - application/json + User-Agent: + - posthog-python/3.9.3 + method: POST + uri: https://us.i.posthog.com/batch/ + response: + body: + string: '{"status":"Ok"}' + headers: + Connection: + - keep-alive + Content-Length: + - '15' + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:52 GMT + access-control-allow-credentials: + - 'true' + server: + - envoy + vary: + - origin, access-control-request-method, access-control-request-headers + x-envoy-upstream-service-time: + - '44' + status: + code: 200 + message: OK +- request: + body: '{"batch": [{"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35168, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true}, "timestamp": "2025-04-27T16:07:51.347055+00:00", "context": {}, "distinct_id": + "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "init"}, {"properties": {"class": + "App", "version": "0.1.126", "language": "python", "pid": 35168, "$lib": "posthog-python", + "$lib_version": "3.9.3", "$geoip_disable": true, "data_type": "json", "word_count": + 7, "chunks_count": 1}, "timestamp": "2025-04-27T16:07:51.676881+00:00", "context": + {}, "distinct_id": "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "add"}], + "historical_migration": false, "sentAt": "2025-04-27T16:07:51.852107+00:00", + "api_key": "phc_PHQDA5KwztijnSojsxJ2c1DuJd52QCzJzT2xnSGvjN2"}' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate, zstd + Connection: + - keep-alive + Content-Length: + - '812' + Content-Type: + - application/json + User-Agent: + - posthog-python/3.9.3 + method: POST + uri: https://us.i.posthog.com/batch/ + response: + body: + string: '{"status":"Ok"}' + headers: + Connection: + - keep-alive + Content-Length: + - '15' + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:52 GMT + access-control-allow-credentials: + - 'true' + server: + - envoy + vary: + - origin, access-control-request-method, access-control-request-headers + x-envoy-upstream-service-time: + - '24' + status: + code: 200 + message: OK +- request: + body: '{"input": ["test JSON"], "model": "text-embedding-ada-002", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '88' + content-type: + - application/json + cookie: + - __cf_bm=ZWmwH7qy_Do2gMLxa1sSsrEo.85HbT2vglvD1Dwg1Zs-1745770071-1.0.1.1-WFNWy52G66A4oGmHOWFAlhnFBFbZJ31LnUNvi7bwKg2R2anwH7wnxAc.zA9GMIYExcRah3uIl5KRt723DyGt5EZ60XcQksxVd2co80t2i.g; + _cfuvid=u7YNKY8LlLPo_cstP53bpHP1eV7pP._t2QByCJYNkyk-1745770071796-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 2,\n \"total_tokens\": 2\n }\n}\n" + headers: + CF-RAY: + - 936f9344eed57df5-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:52 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '196' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5b456cc969-csbxc + x-envoy-upstream-service-time: + - '104' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999998' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_e2376f4641b02bc9b096c5b33fd91f9d + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/tools/cassettes/test_search_tools/test_mdx_search_tool.yaml b/tests/tools/cassettes/test_search_tools/test_mdx_search_tool.yaml new file mode 100644 index 000000000..914ee947f --- /dev/null +++ b/tests/tools/cassettes/test_search_tools/test_mdx_search_tool.yaml @@ -0,0 +1,255 @@ +interactions: +- request: + body: '{"input": ["# Test MDX This is a test MDX file"], "model": "text-embedding-ada-002", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '113' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 11,\n \"total_tokens\": 11\n }\n}\n" + headers: + CF-RAY: + - 936f936a5c107e1e-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:58 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=utmyQFzT_wcpHa9.mgJCTUKMEwjaKO1KUN4w4FESXA8-1745770078-1.0.1.1-c__HC5oqY30dc8uUgateYwWXyd5rkkLT_sv7FaglerEzNk2yyURMruWVkA12xyL7Frj5cXci33jdwdr8.yO6MRk_jssq5iAvJP3Aq.SVfyE; + path=/; expires=Sun, 27-Apr-25 16:37:58 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=mD0miBgD.AKaxJ3xiOsfjrDskazLjoHBA1QrHecqrX0-1745770078037-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '61' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5f4895bd76-h5k2k + x-envoy-upstream-service-time: + - '41' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999991' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_3609b88991fc31a1bcb94c34547d9451 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"batch": [{"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35168, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true, "data_type": "csv", "word_count": 9, "chunks_count": 1}, "timestamp": + "2025-04-27T16:07:57.041070+00:00", "context": {}, "distinct_id": "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", + "event": "add"}, {"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35168, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true}, "timestamp": "2025-04-27T16:07:57.605978+00:00", "context": {}, "distinct_id": + "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "query"}], "historical_migration": + false, "sentAt": "2025-04-27T16:07:57.928462+00:00", "api_key": "phc_PHQDA5KwztijnSojsxJ2c1DuJd52QCzJzT2xnSGvjN2"}' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate, zstd + Connection: + - keep-alive + Content-Length: + - '812' + Content-Type: + - application/json + User-Agent: + - posthog-python/3.9.3 + method: POST + uri: https://us.i.posthog.com/batch/ + response: + body: + string: '{"status":"Ok"}' + headers: + Connection: + - keep-alive + Content-Length: + - '15' + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:58 GMT + access-control-allow-credentials: + - 'true' + server: + - envoy + vary: + - origin, access-control-request-method, access-control-request-headers + x-envoy-upstream-service-time: + - '39' + status: + code: 200 + message: OK +- request: + body: '{"input": ["test MDX"], "model": "text-embedding-ada-002", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '87' + content-type: + - application/json + cookie: + - __cf_bm=utmyQFzT_wcpHa9.mgJCTUKMEwjaKO1KUN4w4FESXA8-1745770078-1.0.1.1-c__HC5oqY30dc8uUgateYwWXyd5rkkLT_sv7FaglerEzNk2yyURMruWVkA12xyL7Frj5cXci33jdwdr8.yO6MRk_jssq5iAvJP3Aq.SVfyE; + _cfuvid=mD0miBgD.AKaxJ3xiOsfjrDskazLjoHBA1QrHecqrX0-1745770078037-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 3,\n \"total_tokens\": 3\n }\n}\n" + headers: + CF-RAY: + - 936f936becf67e1e-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:59 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '191' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-59cfcdcc4b-wnwks + x-envoy-upstream-service-time: + - '90' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999998' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_e29bb7e5a6b3af41f94939adce45f5f1 + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/tools/cassettes/test_search_tools/test_txt_search_tool.yaml b/tests/tools/cassettes/test_search_tools/test_txt_search_tool.yaml new file mode 100644 index 000000000..18d07c0b3 --- /dev/null +++ b/tests/tools/cassettes/test_search_tools/test_txt_search_tool.yaml @@ -0,0 +1,251 @@ +interactions: +- request: + body: '{"input": ["This is a test file for txt search"], "model": "text-embedding-ada-002", + "encoding_format": "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '113' + content-type: + - application/json + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 8,\n \"total_tokens\": 8\n }\n}\n" + headers: + CF-RAY: + - 936f933c6fce7e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:50 GMT + Server: + - cloudflare + Set-Cookie: + - __cf_bm=yAVgFNKcy2l7Cppym.kBBGNZMWvD0zYJbXBq3jJGg4A-1745770070-1.0.1.1-JvNpysiGohLJGBruqnedD94Y4r9AHPY_.gIefUGns48V4KkyaY5gC8yad0_SwaXeXArhpipuz5eQynAK2Rawe64.qrtUlri84024pQ0V8lE; + path=/; expires=Sun, 27-Apr-25 16:37:50 GMT; domain=.api.openai.com; HttpOnly; + Secure; SameSite=None + - _cfuvid=NOl2bW7B9MHsJt0XLs1fWk8BS4vWKLsCcHDInciUQBY-1745770070996-0.0.1.1-604800000; + path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '172' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-5f4895bd76-msnvl + x-envoy-upstream-service-time: + - '100' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999991' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_20f7c5a3327d4060dbc7a61f4c5c4ba1 + http_version: HTTP/1.1 + status_code: 200 +- request: + body: '{"batch": [{"properties": {"class": "App", "version": "0.1.126", "language": + "python", "pid": 35168, "$lib": "posthog-python", "$lib_version": "3.9.3", "$geoip_disable": + true}, "timestamp": "2025-04-27T16:07:50.287520+00:00", "context": {}, "distinct_id": + "5303ea6e-a423-419e-a71c-3a0f0eaaaa16", "event": "init"}], "historical_migration": + false, "sentAt": "2025-04-27T16:07:50.792604+00:00", "api_key": "phc_PHQDA5KwztijnSojsxJ2c1DuJd52QCzJzT2xnSGvjN2"}' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate, zstd + Connection: + - keep-alive + Content-Length: + - '453' + Content-Type: + - application/json + User-Agent: + - posthog-python/3.9.3 + method: POST + uri: https://us.i.posthog.com/batch/ + response: + body: + string: '{"status":"Ok"}' + headers: + Connection: + - keep-alive + Content-Length: + - '15' + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:51 GMT + access-control-allow-credentials: + - 'true' + server: + - envoy + vary: + - origin, access-control-request-method, access-control-request-headers + x-envoy-upstream-service-time: + - '46' + status: + code: 200 + message: OK +- request: + body: '{"input": ["test file"], "model": "text-embedding-ada-002", "encoding_format": + "base64"}' + headers: + accept: + - application/json + accept-encoding: + - gzip, deflate, zstd + connection: + - keep-alive + content-length: + - '88' + content-type: + - application/json + cookie: + - __cf_bm=yAVgFNKcy2l7Cppym.kBBGNZMWvD0zYJbXBq3jJGg4A-1745770070-1.0.1.1-JvNpysiGohLJGBruqnedD94Y4r9AHPY_.gIefUGns48V4KkyaY5gC8yad0_SwaXeXArhpipuz5eQynAK2Rawe64.qrtUlri84024pQ0V8lE; + _cfuvid=NOl2bW7B9MHsJt0XLs1fWk8BS4vWKLsCcHDInciUQBY-1745770070996-0.0.1.1-604800000 + host: + - api.openai.com + user-agent: + - OpenAI/Python 1.66.3 + x-stainless-arch: + - arm64 + x-stainless-async: + - 'false' + x-stainless-lang: + - python + x-stainless-os: + - MacOS + x-stainless-package-version: + - 1.66.3 + x-stainless-read-timeout: + - '600' + x-stainless-retry-count: + - '0' + x-stainless-runtime: + - CPython + x-stainless-runtime-version: + - 3.12.9 + method: POST + uri: https://api.openai.com/v1/embeddings + response: + content: "{\n \"object\": \"list\",\n \"data\": [\n {\n \"object\": + \"embedding\",\n \"index\": 0,\n \"embedding\": \"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\"\n + \ }\n ],\n \"model\": \"text-embedding-ada-002-v2\",\n \"usage\": {\n \"prompt_tokens\": + 2,\n \"total_tokens\": 2\n }\n}\n" + headers: + CF-RAY: + - 936f933fe9eb7e0a-GRU + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sun, 27 Apr 2025 16:07:51 GMT + Server: + - cloudflare + Transfer-Encoding: + - chunked + X-Content-Type-Options: + - nosniff + access-control-allow-origin: + - '*' + access-control-expose-headers: + - X-Request-ID + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + openai-model: + - text-embedding-ada-002-v2 + openai-organization: + - crewai-iuxna1 + openai-processing-ms: + - '179' + openai-version: + - '2020-10-01' + strict-transport-security: + - max-age=31536000; includeSubDomains; preload + via: + - envoy-router-7bbfccd4b9-p6rt4 + x-envoy-upstream-service-time: + - '105' + x-ratelimit-limit-requests: + - '10000' + x-ratelimit-limit-tokens: + - '10000000' + x-ratelimit-remaining-requests: + - '9999' + x-ratelimit-remaining-tokens: + - '9999998' + x-ratelimit-reset-requests: + - 6ms + x-ratelimit-reset-tokens: + - 0s + x-request-id: + - req_b1ab10d1ad4421252a7eb1b01ad92f5b + http_version: HTTP/1.1 + status_code: 200 +version: 1 diff --git a/tests/tools/test_search_tools.py b/tests/tools/test_search_tools.py new file mode 100644 index 000000000..eaa0c591c --- /dev/null +++ b/tests/tools/test_search_tools.py @@ -0,0 +1,309 @@ +import os +import tempfile +from pathlib import Path +from unittest.mock import ANY, MagicMock + +import pytest +from embedchain.models.data_type import DataType + +from crewai_tools.tools import ( + CodeDocsSearchTool, + CSVSearchTool, + DirectorySearchTool, + DOCXSearchTool, + GithubSearchTool, + JSONSearchTool, + MDXSearchTool, + PDFSearchTool, + TXTSearchTool, + WebsiteSearchTool, + XMLSearchTool, + YoutubeChannelSearchTool, + YoutubeVideoSearchTool, +) +from crewai_tools.tools.rag.rag_tool import Adapter + +pytestmark = [pytest.mark.vcr(filter_headers=["authorization"])] + + +@pytest.fixture +def mock_adapter(): + mock_adapter = MagicMock(spec=Adapter) + return mock_adapter + + +def test_directory_search_tool(): + with tempfile.TemporaryDirectory() as temp_dir: + test_file = Path(temp_dir) / "test.txt" + test_file.write_text("This is a test file for directory search") + + tool = DirectorySearchTool(directory=temp_dir) + result = tool._run(search_query="test file") + assert "test file" in result.lower() + + +def test_pdf_search_tool(mock_adapter): + mock_adapter.query.return_value = "this is a test" + + tool = PDFSearchTool(pdf="test.pdf", adapter=mock_adapter) + result = tool._run(query="test content") + assert "this is a test" in result.lower() + mock_adapter.add.assert_called_once_with("test.pdf", data_type=DataType.PDF_FILE) + mock_adapter.query.assert_called_once_with("test content") + + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = PDFSearchTool(adapter=mock_adapter) + result = tool._run(pdf="test.pdf", query="test content") + assert "this is a test" in result.lower() + mock_adapter.add.assert_called_once_with("test.pdf", data_type=DataType.PDF_FILE) + mock_adapter.query.assert_called_once_with("test content") + + +def test_txt_search_tool(): + with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as temp_file: + temp_file.write(b"This is a test file for txt search") + temp_file_path = temp_file.name + + try: + tool = TXTSearchTool() + tool.add(temp_file_path) + result = tool._run(search_query="test file") + assert "test file" in result.lower() + finally: + os.unlink(temp_file_path) + + +def test_docx_search_tool(mock_adapter): + mock_adapter.query.return_value = "this is a test" + + tool = DOCXSearchTool(docx="test.docx", adapter=mock_adapter) + result = tool._run(search_query="test content") + assert "this is a test" in result.lower() + mock_adapter.add.assert_called_once_with("test.docx", data_type=DataType.DOCX) + mock_adapter.query.assert_called_once_with("test content") + + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = DOCXSearchTool(adapter=mock_adapter) + result = tool._run(docx="test.docx", search_query="test content") + assert "this is a test" in result.lower() + mock_adapter.add.assert_called_once_with("test.docx", data_type=DataType.DOCX) + mock_adapter.query.assert_called_once_with("test content") + + +def test_json_search_tool(): + with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as temp_file: + temp_file.write(b'{"test": "This is a test JSON file"}') + temp_file_path = temp_file.name + + try: + tool = JSONSearchTool() + result = tool._run(search_query="test JSON", json_path=temp_file_path) + assert "test json" in result.lower() + finally: + os.unlink(temp_file_path) + + +def test_xml_search_tool(mock_adapter): + mock_adapter.query.return_value = "this is a test" + + tool = XMLSearchTool(adapter=mock_adapter) + result = tool._run(search_query="test XML", xml="test.xml") + assert "this is a test" in result.lower() + mock_adapter.add.assert_called_once_with("test.xml") + mock_adapter.query.assert_called_once_with("test XML") + + +def test_csv_search_tool(): + with tempfile.NamedTemporaryFile(suffix=".csv", delete=False) as temp_file: + temp_file.write(b"name,description\ntest,This is a test CSV file") + temp_file_path = temp_file.name + + try: + tool = CSVSearchTool() + tool.add(temp_file_path) + result = tool._run(search_query="test CSV") + assert "test csv" in result.lower() + finally: + os.unlink(temp_file_path) + + +def test_mdx_search_tool(): + with tempfile.NamedTemporaryFile(suffix=".mdx", delete=False) as temp_file: + temp_file.write(b"# Test MDX\nThis is a test MDX file") + temp_file_path = temp_file.name + + try: + tool = MDXSearchTool() + tool.add(temp_file_path) + result = tool._run(search_query="test MDX") + assert "test mdx" in result.lower() + finally: + os.unlink(temp_file_path) + + +def test_website_search_tool(mock_adapter): + mock_adapter.query.return_value = "this is a test" + + website = "https://crewai.com" + search_query = "what is crewai?" + tool = WebsiteSearchTool(website=website, adapter=mock_adapter) + result = tool._run(search_query=search_query) + + mock_adapter.query.assert_called_once_with("what is crewai?") + mock_adapter.add.assert_called_once_with(website, data_type=DataType.WEB_PAGE) + + assert "this is a test" in result.lower() + + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = WebsiteSearchTool(adapter=mock_adapter) + result = tool._run(website=website, search_query=search_query) + + mock_adapter.query.assert_called_once_with("what is crewai?") + mock_adapter.add.assert_called_once_with(website, data_type=DataType.WEB_PAGE) + + assert "this is a test" in result.lower() + + +def test_youtube_video_search_tool(mock_adapter): + mock_adapter.query.return_value = "some video description" + + youtube_video_url = "https://www.youtube.com/watch?v=sample-video-id" + search_query = "what is the video about?" + tool = YoutubeVideoSearchTool( + youtube_video_url=youtube_video_url, + adapter=mock_adapter, + ) + result = tool._run(search_query=search_query) + assert "some video description" in result + + mock_adapter.add.assert_called_once_with( + youtube_video_url, data_type=DataType.YOUTUBE_VIDEO + ) + mock_adapter.query.assert_called_once_with(search_query) + + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = YoutubeVideoSearchTool(adapter=mock_adapter) + result = tool._run(youtube_video_url=youtube_video_url, search_query=search_query) + assert "some video description" in result + + mock_adapter.add.assert_called_once_with( + youtube_video_url, data_type=DataType.YOUTUBE_VIDEO + ) + mock_adapter.query.assert_called_once_with(search_query) + + +def test_youtube_channel_search_tool(mock_adapter): + mock_adapter.query.return_value = "channel description" + + youtube_channel_handle = "@crewai" + search_query = "what is the channel about?" + tool = YoutubeChannelSearchTool( + youtube_channel_handle=youtube_channel_handle, adapter=mock_adapter + ) + result = tool._run(search_query=search_query) + assert "channel description" in result + mock_adapter.add.assert_called_once_with( + youtube_channel_handle, data_type=DataType.YOUTUBE_CHANNEL + ) + mock_adapter.query.assert_called_once_with(search_query) + + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = YoutubeChannelSearchTool(adapter=mock_adapter) + result = tool._run( + youtube_channel_handle=youtube_channel_handle, search_query=search_query + ) + assert "channel description" in result + + mock_adapter.add.assert_called_once_with( + youtube_channel_handle, data_type=DataType.YOUTUBE_CHANNEL + ) + mock_adapter.query.assert_called_once_with(search_query) + + +def test_code_docs_search_tool(mock_adapter): + mock_adapter.query.return_value = "test documentation" + + docs_url = "https://crewai.com/any-docs-url" + search_query = "test documentation" + tool = CodeDocsSearchTool(docs_url=docs_url, adapter=mock_adapter) + result = tool._run(search_query=search_query) + assert "test documentation" in result + mock_adapter.add.assert_called_once_with(docs_url, data_type=DataType.DOCS_SITE) + mock_adapter.query.assert_called_once_with(search_query) + + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = CodeDocsSearchTool(adapter=mock_adapter) + result = tool._run(docs_url=docs_url, search_query=search_query) + assert "test documentation" in result + mock_adapter.add.assert_called_once_with(docs_url, data_type=DataType.DOCS_SITE) + mock_adapter.query.assert_called_once_with(search_query) + + +def test_github_search_tool(mock_adapter): + mock_adapter.query.return_value = "repo description" + + # ensure the provided repo and content types are used after initialization + tool = GithubSearchTool( + gh_token="test_token", + github_repo="crewai/crewai", + content_types=["code"], + adapter=mock_adapter, + ) + result = tool._run(search_query="tell me about crewai repo") + assert "repo description" in result + mock_adapter.add.assert_called_once_with( + "repo:crewai/crewai type:code", data_type="github", loader=ANY + ) + mock_adapter.query.assert_called_once_with("tell me about crewai repo") + + # ensure content types provided by run call is used + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = GithubSearchTool(gh_token="test_token", adapter=mock_adapter) + result = tool._run( + github_repo="crewai/crewai", + content_types=["code", "issue"], + search_query="tell me about crewai repo", + ) + assert "repo description" in result + mock_adapter.add.assert_called_once_with( + "repo:crewai/crewai type:code,issue", data_type="github", loader=ANY + ) + mock_adapter.query.assert_called_once_with("tell me about crewai repo") + + # ensure default content types are used if not provided + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = GithubSearchTool(gh_token="test_token", adapter=mock_adapter) + result = tool._run( + github_repo="crewai/crewai", + search_query="tell me about crewai repo", + ) + assert "repo description" in result + mock_adapter.add.assert_called_once_with( + "repo:crewai/crewai type:code,repo,pr,issue", data_type="github", loader=ANY + ) + mock_adapter.query.assert_called_once_with("tell me about crewai repo") + + # ensure nothing is added if no repo is provided + mock_adapter.query.reset_mock() + mock_adapter.add.reset_mock() + + tool = GithubSearchTool(gh_token="test_token", adapter=mock_adapter) + result = tool._run(search_query="tell me about crewai repo") + mock_adapter.add.assert_not_called() + mock_adapter.query.assert_called_once_with("tell me about crewai repo")