chore: Triaging agent improvements & github workflow

* modified list issues to only return unlabelled open issues
* added github workflow to run on schedule and issue open/reopen
* interactive/workflow modes
* readme document

PiperOrigin-RevId: 771152306

.github/workflows/triage.yml

@@ -0,0 +1,43 @@
+name: ADK Issue Triaging Agent
+
+on:
+  issues:
+    types: [opened, reopened]
+  schedule:
+    - cron: '0 */6 * * *' # every 6h
+
+jobs:
+  agent-triage-issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      contents: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install requests google-adk
+
+      - name: Run Triaging Script
+        env:
+          GITHUB_TOKEN: ${{ secrets.ADK_TRIAGE_AGENT }}
+          GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+          GOOGLE_GENAI_USE_VERTEXAI: 0
+          OWNER: 'google'
+          REPO: 'adk-python'
+          INTERACTIVE: 0
+          EVENT_NAME: ${{ github.event_name }} # 'issues', 'schedule', etc.
+          ISSUE_NUMBER: ${{ github.event.issue.number }}
+          ISSUE_TITLE: ${{ github.event.issue.title }}
+          ISSUE_BODY: ${{ github.event.issue.body }}
+          ISSUE_COUNT_TO_PROCESS: '3' # Process 3 issues at a time on schedule
+        run: python contributing/samples/adk_triaging_agent/main.py

contributing/samples/adk_triaging_agent/README.md

@@ -0,0 +1,67 @@
+# ADK Issue Triaging Assistant
+
+The ADK Issue Triaging Assistant is a Python-based agent designed to help manage and triage GitHub issues for the `google/adk-python` repository. It uses a large language model to analyze new and unlabelled issues, recommend appropriate labels based on a predefined set of rules, and apply them.
+
+This agent can be operated in two distinct modes: an interactive mode for local use or as a fully automated GitHub Actions workflow.
+
+---
+
+## Interactive Mode
+
+This mode allows you to run the agent locally to review its recommendations in real-time before any changes are made to your repository's issues.
+
+### Features
+* **Web Interface**: The agent's interactive mode can be rendered in a web browser using the ADK's `adk web` command.
+* **User Approval**: In interactive mode, the agent is instructed to ask for your confirmation before applying a label to a GitHub issue.
+
+### Running in Interactive Mode
+To run the agent in interactive mode, first set the required environment variables. Then, execute the following command in your terminal:
+
+```bash
+adk web
+```
+This will start a local server and provide a URL to access the agent's web interface in your browser.
+
+---
+
+## GitHub Workflow Mode
+
+For automated, hands-off issue triaging, the agent can be integrated directly into your repository's CI/CD pipeline using a GitHub Actions workflow.
+
+### Workflow Triggers
+The GitHub workflow is configured to run on specific triggers:
+
+1.  **Issue Events**: The workflow executes automatically whenever a new issue is `opened` or an existing one is `reopened`.
+
+2.  **Scheduled Runs**: The workflow also runs on a recurring schedule (every 6 hours) to process any unlabelled issues that may have been missed.
+
+### Automated Labeling
+When running as part of the GitHub workflow, the agent operates non-interactively. It identifies the best label and applies it directly without requiring user approval. This behavior is configured by setting the `INTERACTIVE` environment variable to `0` in the workflow file.
+
+### Workflow Configuration
+The workflow is defined in a YAML file (`.github/workflows/triage.yml`). This file contains the steps to check out the code, set up the Python environment, install dependencies, and run the triaging script with the necessary environment variables and secrets.
+
+---
+
+## Setup and Configuration
+
+Whether running in interactive or workflow mode, the agent requires the following setup.
+
+### Dependencies
+The agent requires the following Python libraries.
+
+```bash
+pip install --upgrade pip
+pip install google-adk requests
+```
+
+### Environment Variables
+The following environment variables are required for the agent to connect to the necessary services.
+
+* `GITHUB_TOKEN`: **(Required)** A GitHub Personal Access Token with `issues:write` permissions. Needed for both interactive and workflow modes.
+* `GOOGLE_API_KEY`: **(Required)** Your API key for the Gemini API. Needed for both interactive and workflow modes.
+* `OWNER`: The GitHub organization or username that owns the repository (e.g., `google`). Needed for both modes.
+* `REPO`: The name of the GitHub repository (e.g., `adk-python`). Needed for both modes.
+* `INTERACTIVE`: Controls the agent's interaction mode. For the automated workflow, this is set to `0`. For interactive mode, it should be set to `1` or left unset.
+
+For local execution in interactive mode, you can place these variables in a `.env` file in the project's root directory. For the GitHub workflow, they should be configured as repository secrets.

