tavily-python 0.7.20__tar.gz → 0.7.22__tar.gz

{tavily_python-0.7.20 → tavily_python-0.7.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tavily-python
-Version: 0.7.20
+Version: 0.7.22
 Summary: Python wrapper for the Tavily API
 Home-page: https://github.com/tavily-ai/tavily-python
 Author: Tavily AI
@@ -63,6 +63,21 @@ response = tavily_client.search("Who is Leo Messi?")
 print(response)
 ```
 
+### Using exact match to find specific names or phrases
+
+```python
+from tavily import TavilyClient
+
+client = TavilyClient(api_key="tvly-YOUR_API_KEY")
+
+# Use exact_match=True to only return results containing the exact phrase(s) inside quotes
+response = client.search(
+    query='"John Smith" CEO Acme Corp',
+    exact_match=True
+)
+print(response)
+```
+
 This is equivalent to directly querying our REST API.
 
 ### Generating context for a RAG Application

{tavily_python-0.7.20 → tavily_python-0.7.22}/README.md

@@ -36,6 +36,21 @@ response = tavily_client.search("Who is Leo Messi?")
 print(response)
 ```
 
+### Using exact match to find specific names or phrases
+
+```python
+from tavily import TavilyClient
+
+client = TavilyClient(api_key="tvly-YOUR_API_KEY")
+
+# Use exact_match=True to only return results containing the exact phrase(s) inside quotes
+response = client.search(
+    query='"John Smith" CEO Acme Corp',
+    exact_match=True
+)
+print(response)
+```
+
 This is equivalent to directly querying our REST API.
 
 ### Generating context for a RAG Application

{tavily_python-0.7.20 → tavily_python-0.7.22}/setup.py

@@ -5,7 +5,7 @@ with open('README.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='tavily-python',
-    version='0.7.20',
+    version='0.7.22',
     url='https://github.com/tavily-ai/tavily-python',
     author='Tavily AI',
     author_email='support@tavily.com',

{tavily_python-0.7.20 → tavily_python-0.7.22}/tavily/async_tavily.py

@@ -44,8 +44,9 @@ class AsyncTavilyClient:
         tavily_project = project_id or os.getenv("TAVILY_PROJECT")
 
         self._api_base_url = api_base_url or "https://api.tavily.com"
-        
-        self._client_creator = lambda: httpx.AsyncClient(
+
+        # Create a persistent client for connection pooling
+        self._client = httpx.AsyncClient(
             headers={
                 "Content-Type": "application/json",
                 "Authorization": f"Bearer {api_key}",
@@ -57,6 +58,16 @@ class AsyncTavilyClient:
         )
         self._company_info_tags = company_info_tags
 
+    async def close(self):
+        """Close the client and release connection pool resources."""
+        await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
     async def _search(
             self,
             query: str,
@@ -77,6 +88,7 @@ class AsyncTavilyClient:
             auto_parameters: bool = None,
             include_favicon: bool = None,
             include_usage: bool = None,
+            exact_match: bool = None,
             **kwargs,
     ) -> dict:
         """
@@ -100,6 +112,7 @@ class AsyncTavilyClient:
             "auto_parameters": auto_parameters,
             "include_favicon": include_favicon,
             "include_usage": include_usage,
+            "exact_match": exact_match,
         }
 
         data = {k: v for k, v in data.items() if v is not None}
@@ -109,11 +122,10 @@ class AsyncTavilyClient:
 
         timeout = min(timeout, 120)
 
-        async with self._client_creator() as client:
-            try:
-                response = await client.post("/search", content=json.dumps(data), timeout=timeout)
-            except httpx.TimeoutException:
-                raise TimeoutError(timeout)
+        try:
+            response = await self._client.post("/search", content=json.dumps(data), timeout=timeout)
+        except httpx.TimeoutException:
+            raise TimeoutError(timeout)
 
         if response.status_code == 200:
             return response.json()
@@ -154,6 +166,7 @@ class AsyncTavilyClient:
                      auto_parameters: bool = None,
                      include_favicon: bool = None,
                      include_usage: bool = None,
+                     exact_match: bool = None,
                      **kwargs,  # Accept custom arguments
                      ) -> dict:
         """
@@ -178,6 +191,7 @@ class AsyncTavilyClient:
                                            auto_parameters=auto_parameters,
                                            include_favicon=include_favicon,
                                            include_usage=include_usage,
+                                           exact_match=exact_match,
                                            **kwargs,
                                            )
 
@@ -221,11 +235,10 @@ class AsyncTavilyClient:
         if kwargs:
             data.update(kwargs)
 
-        async with self._client_creator() as client:
-            try:
-                response = await client.post("/extract", content=json.dumps(data), timeout=timeout)
-            except httpx.TimeoutException:
-                raise TimeoutError(timeout)
+        try:
+            response = await self._client.post("/extract", content=json.dumps(data), timeout=timeout)
+        except httpx.TimeoutException:
+            raise TimeoutError(timeout)
 
         if response.status_code == 200:
             return response.json()
@@ -283,7 +296,7 @@ class AsyncTavilyClient:
         response_dict["failed_results"] = failed_results
 
         return response_dict
-    
+
     async def _crawl(self,
                url: str,
                max_depth: int = None,
@@ -332,31 +345,30 @@ class AsyncTavilyClient:
 
         data = {k: v for k, v in data.items() if v is not None}
 
-        async with self._client_creator() as client:
+        try:
+            response = await self._client.post("/crawl", content=json.dumps(data), timeout=timeout)
+        except httpx.TimeoutException:
+            raise TimeoutError(timeout)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            detail = ""
             try:
-                response = await client.post("/crawl", content=json.dumps(data), timeout=timeout)
-            except httpx.TimeoutException:
-                raise TimeoutError(timeout)
+                detail = response.json().get("detail", {}).get("error", None)
+            except Exception:
+                pass
 
-            if response.status_code == 200:
-                return response.json()
+            if response.status_code == 429:
+                raise UsageLimitExceededError(detail)
+            elif response.status_code in [403,432,433]:
+                raise ForbiddenError(detail)
+            elif response.status_code == 401:
+                raise InvalidAPIKeyError(detail)
+            elif response.status_code == 400:
+                raise BadRequestError(detail)
             else:
-                detail = ""
-                try:
-                    detail = response.json().get("detail", {}).get("error", None)
-                except Exception:
-                    pass
-
-                if response.status_code == 429:
-                    raise UsageLimitExceededError(detail)
-                elif response.status_code in [403,432,433]:
-                    raise ForbiddenError(detail)
-                elif response.status_code == 401:
-                    raise InvalidAPIKeyError(detail)
-                elif response.status_code == 400:
-                    raise BadRequestError(detail)
-                else:
-                    raise response.raise_for_status()
+                raise response.raise_for_status()
 
     async def crawl(self,
                     url: str,
@@ -380,7 +392,7 @@ class AsyncTavilyClient:
                     ) -> dict:
         """
         Combined crawl method.
-        
+
         """
         response_dict = await self._crawl(url,
                                     max_depth=max_depth,
@@ -402,7 +414,7 @@ class AsyncTavilyClient:
                                     **kwargs)
 
         return response_dict
-    
+
     async def _map(self,
                url: str,
                max_depth: int = None,
@@ -443,31 +455,30 @@ class AsyncTavilyClient:
 
         data = {k: v for k, v in data.items() if v is not None}
 
-        async with self._client_creator() as client:
+        try:
+            response = await self._client.post("/map", content=json.dumps(data), timeout=timeout)
+        except httpx.TimeoutException:
+            raise TimeoutError(timeout)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            detail = ""
             try:
-                response = await client.post("/map", content=json.dumps(data), timeout=timeout)
-            except httpx.TimeoutException:
-                raise TimeoutError(timeout)
+                detail = response.json().get("detail", {}).get("error", None)
+            except Exception:
+                pass
 
-            if response.status_code == 200:
-                return response.json()
+            if response.status_code == 429:
+                raise UsageLimitExceededError(detail)
+            elif response.status_code in [403,432,433]:
+                raise ForbiddenError(detail)
+            elif response.status_code == 401:
+                raise InvalidAPIKeyError(detail)
+            elif response.status_code == 400:
+                raise BadRequestError(detail)
             else:
-                detail = ""
-                try:
-                    detail = response.json().get("detail", {}).get("error", None)
-                except Exception:
-                    pass
-
-                if response.status_code == 429:
-                    raise UsageLimitExceededError(detail)
-                elif response.status_code in [403,432,433]:
-                    raise ForbiddenError(detail)
-                elif response.status_code == 401:
-                    raise InvalidAPIKeyError(detail)
-                elif response.status_code == 400:
-                    raise BadRequestError(detail)
-                else:
-                    raise response.raise_for_status()
+                raise response.raise_for_status()
 
     async def map(self,
                     url: str,
@@ -639,68 +650,66 @@ class AsyncTavilyClient:
         if stream:
             async def stream_generator() -> AsyncGenerator[bytes, None]:
                 try:
-                    async with self._client_creator() as client:
-                        async with client.stream(
-                            "POST",
-                            "/research",
-                            content=json.dumps(data),
-                            timeout=timeout
-                        ) as response:
-                            if response.status_code != 200:
-                                try:
-                                    error_text = await response.aread()
-                                    error_text = error_text.decode('utf-8') if isinstance(error_text, bytes) else error_text
-                                except Exception:
-                                    error_text = "Unknown error"
-                                
-                                if response.status_code == 429:
-                                    raise UsageLimitExceededError(error_text)
-                                elif response.status_code in [403,432,433]:
-                                    raise ForbiddenError(error_text)
-                                elif response.status_code == 401:
-                                    raise InvalidAPIKeyError(error_text)
-                                elif response.status_code == 400:
-                                    raise BadRequestError(error_text)
-                                else:
-                                    raise Exception(f"Error {response.status_code}: {error_text}")
-                            
-                            async for chunk in response.aiter_bytes():
-                                if chunk:
-                                    yield chunk
+                    async with self._client.stream(
+                        "POST",
+                        "/research",
+                        content=json.dumps(data),
+                        timeout=timeout
+                    ) as response:
+                        if response.status_code != 200:
+                            try:
+                                error_text = await response.aread()
+                                error_text = error_text.decode('utf-8') if isinstance(error_text, bytes) else error_text
+                            except Exception:
+                                error_text = "Unknown error"
+
+                            if response.status_code == 429:
+                                raise UsageLimitExceededError(error_text)
+                            elif response.status_code in [403,432,433]:
+                                raise ForbiddenError(error_text)
+                            elif response.status_code == 401:
+                                raise InvalidAPIKeyError(error_text)
+                            elif response.status_code == 400:
+                                raise BadRequestError(error_text)
+                            else:
+                                raise Exception(f"Error {response.status_code}: {error_text}")
+
+                        async for chunk in response.aiter_bytes():
+                            if chunk:
+                                yield chunk
                 except httpx.TimeoutException:
                     raise TimeoutError(timeout)
                 except Exception as e:
                     raise Exception(f"Error during research stream: {str(e)}")
-            
+
             return stream_generator()
         else:
             async def _make_request():
-                async with self._client_creator() as client:
-                    try:
-                        response = await client.post("/research", content=json.dumps(data), timeout=timeout)
-                    except httpx.TimeoutException:
-                        raise TimeoutError(timeout)
+                try:
+                    response = await self._client.post("/research", content=json.dumps(data), timeout=timeout)
+                except httpx.TimeoutException:
+                    raise TimeoutError(timeout)
 
-                    if response.status_code == 200:
-                        return response.json()
+                if response.status_code == 200:
+                    return response.json()
+                else:
+                    detail = ""
+                    try:
+                        detail = response.json().get("detail", {}).get("error", None)
+                    except Exception:
+                        pass
+
+                    if response.status_code == 429:
+                        raise UsageLimitExceededError(detail)
+                    elif response.status_code in [403,432,433]:
+                        raise ForbiddenError(detail)
+                    elif response.status_code == 401:
+                        raise InvalidAPIKeyError(detail)
+                    elif response.status_code == 400:
+                        raise BadRequestError(detail)
                     else:
-                        detail = ""
-                        try:
-                            detail = response.json().get("detail", {}).get("error", None)
-                        except Exception:
-                            pass
-
-                        if response.status_code == 429:
-                            raise UsageLimitExceededError(detail)
-                        elif response.status_code in [403,432,433]:
-                            raise ForbiddenError(detail)
-                        elif response.status_code == 401:
-                            raise InvalidAPIKeyError(detail)
-                        elif response.status_code == 400:
-                            raise BadRequestError(detail)
-                        else:
-                            raise response.raise_for_status()
-            
+                        raise response.raise_for_status()
+
             return _make_request()
 
     async def research(self,
@@ -714,16 +723,16 @@ class AsyncTavilyClient:
                        ) -> Union[dict, AsyncGenerator[bytes, None]]:
         """
         Research method to create a research task.
-        
+
         Args:
             input: The research task description (required).
             model: Research depth - must be either 'mini', 'pro', or 'auto'.
             output_schema: Schema for the 'structured_output' response format (JSON Schema dict).
             stream: Whether to stream the research task.
             citation_format: Citation format - must be either 'numbered', 'mla', 'apa', or 'chicago'.
-            timeout: Optional HTTP request timeout in seconds. 
+            timeout: Optional HTTP request timeout in seconds.
             **kwargs: Additional custom arguments.
-        
+
         Returns:
             When stream=False: dict - the response dictionary.
             When stream=True: AsyncGenerator[bytes, None] - iterate over this to get streaming chunks.
@@ -740,43 +749,42 @@ class AsyncTavilyClient:
         if stream:
             return result # Don't await the result, it's an AsyncGenerator that will be lazy and only execute when iterated over with async for
         else:
-            return await result 
+            return await result
 
     async def get_research(self,
                            request_id: str
                            ) -> dict:
         """
         Get research results by request_id.
-        
+
         Args:
             request_id: The research request ID.
-        
+
         Returns:
             dict: Research response containing request_id, created_at, completed_at, status, content, and sources.
         """
-        async with self._client_creator() as client:
+        try:
+            response = await self._client.get(f"/research/{request_id}")
+        except Exception as e:
+            raise Exception(f"Error getting research: {e}")
+
+        if response.status_code in (200, 202):
+            data = response.json()
+            return data
+        else:
+            detail = ""
             try:
-                response = await client.get(f"/research/{request_id}")
-            except Exception as e:
-                raise Exception(f"Error getting research: {e}")
+                detail = response.json().get("detail", {}).get("error", None)
+            except Exception:
+                pass
 
-            if response.status_code in (200, 202):
-                data = response.json()
-                return data
+            if response.status_code == 429:
+                raise UsageLimitExceededError(detail)
+            elif response.status_code in [403,432,433]:
+                raise ForbiddenError(detail)
+            elif response.status_code == 401:
+                raise InvalidAPIKeyError(detail)
+            elif response.status_code == 400:
+                raise BadRequestError(detail)
             else:
-                detail = ""
-                try:
-                    detail = response.json().get("detail", {}).get("error", None)
-                except Exception:
-                    pass
-
-                if response.status_code == 429:
-                    raise UsageLimitExceededError(detail)
-                elif response.status_code in [403,432,433]:
-                    raise ForbiddenError(detail)
-                elif response.status_code == 401:
-                    raise InvalidAPIKeyError(detail)
-                elif response.status_code == 400:
-                    raise BadRequestError(detail)
-                else:
-                    raise response.raise_for_status()
+                raise response.raise_for_status()

{tavily_python-0.7.20 → tavily_python-0.7.22}/tavily/tavily.py

@@ -71,6 +71,7 @@ class TavilyClient:
                 auto_parameters: bool = None,
                 include_favicon: bool = None,
                 include_usage: bool = None,
+                exact_match: bool = None,
                 **kwargs
                 ) -> dict:
         """
@@ -95,6 +96,7 @@ class TavilyClient:
             "auto_parameters": auto_parameters,
             "include_favicon": include_favicon,
             "include_usage": include_usage,
+            "exact_match": exact_match,
         }
 
         data = {k: v for k, v in data.items() if v is not None}
@@ -151,6 +153,7 @@ class TavilyClient:
                auto_parameters: bool = None,
                include_favicon: bool = None,
                include_usage: bool = None,
+               exact_match: bool = None,
                **kwargs,  # Accept custom arguments
                ) -> dict:
         """
@@ -175,6 +178,7 @@ class TavilyClient:
                                      auto_parameters=auto_parameters,
                                      include_favicon=include_favicon,
                                      include_usage=include_usage,
+                                     exact_match=exact_match,
                                      **kwargs)
         response_dict.setdefault("results", [])
         return response_dict

{tavily_python-0.7.20 → tavily_python-0.7.22}/tavily_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tavily-python
-Version: 0.7.20
+Version: 0.7.22
 Summary: Python wrapper for the Tavily API
 Home-page: https://github.com/tavily-ai/tavily-python
 Author: Tavily AI
@@ -63,6 +63,21 @@ response = tavily_client.search("Who is Leo Messi?")
 print(response)
 ```
 
+### Using exact match to find specific names or phrases
+
+```python
+from tavily import TavilyClient
+
+client = TavilyClient(api_key="tvly-YOUR_API_KEY")
+
+# Use exact_match=True to only return results containing the exact phrase(s) inside quotes
+response = client.search(
+    query='"John Smith" CEO Acme Corp',
+    exact_match=True
+)
+print(response)
+```
+
 This is equivalent to directly querying our REST API.
 
 ### Generating context for a RAG Application

{tavily_python-0.7.20 → tavily_python-0.7.22}/tavily_python.egg-info/SOURCES.txt

@@ -18,4 +18,5 @@ tests/test_crawl.py
 tests/test_errors.py
 tests/test_map.py
 tests/test_research.py
-tests/test_search.py
+tests/test_search.py
+tests/test_session_pooling.py

{tavily_python-0.7.20 → tavily_python-0.7.22}/tests/test_errors.py

@@ -11,7 +11,10 @@ def set_api_key():
     old_key = os.getenv("TAVILY_API_KEY")
     os.environ["TAVILY_API_KEY"] = "test_api_key"
     yield
-    os.environ["TAVILY_API_KEY"] = old_key
+    if old_key is not None:
+        os.environ["TAVILY_API_KEY"] = old_key
+    elif "TAVILY_API_KEY" in os.environ:
+        del os.environ["TAVILY_API_KEY"]
 
 @pytest.fixture
 def clear_api_key():

{tavily_python-0.7.20 → tavily_python-0.7.22}/tests/test_search.py

@@ -32,7 +32,7 @@ def validate_specific(request, response):
     assert request.headers["Authorization"] == "Bearer tvly-test"
     assert request.headers["X-Client-Source"] == "tavily-python"
     assert request.timeout == 10
-    
+
     request_json = request.json()
     for key, value in {
         "query": "What is Tavily?",
@@ -44,7 +44,8 @@ def validate_specific(request, response):
         "exclude_domains": ["example.com"],
         "include_answer": "advanced",
         "include_raw_content": True,
-        "include_images": True
+        "include_images": True,
+        "exact_match": True
     }.items():
         assert request_json.get(key) == value
 
@@ -69,6 +70,7 @@ def test_sync_search_specific(sync_interceptor, sync_client):
         include_answer="advanced",
         include_raw_content=True,
         include_images=True,
+        exact_match=True,
         timeout=10
     )
 
@@ -94,8 +96,61 @@ def test_async_search_specific(async_interceptor, async_client):
         include_answer="advanced",
         include_raw_content=True,
         include_images=True,
+        exact_match=True,
         timeout=10
     ))
 
     request = async_interceptor.get_request()
     validate_specific(request, response)
+
+def test_sync_search_exact_match_not_sent_by_default(sync_interceptor, sync_client):
+    sync_interceptor.set_response(200, json=dummy_response)
+    sync_client.search("What is Tavily?")
+    request = sync_interceptor.get_request()
+    assert "exact_match" not in request.json()
+
+def test_sync_search_exact_match_true(sync_interceptor, sync_client):
+    sync_interceptor.set_response(200, json=dummy_response)
+    sync_client.search("What is Tavily?", exact_match=True)
+    request = sync_interceptor.get_request()
+    assert request.json()["exact_match"] is True
+
+def test_sync_search_exact_match_false(sync_interceptor, sync_client):
+    sync_interceptor.set_response(200, json=dummy_response)
+    sync_client.search("What is Tavily?", exact_match=False)
+    request = sync_interceptor.get_request()
+    assert request.json()["exact_match"] is False
+
+def test_async_search_exact_match_not_sent_by_default(async_interceptor, async_client):
+    async_interceptor.set_response(200, json=dummy_response)
+    asyncio.run(async_client.search("What is Tavily?"))
+    request = async_interceptor.get_request()
+    assert "exact_match" not in request.json()
+
+def test_async_search_exact_match_true(async_interceptor, async_client):
+    async_interceptor.set_response(200, json=dummy_response)
+    asyncio.run(async_client.search("What is Tavily?", exact_match=True))
+    request = async_interceptor.get_request()
+    assert request.json()["exact_match"] is True
+
+def test_async_search_exact_match_false(async_interceptor, async_client):
+    async_interceptor.set_response(200, json=dummy_response)
+    asyncio.run(async_client.search("What is Tavily?", exact_match=False))
+    request = async_interceptor.get_request()
+    assert request.json()["exact_match"] is False
+
+def test_sync_search_exact_match_query_quotes_escaped_in_payload(sync_interceptor, sync_client):
+    sync_interceptor.set_response(200, json=dummy_response)
+    sync_client.search('"John Smith" CEO Acme Corp', exact_match=True)
+    request = sync_interceptor.get_request()
+    # The raw JSON payload should have escaped quotes for the quoted phrase
+    assert r'\"John Smith\"' in request.body
+    # But the parsed query should preserve the original quotes
+    assert request.json()["query"] == '"John Smith" CEO Acme Corp'
+
+def test_async_search_exact_match_query_quotes_escaped_in_payload(async_interceptor, async_client):
+    async_interceptor.set_response(200, json=dummy_response)
+    asyncio.run(async_client.search('"John Smith" CEO Acme Corp', exact_match=True))
+    request = async_interceptor.get_request()
+    assert r'\"John Smith\"' in request.body
+    assert request.json()["query"] == '"John Smith" CEO Acme Corp'

tavily_python-0.7.22/tests/test_session_pooling.py

@@ -0,0 +1,152 @@
+"""
+Tests for session pooling functionality in both sync and async clients.
+"""
+import asyncio
+import pytest
+
+import tavily.tavily as sync_tavily
+import tavily.async_tavily as async_tavily
+from tests.request_intercept import intercept_requests, clear_interceptor
+
+
+dummy_response = {
+    "query": "test",
+    "results": [{"title": "Test", "url": "https://test.com", "content": "Test content", "score": 0.99}],
+    "response_time": 0.1
+}
+
+
+# =============================================================================
+# SYNC CLIENT TESTS
+# =============================================================================
+
+class TestSyncSessionPooling:
+    """Test sync client session pooling and lifecycle."""
+
+    @pytest.fixture
+    def interceptor(self):
+        yield intercept_requests(sync_tavily)
+        clear_interceptor(sync_tavily)
+
+    def test_context_manager(self, interceptor):
+        """Test that sync client works with context manager."""
+        interceptor.set_response(200, json=dummy_response)
+
+        with sync_tavily.TavilyClient(api_key="tvly-test") as client:
+            response = client.search("test query")
+            assert response["results"][0]["title"] == "Test"
+
+    def test_close_method(self, interceptor):
+        """Test that close() method works without error."""
+        interceptor.set_response(200, json=dummy_response)
+
+        client = sync_tavily.TavilyClient(api_key="tvly-test")
+        response = client.search("test query")
+        assert response["results"][0]["title"] == "Test"
+
+        # close() should not raise
+        client.close()
+
+    def test_multiple_sequential_requests(self, interceptor):
+        """Test that multiple requests work with same client (connection reuse)."""
+        interceptor.set_response(200, json=dummy_response)
+
+        client = sync_tavily.TavilyClient(api_key="tvly-test")
+
+        # Make multiple requests with same client
+        for i in range(3):
+            response = client.search(f"test query {i}")
+            assert response["results"][0]["title"] == "Test"
+
+        client.close()
+
+    def test_context_manager_multiple_requests(self, interceptor):
+        """Test multiple requests within context manager."""
+        interceptor.set_response(200, json=dummy_response)
+
+        with sync_tavily.TavilyClient(api_key="tvly-test") as client:
+            for i in range(3):
+                response = client.search(f"test query {i}")
+                assert response["results"][0]["title"] == "Test"
+
+
+# =============================================================================
+# ASYNC CLIENT TESTS
+# =============================================================================
+
+class TestAsyncSessionPooling:
+    """Test async client session pooling and lifecycle."""
+
+    @pytest.fixture
+    def interceptor(self):
+        yield intercept_requests(async_tavily)
+        clear_interceptor(async_tavily)
+
+    def test_context_manager(self, interceptor):
+        """Test that async client works with async context manager."""
+        interceptor.set_response(200, json=dummy_response)
+
+        async def run():
+            async with async_tavily.AsyncTavilyClient(api_key="tvly-test") as client:
+                response = await client.search("test query")
+                assert response["results"][0]["title"] == "Test"
+
+        asyncio.run(run())
+
+    def test_close_method(self, interceptor):
+        """Test that close() method works without error."""
+        interceptor.set_response(200, json=dummy_response)
+
+        async def run():
+            client = async_tavily.AsyncTavilyClient(api_key="tvly-test")
+            response = await client.search("test query")
+            assert response["results"][0]["title"] == "Test"
+
+            # close() should not raise
+            await client.close()
+
+        asyncio.run(run())
+
+    def test_multiple_sequential_requests(self, interceptor):
+        """Test that multiple requests work with same client (connection reuse)."""
+        interceptor.set_response(200, json=dummy_response)
+
+        async def run():
+            client = async_tavily.AsyncTavilyClient(api_key="tvly-test")
+
+            # Make multiple requests with same client
+            for i in range(3):
+                response = await client.search(f"test query {i}")
+                assert response["results"][0]["title"] == "Test"
+
+            await client.close()
+
+        asyncio.run(run())
+
+    def test_context_manager_multiple_requests(self, interceptor):
+        """Test multiple requests within async context manager."""
+        interceptor.set_response(200, json=dummy_response)
+
+        async def run():
+            async with async_tavily.AsyncTavilyClient(api_key="tvly-test") as client:
+                for i in range(3):
+                    response = await client.search(f"test query {i}")
+                    assert response["results"][0]["title"] == "Test"
+
+        asyncio.run(run())
+
+    def test_concurrent_requests_same_client(self, interceptor):
+        """Test concurrent requests using same client."""
+        interceptor.set_response(200, json=dummy_response)
+
+        async def run():
+            async with async_tavily.AsyncTavilyClient(api_key="tvly-test") as client:
+                # Run multiple searches concurrently
+                tasks = [client.search(f"query {i}") for i in range(3)]
+                results = await asyncio.gather(*tasks)
+
+                assert len(results) == 3
+                for result in results:
+                    assert result["results"][0]["title"] == "Test"
+
+        asyncio.run(run())