models/gemini-2.5-pro-preview-05-06 is not found for API version v1alpha, or is not supported for bidiGenerateContent

[RafalJachimczyk]

Hi,

I'm trying to build a simple UI interface in Next.Js where I invoke my agent. It does work when I start the agent with adk api_server

I'm suspecting that running adk api_server is not appropriate solution to run agents in production ( I will be hosting this agent in docker / AWS ECS) so I am trying to build a simple python program to serve SSE events to my UI app.

Here is the main.py code :

import json
from typing import Dict, Tuple, Optional

from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import StreamingResponse

# ---- ADK imports ----------------------------------------------------
from google.adk.runners import InMemoryRunner
from google.adk.agents import RunConfig
from google.adk.agents import LiveRequestQueue
from google.genai.types import Content, Part, Blob

# ---- your agent -----------------------------------------------------
# Keep the full agent definition in a separate python file (e.g. refund_agent.py)
# that sets `workflow_agent_refund` exactly as in your paste.
from workflow_refund import workflow_agent_refund

APP_NAME = "Fraud-Refund-Workflow-Demo"

# In-memory map of {user_id -> LiveRequestQueue}
active_sessions: Dict[str, LiveRequestQueue] = {}

app = FastAPI()


# ---------------------------------------------------------------------
# Helper – spin up an isolated ADK session for a new browser tab
# ---------------------------------------------------------------------
async def start_agent_session(user_id: str) -> Tuple:
    """
    Returns `(live_events_generator, live_request_queue)`
    so we can both read *from* the agent (events) and write *to* it
    (queue.send_content()).
    """
    runner = InMemoryRunner(agent=workflow_agent_refund, app_name=APP_NAME)

    session = await runner.session_service.create_session(
        app_name=APP_NAME,
        user_id=user_id,
    )

    # We only need text responses for this UI.
    run_config = RunConfig(response_modalities=["TEXT"])

    live_request_queue = LiveRequestQueue()
    live_events = runner.run_live(
        session=session,
        live_request_queue=live_request_queue,
        run_config=run_config,
    )
    return live_events, live_request_queue


# ---------------------------------------------------------------------
# Helper – translate ADK Event → tiny JSON the React panel expects
# ---------------------------------------------------------------------
async def agent_to_client_sse(live_events):
    async for event in live_events:
        # turn complete / interrupted flags
        if event.turn_complete or event.interrupted:
            yield f"data: {json.dumps({'turn_complete': event.turn_complete, 'interrupted': event.interrupted})}\n\n"
            continue

        # First content part (ADK always puts text in the first part for LLM output)
        part: Optional[Part] = event.content.parts[0] if (event.content and event.content.parts) else None
        if not part:
            continue

        # Text stream
        if part.text:
            payload = {"mime_type": "text/plain", "data": part.text}
            yield f"data: {json.dumps(payload)}\n\n"


# ---------------------------------------------------------------------
# GET  /events/{user_id}  → opens SSE stream
# ---------------------------------------------------------------------
@app.get("/events/{user_id}")
async def events_endpoint(user_id: str):
    if user_id in active_sessions:
        # Browser refreshed without closing previous tab – reject to avoid dup session
        raise HTTPException(status_code=409, detail="Session already active")

    # Kick off the agent for this user
    live_events, live_request_queue = await start_agent_session(user_id)
    active_sessions[user_id] = live_request_queue
    print(f"[SSE] client {user_id} connected")

    async def event_generator():
        try:
            async for chunk in agent_to_client_sse(live_events):
                yield chunk
        finally:
            # Client closed connection → cleanup
            live_request_queue.close()
            active_sessions.pop(user_id, None)
            print(f"[SSE] client {user_id} disconnected")

    # Standard SSE headers
    return StreamingResponse(
        event_generator(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
            "Access-Control-Allow-Origin": "*",
        },
    )


# ---------------------------------------------------------------------
# POST /send/{user_id}  → forward message from browser to agent
# ---------------------------------------------------------------------
@app.post("/send/{user_id}")
async def send_endpoint(user_id: str, request: Request):
    live_request_queue = active_sessions.get(user_id)
    if not live_request_queue:
        raise HTTPException(status_code=404, detail="Session not found")

    body = await request.json()
    mime_type = body.get("mime_type")
    data = body.get("data")

    if mime_type == "text/plain":
        content = Content(role="user", parts=[Part.from_text(text=data)])
        live_request_queue.send_content(content)
        print(f"[CLIENT → AGENT] {data}")

    else:
        raise HTTPException(status_code=400, detail=f"Unsupported mime_type: {mime_type}")

    return {"status": "sent"}

Next.js routes:

import { NextRequest, NextResponse } from 'next/server';

// This is the URL of our main.py backend
const AGENT_API_URL = process.env.AGENT_API_URL || 'http://localhost:8000';

export async function GET(
  request: NextRequest,
  { params }: { params: { userId: string } }
) {
  const userId = params.userId;
  
  // Create a new TransformStream for SSE
  const encoder = new TextEncoder();
  const stream = new TransformStream();
  const writer = stream.writable.getWriter();

  // Connect to the agent's SSE endpoint
  const agentResponse = await fetch(`${AGENT_API_URL}/events/${userId}`, {
    method: 'GET',
    headers: {
      'Accept': 'text/event-stream',
    },
  });

  if (!agentResponse.ok) {
    return NextResponse.json(
      { error: `Failed to connect to agent: ${agentResponse.statusText}` },
      { status: agentResponse.status }
    );
  }

  // Get the response body as a readable stream
  const reader = agentResponse.body?.getReader();
  if (!reader) {
    return NextResponse.json(
      { error: 'Failed to get response stream from agent' },
      { status: 500 }
    );
  }

  // Forward SSE events from the agent to the client
  (async () => {
    try {
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        await writer.write(value);
      }
    } catch (error) {
      console.error('Error forwarding SSE events:', error);
    } finally {
      reader.releaseLock();
      await writer.close();
    }
  })();

  // Return the stream as an SSE response
  return new Response(stream.readable, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive',
    },
  });
}

import { NextRequest, NextResponse } from 'next/server';

// This is the URL of our main.py backend
const AGENT_API_URL = process.env.AGENT_API_URL || 'http://localhost:8000';

export async function POST(
  request: NextRequest,
  { params }: { params: { userId: string } }
) {
  const userId = params.userId;
  
  try {
    // Get the request body
    const body = await request.json();
    
    // Forward the request to the agent
    const agentResponse = await fetch(`${AGENT_API_URL}/send/${userId}`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(body),
    });
    
    if (!agentResponse.ok) {
      return NextResponse.json(
        { error: `Failed to send message to agent: ${agentResponse.statusText}` },
        { status: agentResponse.status }
      );
    }
    
    // Return the agent's response
    const agentResponseData = await agentResponse.json();
    return NextResponse.json(agentResponseData);
  } catch (error) {
    console.error('Error sending message to agent:', error);
    return NextResponse.json(
      { error: 'Failed to send message to agent' },
      { status: 500 }
    );
  }
}

And the UI component itself:

'use client';

import * as React from 'react';
import {
  Box,
  Button,
  CircularProgress,
  Paper,
  Stack,
  Typography,
  Alert
} from '@mui/material';
import { Robot as RobotIcon } from '@phosphor-icons/react/dist/ssr/Robot';

interface RefundAgentPanelProps {
  caseId: string;
}