contributing/samples/adk_triaging_agent/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2025 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/adk_triaging_agent/agent.py

@@ -13,61 +13,73 @@
 # limitations under the License.
 
 import os
-import random
-import time
 
 from google.adk import Agent
-from google.adk.tools.tool_context import ToolContext
-from google.genai import types
 import requests
 
-# Read the PAT from the environment variable
-GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")  # Ensure you've set this in your shell
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
 if not GITHUB_TOKEN:
   raise ValueError("GITHUB_TOKEN environment variable not set")
 
-# Repository information
-OWNER = "google"
-REPO = "adk-python"
+OWNER = os.getenv("OWNER", "google")
+REPO = os.getenv("REPO", "adk-python")
+BOT_LABEL = os.getenv("BOT_LABEL", "bot_triaged")
 
-# Base URL for the GitHub API
 BASE_URL = "https://api.github.com"
 
-# Headers including the Authorization header
 headers = {
     "Authorization": f"token {GITHUB_TOKEN}",
     "Accept": "application/vnd.github.v3+json",
 }
 
+ALLOWED_LABELS = [
+    "documentation",
+    "services",
+    "question",
+    "tools",
+    "eval",
+    "live",
+    "models",
+    "tracing",
+    "core",
+    "web",
+]
 
-def list_issues(per_page: int):
+
+def is_interactive():
+  return os.environ.get("INTERACTIVE", "1").lower() in ["true", "1"]
+
+
+def list_issues(issue_count: int):
   """
   Generator to list all issues for the repository by handling pagination.
 
   Args:
-    per_page: number of pages to return per page.
+    issue_count: number of issues to return
 
   """
-  state = "open"
-  # only process the 1st page for testing for now
-  page = 1
-  results = []
-  url = (  # :contentReference[oaicite:16]{index=16}
-      f"{BASE_URL}/repos/{OWNER}/{REPO}/issues"
-  )
-  # Warning: let's only handle max 10 issues at a time to avoid bad results
-  params = {"state": state, "per_page": per_page, "page": page}
-  response = requests.get(url, headers=headers, params=params)
-  response.raise_for_status()  # :contentReference[oaicite:17]{index=17}
-  issues = response.json()
+  query = f"repo:{OWNER}/{REPO} is:open is:issue no:label"
+
+  unlabelled_issues = []
+  url = f"{BASE_URL}/search/issues"
+
+  params = {
+      "q": query,
+      "sort": "created",
+      "order": "desc",
+      "per_page": issue_count,
+      "page": 1,
+  }
+  response = requests.get(url, headers=headers, params=params, timeout=60)
+  response.raise_for_status()
+  json_response = response.json()
+  issues = json_response.get("items", None)
   if not issues:
     return []
   for issue in issues:
-    # Skip pull requests (issues API returns PRs as well)
-    if "pull_request" in issue:
-      continue
-    results.append(issue)
-  return results
+    if not issue.get("labels", None) or len(issue["labels"]) == 0:
+      unlabelled_issues.append(issue)
+  return unlabelled_issues
 
 
 def add_label_to_issue(issue_number: str, label: str):
