Found docs updates needed from ADK python release v1.20.0 to v1.21.0

[adk-bot]

This issue outlines the necessary documentation updates for the ADK Python release from v1.20.0 to v1.21.0. You can see the full list of changes in the compare link.

Here are the recommended changes:

1. [Feature] Add documentation for the new Interactions API support.
   The newly released Gemini Interactions API is now supported in ADK. A new page should be created to document this feature.

   Proposed Change:
   Create a new file docs/agents/interactions-api.md with the following content:

   # Using the Gemini Interactions API
   
   The Gemini Interactions API provides stateful conversation capabilities, allowing you to chain interactions using a `previous_interaction_id` instead of sending the full conversation history with each request. This can be more efficient for long conversations.
   
   To enable the Interactions API, set the `use_interactions_api=True` parameter in the `Gemini` model configuration.
   
   ## Example
   
   ```python
   from google.adk.agents.llm_agent import Agent
   from google.adk.models.google_llm import Gemini
   
   root_agent = Agent(
       model=Gemini(
           model="gemini-2.5-flash",
           use_interactions_api=True,
       ),
       name="interactions_test_agent",
       description="An agent for testing the Interactions API integration",
       instruction="You are a helpful assistant.",
   )

   For a more detailed example, see the Interactions API sample.

   
   Also, add a link to this new page in the `mkdocs.yml` file under the "Agents" section.
   
   **Reasoning**:
   This is a major new feature that provides a new way to interact with Gemini models. The documentation should explain what it is, how to use it, and provide an example.
   
   **Reference**:
   - `src/google/adk/models/google_llm.py`
   - `src/google/adk/flows/llm_flows/interactions_processor.py`
   - `contributing/samples/interactions_api/`
   
   

2. [Feature] Document the new Gemma3Ollama model integration.
   A new model integration for running Gemma 3 models with Ollama has been added.

   Proposed Change:
   In docs/agents/models.md, add a new subsection under the "Ollama Integration" section.

   Current state:
   The "Ollama Integration" section explains how to use Ollama with the ollama_chat provider in LiteLlm.

   Proposed Change:
   Add the following subsection:

   ### Using Gemma3Ollama
   
   For Gemma 3 models running on Ollama, you can use the `Gemma3Ollama` model class, which provides better support for Gemma 3's function calling capabilities.
   
   ```python
   from google.adk.agents.llm_agent import Agent
   from google.adk.models import Gemma3Ollama
   
   root_agent = Agent(
       model=Gemma3Ollama(model="ollama/gemma3:12b"),
       name="gemma_agent",
       instruction="You are a helpful assistant.",
   )

   For a complete example, see the hello_world_gemma3_ollama sample.

   
   **Reasoning**:
   This new model class provides a better experience for using Gemma 3 models with Ollama, and it should be documented.
   
   **Reference**:
   - `src/google/adk/models/gemma_llm.py`
   - `contributing/samples/hello_world_gemma3_ollama/`
   
   

3. [Feature] Document add_session_to_memory on CallbackContext and ToolContext.
   A new method add_session_to_memory has been added to CallbackContext and ToolContext to allow for explicit saving of the session to memory.

   Proposed Change:
   In docs/sessions/memory.md, add a new section.

   Current state:
   The documentation explains how to use memory_service.add_session_to_memory(session).

   Proposed Change:
   Add the following section:

   ### Explicitly Saving to Memory from Callbacks and Tools
   
   You can now explicitly trigger saving the current session to memory from within a callback or a tool by using the `add_session_to_memory()` method on the `CallbackContext` or `ToolContext`.
   
   #### From a Callback
   
   ```python
   async def auto_save_session_to_memory_callback(callback_context: CallbackContext):
       await callback_context.add_session_to_memory()
   
   agent = Agent(
       ...
       after_agent_callback=auto_save_session_to_memory_callback,
   )

   From a Tool

   async def my_tool(tool_context: ToolContext) -> str:
       # ... do some work ...
       await tool_context.add_session_to_memory()
       return "Work done and session saved to memory."

   
   **Reasoning**:
   This new feature provides a more convenient way to save the session to memory, and it should be documented.
   
   **Reference**:
   - `src/google/adk/agents/callback_context.py`
   - `src/google/adk/tools/tool_context.py`
   
   

4. [Feature] Update BigQueryAgentAnalyticsPlugin documentation for v2.0.
   The BigQueryAgentAnalyticsPlugin has been significantly updated. The documentation needs to be updated to reflect the new API and features.

   Proposed Change:
   In docs/tools/google-cloud/bigquery-agent-analytics.md, update the code samples and configuration options to reflect the new v2.0 API.

   Current state:
   The documentation is for the old version of the plugin.

   Proposed Change:
   The entire document should be reviewed and updated. Key changes include:

   • The plugin initialization has changed.
   • The configuration options in BigQueryLoggerConfig have been updated.
   • The schema of the BigQuery table has been updated.
   • New features like multi-modal content logging and GCS offloading have been added.

   Please refer to the source code for the new API and update the documentation accordingly.

   Reasoning:
   The plugin has been completely rewritten, and the documentation is now out of date.

   Reference:

   • src/google/adk/plugins/bigquery_agent_analytics_plugin.py

5. [Feature] Document OpenAPI Toolset enhancements.
   OpenAPIToolset and RestApiTool have been enhanced with new features: header_provider, ssl_verify, and tool_name_prefix.

   Proposed Change:
   In docs/tools-custom/openapi-tools.md, add a new section for advanced configuration.

   Current state:
   The documentation explains the basic usage of OpenAPIToolset.

   Proposed Change:
   Add the following section:

   ## Advanced Configuration
   
   ### Custom Headers with `header_provider`
   
   You can provide a callable to `header_provider` to dynamically add custom headers to every API request. The callable receives the `ReadonlyContext` and should return a dictionary of headers.
   
   ```python
   def my_header_provider(context: ReadonlyContext) -> dict[str, str]:
       return {"X-Request-ID": context.invocation_id}
   
   toolset = OpenAPIToolset(
       spec_dict=openapi_spec,
       header_provider=my_header_provider,
   )

   SSL Certificate Verification with ssl_verify

   You can configure SSL certificate verification for all tools in the toolset using the ssl_verify parameter. This is useful for environments with custom CA certificates.

   toolset = OpenAPIToolset(
       spec_dict=openapi_spec,
       ssl_verify="/path/to/ca.pem",
   )

   Tool Name Prefix with tool_name_prefix

   You can add a prefix to all tool names generated by the toolset using the tool_name_prefix parameter. This is useful for avoiding name collisions when using multiple OpenAPI specs.

   toolset = OpenAPIToolset(
       spec_dict=openapi_spec,
       tool_name_prefix="my_api",
   )

   
   **Reasoning**:
   These new features provide more flexibility and control over the OpenAPI tools, and they should be documented.
   
   **Reference**:
   - `src/google/adk/tools/openapi_tool/openapi_spec_parser/openapi_toolset.py`
   - `src/google/adk/tools/openapi_tool/openapi_spec_parser/rest_api_tool.py`
   
   

