[BUG] Reasoning Engine stream path fails with structured output (`response_mime_type` unexpected in `Runner.run_async`)

[FudoROK]

Title
[BUG] Reasoning Engine / ADK stream path fails when structured output is enforced (response_mime_type unexpected in Runner.run_async)

Description
We have a production backend on Vertex AI + ADK with two agents:

• a main reply agent
• a memory agent

Both agents have their own instructions and are expected to return strict backend-owned JSON contracts.

We recently switched our runtime path so that reply and memory tasks go through the ADK / Reasoning Engine agent runtime path instead of a direct structured Gemini call.

After that switch, the agent runtime starts correctly, but the request fails inside the remote ADK runtime when structured-output parameters are involved.

What we want
We want to use:

• the agent’s own instruction/runtime path
• plus strict JSON output for backend contracts

In other words:

• agent behavior must come from ADK agent instructions
• backend still needs strict JSON output (reply_text + system_payload for reply, typed JSON for memory tasks)

Observed behavior
The request reaches Reasoning Engine successfully:

• VERTEX_AGENT_INVOCATION_START
• QueryReasoningEngine
• CreateSession
• StreamQueryReasoningEngine

Then the remote runtime fails with:

TypeError: Runner.run_async() got an unexpected keyword argument 'response_mime_type'

After that, backend-side structured extraction fails with:

Vertex structured output extraction contract violation: no valid candidate

Relevant log excerpt

VERTEX_AGENT_INVOCATION_START
QueryReasoningEngine
CreateSession
VERTEX_AGENT_STREAM_QUERY_START
StreamQueryReasoningEngine

ERROR: Runner.run_async() got an unexpected keyword argument 'response_mime_type'

VERTEX_AGENT_INVOCATION_ERROR
Exception: Vertex structured output extraction contract violation: no valid candidate

LLM_TASK_FAILED
task=reply
provider=vertex
error_type=invalid_output
reply_path=agent_runtime
execution_path=agent_runtime

Important context
Before this change, the same task worked through a direct structured Gemini path:

• direct GenerateContent
• response_mime_type="application/json"
• response_schema
• strict backend validation succeeded

That path produced valid JSON, but it bypassed the ADK agent instruction contour, which is not acceptable for our use case.

Now we have the opposite:

• ADK agent runtime is active
• but strict structured output fails inside the ADK / Reasoning Engine stream path

Question
What is the correct supported way to combine:

1. ADK / Reasoning Engine agent runtime path
2. agent-owned instructions / role behavior
3. strict JSON output contract for backend integration

Specifically:

• Is stream_query expected to support structured output in this setup?
• Is response_mime_type / schema supposed to be passed through the transport layer at all?
• Should this be done only inside the deployed ADK agent runtime?
• Is non-streaming query the only supported option for strict structured JSON with ADK agents?
• If supported, what is the correct pattern for enforcing a typed JSON contract from an ADK agent without bypassing the agent contour?

Environment

• Vertex AI Reasoning Engine / ADK runtime
• Python backend calling remote agent runtime
• Gemini model behind Vertex
• strict backend-owned JSON contracts
• no tool side effects inside the agent
• side effects remain in backend only

Why this matters
This is not just about formatting.
We need both:

• instruction-owned agent behavior
• strict machine-valid JSON output for backend orchestration

Right now we can get either:

• correct JSON through direct Gemini structured path
• or agent runtime behavior through ADK path

But not both together reliably.

If needed, I can provide:

• a minimal reproduction
• the relevant provider code path
• the exact payload shape used before and after the runtime switch
• full logs

[sanketpatil06]

Hi @FudoROK , The TypeError: Runner.run_async() got an unexpected keyword argument occurs because the ADK separates the roles of the Agent and the Runner. The Agent handles the model's behavior while the Runner manages the workflow like sessions and routing.

Because of this, Runner.run_async() does not accept model-specific arguments like response_mime_type. To set up structured output especially when deploying to Vertex AI Reasoning Engine define these settings using GenerateContentConfig when you first initialize the Agent.

Here is a minimal example of how to implement this correctly:

import asyncio
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types  

async def main():
    APP_NAME = "my_app"
    USER_ID = "user_1"
    SESSION_ID = "session_1"

    # 1. Define structured output constraints natively at the Agent level
    agent = Agent(
        name="json_agent",
        model="gemini-2.5-flash",
        instruction="Return strictly formatted JSON data.",
        generate_content_config=types.GenerateContentConfig(
            response_mime_type="application/json",
            # You can also pass response_schema here if needed
        )
    )
    
    session_service = InMemorySessionService()
    runner = Runner(app_name=APP_NAME, agent=agent, session_service=session_service)
    
    # 2. Explicitly initialize the session
    await session_service.create_session(
        app_name=APP_NAME,
        user_id=USER_ID,
        session_id=SESSION_ID
    )
    
    # 3. Format the raw string into a structured Content object
    user_message = types.Content(
        role="user", 
        parts=[types.Part.from_text(text="Return a JSON string with a 'message' key saying 'Hello'.")]
    )
    
    # 4. Stream executes cleanly without runtime argument conflicts
    async for event in runner.run_async(
        session_id=SESSION_ID, 
        user_id=USER_ID,
        new_message=user_message
    ):
        if getattr(event, "content", None) and event.content.parts:
            print(event.content.parts[0].text, end="")

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

Could you please try this approach and let us know if it resolves the issue with your Reasoning Engine deployment?
If you are still encountering problems after moving the configuration to the Agent level, please provide:

1. A minimal reproduction script.
2. The exact google-adk version you are using.
3. The full error traceback.
   Thanks.