@@ -78,41 +90,56 @@ def add_label_to_issue(issue_number: str, label: str):
     issue_number: issue number of the Github issue, in string foramt.
     label: label to assign
   """
+  print(f"Attempting to add label '{label}' to issue #{issue_number}")
+  if label not in ALLOWED_LABELS:
+    error_message = (
+        f"Error: Label '{label}' is not an allowed label. Will not apply."
+    )
+    print(error_message)
+    return {"status": "error", "message": error_message, "applied_label": None}
+
   url = f"{BASE_URL}/repos/{OWNER}/{REPO}/issues/{issue_number}/labels"
-  payload = [label]
-  response = requests.post(url, headers=headers, json=payload)
+  payload = [label, BOT_LABEL]
+  response = requests.post(url, headers=headers, json=payload, timeout=60)
   response.raise_for_status()
   return response.json()
 
 
+approval_instruction = (
+    "Only label them when the user approves the labeling!"
+    if is_interactive()
+    else (
+        "Do not ask for user approval for labeling! If you can't find a"
+        " appropriate labels for the issue, do not label it."
+    )
+)
+
 root_agent = Agent(
     model="gemini-2.5-pro-preview-05-06",
     name="adk_triaging_assistant",
     description="Triage ADK issues.",
-    instruction="""
-      You are a Github adk-python repo triaging bot. You will help get issues, and label them.
+    instruction=f"""
+      You are a Github adk-python repo triaging bot. You will help get issues, and recommend a label.
+      IMPORTANT: {approval_instruction}
       Here are the rules for labeling:
       - If the user is asking about documentation-related questions, label it with "documentation".
       - If it's about session, memory services, label it with "services"
-      - If it's about UI/web, label it with "question"
+      - If it's about UI/web, label it with "web"
+      - If the user is asking about a question, label it with "question"
       - If it's related to tools, label it with "tools"
       - If it's about agent evalaution, then label it with "eval".
       - If it's about streaming/live, label it with "live".
       - If it's about model support(non-Gemini, like Litellm, Ollama, OpenAI models), label it with "models".
       - If it's about tracing, label it with "tracing".
       - If it's agent orchestration, agent definition, label it with "core".
-      - If you can't find a appropriate labels for the issue, return the issues to user to decide.
+      - If you can't find a appropriate labels for the issue, follow the previous instruction that starts with "IMPORTANT:".
+
+      Present the followings in an easy to read format highlighting issue number and your label.
+      - the issue summary in a few sentence
+      - your label recommendation and justification
     """,
     tools=[
         list_issues,
         add_label_to_issue,
     ],
-    generate_content_config=types.GenerateContentConfig(
-        safety_settings=[
-            types.SafetySetting(  # avoid false alarm about rolling dice.
-                category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
-                threshold=types.HarmBlockThreshold.OFF,
-            ),
-        ]
-    ),
 )

contributing/samples/adk_triaging_agent/main.py

