add integration tests for FileSearchTool

Added integration tests for both OpenAI and Google that create resources using SDK clients, run the agent, and clean up properly. Tests cover both streaming and non-streaming for each provider.

Author: gorkachea

tests/models/test_google.py

@@ -3203,8 +3203,95 @@ def _generate_response_with_texts(response_id: str, texts: list[str]) -> Generat
     )
 
 
+async def test_google_model_file_search_tool(allow_model_requests: None, google_provider: GoogleProvider):
+    """Integration test for FileSearchTool with Google."""
+    from pydantic_ai.builtin_tools import FileSearchTool
+
+    client = google_provider.client
+    
+    import tempfile
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        f.write('Paris is the capital of France. The Eiffel Tower is a famous landmark in Paris.')
+        test_file_path = f.name
+    
+    try:
+        store = await client.aio.file_search_stores.create(
+            display_name='test-file-search-store'
+        )
+        
+        with open(test_file_path, 'rb') as f:
+            await client.aio.file_search_stores.upload_to_file_search_store(
+                file_search_store=store.name,
+                file=f,
+                config={'mime_type': 'text/plain'}
+            )
+        
+        import asyncio
+        await asyncio.sleep(3)
+        
+        model = GoogleModel('gemini-2.5-pro', provider=google_provider)
+        agent = Agent(model=model, builtin_tools=[FileSearchTool(vector_store_ids=[store.name])])
+        
+        result = await agent.run('What is the capital of France according to my files?')
+        
+        assert 'Paris' in result.output or 'paris' in result.output.lower()
+        
+    finally:
+        import os
+        os.unlink(test_file_path)
+        if 'store' in locals():
+            await client.aio.file_search_stores.delete(name=store.name)
+
+
+async def test_google_model_file_search_tool_stream(allow_model_requests: None, google_provider: GoogleProvider):
+    """Integration test for FileSearchTool streaming with Google."""
+    from pydantic_ai.builtin_tools import FileSearchTool
+
+    client = google_provider.client
+    
+    import tempfile
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        f.write('The Louvre Museum is located in Paris, France. It houses the Mona Lisa.')
+        test_file_path = f.name
+    
+    try:
+        store = await client.aio.file_search_stores.create(
+            display_name='test-file-search-stream'
+        )
+        
+        with open(test_file_path, 'rb') as f:
+            await client.aio.file_search_stores.upload_to_file_search_store(
+                file_search_store=store.name,
+                file=f,
+                config={'mime_type': 'text/plain'}
+            )
+        
+        import asyncio
+        await asyncio.sleep(3)
+        
+        model = GoogleModel('gemini-2.5-pro', provider=google_provider)
+        agent = Agent(model=model, builtin_tools=[FileSearchTool(vector_store_ids=[store.name])])
+        
+        events = []
+        async with agent.iter(user_prompt='Where is the Louvre Museum according to my files?') as agent_run:
+            async for node in agent_run:
+                if Agent.is_model_request_node(node):
+                    async with node.stream(agent_run.ctx) as stream:
+                        async for event in stream:
+                            events.append(event)
+        
+        assert len(events) > 0
+        output = ''.join(str(e.part.content) if hasattr(e, 'part') and hasattr(e.part, 'content') else '' for e in events)
+        assert 'Paris' in output or 'France' in output or 'Louvre' in output or 'paris' in output.lower()
+        
+    finally:
+        import os
+        os.unlink(test_file_path)
+        if 'store' in locals():
+            await client.aio.file_search_stores.delete(name=store.name)
+
+
 # Unit tests below validate the FileSearchTool parsing logic.
-# Integration tests require setting up file search stores via the Google API.
 
 
 def test_map_file_search_grounding_metadata():

tests/models/test_openai_responses.py

@@ -7436,7 +7436,93 @@ def get_meaning_of_life() -> int:
     )
 
 
-# Integration tests for FileSearchTool require vector store setup and cassette recording.
+async def test_openai_responses_model_file_search_tool(allow_model_requests: None, openai_api_key: str):
+    """Integration test for FileSearchTool with OpenAI."""
+    from openai import AsyncOpenAI
+
+    from pydantic_ai.builtin_tools import FileSearchTool
+    from pydantic_ai.providers.openai import OpenAIProvider
+
+    async_client = AsyncOpenAI(api_key=openai_api_key)
+    
+    import tempfile
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        f.write('Paris is the capital of France. It is known for the Eiffel Tower.')
+        test_file_path = f.name
+    
+    try:
+        with open(test_file_path, 'rb') as f:
+            file = await async_client.files.create(file=f, purpose='assistants')
+        
+        vector_store = await async_client.vector_stores.create(name='test-file-search')
+        await async_client.vector_stores.files.create(vector_store_id=vector_store.id, file_id=file.id)
+        
+        import asyncio
+        await asyncio.sleep(2)
+        
+        model = OpenAIResponsesModel('gpt-4o', provider=OpenAIProvider(openai_client=async_client))
+        agent = Agent(model=model, builtin_tools=[FileSearchTool(vector_store_ids=[vector_store.id])])
+        
+        result = await agent.run('What is the capital of France according to my files?')
+        
+        assert 'Paris' in result.output or 'paris' in result.output.lower()
+        
+    finally:
+        import os
+        os.unlink(test_file_path)
+        if 'file' in locals():
+            await async_client.files.delete(file.id)
+        if 'vector_store' in locals():
+            await async_client.vector_stores.delete(vector_store.id)
+        await async_client.close()
+
+
+async def test_openai_responses_model_file_search_tool_stream(allow_model_requests: None, openai_api_key: str):
+    """Integration test for FileSearchTool streaming with OpenAI."""
+    from openai import AsyncOpenAI
+
+    from pydantic_ai.builtin_tools import FileSearchTool
+    from pydantic_ai.providers.openai import OpenAIProvider
+
+    async_client = AsyncOpenAI(api_key=openai_api_key)
+    
+    import tempfile
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        f.write('The Eiffel Tower is located in Paris, France.')
+        test_file_path = f.name
+    
+    try:
+        with open(test_file_path, 'rb') as f:
+            file = await async_client.files.create(file=f, purpose='assistants')
+        
+        vector_store = await async_client.vector_stores.create(name='test-file-search-stream')
+        await async_client.vector_stores.files.create(vector_store_id=vector_store.id, file_id=file.id)
+        
+        import asyncio
+        await asyncio.sleep(2)
+        
+        model = OpenAIResponsesModel('gpt-4o', provider=OpenAIProvider(openai_client=async_client))
+        agent = Agent(model=model, builtin_tools=[FileSearchTool(vector_store_ids=[vector_store.id])])
+        
+        parts = []
+        async with agent.run_stream('Where is the Eiffel Tower according to my files?') as result:
+            async for part in result.stream_responses(debounce_by=None):
+                parts.append(part)
+            output = await result.get_output()
+        
+        assert len(parts) > 0
+        assert 'Paris' in output or 'France' in output or 'paris' in output.lower()
+        
+    finally:
+        import os
+        os.unlink(test_file_path)
+        if 'file' in locals():
+            await async_client.files.delete(file.id)
+        if 'vector_store' in locals():
+            await async_client.vector_stores.delete(vector_store.id)
+        await async_client.close()
+
+
 # Unit tests below validate the parsing logic.