6. [Feature] Document Spanner QueryResultMode.DICT_LIST.
   The Spanner tool now supports returning query results as a list of dictionaries.

   Proposed Change:
   In docs/tools/built-in-tools.md, update the Spanner section to include information about QueryResultMode.DICT_LIST.

   Current state:
   The documentation for the Spanner toolset is minimal.

   Proposed Change:
   Add the following to the Spanner section:

   The `execute_sql` tool can now return results as a list of dictionaries. To enable this, set `query_result_mode=QueryResultMode.DICT_LIST` in `SpannerToolSettings`.
   
   ```python
   from google.adk.tools.spanner.settings import QueryResultMode, SpannerToolSettings
   from google.adk.tools.spanner.spanner_toolset import SpannerToolset
   
   tool_settings = SpannerToolSettings(query_result_mode=QueryResultMode.DICT_LIST)
   spanner_toolset = SpannerToolset(spanner_tool_settings=tool_settings)

   
   **Reasoning**:
   This new feature provides a more convenient way to work with Spanner query results, and it should be documented.
   
   **Reference**:
   - `src/google/adk/tools/spanner/settings.py`
   - `src/google/adk/tools/spanner/query_tool.py`
   
   

7. [Feature] Document Application Integration connection_template_override.
   The ApplicationIntegrationToolset now has a connection_template_override parameter.

   Proposed Change:
   In docs/tools/google-cloud-tools.md, update the ApplicationIntegrationToolset section.

   Current state:
   The documentation for ApplicationIntegrationToolset does not mention this parameter.

   Proposed Change:
   Add a note about the connection_template_override parameter to the ApplicationIntegrationToolset section.

   connector_tool = ApplicationIntegrationToolset(
       project="test-project",
       location="us-central1",
       connection="test-connection",
       connection_template_override="MyExecuteConnection",
   )

   Reasoning:
   This new parameter allows users to override the default connection template, which should be documented.

   Reference:

   • src/google/adk/tools/application_integration_tool/application_integration_toolset.py

8. [Feature] Document JSON Schema for Function Tool Declaration.
   A new feature has been added to build_function_declaration that uses Pydantic's JSON schema generation.

   Proposed Change:
   In docs/tools-custom/function-tools.md, add a new section.

   Current state:
   The documentation explains how to define function signatures.

   Proposed Change:
   Add a new section about the JSON schema-based function declaration.

   ## Simplified Tool Declaration with JSON Schema (Experimental)
   
   ADK now offers a simplified way to declare function tools by generating a JSON schema from your function's signature using Pydantic. This feature can be enabled via a feature flag.
   
   When enabled, `build_function_declaration` will automatically generate a JSON schema for your function's parameters, which simplifies the declaration process and provides more accurate type information to the LLM.
   
   This feature is currently experimental and can be enabled by setting the `ADK_ENABLE_JSON_SCHEMA_FOR_FUNC_DECL` environment variable to `true`.

   Reasoning:
   This new feature simplifies the process of creating function tools and should be documented.

   Reference:

   • src/google/adk/tools/_automatic_function_calling_util.py
   • src/google/adk/tools/_function_tool_declarations.py