Merge branch 'main' into add-agent-registry-support

Author: agrawalradhika-cell

.agents/skills/adk-git/SKILL.md

@@ -73,6 +73,7 @@ Self-check before committing: read your subject line and ask "does this tell me
 4. **50 char limit** on subject line when possible, max 72.
 5. **Use body for context** - Add a blank line then explain _why_,
    not _how_, when the subject alone isn't enough.
+6. **Reference GitHub issues** - If the commit fixes a GitHub issue, include "Fixes #<issue-number>" or "Closes #<issue-number>" (or the full issue URL if cross-repository) in the commit message body.
 
 ### Examples
 

.agents/skills/adk-issue/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: adk-issue
+description: Analyze and triage GitHub issues for the adk-python repository. Use this skill when the user provides an issue number or link to investigate whether the issue is legitimate, whether it should be fixed, and if there is an existing PR addressing it. Triggers on "analyze issue", "issue #", "github issue", "github.com/google/adk-python/issues/".
+---
+
+# ADK Issue Analyzer & Triager
+
+This skill provides a structured workflow for analyzing, verifying, and triaging GitHub issues from the `google/adk-python` repository. When a user provides a GitHub issue number or link, use this skill to perform deep investigation and report your findings.
+
+## Issue Triage Workflow
+
+Follow this 3-step process to analyze the issue:
+
+### Step 1: Retrieve and Parse the Issue
+1. **Extract the issue number**: Parse the number from the link or prompt (e.g., `https://github.com/google/adk-python/issues/5882` -> `5882`).
+2. **Fetch issue details**: Use the `gh` CLI tool to fetch issue details in JSON format:
+   ```bash
+   gh issue view <issue_number> --repo google/adk-python --json number,title,body,state,labels,comments,assignees,createdAt,closedAt
+   ```
+   *If the `gh` CLI is not available or errors out, use `read_url_content` to fetch the public GitHub issue page:*
+   ```
+   https://github.com/google/adk-python/issues/<issue_number>
+   ```
+
+---
+
+### Step 2: Deep Investigation & Analysis
+Address the following four critical questions and present your findings in a structured, premium report.
+
+#### 1. What is broken?
+Explain the root cause of the issue or failure:
+- **Trace the execution flow**: Identify which components, classes, or functions are malfunctioning.
+- **Pinpoint the bug**: Detail why the system is behaving incorrectly and where the failure originates (e.g. incorrect logic, missing configuration, unhandled states).
+
+#### 2. Is the issue legitimate?
+Inspect the codebase to confirm if the issue represents a real problem:
+- **Examine the description**: Identify the component, class, function, or file referenced.
+- **Search the codebase**: Use `grep_search` to locate the relevant files/functions in the local workspace.
+- **Inspect the code**: Open the files using `view_file` to analyze the code's current logic.
+- **Verify the bug**:
+  - Is the reported problem actually present in the code?
+  - Does it produce the reported error or behavior under the current version (ADK 2.0)?
+  - Is it a documentation typo, setup discrepancy, or a genuine code/logic bug?
+- **Document your code evidence**: Reference specific file paths and line ranges (using clickable markdown file links, e.g., `[skill_toolset.py](file:///path/to/file#L123)`) in your report.
+
+#### 3. Should we fix it?
+Formulate a recommendation on whether the issue should be addressed:
+- **Assess the impact**:
+  - Does it break core functionality?
+  - Does it affect standard developer workflows or introduce brittle workarounds?
+  - Is it a high-priority bug or a low-impact cosmetic/feature request?
+- **Check alignment**:
+  - Does the suggested solution align with `adk-architecture` and `adk-style`?
+  - Is it consistent with Python idioms and Pydantic validation rules?
+- **Evaluate workarounds**: Is there a clean workaround, or is a core fix necessary?
+- **Final Recommendation**: Clearly declare whether we should fix it, along with the reasoning and estimated complexity/scope of the fix.
+
+#### 4. Is there a linked PR that fixes this issue?
+Search for any existing pull requests that attempt to resolve the issue:
+- **Search PRs**: Run `gh pr list --repo google/adk-python --search "<issue_number>"` to list pull requests mentioning the issue number in the branch name, title, or body.
+- **Verify the PR details**: If PRs are found, fetch their details:
+  ```bash
+  gh pr view <pr_number> --repo google/adk-python --json number,title,state,url,body,author
+  ```
+- **Analyze progress**: Check if the PR is open, merged, or closed, and if it successfully fixes the issue according to the repository's testing patterns.
+- **Offer to create a fix**: If no existing PR is found, you MUST explicitly ask the user: "Would you like me to create and implement a fix for this issue in the workspace? (Note: The changes and tests will be created in a new branch but NOT committed, so you can review and iterate on them.)"
+
+---
+
+### Step 3: Report & Propose Fix
+1. **Present the structured report**: Follow the **Report Template** below to format your findings.
+2. **Propose a fix**: If there is no existing PR addressing the issue, explicitly ask the user if they would like you to implement the fix in the workspace. When implementing the fix:
+   - **Do NOT commit the changes**: Leave them uncommitted in the workspace so the user can review and iterate on them.
+   - **Base the branch on remote HEAD**: When creating the new branch, ensure it is based on the remote tracking branch HEAD (`origin/main`), not the current local branch. For example:
+     ```bash
+     git checkout -b fix/<issue_number>-<desc> origin/main
+     ```
+   - **Follow these implementation steps**:
+     1. **Create the fix**: Modify the necessary source files implementing clean, robust logic following `adk-style` and `adk-architecture`.
+     2. **Add or update unittests**: Write comprehensive unit tests to verify the behavior and prevent regressions.
+     3. **Update documentation**: Update `/docs/design` and `/docs/guides` if applicable to the changes.
+     4. **Update samples**: Update `/contributing/samples` if applicable to demonstrate the new capability or updated behavior.
+
+---
+
+## Report Template
+
+Present your final analysis as a high-quality markdown response using the following structure:
+
+```markdown
+# GitHub Issue #<issue_number> Analysis: <Issue Title>
+
+## Detailed Analysis
+
+### 1. Root Cause Analysis ("What is broken?")
+- Explanation of the failure or bug (what is failing and why).
+- Pinpoint the exact file, function, or design component that is malfunctioning.
+
+### 2. Legitimacy Analysis
+- **Status**: [Legitimate Bug / Feature Request / Duplicate / Invalid / Not Reproducible]
+- **Evidence**:
+  - Code references: [filename.py](file:///absolute/path/to/file#L100-L120)
+  - Analysis of code behavior and why the issue occurs.
+
+### 3. Fix Recommendation
+- **Recommendation**: [Should Fix (High Priority) / Should Fix (Medium/Low Priority) / Won't Fix / Needs Discussion]
+- **Rationale**:
+  - Impact on user experience, workflows, or architecture.
+  - Implementation complexity and risk of side effects.
+
+### 4. Existing Pull Requests
+- **Linked PR**: [None / Pull Request #<pr_number> - <PR Title> (<state>)]
+- **PR URL**: <PR URL>
+- **Analysis**: Brief summary of the PR's approach and status (e.g., "Fixes the bug by implementing X in Y, currently awaiting review").
+
+---
+
+## Executive Summary
+1. **What is broken?** [Brief explanation of the root cause or error]
+2. **Is the issue legitimate?** [Yes / No - brief explanation]
+3. **Should we fix it?** [Yes / No / Needs Discussion - priority & brief reasoning]
+4. **Is there a linked PR that fixes this issue?** [None / Yes, PR #<pr_number> - <state>]
+```
+
+---
+
+## Tips & Best Practices
+> [!TIP]
+> Always use explicit repository qualifiers (`--repo google/adk-python`) when running `gh` commands to avoid failures due to custom internal or local git remotes.
+
+> [!IMPORTANT]
+> When presenting code files and lines, always use markdown file links that point directly to the files in the workspace. Make sure the link is clickable and formatted as `[filename.py](file:///absolute/path/to/file#L100-L120)` without surrounding backticks around the brackets.

