Merge branch 'main' into fix-windows-click-glob-expansion

Author: Abdullah-k0de

.github/workflows/issue-maintenance.yml

@@ -0,0 +1,100 @@
+# 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.
+
+name: "ADK Issue Tracker Maintenance"
+
+on:
+  # Daily background cleanup at 6:00 AM UTC (10 PM PST)
+  schedule:
+    - cron: '0 6 * * *'
+
+  # Allows manual triggering from the Actions console
+  workflow_dispatch:
+    inputs:
+      run_spam_monitor:
+        description: 'Run Issue Monitoring Agent (Spam Sweep)'
+        type: boolean
+        default: true
+      full_scan:
+        description: 'For Issue Monitoring: Run an Initial Full Scan of ALL open issues'
+        type: boolean
+        default: false
+      run_stale_auditor:
+        description: 'Run Stale Issue Auditor Agent'
+        type: boolean
+        default: true
+
+permissions:
+  issues: write
+  contents: read
+
+env:
+  GITHUB_TOKEN: ${{ secrets.ADK_TRIAGE_AGENT }}
+  GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+  OWNER: ${{ github.repository_owner }}
+  REPO: adk-python
+  CONCURRENCY_LIMIT: 3
+  LLM_MODEL_NAME: "gemini-3.5-flash"
+  PYTHONPATH: contributing/samples/adk_team
+
+jobs:
+  # 1. Sweep for spam, advertising, and invalid issues
+  sweep-spam:
+    if: |
+      github.repository == 'google/adk-python' &&
+      (github.event_name == 'schedule' || github.event.inputs.run_spam_monitor == 'true')
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install requests google-adk python-dotenv
+
+      - name: Run Issue Monitoring Agent (Spam Sweep)
+        env:
+          INITIAL_FULL_SCAN: ${{ github.event.inputs.full_scan == 'true' }}
+        run: python -m adk_issue_monitoring_agent.main
+
+  # 2. Audit inactive issues and nudge/close them
+  audit-stale:
+    if: |
+      github.repository == 'google/adk-python' &&
+      (github.event_name == 'schedule' || github.event.inputs.run_stale_auditor == 'true')
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install requests google-adk python-dateutil
+
+      - name: Run Stale Auditor Agent
+        run: python -m adk_stale_agent.main

.github/workflows/issue-monitor.yml

@@ -520,9 +520,13 @@ async def _run_async_impl(
       return
 
     should_pause = False
+    output_accumulator = ''
     async with Aclosing(self._llm_flow.run_async(ctx)) as agen:
       async for event in agen:
         self.__maybe_save_output_to_state(event)
+        output_accumulator = self.__maybe_accumulate_streaming_output(
+            event, output_accumulator
+        )
         yield event
         if ctx.should_pause_invocation(event):
           # Do not pause immediately, wait until the long-running tool call is
@@ -544,9 +548,13 @@ async def _run_async_impl(
   async def _run_live_impl(
       self, ctx: InvocationContext
   ) -> AsyncGenerator[Event, None]:
+    output_accumulator = ''
     async with Aclosing(self._llm_flow.run_live(ctx)) as agen:
       async for event in agen:
         self.__maybe_save_output_to_state(event)
+        output_accumulator = self.__maybe_accumulate_streaming_output(
+            event, output_accumulator
+        )
         yield event
       if ctx.end_invocation:
         return
@@ -962,6 +970,47 @@ def __maybe_save_output_to_state(self, event: Event):
         result = validate_schema(self.output_schema, result)
       event.actions.state_delta[self.output_key] = result
 
+  def __maybe_accumulate_streaming_output(
+      self, event: Event, accumulator: str
+  ) -> str:
+    """Accumulates output_key text across a streaming model turn.
+
+    Streaming with tool calls produces non-partial events that carry text
+    alongside a function_call. is_final_response() rejects those, so
+    __maybe_save_output_to_state skips them and the text on those events
+    is dropped from output_key. Accumulate every non-partial text-bearing
+    event from this agent across the model turn so the segments survive
+    in session state. See issue #5590.
+
+    No-op when accumulation doesn't apply (different author, no
+    output_key, output_schema set, partial event, no content, no text).
+    For applicable events, appends the event's text to ``accumulator``
+    and writes the running value to state_delta[output_key], overwriting
+    any value __maybe_save_output_to_state set on the same event.
+    Returns the new accumulator value.
+    """
+    if (
+        not self.output_key
+        or self.output_schema
+        or event.author != self.name
+        or event.partial
+        or not event.content
+        or not event.content.parts
+    ):
+      return accumulator
+
+    text = ''.join(
+        part.text
+        for part in event.content.parts
+        if part.text and not part.thought
+    )
+    if not text:
+      return accumulator
+
+    accumulator += text
+    event.actions.state_delta[self.output_key] = accumulator
+    return accumulator
+
   @model_validator(mode='after')
   def __model_validator_after(self) -> LlmAgent:
     return self

.github/workflows/stale-bot.yml

@@ -541,18 +541,36 @@ async def search_memory(self, *, app_name: str, user_id: str, query: str):
     logger.info('Search memory response received.')
 
     memory_events: list[MemoryEntry] = []
-    async for retrieved_memory in retrieved_memories_iterator:
-      # TODO: add more complex error handling
-      logger.debug('Retrieved memory: %s', retrieved_memory)
-      memory_events.append(
-          MemoryEntry(
-              author='user',
-              content=types.Content(
-                  parts=[types.Part(text=retrieved_memory.memory.fact)],
-                  role='user',
-              ),
-              timestamp=retrieved_memory.memory.update_time.isoformat(),
+    try:
+      async for retrieved_memory in retrieved_memories_iterator:
+        try:
+          memory = retrieved_memory.memory
+          if memory is None:
+            logger.warning('Skipping memory entry with missing memory object.')
+            continue
+          fact = memory.fact
+          if not fact:
+            logger.warning('Skipping memory entry with empty or missing fact.')
+            continue
+          update_time = memory.update_time
+          memory_events.append(
+              MemoryEntry(
+                  author='user',
+                  content=types.Content(
+                      parts=[types.Part(text=fact)],
+                      role='user',
+                  ),
+                  timestamp=update_time.isoformat() if update_time else None,
+              )
+          )
+        except AttributeError:
+          logger.warning(
+              'Skipping malformed memory entry: %s', retrieved_memory
           )
+    except Exception:
+      logger.exception(
+          'Error while iterating memory results. Returning %d partial results.',
+          len(memory_events),
       )
     return SearchMemoryResponse(memories=memory_events)