export function RefundAgentPanel({ caseId }: RefundAgentPanelProps): React.JSX.Element {
  const [isConnecting, setIsConnecting] = React.useState(false);
  const [isConnected, setIsConnected] = React.useState(false);
  const [messages, setMessages] = React.useState<string[]>([]);
  const [error, setError] = React.useState<string | null>(null);
  const [isComplete, setIsComplete] = React.useState(false);
  
  const messagesEndRef = React.useRef<HTMLDivElement>(null);
  
  // Scroll to bottom when messages change
  React.useEffect(() => {
    if (messagesEndRef.current) {
      messagesEndRef.current.scrollIntoView({ behavior: 'smooth' });
    }
  }, [messages]);

  // Function to start the refund workflow
  const startRefundWorkflow = async () => {
    setIsConnecting(true);
    setError(null);
    setMessages([]);
    setIsComplete(false);
    
    try {
      // Generate a unique user ID for this session
      const userId = Date.now().toString();
      
      // Connect to the SSE endpoint
      const eventSource = new EventSource(`/api/events/${userId}`);
      
      // Handle connection open
      eventSource.onopen = () => {
        setIsConnecting(false);
        setIsConnected(true);
        setMessages(prev => [...prev, "Connected to agent. Starting refund workflow..."]);
        
        // Send the case ID to the agent
        setMessages(prev => [...prev, `Sending case ID ${caseId} to the refund workflow agent...`]);
        
        fetch(`/api/send/${userId}`, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            mime_type: 'text/plain',
            data: caseId
          }),
        })
        .then(response => {
          if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
          }
          setMessages(prev => [...prev, "Case ID sent successfully. Waiting for agent response..."]);
        })
        .catch(err => {
          setError(`Failed to send case ID to agent: ${err.message}`);
        });
      };
      
      // Handle messages
      eventSource.addEventListener('message', (event) => {
        try {
          const data = JSON.parse(event.data);
          
          // Check if the turn is complete
          if (data.turn_complete) {
            setIsComplete(true);
            setIsConnected(false);
            setMessages(prev => [...prev, "\n✅ Refund workflow completed successfully."]);
            eventSource.close();
            return;
          }
          
          // Check if the message was interrupted
          if (data.interrupted) {
            setIsConnected(false);
            eventSource.close();
            setMessages(prev => [...prev, "\n⚠️ The agent workflow was interrupted."]);
            setError("The agent workflow was interrupted. You may try again or contact support if the issue persists.");
            return;
          }
          
          // Handle text messages
          if (data.mime_type === 'text/plain') {
            setMessages(prev => {
              // If this is a partial message, update the last message
              if (prev.length > 0 && !prev[prev.length - 1].endsWith('\n')) {
                const newMessages = [...prev];
                newMessages[newMessages.length - 1] += data.data;
                return newMessages;
              }
              // Otherwise add a new message
              return [...prev, data.data];
            });
          }
        } catch (err) {
          console.error('Error parsing SSE message:', err);
        }
      });
      
      // Handle errors
      eventSource.onerror = (err) => {
        console.error('SSE Error:', err);
        setError('Connection to agent failed or was closed unexpectedly. Please try again or check if the agent server is running.');
        setIsConnecting(false);
        setIsConnected(false);
        setMessages(prev => [...prev, "⚠️ Connection error. The agent workflow was interrupted."]);
        eventSource.close();
      };
      
      // Clean up on unmount
      return () => {
        eventSource.close();
      };
    } catch (err) {
      setIsConnecting(false);
      setError(`Failed to connect to agent: ${err instanceof Error ? err.message : String(err)}`);
    }
  };

  return (
    <Stack spacing={2}>
      <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
        <Typography variant="h6" sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
          <RobotIcon size={24} />
          Fraud Refund Workflow
        </Typography>
        <Button
          variant="contained"
          color="primary"
          disabled={isConnecting || isConnected}
          onClick={startRefundWorkflow}
          startIcon={isConnecting ? <CircularProgress size={20} color="inherit" /> : null}
        >
          {isConnecting ? 'Connecting...' : isConnected ? 'Connected' : 'Start Refund Workflow'}
        </Button>
      </Box>
      
      {error && (
        <Alert severity="error" sx={{ mt: 2 }}>
          {error}
        </Alert>
      )}
      
      <Paper
        variant="outlined"
        sx={{
          p: 2,
          height: '400px',
          overflowY: 'auto',
          bgcolor: 'background.default',
          fontFamily: 'monospace',
          fontSize: '0.875rem',
          whiteSpace: 'pre-wrap',
          wordBreak: 'break-word',
          position: 'relative',
          borderColor: isConnected ? 'primary.main' : 'divider'
        }}
      >
        {isConnected && (
          <Box
            sx={{
              position: 'absolute',
              top: 8,
              right: 8,
              display: 'flex',
              alignItems: 'center',
              gap: 1,
              bgcolor: 'primary.main',
              color: 'primary.contrastText',
              px: 1,
              py: 0.5,
              borderRadius: 1,
              fontSize: '0.75rem'
            }}
          >
            <CircularProgress size={12} color="inherit" />
            <Typography variant="caption">Agent Running</Typography>
          </Box>
        )}
        {messages.length === 0 ? (
          <Typography color="text.secondary" sx={{ fontStyle: 'italic' }}>
            Click "Start Refund Workflow" to begin the automated fraud refund process for this case.
            The agent will analyze the case, identify the suspect account, recover funds, and issue a refund.
          </Typography>
        ) : (
          messages.map((message, index) => (
            <div key={index}>{message}</div>
          ))
        )}
        <div ref={messagesEndRef} />
      </Paper>
      
      {isComplete && (
        <Alert severity="success">
          Refund workflow completed successfully.
        </Alert>
      )}
    </Stack>
  );
}

When I invoke the agent from the UI I get this error:

websockets.exceptions.ConnectionClosedError: received 1008 (policy violation) models/gemini-2.5-pro-preview-05-06 is not found for API version v1alpha, or is not supported for bidiGenerateContent. Call; then sent 1008 (policy violation) models/gemini-2.5-pro-preview-05-06 is not found for API version v1alpha, or is not supported for bidiGenerateContent. Call

As mentioned before - I can get this running with adk api_server

I'm guessing v1alpha does not support something that is needed, but tried changing to v1beta - but I don't know how !

Cheers,
Rafal

[Orlando-gds]

have you tried changing your model for example gemini-2.0-flash-live-001?