contributing/samples/core/abort/README.md

@@ -0,0 +1,91 @@
+# Abort Agent Sample
+
+## Overview
+
+This sample demonstrates a standalone ADK agent designed specifically to showcase cooperative task cancellation on client disconnections.
+
+The agent leverages a custom tool that counts from 1 to a target number requested by the user, pausing 1 second between each count and printing the progress directly to the server's stdout terminal. This delay allows you to easily trigger connection drops (by cancelling client requests mid-execution) and visually observe that background agent execution halts immediately in the server terminal, resolving resource leaks.
+
+## Sample Inputs
+
+- `Count to 10 seconds`
+
+  The agent will call the `count_seconds` tool with a target count of 10, pausing 1 second between each increment.
+
+- `Please count up to 20`
+
+  The agent will invoke the tool to count to 20. If you close the client connection (such as pressing `Ctrl+C` in a cURL window or closing your browser tab) while the loop is running, counting halts immediately.
+
+## Graph
+
+```mermaid
+graph TD
+    START --> AbortAgent
+    AbortAgent --> |"Invoke Tool"| count_seconds
+    count_seconds --> |"Abort if Disconnected / Done"| AbortAgent
+    AbortAgent --> ANSWER
+```
+
+## How To
+
+### 1. Running Locally via the CLI
+
+To interact with the agent in your local shell terminal:
+
+```bash
+adk run contributing/samples/core/abort/
+```
+
+Type `count to 10` at the `[user]:` prompt. Pressing `Ctrl+C` mid-run will abort counting and exit.
+
+### 2. Running via HTTP Server and cURL
+
+To verify connection-drop abortion over network protocols (e.g. simple HTTP REST request):
+
+1. Start the local development server to watch the sample workspace:
+   ```bash
+   adk web --allow_origins=http://localhost:4200 contributing/samples/
+   ```
+1. In a separate terminal, register the test session (local CLI development servers run with `--auto_create_session` set to `False` by default):
+   ```bash
+   curl -X POST http://localhost:8000/apps/abort_agent/users/user/sessions \
+     -H "Content-Type: application/json" \
+     -d '{"session_id": "8b24e6ed-1fff-4f0c-a06a-e065692a446e"}'
+   ```
+1. Initiate the count request (this blocks waiting for a response):
+   ```bash
+   curl -X POST http://localhost:8000/run \
+     -H "Content-Type: application/json" \
+     -d '{
+       "app_name": "abort_agent",
+       "user_id": "user",
+       "session_id": "8b24e6ed-1fff-4f0c-a06a-e065692a446e",
+       "new_message": {
+         "role": "user",
+         "parts": [{"text": "count to 100"}]
+       }
+     }'
+   ```
+1. Observe your `adk web` terminal window. You will see the counting progress logging.
+1. **Trigger the Abort**: Press `Ctrl+C` in your cURL terminal window to close the client connection.
+1. Observe the server console window. Counting halts instantly and prints:
+   ```text
+   [Counting Tool] Count was ABORTED mid-run at progress: X/100 (Client Disconnected)!
+   ```
+
+### 3. Running and Testing via ADK Web (Dev UI)
+
+To observe cooperative aborts interactively in the web-based developer interface:
+
+1. Start the local development server:
+   ```bash
+   adk web --allow_origins=http://localhost:4200 contributing/samples/
+   ```
+1. Open the ADK Web interface (`http://localhost:4200`) in your web browser.
+1. Select the **`abort_agent`** app from the left sidebar panel.
+1. Type `count to 100` in the message input box and click submit.
+1. **Trigger the Abort**: Simply close your browser tab, refresh the page, or navigate away from the chat panel.
+1. Observe the server's stdout terminal console. You will see that counting halts immediately and logs:
+   ```text
+   [Counting Tool] Count was ABORTED mid-run (Client Disconnected)!
+   ```

