feat(gemini): Add generic tools parameter for all Gemini built-in tools

- Add tools.py with wrapper classes for all 6 Gemini tools:
  - FileSearch: RAG over documents
  - GoogleSearch: Ground responses with web data
  - CodeExecution: Run Python code
  - URLContext: Read specific web pages
  - GoogleMaps: Location-aware queries
  - ComputerUse: Browser automation

- Replace hardcoded file_search_store param with generic tools list
- Update _build_config() to handle multiple tools
- Update phone example to use new tools API
- Add unit tests for all tool wrappers

Usage:
  llm = gemini.LLM(tools=[
      gemini.tools.FileSearch(store),
      gemini.tools.GoogleSearch(),
      gemini.tools.CodeExecution(),
  ])

Author: d3xvn

examples/03_phone_and_rag_example/inbound_phone_and_rag_example.py

@@ -180,7 +180,10 @@ async def search_knowledge(query: str) -> str:
             return await rag.search(query, top_k=3)
 
     else:
-        llm = gemini.LLM("gemini-2.5-flash-lite", file_search_store=file_search_store)
+        llm = gemini.LLM(
+            "gemini-2.5-flash-lite",
+            tools=[gemini.tools.FileSearch(file_search_store)],
+        )
 
     return Agent(
         edge=getstream.Edge(),

plugins/gemini/tests/test_gemini_file_search.py

@@ -22,7 +22,7 @@
 async def rag():
     """Create a RAG instance for testing, clean up after."""
     # Use unique name to avoid conflicts
-    rag = GeminiFilesearchRAG(name=f"test-rag-123")
+    rag = GeminiFilesearchRAG(name="test-rag-123")
     await rag.create()
     yield rag
     await rag.clear()

plugins/gemini/tests/test_gemini_tools.py

@@ -0,0 +1,107 @@
+"""Tests for Gemini built-in tools."""
+
+from unittest.mock import MagicMock
+
+from google.genai import types
+
+from vision_agents.plugins.gemini import tools
+
+
+class TestGoogleSearch:
+    """Tests for GoogleSearch tool."""
+
+    def test_to_tool(self):
+        """Test GoogleSearch converts to Tool correctly."""
+        tool = tools.GoogleSearch()
+        result = tool.to_tool()
+
+        assert isinstance(result, types.Tool)
+        assert result.google_search is not None
+
+
+class TestCodeExecution:
+    """Tests for CodeExecution tool."""
+
+    def test_to_tool(self):
+        """Test CodeExecution converts to Tool correctly."""
+        tool = tools.CodeExecution()
+        result = tool.to_tool()
+
+        assert isinstance(result, types.Tool)
+        assert result.code_execution is not None
+
+
+class TestURLContext:
+    """Tests for URLContext tool."""
+
+    def test_to_tool(self):
+        """Test URLContext converts to Tool correctly."""
+        tool = tools.URLContext()
+        result = tool.to_tool()
+
+        assert isinstance(result, types.Tool)
+        assert result.url_context is not None
+
+
+class TestGoogleMaps:
+    """Tests for GoogleMaps tool."""
+
+    def test_to_tool(self):
+        """Test GoogleMaps converts to Tool correctly."""
+        tool = tools.GoogleMaps()
+        result = tool.to_tool()
+
+        assert isinstance(result, types.Tool)
+        assert result.google_maps is not None
+
+
+class TestComputerUse:
+    """Tests for ComputerUse tool."""
+
+    def test_to_tool(self):
+        """Test ComputerUse converts to Tool correctly."""
+        tool = tools.ComputerUse()
+        result = tool.to_tool()
+
+        assert isinstance(result, types.Tool)
+        assert result.computer_use is not None
+
+    def test_custom_environment(self):
+        """Test ComputerUse with custom environment."""
+        tool = tools.ComputerUse(environment=types.Environment.ENVIRONMENT_BROWSER)
+        result = tool.to_tool()
+
+        assert result.computer_use.environment == types.Environment.ENVIRONMENT_BROWSER
+
+
+class TestFileSearch:
+    """Tests for FileSearch tool."""
+
+    def test_to_tool_with_created_store(self):
+        """Test FileSearch converts to Tool when store is created."""
+        # Mock the store
+        mock_store = MagicMock()
+        mock_store.is_created = True
+        mock_store.get_tool.return_value = types.Tool(
+            file_search=types.FileSearch(file_search_store_names=["test-store"])
+        )
+
+        tool = tools.FileSearch(mock_store)
+        result = tool.to_tool()
+
+        assert isinstance(result, types.Tool)
+        assert result.file_search is not None
+        mock_store.get_tool.assert_called_once()
+
+    def test_to_tool_raises_when_store_not_created(self):
+        """Test FileSearch raises error when store is not created."""
+        mock_store = MagicMock()
+        mock_store.is_created = False
+
+        tool = tools.FileSearch(mock_store)
+
+        try:
+            tool.to_tool()
+            assert False, "Should have raised ValueError"
+        except ValueError as e:
+            assert "not created" in str(e)

plugins/gemini/vision_agents/plugins/gemini/__init__.py

@@ -1,14 +1,18 @@
 from .gemini_llm import GeminiLLM as LLM
 from .gemini_realtime import GeminiRealtime as Realtime
 from .file_search import GeminiFilesearchRAG, FileSearchStore, create_file_search_store
+from . import tools
 from google.genai.types import ThinkingLevel, MediaResolution
 
 __all__ = [
     "Realtime",
     "LLM",
     "ThinkingLevel",
     "MediaResolution",
+    # Tools
+    "tools",
+    # File Search (convenience exports)
     "GeminiFilesearchRAG",
-    "FileSearchStore",  # Backwards compatibility alias
+    "FileSearchStore",
     "create_file_search_store",
 ]

plugins/gemini/vision_agents/plugins/gemini/gemini_llm.py

@@ -19,7 +19,7 @@
 )
 
 from . import events