@@ -0,0 +1,164 @@
+# Copyright 2025 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 os
+import time
+
+import agent
+from dotenv import load_dotenv
+from google.adk.agents.run_config import RunConfig
+from google.adk.runners import InMemoryRunner
+from google.adk.sessions import Session
+from google.genai import types
+import requests
+
+load_dotenv(override=True)
+
+OWNER = os.getenv("OWNER", "google")
+REPO = os.getenv("REPO", "adk-python")
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
+BASE_URL = "https://api.github.com"
+headers = {
+    "Authorization": f"token {GITHUB_TOKEN}",
+    "Accept": "application/vnd.github.v3+json",
+}
+
+if not GITHUB_TOKEN:
+  print(
+      "Warning: GITHUB_TOKEN environment variable not set. API calls might"
+      " fail."
+  )
+
+
+async def fetch_specific_issue_details(issue_number: int):
+  """Fetches details for a single issue if it's unlabelled."""
+  if not GITHUB_TOKEN:
+    print("Cannot fetch issue details: GITHUB_TOKEN is not set.")
+    return None
+
+  url = f"{BASE_URL}/repos/{OWNER}/{REPO}/issues/{issue_number}"
+  print(f"Fetching details for specific issue: {url}")
+  try:
+    response = requests.get(url, headers=headers, timeout=60)
+    response.raise_for_status()
+    issue_data = response.json()
+    if not issue_data.get("labels") or len(issue_data["labels"]) == 0:
+      print(f"Issue #{issue_number} is unlabelled. Proceeding.")
+      return {
+          "number": issue_data["number"],
+          "title": issue_data["title"],
+          "body": issue_data.get("body", ""),
+      }
+    else:
+      print(f"Issue #{issue_number} is already labelled. Skipping.")
+      return None
+  except requests.exceptions.RequestException as e:
+    print(f"Error fetching issue #{issue_number}: {e}")
+    if hasattr(e, "response") and e.response is not None:
+      print(f"Response content: {e.response.text}")
+    return None
+
+
+async def main():
+  app_name = "triage_app"
+  user_id_1 = "triage_user"
+  runner = InMemoryRunner(
+      agent=agent.root_agent,
+      app_name=app_name,
+  )
+  session_11 = await runner.session_service.create_session(
+      app_name=app_name, user_id=user_id_1
+  )
+
+  async def run_agent_prompt(session: Session, prompt_text: str):
+    content = types.Content(
+        role="user", parts=[types.Part.from_text(text=prompt_text)]
+    )
+    print(f"\n>>>> Agent Prompt: {prompt_text}")
+    final_agent_response_parts = []
+    async for event in runner.run_async(
+        user_id=user_id_1,
+        session_id=session.id,
+        new_message=content,
+        run_config=RunConfig(save_input_blobs_as_artifacts=False),
+    ):
+      if event.content.parts and event.content.parts[0].text:
+        print(f"** {event.author} (ADK): {event.content.parts[0].text}")
+        if event.author == agent.root_agent.name:
+          final_agent_response_parts.append(event.content.parts[0].text)
+    print(f"<<<< Agent Final Output: {''.join(final_agent_response_parts)}\n")
+
+  event_name = os.getenv("EVENT_NAME")
+  issue_number_str = os.getenv("ISSUE_NUMBER")
+
+  if event_name == "issues" and issue_number_str:
+    print(f"EVENT: Processing specific issue due to '{event_name}' event.")
+    try:
+      issue_number = int(issue_number_str)
+      specific_issue = await fetch_specific_issue_details(issue_number)
+
+      if specific_issue:
+        prompt = (
+            f"A new GitHub issue #{specific_issue['number']} has been opened or"
+            f" reopened. Title: \"{specific_issue['title']}\"\nBody:"
+            f" \"{specific_issue['body']}\"\n\nBased on the rules, recommend an"
+            " appropriate label and its justification."
+            " Then, use the 'add_label_to_issue' tool to apply the label "
+            "directly to this issue."
+            f" The issue number is {specific_issue['number']}."
+        )
+        await run_agent_prompt(session_11, prompt)
+      else:
+        print(
+            f"No unlabelled issue details found for #{issue_number} or an error"
+            " occurred. Skipping agent interaction."
+        )
+
+    except ValueError:
+      print(f"Error: Invalid ISSUE_NUMBER received: {issue_number_str}")
+
+  else:
+    print(f"EVENT: Processing batch of issues (event: {event_name}).")
+    issue_count_str = os.getenv("ISSUE_COUNT_TO_PROCESS", "3")
+    try:
+      num_issues_to_process = int(issue_count_str)
+    except ValueError:
+      print(f"Warning: Invalid ISSUE_COUNT_TO_PROCESS. Defaulting to 3.")
+      num_issues_to_process = 3
+
+    prompt = (
+        f"List the first {num_issues_to_process} unlabelled open issues from"
+        f" the {OWNER}/{REPO} repository. For each issue, provide a summary,"
+        " recommend a label with justification, and then use the"
+        " 'add_label_to_issue' tool to apply the recommended label directly."
+    )
+    await run_agent_prompt(session_11, prompt)
+
+
+if __name__ == "__main__":
+  start_time = time.time()
+  print(
+      "Script start time:",
+      time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(start_time)),
+  )
+  print("------------------------------------")
+  asyncio.run(main())
+  end_time = time.time()
+  print("------------------------------------")
+  print(
+      "Script end time:",
+      time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(end_time)),
+  )
+  print("Total script execution time:", f"{end_time - start_time:.2f} seconds")