contributing/samples/core/abort/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import agent

contributing/samples/core/abort/agent.py

@@ -0,0 +1,70 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import logging
+
+from google.adk import Agent
+
+logger = logging.getLogger("google_adk." + __name__)
+
+
+async def count_seconds(target: int) -> str:
+  """Counts from 1 to the target number, pausing 1 second between counts, and prints each count.
+
+  Args:
+    target: The target number to count to.
+  """
+  logger.info("Starting count from 1 to %d...", target)
+  print(
+      f"\n[Counting Tool] Starting counting up to {target} in console...",
+      flush=True,
+  )
+
+  i = 0
+  try:
+    for i in range(1, target + 1):
+      await asyncio.sleep(1)
+      # Print to standard stdout so it shows directly in the server terminal
+      print(f"[Counting Tool] Progress: {i}/{target}", flush=True)
+      logger.info("Counted: %d/%d", i, target)
+
+    print(
+        f"[Counting Tool] Finished counting up to {target}.\n",
+        flush=True,
+    )
+    return f"Successfully counted from 1 to {target} in the console."
+  except asyncio.CancelledError:
+    print(
+        f"\n[Counting Tool] Count was ABORTED mid-run at progress: {i}/{target}"
+        " (Client Disconnected)!\n",
+        flush=True,
+    )
+    logger.warning("Counting tool was cancelled mid-run.")
+    raise
+
+
+root_agent = Agent(
+    name="abort_agent",
+    description=(
+        "An agent designed to demonstrate how ADK handles client disconnects"
+        " and aborts agent executions mid-run using a counting loop with a"
+        " 1-second delay."
+    ),
+    instruction="""You are an abort coordinator.
+Your goal is to demonstrate cooperative task abortion.
+When asked to count to a number (or count for a number of seconds), invoke the `count_seconds` tool with the target number.
+Do not try to count by yourself; always delegate counting to the `count_seconds` tool so that progress is accurately printed and logs can show task cancellation when a disconnect happens.""",
+    tools=[count_seconds],
+)

