Down the line `SequentialAgent` has access to all previous conversations

[jorism1993]

Describe the bug
Down the line SequentialAgent has access to all previous conversations through llm_request.contents, instead of running as a standalone agent. Even when setting include_contents='none', it still has access to the last llm_request.contents part, leading to context rot.

To Reproduce

from typing import Optional

from google.adk.agents import LlmAgent, SequentialAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.agents.callback_context import CallbackContext
from google.genai.types import Content, Part
from google.adk.models import LlmResponse, LlmRequest

import asyncio

GEMINI_MODEL = "gemini-2.5-flash"

# Constants for session management
APP_NAME = 'code_pipeline_app'
USER_ID = 'test_user'
SESSION_ID = 'code_pipeline_session'


# --- Define the Callback Function ---
def set_last_user_message_callback(
        callback_context: CallbackContext,
        llm_request: LlmRequest
) -> Optional[LlmResponse]:
    """Inspects/modifies the LLM request or skips the call."""

    # last_user_message = ""
    last_message = llm_request.contents[-1].parts[0]

    import pdb
    pdb.set_trace()

    return None


# --- 1. Define Sub-Agents for Each Pipeline Stage ---

# Code Writer Agent
code_writer_agent = LlmAgent(
    name="CodeWriterAgent",
    model=GEMINI_MODEL,
    instruction="""You are a Python Code Generator.
Based *only* on the user's request, write Python code that fulfills the requirement.
Output *only* the complete Python code block, enclosed in <code> tags (<code>python ... </code>). 
Do not add any other text before or after the code block.
""",
    description="Writes initial Python code based on a specification.",
    output_key="generated_code"
)

# Code Reviewer Agent
code_reviewer_agent = LlmAgent(
    name="CodeReviewerAgent",
    model=GEMINI_MODEL,
    instruction="""You are an expert Python Code Reviewer. 
    Your task is to provide constructive feedback on the provided code.

    **Code to Review:**
    <code>
    {generated_code}
    </code>

**Review Criteria:**
1.  **Correctness:** Does the code work as intended? Are there logic errors?
2.  **Readability:** Is the code clear and easy to understand? Follows PEP 8 style guidelines?
3.  **Efficiency:** Is the code reasonably efficient? Any obvious performance bottlenecks?
4.  **Edge Cases:** Does the code handle potential edge cases or invalid inputs gracefully?
5.  **Best Practices:** Does the code follow common Python best practices?

**Output:**
Provide your feedback as a concise, bulleted list. Focus on the most important points for improvement.
If the code is excellent and requires no changes, simply state: "No major issues found."
Output *only* the review comments or the "No major issues" statement.
""",
    description="Reviews code and provides feedback.",
    output_key="review_comments",
)

# Code Refactorer Agent
code_refactorer_agent = LlmAgent(
    name="CodeRefactorerAgent",
    model=GEMINI_MODEL,
    instruction="""You are a Python Code Refactoring AI.
Your goal is to improve the given Python code based on the provided review comments.

  **Original Code:**
  <code>
  {generated_code}
  </code>

  **Review Comments:**
  {review_comments}

**Task:**
Carefully apply the suggestions from the review comments to refactor the original code.
If the review comments state "No major issues found," return the original code unchanged.
Ensure the final code is complete, functional, and includes necessary imports and docstrings.

**Output:**
Output *only* the final, refactored Python code block, enclosed in <code> tags (<code>python ... </code>). 
Do not add any other text before or after the code block.
""",
    description="Refactors code based on review comments.",
    output_key="refactored_code",
    before_model_callback=set_last_user_message_callback,
    include_contents='none',
)

# --- 2. Create the SequentialAgent ---
code_pipeline_agent = SequentialAgent(
    name="CodePipelineAgent",
    sub_agents=[code_writer_agent, code_reviewer_agent, code_refactorer_agent],
    description="Executes a sequence of code writing, reviewing, and refactoring.",
)

# For ADK tools compatibility, the root agent must be named `root_agent`
root_agent = code_pipeline_agent

# --- 3. Initialize Session Service and Create Session ---
session_service = InMemorySessionService()

# Create session for the pipeline
# Session creation is asynchronous; it will be performed inside `main()` where we can `await` the coroutine.

# Create runner
pipeline_runner = Runner(
    agent=code_pipeline_agent,
    app_name=APP_NAME,
    session_service=session_service
)


# --- 4. Define Pipeline Interaction Logic ---
async def run_code_pipeline(query: str):
    """Runs the code pipeline and prints detailed results for each stage."""
    print(f"\n>>> Running Code Pipeline | Query: {query}")

    user_content = Content(role='user', parts=[Part(text=query)])

    final_response_content = "No final response received."

    # Run the pipeline
    async for event in pipeline_runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=user_content):
        # Uncomment for detailed event logging
        # print(f"Event: {event.type}, Author: {event.author}")

        if event.is_final_response() and event.content and event.content.parts:
            final_response_content = event.content.parts[0].text

    print(f"<<< Pipeline Final Response: {final_response_content}")

    # Get the current session to inspect intermediate results
    current_session = await session_service.get_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)

    if current_session is None:
        print("Warning: Session not found when retrieving stage results.")
        return

    # Print results from each stage
    print("\n--- Pipeline Stage Results ---")

    # Generated Code
    generated_code = current_session.state.get("generated_code")
    if generated_code:
        print("1. Generated Code:")
        print(generated_code)
        print("-" * 50)

    # Review Comments
    review_comments = current_session.state.get("review_comments")
    if review_comments:
        print("2. Review Comments:")
        print(review_comments)
        print("-" * 50)

    # Refactored Code
    refactored_code = current_session.state.get("refactored_code")
    if refactored_code:
        print("3. Refactored Code:")
        print(refactored_code)
        print("-" * 50)