-from .file_search import FileSearchStore
+from .tools import GeminiTool
 
 from vision_agents.core.processors import Processor
 
@@ -58,7 +58,7 @@ def __init__(
         thinking_level: Optional[ThinkingLevel] = None,
         media_resolution: Optional[MediaResolution] = None,
         config: Optional[GenerateContentConfig] = None,
-        file_search_store: Optional[FileSearchStore] = None,
+        tools: Optional[List[GeminiTool]] = None,
         **kwargs,
     ):
         """
@@ -77,17 +77,22 @@ def __init__(
                 "low"/"medium" for general video, "high" for text-heavy video.
             config: Optional[GenerateContentConfig] to use as base. Any kwargs will be passed
                 to GenerateContentConfig constructor if config is not provided.
-            file_search_store: Optional FileSearchStore for RAG functionality. When provided,
-                the model will use the indexed documents to answer questions.
-                See: https://ai.google.dev/gemini-api/docs/file-search
+            tools: Optional list of Gemini built-in tools. Available tools:
+                - tools.FileSearch(store): RAG over your documents
+                - tools.GoogleSearch(): Ground responses with web data
+                - tools.CodeExecution(): Run Python code
+                - tools.URLContext(): Read specific web pages
+                - tools.GoogleMaps(): Location-aware queries (Preview)
+                - tools.ComputerUse(): Browser automation (Preview)
+                See: https://ai.google.dev/gemini-api/docs/tools
             **kwargs: Additional arguments passed to GenerateContentConfig constructor.
         """
         super().__init__()
         self.events.register_events_from_module(events)
         self.model = model
         self.thinking_level = thinking_level
         self.media_resolution = media_resolution
-        self.file_search_store = file_search_store
+        self._builtin_tools = tools or []
 
         if config is not None:
             self._base_config: Optional[GenerateContentConfig] = config
@@ -109,15 +114,15 @@ def _build_config(
         base_config: Optional[GenerateContentConfig] = None,
     ) -> GenerateContentConfig:
         """
-        Build GenerateContentConfig with Gemini 3 features and file search.
+        Build GenerateContentConfig with Gemini 3 features and built-in tools.
 
         Args:
             system_instruction: Optional system instruction to include. If not provided,
                 uses self._instructions to ensure instructions are always passed.
             base_config: Optional base config to extend (takes precedence over self._base_config)
 
         Returns:
-            GenerateContentConfig with thinking_level, media_resolution, and file_search if set
+            GenerateContentConfig with thinking_level, media_resolution, and tools if set
         """
         if base_config is not None:
             config = base_config
@@ -142,14 +147,14 @@ def _build_config(
         if self.media_resolution:
             config.media_resolution = self.media_resolution
 
-        # Add file search tool if store is configured
-        if self.file_search_store and self.file_search_store.is_created:
-            file_search_tool = self.file_search_store.get_tool()
+        # Add built-in tools if configured
+        if self._builtin_tools:
+            builtin_tool_objects = [tool.to_tool() for tool in self._builtin_tools]
             if config.tools is None:
-                config.tools = [file_search_tool]
+                config.tools = builtin_tool_objects
             else:
                 # Append to existing tools
-                config.tools = list(config.tools) + [file_search_tool]
+                config.tools = list(config.tools) + builtin_tool_objects
 
         return config