contributing/samples/models/interactions_api/agent.py

@@ -13,17 +13,6 @@
 # limitations under the License.
 
 """Agent definition for testing the Interactions API integration.
-
-NOTE: The Interactions API does NOT support mixing custom function calling tools
-with built-in tools in the same agent. To work around this limitation, we use
-bypass_multi_tools_limit=True on GoogleSearchTool, which converts the built-in
-google_search to a function calling tool (via GoogleSearchAgentTool).
-
-The bypass is only triggered when len(agent.tools) > 1, so we include multiple
-tools in the agent (GoogleSearchTool + get_current_weather).
-
-With bypass_multi_tools_limit=True and multiple tools, all tools become function
-calling tools, which allows mixing google_search with custom function tools.
 """
 
 from google.adk.agents.llm_agent import Agent
@@ -74,16 +63,13 @@ def get_current_weather(city: str) -> dict:
     }
 
 
-# Main agent with google_search (via bypass) and custom function tools
-# Using bypass_multi_tools_limit=True converts google_search to a function calling tool.
-# We need len(tools) > 1 to trigger the bypass, so we include get_current_weather directly.
-# This allows mixing google_search with custom function tools via the Interactions API.
+# Main agent with google_search built-in tool and custom function tools
 #
 # NOTE: code_executor is not compatible with function calling mode because the model
 # tries to call a function (e.g., run_code) instead of outputting code in markdown.
 root_agent = Agent(
     model=Gemini(
-        model="gemini-3-flash-preview",
+        model="gemini-3.1-flash-lite",
         use_interactions_api=True,
     ),
     name="interactions_test_agent",
@@ -99,7 +85,7 @@ def get_current_weather(city: str) -> dict:
 Be concise and helpful in your responses. Always confirm what you did.
 """,
     tools=[
-        GoogleSearchTool(bypass_multi_tools_limit=True),
+        GoogleSearchTool(),
         get_current_weather,
     ],
 )