# --- 5. Main Execution ---
async def main():
    print("=== Code Pipeline Demo ===")

    # Ensure the session exists before running the pipeline.
    # If the session already exists, this call will simply retrieve it.
    await session_service.create_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)

    # Test with different code requests
    await run_code_pipeline("Write some code to add two numbers together in Python.")

    # print("\n" + "=" * 60 + "\n")
    #
    # await run_code_pipeline("Create a function that calculates the factorial of a number using recursion.")
    #
    # print("\n" + "=" * 60 + "\n")
    #
    # await run_code_pipeline("Write a class for a simple calculator with basic arithmetic operations.")


if __name__ == "__main__":
    asyncio.run(main())

See code example to run. Inspect variables in the callback

Expected behavior
I expect the agent to run as a standalone agent, and pass information through the {} in the prompts. I expect it to not have access to the previous prompts and answers.

[aperepel]

Ran into it as well, and it is jarring, please raise the priority, if possible, it greatly affects the value of ADK.

Some justification for the nudge:
Current State (with bug):

• Token waste: ~1000-2000 extra tokens per agent (6 agents × 2000 = 12K tokens/document)
• Cost increase: ~40% higher LLM costs
• Latency increase: ~20-30% slower due to larger prompts

[aperepel]

Workaround Solution: before_model_callback Filter

I've been hitting this issue hard with a SequentialAgent pipeline, and can confirm the token waste and cost impact are real. Here's a working workaround using before_model_callback to strip the pollution before it reaches the LLM.

The Problem

Despite include_contents='none', SequentialAgent injects previous agent outputs as:

For context:

[agent_name] said: {"output": "..."}

This caused 1000-2000 extra tokens per agent in our pipeline (~16K tokens/run for 8 agents).

The Solution

Use before_model_callback to intercept and filter the LLM request before it's sent:

import re
from typing import Optional
from google.adk.agents.callback_context import CallbackContext
from google.adk.models import LlmRequest, LlmResponse

# Pattern to detect polluted context
AGENT_SAID_PATTERN = re.compile(r'\[[\w_]+\]\s+said:', re.IGNORECASE)

def strip_agent_said_pollution(
    callback_context: CallbackContext,
    llm_request: LlmRequest
) -> Optional[LlmResponse]:
    """
    Remove context pollution from LLM requests.

    Removes BOTH pollution parts:
      1. "For context:" label
      2. "[agent_name] said: {output}"
    """
    if not hasattr(llm_request, 'contents'):
        return None

    filtered_contents = []

    for content in llm_request.contents:
        if hasattr(content, 'parts'):
            clean_parts = []

            for part in content.parts:
                if hasattr(part, 'text') and part.text is not None:
                    text = part.text.strip()

                    # Skip "For context:" parts
                    if text.lower() == "for context:" or text.lower().startswith("for context:"):
                        continue

                    # Skip "[agent_name] said:" parts
                    if AGENT_SAID_PATTERN.search(text):
                        continue

                    clean_parts.append(part)
                else:
                    clean_parts.append(part)

            if clean_parts:
                content.parts = clean_parts
                filtered_contents.append(content)
        else:
            filtered_contents.append(content)

    llm_request.contents = filtered_contents
    return None  # Allow request to proceed

Usage in Agent Configuration

Apply the filter to each agent in your SequentialAgent pipeline:

from google.adk import Agent, SequentialAgent

agent = Agent(
    model=get_model(),
    name="statement_extractor",
    instruction="Extract statements from: {input_text}",
    output_schema=MyOutputSchema,
    include_contents='none',  # Keep this for when bug is fixed
    before_model_callback=strip_agent_said_pollution,  # Workaround
)

# Use in SequentialAgent
pipeline = SequentialAgent(
    name="pipeline",
    sub_agents=[agent1, agent2, agent3]  # Each with filter applied
)

Results

Before workaround:

• extra tokens per document (8 agents × 2000 tokens)
• higher LLM costs
• slower latency

After workaround:

• 60-80% token reduction per agent invocation
• Costs normalized
• Clean, focused prompts

Testing

You can verify the filter works by inspecting LLM requests in a callback:

def debug_callback(ctx, llm_request):
    for content in llm_request.contents:
        for part in content.parts:
            if hasattr(part, 'text'):
                assert '[agent_name] said:' not in part.text
                assert 'For context:' not in part.text.lower()
    return None

Long-Term

Once this issue is resolved in ADK, we can:

1. Remove before_model_callback from all agents
2. Keep include_contents='none' (will work natively)

Hope this helps others hitting the same issue! Happy to provide more details if needed.

[Jacksunwei]

Context on Current Behavior

The include_contents='none' option is working as designed, though we acknowledge the naming is confusing.

Currently, 'none' means "no full conversation history, but include immediate workflow context from the previous agent" - which is why you're seeing "For context: [agent] said: ..." being injected.

This behavior is intentional for workflow scenarios where sequential agents need context from previous steps, but we recognize the naming doesn't clearly communicate this.

---

@aperepel's before_model_callback workaround is the correct approach for achieving true isolation. Thank you for documenting it so thoroughly - it will help others with the same use case!

We're considering a broader redesign of context management that would make these options clearer, but for now, the workaround is the recommended solution.

Closing this as working as designed. The workaround provides the isolation you need.