Initial commit: Week 3 workspace (notebook + multi-agent customer support)

.gitignore

@@ -0,0 +1,36 @@
+# Secrets — never commit
+.env
+.env.*
+!.env.example
+
+# Local editor / MCP (machine-specific paths)
+.cursor/
+
+# Python (any subfolder)
+**/.venv/
+**/venv/
+**/__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.eggs/
+dist/
+build/
+
+# Testing / coverage
+**/.pytest_cache/
+.coverage
+htmlcov/
+
+# Generated reports
+**/reports/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# OS / IDE
+.idea/
+.vscode/
+*.swp
+.DS_Store
+Thumbs.db

multi_agent_customer_support/.env.example

@@ -0,0 +1,17 @@
+# Copy this file to .env and fill values before running.
+APP_ENV=development
+APP_HOST=127.0.0.1
+APP_PORT=8000
+
+# Returns service endpoint used by the remote returns agent.
+RETURNS_SERVICE_URL=http://127.0.0.1:8081
+# Optional: full Agent Card URL for ADK RemoteA2aAgent (default: {RETURNS_SERVICE_URL}/.well-known/agent-card.json).
+# RETURNS_A2A_AGENT_CARD_URL=http://127.0.0.1:8081/.well-known/agent-card.json
+
+# Supabase settings for MCP server integration.
+SUPABASE_URL=https://your-project.supabase.co
+# App / supabase_client.py: use the anon key for client-side style access.
+SUPABASE_ANON_KEY=your-supabase-anon-key
+# Legacy name (optional): some files still read SUPABASE_KEY.
+SUPABASE_KEY=your-supabase-service-role-or-anon-key
+SUPABASE_ACCESS_TOKEN=your-supabase-personal-access-token

multi_agent_customer_support/.gitignore

@@ -0,0 +1,34 @@
+# Environment and secrets
+.env
+.env.*
+!.env.example
+
+# Python
+.venv/
+venv/
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+.eggs/
+dist/
+build/
+*.egg
+
+# Testing / coverage
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Generated reports (regenerate with pytest --html)
+reports/
+
+# IDE / OS
+.idea/
+.vscode/
+*.swp
+.DS_Store
+Thumbs.db

multi_agent_customer_support/README.md

@@ -0,0 +1,180 @@
+# Multi-Agent Customer Support System with MCP and A2A
+
+**Multi-Agent Customer Support System with MCP and A2A** — a Python reference app where a **RouterAgent** classifies customer messages and delegates to specialists: **BillingAgent** and **SupportAgent** (data via Supabase, exposed through MCP-style tools), and **ReturnsRemoteAgent** (remote **Agent-to-Agent** protocol to a dedicated returns FastAPI service).
+
+## Architecture
+
+```text
+                         +------------------+
+                         |   RouterAgent    |
+                         |  (intent route)  |
+                         +--------+---------+
+                                  |
+          +-----------------------+----------------------+
+          |                       |                      |
+          v                       v                      v
++----------------+    +-------------------+    +----------------------+
+|  BillingAgent  |    |   SupportAgent    |    | ReturnsRemoteAgent   |
+|  ADK + tools   |    |  ADK + tickets    |    |  ADK RemoteA2aAgent  |
++-------+--------+    +---------+---------+    +----------+-----------+
+        |                       |                         |
+        |  MCP tool parity      |  MCP tool parity        |  A2A JSON-RPC
+        |  (FunctionTool /      |  (get_support_tickets)  |  + agent card
+        |   stdio MCP server)   |                         |
+        v                       v                         v
++----------------+    +-------------------+    +----------------------+
+|    Supabase    |    |     Supabase      |    |  Returns Service     |
+|  customers,    |    |  support_tickets  |    |  (FastAPI, port 8081)  |
+|  orders, ...   |    |                   |    |  eligibility + return  |
++----------------+    +-------------------+    +----------------------+
+```
+
+- **MCP → Supabase**: `src/mcp/supabase_mcp_server.py` exposes `get_billing_info` / `get_support_tickets` over stdio MCP; the same logic is called in-process from agents via `FunctionTool`.
+- **A2A → Returns Service**: `servers/returns_service/main.py` serves an ADK agent over A2A; `ReturnsRemoteAgent` connects using the Agent Card URL.
+
+## Tech Stack
+
+- Google ADK (`google-adk`), A2A SDK (`a2a-sdk`), MCP (`mcp`), FastMCP, FastAPI, Uvicorn, Supabase (`supabase`), `httpx`, `python-dotenv`
+
+## Project Structure
+
+```text
+multi_agent_customer_support/
+  sql/
+    schema_and_seed.sql    # DDL + seed data
+    fix_rls_and_verify.sql # RLS policies + checks (run after schema if needed)
+  src/
+    main.py                 # FastAPI + CLI entry (`python -m src.main`)
+    agents/
+      router_agent.py
+      billing_agent.py
+      support_agent.py
+      returns_remote_agent.py
+    mcp/
+      supabase_mcp_server.py
+      supabase_mcp_connection.py
+  servers/returns_service/main.py  # Returns A2A microservice
+  tests/
+  .env.example
+  README.md
+```
+
+## Setup
+
+### 1. Supabase: project, schema, and seed
+
+1. Create a project in [Supabase](https://supabase.com).
+2. In the SQL editor (or `psql`), run:
+   - `sql/schema_and_seed.sql` — tables, seed rows, and dev-oriented RLS as provided.
+   - If you hit RLS / permission issues with the anon key, run `sql/fix_rls_and_verify.sql` and re-check policies.
+
+### 2. Environment variables
+
+Copy and edit:
+
+```bash
+cp .env.example .env
+```
+
+Typical variables:
+
+| Variable | Purpose |
+|----------|---------|
+| `SUPABASE_URL` | Project URL |
+| `SUPABASE_ANON_KEY` | Anon key (or `SUPABASE_KEY` legacy) |
+| `GEMINI_API_KEY` or `GOOGLE_API_KEY` | ADK / Gemini for router and agents |
+| `RETURNS_SERVICE_URL` | Returns service base URL (default `http://127.0.0.1:8081`) |
+| `RETURNS_A2A_AGENT_CARD_URL` | Optional full Agent Card URL override |
+
+### 3. Install dependencies
+
+Python **3.12** recommended.
+
+```powershell
+cd multi_agent_customer_support
+py -3.12 -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+pip install -e .
+pip install -e ".[dev]"   # optional: pytest + pytest-asyncio
+```
+
+### 4. Run the Supabase MCP server (separate process)
+
+From `multi_agent_customer_support/`:
+
+```powershell
+python -m src.mcp.supabase_mcp_server
+```
+
+Uses stdio MCP; configure Cursor or other MCP hosts to launch this command with the same working directory and `.env` loaded.
+
+### 5. Run the Returns FastAPI (A2A) service
+
+```powershell
+uvicorn servers.returns_service.main:app --host 127.0.0.1 --port 8081
+```
+
+Or: `python -m servers.returns_service.main`  
+Agent card: `GET http://127.0.0.1:8081/.well-known/agent-card.json`
+
+### 6. Run the main CLI
+
+```powershell
+python -m src.main
+```
+
+Optional: `CLI_CUSTOMER_ID` in `.env` to skip the customer-id prompt.  
+Type `quit` or `exit` to stop.
+
+### Run the HTTP API (optional)
+
+```powershell
+uvicorn src.main:app --reload --port 8000
+```
+
+Example:
+
+```bash
+curl -X POST http://127.0.0.1:8000/support/query \
+  -H "Content-Type: application/json" \
+  -d "{\"customer_id\":\"you@example.com\",\"message\":\"I was charged twice\"}"
+```
+
+Response includes `result`, `routed_to`, `escalated`, and `rationale`.
+
+## Example conversations (CLI)
+
+Use a **real seeded customer email** from Supabase when testing billing/support data.
+
+### Billing
+
+```text
+> I was charged twice for my last order. Can you check my billing?
+```
+
+Expect routing to **billing** and a summary grounded in `get_billing_info` / orders.
+
+### Returns
+
+```text
+> I want to return order ORD-123. Am I eligible for a refund?
+```
+
+Expect routing to **returns** and an answer from the remote **Returns** A2A agent (returns service must be running with `GEMINI_API_KEY`).
+
+### Escalation
+
+```text
+> My account was hacked, all my orders are gone, and nobody is helping me.
+```
+
+For high-severity or ambiguous cases the router may return an **escalation** response (`[ESCALATE]`, `ESCALATE_FLAG`) so a human can take over; exact behavior may use the LLM router when API keys are set, or heuristics when not.
+
+## Tests
+
+```powershell
+pytest tests/ -q
+```
+
+Scenario tests live in `tests/test_scenarios.py`.

multi_agent_customer_support/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "multi-agent-customer-support"
+version = "0.1.0"
+description = "Multi-agent customer support app using Google's ADK, FastAPI, and Supabase."
+readme = "README.md"
+requires-python = ">=3.12,<3.13"
+dependencies = [
+  "google-adk",
+  "a2a-sdk",
+  "mcp",
+  "a2a-mcp-server==0.1.5",
+  "fastmcp==3.2.4",
+  "fastapi",
+  "uvicorn",
+  "supabase",
+  "python-dotenv",
+  "httpx",
+]
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0",
+  "pytest-asyncio>=0.24",
+  "pytest-html>=4.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"

multi_agent_customer_support/scripts/load_dotenv_and_run.ps1

@@ -0,0 +1,50 @@
+param(
+  [Parameter(Mandatory = $true)]
+  [string]$EnvFile,
+
+  [Parameter(Mandatory = $true)]
+  [string]$Command,
+
+  [Parameter(Mandatory = $false)]
+  [string[]]$Arguments = @()
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+function Import-DotEnvFile {
+  param([string]$Path)
+
+  if (-not (Test-Path -LiteralPath $Path)) {
+    Write-Error "Dotenv file not found: $Path"
+  }
+
+  Get-Content -LiteralPath $Path | ForEach-Object {
+    $line = $_.Trim()
+    if (-not $line -or $line.StartsWith("#")) {
+      return
+    }
+
+    $eq = $line.IndexOf("=")
+    if ($eq -lt 1) {
+      return
+    }
+
+    $key = $line.Substring(0, $eq).Trim()
+    $value = $line.Substring($eq + 1).Trim()
+
+    # Strip optional quotes
+    if (($value.StartsWith('"') -and $value.EndsWith('"')) -or ($value.StartsWith("'") -and $value.EndsWith("'"))) {
+      $value = $value.Substring(1, $value.Length - 2)
+    }
+
+    if ($key) {
+      Set-Item -Path ("Env:{0}" -f $key) -Value $value
+    }
+  }
+}
+
+Import-DotEnvFile -Path $EnvFile
+
+& $Command @Arguments
+exit $LASTEXITCODE

multi_agent_customer_support/servers/returns_service/__init__.py

@@ -0,0 +1 @@
+"""Returns microservice package."""

multi_agent_customer_support/servers/returns_service/main.py

@@ -0,0 +1,273 @@
+"""
+Returns microservice: FastAPI + A2A (Agent-to-Agent) JSON-RPC for an ADK ``LlmAgent``.
+
+**Run locally** (from ``multi_agent_customer_support/``; activates the venv first)::
+
+    .venv\\Scripts\\activate
+    uvicorn servers.returns_service.main:app --host 127.0.0.1 --port 8081
+
+Or::
+
+    python -m uvicorn servers.returns_service.main:app --host 127.0.0.1 --port 8081
+
+Environment:
+
+- ``RETURNS_SERVICE_PORT`` — default ``8081`` (used by ``main()`` when you ``python -m servers.returns_service.main``).
+- ``RETURNS_A2A_PUBLIC_URL`` — base URL embedded in the Agent Card (default ``http://127.0.0.1:8081``).
+- ``GOOGLE_API_KEY`` or ``GEMINI_API_KEY`` — required for A2A ``message/send`` so the model can call tools.
+- ``ADK_MODEL`` — optional override (default ``gemini-2.5-flash``).
+
+**Example curl**
+
+Agent card (no API key required)::
+
+    curl -s http://127.0.0.1:8081/.well-known/agent-card.json | head
+
+Direct mock tool endpoints (no LLM; same rules as the agent tools)::
+
+    curl -s -X POST http://127.0.0.1:8081/tools/check_return_eligibility \\
+      -H "Content-Type: application/json" -d "{\\"order_number\\": \\"ORD-42\\"}"
+
+    curl -s -X POST http://127.0.0.1:8081/tools/initiate_return \\
+      -H "Content-Type: application/json" \\
+      -d "{\\"order_number\\": \\"ORD-42\\", \\"reason\\": \\"changed mind\\"}"
+
+A2A JSON-RPC (needs Gemini for the agent to reply; body is illustrative)::
+
+    curl -s -X POST http://127.0.0.1:8081/ \\
+      -H "Content-Type: application/json" \\
+      -d "{\\"jsonrpc\\":\\"2.0\\",\\"id\\":\\"1\\",\\"method\\":\\"message/send\\",\\"params\\":{\\"message\\":{\\"role\\":\\"user\\",\\"parts\\":[{\\"kind\\":\\"text\\",\\"text\\":\\"Is order ORD-42 eligible for return?\\"}],\\"message_id\\":\\"m1\\",\\"kind\\":\\"message\\"}}}"
+"""
+
+from __future__ import annotations
+
+import os
+import uuid
+from contextlib import asynccontextmanager
+from typing import Any
+
+from a2a.server.apps import A2AFastAPIApplication
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.tasks import InMemoryPushNotificationConfigStore
+from a2a.server.tasks import InMemoryTaskStore
+from fastapi import FastAPI
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.a2a.utils.agent_card_builder import AgentCardBuilder
+from google.adk.a2a.utils.agent_to_a2a import to_a2a as adk_to_a2a
+from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService
+from google.adk.auth.credential_service.in_memory_credential_service import (
+    InMemoryCredentialService,
+)
+from google.adk.a2a.executor.a2a_agent_executor import A2aAgentExecutor
+from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
+from google.adk.runners import Runner
+from google.adk.sessions.in_memory_session_service import InMemorySessionService
+from google.adk.tools.function_tool import FunctionTool
+from pydantic import BaseModel
+
+# ---------------------------------------------------------------------------
+# Mock tool implementations (also wrapped as ADK FunctionTools for the LlmAgent)
+# ---------------------------------------------------------------------------
+
+
+def check_return_eligibility(order_number: str) -> dict[str, Any]:
+    """
+    Mock eligibility: last character of ``order_number`` must be a digit; even -> eligible.
+
+    Returns JSON-serializable dict: ``eligible``, ``reason``.
+    """
+    s = (order_number or "").strip()
+    if not s:
+        return {"eligible": False, "reason": "order_number is empty"}
+    last = s[-1]
+    if not last.isdigit():
+        return {
+            "eligible": False,
+            "reason": "last character is not a digit (mock rule requires a trailing digit)",
+        }
+    eligible = int(last) % 2 == 0
+    reason = (
+        "last digit is even - eligible under mock policy"
+        if eligible
+        else "last digit is odd - not eligible under mock policy"
+    )
+    return {"eligible": eligible, "reason": reason}
+
+
+def initiate_return(order_number: str, reason: str) -> dict[str, Any]:
+    """Mock creating a return request."""
+    rid = f"ret-{uuid.uuid4().hex[:12]}"
+    msg = f"Return initiated for order {order_number}"
+    if (reason or "").strip():
+        msg += f" ({reason.strip()[:500]})"
+    return {
+        "return_id": rid,
+        "status": "initiated",
+        "message": msg,
+    }
+
+
+_RETURNS_AGENT_INSTRUCTION = """You are a returns specialist for an online store.
+
+You have two tools:
+- check_return_eligibility(order_number) — returns whether the order is eligible (mock rule) with a reason.
+- initiate_return(order_number, reason) — creates a mock return request.
+
+When the user asks about eligibility, call check_return_eligibility with the order number they provide.
+When they want to start a return, call initiate_return with order number and reason.
+
+Reply in clear, short natural language and include key facts from the tool results.
+"""
+
+
+def build_returns_llm_agent() -> LlmAgent:
+    """ADK agent exposed over A2A (tools: eligibility + initiate return)."""
+    model = os.getenv("ADK_MODEL", "gemini-2.5-flash")
+    return LlmAgent(
+        name="returns_agent",
+        model=model,
+        description="Returns eligibility and return initiation (mock rules).",
+        instruction=_RETURNS_AGENT_INSTRUCTION,
+        tools=[
+            FunctionTool(check_return_eligibility),
+            FunctionTool(initiate_return),
+        ],
+    )
+
+
+def to_a2a(
+    host: str = "127.0.0.1",
+    port: int = 8081,
+) -> Any:
+    """
+    ADK pattern: build a **Starlette** ASGI app that speaks A2A (JSON-RPC + agent card).
+
+    Run with::
+
+        uvicorn servers.returns_service.main:starlette_a2a_app --host 127.0.0.1 --port 8081
+
+    ``starlette_a2a_app`` is created on first access (see ``__getattr__`` below).
+
+    This is the same helper as ``google.adk.a2a.utils.agent_to_a2a.to_a2a`` applied to
+    :func:`build_returns_llm_agent`.
+    """
+    agent = build_returns_llm_agent()
+    return adk_to_a2a(agent, host=host, port=port, protocol="http")
+
+
+_starlette_a2a_singleton: Any | None = None
+
+
+def __getattr__(name: str) -> Any:
+    """Lazily build the Starlette A2A app so importing :data:`app` does not spawn a second ASGI stack."""
+    global _starlette_a2a_singleton
+    if name == "starlette_a2a_app":
+        if _starlette_a2a_singleton is None:
+            _starlette_a2a_singleton = to_a2a()
+        return _starlette_a2a_singleton
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+# ---------------------------------------------------------------------------
+# FastAPI composite app: health, legacy /returns/process, direct tool JSON, + A2A
+# ---------------------------------------------------------------------------
+
+
+class ReturnsProcessBody(BaseModel):
+    customer_id: str
+    message: str
+
+
+class CheckEligibilityBody(BaseModel):
+    order_number: str
+
+
+class InitiateReturnBody(BaseModel):
+    order_number: str
+    reason: str = ""
+
+
+@asynccontextmanager
+async def _lifespan(app: FastAPI):
+    agent = build_returns_llm_agent()
+    public_base = (os.getenv("RETURNS_A2A_PUBLIC_URL") or "http://127.0.0.1:8081").rstrip("/")
+    rpc_url = f"{public_base}/"
+
+    card_builder = AgentCardBuilder(agent=agent, rpc_url=rpc_url)
+    agent_card = await card_builder.build()
+
+    async def _create_runner() -> Runner:
+        return Runner(
+            app_name=agent.name or "returns_service",
+            agent=agent,
+            artifact_service=InMemoryArtifactService(),
+            session_service=InMemorySessionService(),
+            memory_service=InMemoryMemoryService(),
+            credential_service=InMemoryCredentialService(),
+        )
+
+    task_store = InMemoryTaskStore()
+    push_config_store = InMemoryPushNotificationConfigStore()
+    executor = A2aAgentExecutor(runner=_create_runner)
+    handler = DefaultRequestHandler(
+        agent_executor=executor,
+        task_store=task_store,
+        push_config_store=push_config_store,
+    )
+    a2a_http = A2AFastAPIApplication(agent_card=agent_card, http_handler=handler)
+    a2a_http.add_routes_to_app(app)
+    yield
+
+
+app = FastAPI(
+    title="Returns Service",
+    description="Returns A2A agent + legacy HTTP helpers.",
+    lifespan=_lifespan,
+)
+
+
+@app.get("/health")
+async def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.post("/returns/process")
+async def process_return(payload: ReturnsProcessBody) -> dict[str, str]:
+    """Legacy endpoint used by ``ReturnsRemoteAgent`` in the main API."""
+    return {
+        "result": (
+            f"[ReturnsService] Return request noted for `{payload.customer_id}` "
+            f"with message: '{payload.message}'. "
+            "For structured eligibility/initiation use the A2A agent or /tools/* routes."
+        )
+    }
+
+
+@app.post("/tools/check_return_eligibility")
+async def tools_check_eligibility(body: CheckEligibilityBody) -> dict[str, Any]:
+    """Direct HTTP binding of :func:`check_return_eligibility` (no LLM)."""
+    return check_return_eligibility(body.order_number)
+
+
+@app.post("/tools/initiate_return")
+async def tools_initiate_return(body: InitiateReturnBody) -> dict[str, Any]:
+    """Direct HTTP binding of :func:`initiate_return` (no LLM)."""
+    return initiate_return(body.order_number, body.reason)
+
+
+def main() -> None:
+    """CLI entry: ``python -m servers.returns_service.main``."""
+    import uvicorn
+
+    host = os.getenv("RETURNS_SERVICE_HOST", "127.0.0.1")
+    port = int(os.getenv("RETURNS_SERVICE_PORT", "8081"))
+    uvicorn.run(
+        "servers.returns_service.main:app",
+        host=host,
+        port=port,
+        reload=False,
+    )
+
+
+if __name__ == "__main__":
+    main()

multi_agent_customer_support/sql/fix_rls_and_verify.sql

@@ -0,0 +1,39 @@
+-- ============================================================
+-- One-time fix: Row Level Security for anon/API access + verify counts
+-- Run in Supabase SQL Editor if tables already exist but the JS/Python
+-- client sees 0 rows or insert fails with policy errors.
+-- ============================================================
+
+alter table customers enable row level security;
+alter table orders enable row level security;
+alter table support_tickets enable row level security;
+
+drop policy if exists "dev_api_all_customers" on public.customers;
+drop policy if exists "dev_api_all_orders" on public.orders;
+drop policy if exists "dev_api_all_support_tickets" on public.support_tickets;
+
+create policy "dev_api_all_customers"
+  on public.customers
+  for all
+  to anon, authenticated
+  using (true)
+  with check (true);
+
+create policy "dev_api_all_orders"
+  on public.orders
+  for all
+  to anon, authenticated
+  using (true)
+  with check (true);
+
+create policy "dev_api_all_support_tickets"
+  on public.support_tickets
+  for all
+  to anon, authenticated
+  using (true)
+  with check (true);
+
+select
+  (select count(*)::bigint from customers) as customers,
+  (select count(*)::bigint from orders) as orders,
+  (select count(*)::bigint from support_tickets) as support_tickets;

multi_agent_customer_support/sql/schema_and_seed.sql

@@ -0,0 +1,155 @@
+-- ============================================================
+-- Multi-Agent Customer Support - Schema + Seed (Supabase Postgres)
+-- Paste into: Supabase Dashboard → SQL Editor → Run
+-- ============================================================
+
+create extension if not exists pgcrypto;
+
+-- Optional: clean slate (remove if you already have production data!)
+drop table if exists support_tickets cascade;
+drop table if exists orders cascade;
+drop table if exists customers cascade;
+
+-- =====================
+-- 1) TABLE DEFINITIONS
+-- =====================
+
+create table customers (
+  id uuid primary key default gen_random_uuid(),
+  name text not null,
+  email text not null unique,
+  created_at timestamptz not null default now()
+);
+
+create table orders (
+  id uuid primary key default gen_random_uuid(),
+  customer_id uuid not null references customers(id),
+  order_number text not null unique,
+  total_amount numeric not null,
+  status text not null,
+  created_at timestamptz not null default now()
+);
+
+create table support_tickets (
+  id uuid primary key default gen_random_uuid(),
+  customer_id uuid not null references customers(id),
+  order_id uuid references orders(id),
+  category text not null,
+  status text not null,
+  description text not null,
+  created_at timestamptz not null default now()
+);
+
+create index idx_orders_customer_id on orders(customer_id);
+create index idx_tickets_customer_id on support_tickets(customer_id);
+create index idx_tickets_order_id on support_tickets(order_id);
+create index idx_tickets_category_status on support_tickets(category, status);
+
+-- =================
+-- 2) SEEDING DATA
+-- =================
+
+insert into customers (id, name, email, created_at) values
+('11111111-1111-1111-1111-111111111101', 'Ava Thompson',   'ava.thompson@example.com',   now() - interval '90 days'),
+('11111111-1111-1111-1111-111111111102', 'Liam Carter',    'liam.carter@example.com',    now() - interval '88 days'),
+('11111111-1111-1111-1111-111111111103', 'Noah Bennett',   'noah.bennett@example.com',   now() - interval '76 days'),
+('11111111-1111-1111-1111-111111111104', 'Emma Rodriguez', 'emma.rodriguez@example.com', now() - interval '73 days'),
+('11111111-1111-1111-1111-111111111105', 'Sophia Nguyen',  'sophia.nguyen@example.com',  now() - interval '69 days'),
+('11111111-1111-1111-1111-111111111106', 'Mason Patel',    'mason.patel@example.com',    now() - interval '62 days'),
+('11111111-1111-1111-1111-111111111107', 'Isabella Kim',   'isabella.kim@example.com',   now() - interval '55 days'),
+('11111111-1111-1111-1111-111111111108', 'Ethan Brooks',   'ethan.brooks@example.com',   now() - interval '49 days'),
+('11111111-1111-1111-1111-111111111109', 'Olivia Davis',   'olivia.davis@example.com',   now() - interval '35 days'),
+('11111111-1111-1111-1111-111111111110', 'Lucas Garcia',   'lucas.garcia@example.com',   now() - interval '21 days');
+
+insert into orders (id, customer_id, order_number, total_amount, status, created_at) values
+('22222222-2222-2222-2222-222222222201', '11111111-1111-1111-1111-111111111101', 'ORD-2026-0001', 129.99, 'paid',     now() - interval '40 days'),
+('22222222-2222-2222-2222-222222222202', '11111111-1111-1111-1111-111111111102', 'ORD-2026-0002',  79.50, 'shipped',  now() - interval '38 days'),
+('22222222-2222-2222-2222-222222222203', '11111111-1111-1111-1111-111111111103', 'ORD-2026-0003', 249.00, 'paid',     now() - interval '36 days'),
+('22222222-2222-2222-2222-222222222204', '11111111-1111-1111-1111-111111111104', 'ORD-2026-0004',  54.25, 'refunded', now() - interval '33 days'),
+('22222222-2222-2222-2222-222222222205', '11111111-1111-1111-1111-111111111105', 'ORD-2026-0005', 310.75, 'shipped',  now() - interval '30 days'),
+('22222222-2222-2222-2222-222222222206', '11111111-1111-1111-1111-111111111106', 'ORD-2026-0006',  18.99, 'paid',     now() - interval '27 days'),
+('22222222-2222-2222-2222-222222222207', '11111111-1111-1111-1111-111111111107', 'ORD-2026-0007',  97.40, 'paid',     now() - interval '24 days'),
+('22222222-2222-2222-2222-222222222208', '11111111-1111-1111-1111-111111111108', 'ORD-2026-0008', 145.00, 'shipped',  now() - interval '20 days'),
+('22222222-2222-2222-2222-222222222209', '11111111-1111-1111-1111-111111111109', 'ORD-2026-0009', 220.15, 'paid',     now() - interval '17 days'),
+('22222222-2222-2222-2222-222222222210', '11111111-1111-1111-1111-111111111110', 'ORD-2026-0010',  65.00, 'refunded', now() - interval '14 days'),
+('22222222-2222-2222-2222-222222222211', '11111111-1111-1111-1111-111111111101', 'ORD-2026-0011',  33.49, 'paid',     now() - interval '11 days'),
+('22222222-2222-2222-2222-222222222212', '11111111-1111-1111-1111-111111111105', 'ORD-2026-0012', 412.00, 'shipped',  now() - interval '7 days');
+
+insert into support_tickets (id, customer_id, order_id, category, status, description, created_at) values
+('33333333-3333-3333-3333-333333333301', '11111111-1111-1111-1111-111111111101', '22222222-2222-2222-2222-222222222201', 'billing', 'open',
+ 'Customer reports duplicate charge for order ORD-2026-0001.', now() - interval '10 days'),
+
+('33333333-3333-3333-3333-333333333302', '11111111-1111-1111-1111-111111111102', '22222222-2222-2222-2222-222222222202', 'returns', 'in_progress',
+ 'Wrong size delivered; customer requested exchange and return label.', now() - interval '9 days'),
+
+('33333333-3333-3333-3333-333333333303', '11111111-1111-1111-1111-111111111103', '22222222-2222-2222-2222-222222222203', 'general', 'resolved',
+ 'Asked for updated shipping ETA and tracking clarification.', now() - interval '8 days'),
+
+('33333333-3333-3333-3333-333333333304', '11111111-1111-1111-1111-111111111104', '22222222-2222-2222-2222-222222222204', 'billing', 'resolved',
+ 'Refund completed but customer did not see bank settlement yet.', now() - interval '7 days'),
+
+('33333333-3333-3333-3333-333333333305', '11111111-1111-1111-1111-111111111105', '22222222-2222-2222-2222-222222222205', 'returns', 'escalated',
+ 'Item arrived damaged; customer requested full refund with photo evidence.', now() - interval '6 days'),
+
+('33333333-3333-3333-3333-333333333306', '11111111-1111-1111-1111-111111111106', '22222222-2222-2222-2222-222222222206', 'billing', 'in_progress',
+ 'Promo code was not applied at checkout; requesting partial refund.', now() - interval '5 days'),
+
+('33333333-3333-3333-3333-333333333307', '11111111-1111-1111-1111-111111111107', '22222222-2222-2222-2222-222222222207', 'general', 'open',
+ 'Customer wants to update shipping address after placing the order.', now() - interval '4 days'),
+
+('33333333-3333-3333-3333-333333333308', '11111111-1111-1111-1111-111111111108', '22222222-2222-2222-2222-222222222208', 'returns', 'open',
+ 'Return requested for unopened item within return window.', now() - interval '3 days'),
+
+('33333333-3333-3333-3333-333333333309', '11111111-1111-1111-1111-111111111109', '22222222-2222-2222-2222-222222222209', 'billing', 'escalated',
+ 'Customer states tax amount appears incorrect for shipping destination.', now() - interval '2 days'),
+
+('33333333-3333-3333-3333-333333333310', '11111111-1111-1111-1111-111111111110', '22222222-2222-2222-2222-222222222210', 'returns', 'resolved',
+ 'Refund was issued after returned item passed warehouse inspection.', now() - interval '36 hours'),
+
+('33333333-3333-3333-3333-333333333311', '11111111-1111-1111-1111-111111111101', '22222222-2222-2222-2222-222222222211', 'general', 'open',
+ 'Asked whether order can be bundled with a recent purchase.', now() - interval '18 hours'),
+
+('33333333-3333-3333-3333-333333333312', '11111111-1111-1111-1111-111111111105', '22222222-2222-2222-2222-222222222212', 'billing', 'open',
+ 'Invoice email missing line-item breakdown; customer requested corrected invoice.', now() - interval '6 hours');
+
+-- =================
+-- 3) RLS (dev)
+-- =================
+-- PostgREST uses the `anon` / `authenticated` roles. Without policies, SELECT/INSERT
+-- from the Supabase client (anon key) will see 0 rows or get 42501 errors.
+-- Replace these with tighter policies before production.
+
+alter table customers enable row level security;
+alter table orders enable row level security;
+alter table support_tickets enable row level security;
+
+drop policy if exists "dev_api_all_customers" on public.customers;
+drop policy if exists "dev_api_all_orders" on public.orders;
+drop policy if exists "dev_api_all_support_tickets" on public.support_tickets;
+
+create policy "dev_api_all_customers"
+  on public.customers
+  for all
+  to anon, authenticated
+  using (true)
+  with check (true);
+
+create policy "dev_api_all_orders"
+  on public.orders
+  for all
+  to anon, authenticated
+  using (true)
+  with check (true);
+
+create policy "dev_api_all_support_tickets"
+  on public.support_tickets
+  for all
+  to anon, authenticated
+  using (true)
+  with check (true);
+
+-- SQL Editor will show THIS result (otherwise "Success. No rows returned" is normal):
+select
+  (select count(*)::bigint from customers) as customers,
+  (select count(*)::bigint from orders) as orders,
+  (select count(*)::bigint from support_tickets) as support_tickets;

multi_agent_customer_support/src/__init__.py

@@ -0,0 +1 @@
+"""Top-level package for the multi-agent customer support app."""

multi_agent_customer_support/src/agents/__init__.py

@@ -0,0 +1 @@
+"""Agent modules for routing and domain-specific support."""

multi_agent_customer_support/src/agents/adk_runtime.py

@@ -0,0 +1,111 @@
+"""Shared helpers for running ADK ``LlmAgent`` instances with ``Runner`` (stdio-free)."""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import TypeVar
+
+from google.adk.agents.base_agent import BaseAgent
+from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService
+from google.adk.auth.credential_service.in_memory_credential_service import (
+    InMemoryCredentialService,
+)
+from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
+from google.adk.runners import Runner
+from google.adk.sessions.in_memory_session_service import InMemorySessionService
+from google.genai import types
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+TModel = TypeVar("TModel", bound=BaseModel)
+
+
+def genai_api_configured() -> bool:
+    """True when Gemini Developer API keys are present (same convention as google-genai)."""
+    import os
+
+    return bool(os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY"))
+
+
+async def run_llm_agent_once(
+    *,
+    agent: BaseAgent,
+    user_message: str,
+    app_name: str,
+    user_id: str | None = None,
+) -> str:
+    """
+    Run a single-turn conversation: one user message in, final model text out.
+
+    Uses an ephemeral session id so concurrent FastAPI requests do not share history.
+    """
+    session_service = InMemorySessionService()
+    runner = Runner(
+        app_name=app_name,
+        agent=agent,
+        artifact_service=InMemoryArtifactService(),
+        session_service=session_service,
+        memory_service=InMemoryMemoryService(),
+        credential_service=InMemoryCredentialService(),
+        auto_create_session=True,
+    )
+    session_id = str(uuid.uuid4())
+    uid = user_id or "anonymous"
+
+    content = types.Content(
+        role="user",
+        parts=[types.Part(text=user_message)],
+    )
+
+    final_text = ""
+    async for event in runner.run_async(
+        user_id=uid,
+        session_id=session_id,
+        new_message=content,
+    ):
+        if not event.is_final_response():
+            continue
+        if not event.content or not event.content.parts:
+            continue
+        chunk = "".join(
+            part.text
+            for part in event.content.parts
+            if part.text and not getattr(part, "thought", False)
+        )
+        if chunk.strip():
+            final_text = chunk
+
+    return final_text.strip()
+
+
+async def run_router_structured(
+    *,
+    agent: BaseAgent,
+    user_message: str,
+    schema_type: type[TModel],
+    app_name: str = "router",
+) -> TModel | None:
+    """
+    Run router agent expecting structured JSON matching ``schema_type``.
+
+    Returns ``None`` if the model returns empty/unparseable output (caller should fall back).
+    """
+    raw = await run_llm_agent_once(
+        agent=agent,
+        user_message=user_message,
+        app_name=app_name,
+    )
+    if not raw:
+        return None
+    try:
+        return schema_type.model_validate_json(raw)
+    except Exception as exc:
+        logger.warning(
+            "Failed to parse router output as %s: %s — raw: %s",
+            schema_type,
+            exc,
+            raw[:500],
+        )
+        return None

multi_agent_customer_support/src/agents/billing_agent.py

@@ -0,0 +1,124 @@
+"""Billing specialist agent: ADK ``LlmAgent`` + Supabase MCP tool functions (same impl as MCP server)."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.tools.function_tool import FunctionTool
+
+from src.mcp.supabase_mcp_server import get_billing_info, get_support_tickets
+
+from .adk_runtime import genai_api_configured, run_llm_agent_once
+from .customer_context import resolve_customer_email
+
+
+def _billing_tools() -> list[Any]:
+    """Expose MCP-parity tools to the LLM via ADK ``FunctionTool`` wrappers."""
+    return [
+        FunctionTool(get_billing_info),
+        FunctionTool(get_support_tickets),
+    ]
+
+
+_BILLING_INSTRUCTION = """You are a billing assistant for an e-commerce company.
+
+You have tools that mirror the Supabase MCP server:
+- ``get_billing_info(email)`` — JSON with customer orders (order_number, total_amount, status).
+- ``get_support_tickets(email)`` — JSON list of support tickets.
+
+Rules:
+1. The user message includes the **resolved customer email**. Always pass that exact email string to tools.
+2. Call the tools when you need factual data; do not invent amounts or order numbers.
+3. Reply in concise, friendly natural language summarizing billing status and any open billing-related tickets.
+4. If JSON shows ``customer_not_found``, say we could not match an account and ask them to verify their email.
+"""
+
+
+class BillingAgent:
+    """
+    Handles billing-related questions using Gemini + tool calls.
+
+    Tools implement the same behavior as ``src/mcp/supabase_mcp_server.py`` (stdio MCP is optional;
+    in-process calls keep tests and local dev simple).
+    """
+
+    def __init__(self, model: str | None = None) -> None:
+        self._model = model or os.getenv("ADK_MODEL", "gemini-2.5-flash")
+        self._agent = LlmAgent(
+            name="billing_agent",
+            model=self._model,
+            instruction=_BILLING_INSTRUCTION,
+            tools=_billing_tools(),
+        )
+
+    async def handle(self, customer_id: str, message: str) -> str:
+        """
+        Answer a billing question for ``customer_id`` (UUID or email) and user ``message``.
+
+        Uses the LLM when ``GOOGLE_API_KEY`` / ``GEMINI_API_KEY`` is set; otherwise returns a
+        deterministic summary from the same tool functions.
+        """
+        email = resolve_customer_email(customer_id)
+        if not email:
+            return (
+                "We could not resolve an email address for this customer id. "
+                "Please provide a customer id that exists in our system or use your account email."
+            )
+
+        if not genai_api_configured():
+            billing_json = get_billing_info(email)
+            tickets_json = get_support_tickets(email)
+            return _format_billing_fallback(billing_json, tickets_json, message)
+
+        user_prompt = (
+            f"Resolved customer email (use for tool calls): {email}\n"
+            f"Customer id (reference): {customer_id}\n\n"
+            f"User question:\n{message}\n"
+        )
+        return await run_llm_agent_once(
+            agent=self._agent,
+            user_message=user_prompt,
+            app_name="billing",
+        )
+
+
+def _format_billing_fallback(billing_json: str, tickets_json: str, message: str) -> str:
+    """Readable summary without an LLM (offline / CI)."""
+    try:
+        billing = json.loads(billing_json)
+        tickets_payload = json.loads(tickets_json)
+    except json.JSONDecodeError:
+        return "[BillingAgent] Unable to parse billing data."
+
+    lines = [
+        "[BillingAgent — offline summary]",
+        f'Your question: "{message[:200]}"',
+        "",
+    ]
+
+    if billing.get("error") == "customer_not_found":
+        lines.append("No customer record found for that email.")
+        return "\n".join(lines)
+
+    cust = billing.get("customer") or {}
+    lines.append(f"Customer: {cust.get('name', 'Unknown')} ({cust.get('email', '')})")
+    orders = billing.get("orders") or []
+    if not orders:
+        lines.append("No orders on file.")
+    else:
+        lines.append(f"Orders ({len(orders)}):")
+        for o in orders[:10]:
+            lines.append(
+                f"  - {o.get('order_number')}: "
+                f"amount={o.get('total_amount')}, status={o.get('status')}"
+            )
+        if len(orders) > 10:
+            lines.append(f"  … and {len(orders) - 10} more.")
+
+    tickets = tickets_payload.get("tickets") or []
+    lines.append("")
+    lines.append(f"Support tickets on file: {len(tickets)}.")
+    return "\n".join(lines)

multi_agent_customer_support/src/agents/customer_context.py

@@ -0,0 +1,31 @@
+"""Resolve end-user email for MCP tools from API ``customer_id`` (UUID or email)."""
+
+from __future__ import annotations
+
+from src.mcp.supabase_client import SupabaseConfigurationError, get_customer_by_id
+
+
+def resolve_customer_email(customer_id: str) -> str | None:
+    """
+    MCP tools expect an email.
+
+    - If ``customer_id`` looks like an email (contains ``@``), use it as-is.
+    - Otherwise treat it as ``customers.id`` and look up ``email`` from Supabase.
+
+    Returns ``None`` if lookup fails or email is missing.
+    """
+    raw = (customer_id or "").strip()
+    if not raw:
+        return None
+    if "@" in raw:
+        return raw
+
+    try:
+        row = get_customer_by_id(raw)
+    except (SupabaseConfigurationError, ValueError, RuntimeError):
+        return None
+
+    if not row:
+        return None
+    email = row.get("email")
+    return str(email).strip() if email else None

multi_agent_customer_support/src/agents/returns_remote_agent.py

@@ -0,0 +1,166 @@
+"""Remote returns integration via ADK ``RemoteA2aAgent`` (A2A JSON-RPC to the returns service).
+
+The returns microservice (``servers/returns_service/main.py``) exposes an ADK ``LlmAgent`` over A2A
+with tools ``check_return_eligibility`` and ``initiate_return``. This module wraps that remote
+agent so the rest of the app can call those tools without speaking JSON-RPC directly.
+
+**RouterAgent usage**
+
+``RouterAgent`` routes returns-related NL queries here via :meth:`handle`::
+
+    # Inside RouterAgent.route (returns branch):
+    return await self.returns.handle(customer_id, message)
+
+For **structured** calls (tests, future tooling), use :meth:`check_return_eligibility` and
+:meth:`initiate_return` — they send explicit instructions over the same A2A link so the *remote*
+model invokes the matching tool and we parse JSON from the reply.
+
+**Requirements**
+
+- Returns service running (default ``http://127.0.0.1:8081``).
+- Agent card reachable at ``{base_url}/.well-known/agent-card.json`` (or set ``RETURNS_A2A_AGENT_CARD_URL``).
+- Remote service must have ``GEMINI_API_KEY`` / ``GOOGLE_API_KEY`` so its LlmAgent can run tools.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from typing import Any
+
+from google.adk.agents.remote_a2a_agent import RemoteA2aAgent
+
+from .adk_runtime import run_llm_agent_once
+
+logger = logging.getLogger(__name__)
+
+# Stable name for Runner / events (must match RemoteA2aAgent instance name for logging clarity).
+_RETURNS_REMOTE_NAME = "returns_service_a2a"
+
+_APP_NAME = "returns_a2a_client"
+
+
+def _default_agent_card_url(base_url: str) -> str:
+    """Resolve Agent Card URL; override with ``RETURNS_A2A_AGENT_CARD_URL`` for proxies."""
+    explicit = (os.getenv("RETURNS_A2A_AGENT_CARD_URL") or "").strip()
+    if explicit:
+        return explicit
+    return f"{base_url.rstrip('/')}/.well-known/agent-card.json"
+
+
+def _parse_json_object(text: str) -> dict[str, Any]:
+    """Best-effort parse of a single JSON object from model text (may include markdown fences)."""
+    raw = (text or "").strip()
+    if not raw:
+        raise ValueError("empty response from remote A2A agent")
+
+    if raw.startswith("```"):
+        lines = raw.splitlines()
+        if lines and lines[0].startswith("```"):
+            lines = lines[1:]
+        if lines and lines[-1].strip().startswith("```"):
+            lines = lines[:-1]
+        raw = "\n".join(lines).strip()
+
+    try:
+        out = json.loads(raw)
+        if isinstance(out, dict):
+            return out
+    except json.JSONDecodeError:
+        pass
+
+    m = re.search(r"\{[\s\S]*\}", raw)
+    if m:
+        return json.loads(m.group(0))
+
+    raise ValueError(f"no JSON object found in response: {raw[:300]}")
+
+
+class ReturnsRemoteAgent:
+    """
+    Client for the returns microservice using ``RemoteA2aAgent``.
+
+    ``base_url`` is the HTTP origin of the service (e.g. ``http://127.0.0.1:8081``), *not* the
+    JSON-RPC path — the Agent Card URL is derived by :func:`_default_agent_card_url`.
+    """
+
+    def __init__(self, base_url: str) -> None:
+        self.base_url = base_url.rstrip("/")
+        card_url = _default_agent_card_url(self.base_url)
+        self._remote = RemoteA2aAgent(
+            name=_RETURNS_REMOTE_NAME,
+            agent_card=card_url,
+            description="Remote returns A2A agent (eligibility + initiate return tools)",
+        )
+
+    async def check_return_eligibility(self, order_number: str) -> dict[str, Any]:
+        """
+        Ask the remote agent to run ``check_return_eligibility`` for ``order_number``.
+
+        Returns a dict with at least ``eligible`` and ``reason`` (from the remote tool output).
+        """
+        prompt = (
+            "You must call the tool named check_return_eligibility exactly once with the "
+            f"given order_number.\n\norder_number: {order_number!r}\n\n"
+            "After the tool returns, reply with nothing except a single JSON object copying "
+            'the tool result: {"eligible": <bool>, "reason": "<string>"}. '
+            "No markdown, no explanation."
+        )
+        text = await run_llm_agent_once(
+            agent=self._remote,
+            user_message=prompt,
+            app_name=_APP_NAME,
+        )
+        try:
+            data = _parse_json_object(text)
+        except (json.JSONDecodeError, ValueError) as exc:
+            logger.warning("Failed to parse eligibility JSON: %s — raw: %s", exc, text[:500])
+            return {"error": "parse_failed", "detail": str(exc), "raw": text[:2000]}
+        return data
+
+    async def initiate_return(self, order_number: str, reason: str) -> dict[str, Any]:
+        """
+        Ask the remote agent to run ``initiate_return`` for ``order_number`` and ``reason``.
+
+        Returns a dict with ``return_id``, ``status``, and ``message`` when parsing succeeds.
+        """
+        prompt = (
+            "You must call the tool named initiate_return exactly once with:\n"
+            f"  order_number: {order_number!r}\n"
+            f"  reason: {reason!r}\n\n"
+            "After the tool returns, reply with nothing except a single JSON object copying "
+            'the tool result: {"return_id": "<string>", "status": "initiated", "message": "<string>"}. '
+            "No markdown, no explanation."
+        )
+        text = await run_llm_agent_once(
+            agent=self._remote,
+            user_message=prompt,
+            app_name=_APP_NAME,
+        )
+        try:
+            data = _parse_json_object(text)
+        except (json.JSONDecodeError, ValueError) as exc:
+            logger.warning("Failed to parse initiate_return JSON: %s — raw: %s", exc, text[:500])
+            return {"error": "parse_failed", "detail": str(exc), "raw": text[:2000]}
+        return data
+
+    async def handle(self, customer_id: str, message: str) -> str:
+        """
+        Natural-language entry point used by **RouterAgent** for the returns branch.
+
+        Forwards ``customer_id`` and the user ``message`` to the remote returns agent over A2A
+        (same JSON-RPC channel as structured methods, without forcing JSON-only output).
+        """
+        prompt = (
+            f"Customer id: {customer_id}\n\n"
+            f"User message:\n{message}\n\n"
+            "Use the returns tools as needed (check_return_eligibility, initiate_return) "
+            "and answer helpfully."
+        )
+        return await run_llm_agent_once(
+            agent=self._remote,
+            user_message=prompt,
+            app_name=_APP_NAME,
+        )

multi_agent_customer_support/src/agents/router_agent.py

@@ -0,0 +1,256 @@
+"""Router agent (root): classifies NL queries and delegates to domain agents."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Literal
+
+from google.adk.agents.llm_agent import LlmAgent
+from pydantic import BaseModel, Field
+
+from .adk_runtime import genai_api_configured, run_router_structured
+from .billing_agent import BillingAgent
+from .returns_remote_agent import ReturnsRemoteAgent
+from .support_agent import SupportAgent
+
+
+@dataclass
+class RouterOutcome:
+    """Result of :meth:`RouterAgent.route_with_meta` (answer + routing metadata for CLI/API)."""
+
+    answer: str
+    routed_to: Literal["billing", "returns", "support", "escalate"]
+    escalated: bool
+    rationale: str | None = None
+
+
+class RouterDecision(BaseModel):
+    """Structured router output when Gemini is available (matches ``output_schema``)."""
+
+    route: Literal["billing", "returns", "support"] = Field(
+        ...,
+        description="Exactly one downstream agent to handle this turn.",
+    )
+    escalate: bool = Field(False, description="True if a human specialist should take over.")
+    rationale: str = Field("", description="Short justification for auditing.")
+
+
+# Prompt + few-shot exemplars teach the small model routing boundaries without extra tooling.
+_ROUTER_FEW_SHOT = """
+Examples (follow the same routing rules for new inputs):
+
+User: Where can I download last month's VAT invoice?
+Assistant JSON: {"route":"billing","escalate":false,"rationale":"invoice / billing document"}
+
+User: My card was charged twice for order #4412.
+Assistant JSON: {"route":"billing","escalate":false,"rationale":"duplicate charge"}
+
+User: I want to return sneakers and print a prepaid label.
+Assistant JSON: {"route":"returns","escalate":false,"rationale":"return + label"}
+
+User: Am I eligible to return clearance items opened last week?
+Assistant JSON: {"route":"returns","escalate":false,"rationale":"returns eligibility"}
+
+User: The app freezes when I open notifications — generic bug.
+Assistant JSON: {"route":"support","escalate":false,"rationale":"general product issue"}
+
+User: I'm going to sue your company unless I get my money today!!!
+Assistant JSON: {"route":"support","escalate":true,"rationale":"legal threat / high severity"}
+
+User: ???
+Assistant JSON: {"route":"support","escalate":true,"rationale":"unclear intent"}
+"""
+
+
+ROUTER_SYSTEM_INSTRUCTION = f"""You are the intent router for a commerce support system.
+
+Choose exactly one route:
+- billing — invoices, charges, payments, subscriptions, receipts (money on account).
+- returns — product returns, exchanges, prepaid labels, return eligibility.
+- support — general troubleshooting, bugs, vague questions, shipping status *unless* it is clearly billing or returns.
+
+Set escalate=true when:
+- The user is furious, threatens legal action, mentions lawyers/police/regulators,
+- Self-harm or abuse is hinted,
+- The request is too ambiguous to route safely,
+
+Output **only JSON** matching the schema (route, escalate, rationale). No markdown fences.
+
+{_ROUTER_FEW_SHOT}
+"""
+
+
+def classify_intent_fallback(message: str) -> RouterDecision:
+    """
+    Keyword + heuristic router used when Gemini is not configured or JSON parsing fails.
+
+    Kept deterministic for CI and for environments without ``GOOGLE_API_KEY``.
+    """
+    lower = (message or "").lower().strip()
+
+    escalate_terms = (
+        "lawsuit",
+        "lawyer",
+        "attorney",
+        "sue ",
+        " suing",
+        "police",
+        "fcc",
+        " regulator",
+        "suicide",
+        "self-harm",
+        "kill myself",
+        "discriminat",
+    )
+    if any(t in lower for t in escalate_terms):
+        return RouterDecision(
+            route="support",
+            escalate=True,
+            rationale="potential high-severity / legal / safety keywords",
+        )
+
+    if any(
+        k in lower
+        for k in (
+            "return",
+            "exchange",
+            "label",
+            "ship back",
+            "send back",
+            "wrong item",
+            "didn't fit",
+            "doesn't fit",
+            " rma",
+        )
+    ):
+        return RouterDecision(route="returns", escalate=False, rationale="returns-flow keywords")
+
+    billing_terms = (
+        "invoice",
+        "bill",
+        "billing",
+        "charge",
+        "charged",
+        "payment",
+        "subscription",
+        "receipt",
+        "refund",
+        "card",
+        "paypal",
+        "vat",
+        "statement",
+        "duplicate charge",
+        "overcharge",
+    )
+    if any(k in lower for k in billing_terms):
+        return RouterDecision(route="billing", escalate=False, rationale="billing/payment keywords")
+
+    if len(lower) < 4:
+        return RouterDecision(route="support", escalate=True, rationale="message too short / unclear")
+
+    return RouterDecision(route="support", escalate=False, rationale="default general support")
+
+
+class RouterAgent:
+    """
+    Root agent: uses Gemini + few-shot JSON classification when keys exist; otherwise heuristics.
+
+    Construct with explicit specialist agents (wired in ``main.py``):
+
+    - ``billing`` — :class:`BillingAgent` (Supabase tool functions / MCP parity)
+    - ``returns`` — :class:`ReturnsRemoteAgent` (remote returns A2A service)
+    - ``support`` — :class:`SupportAgent`
+    """
+
+    def __init__(
+        self,
+        *,
+        billing: BillingAgent,
+        support: SupportAgent,
+        returns: ReturnsRemoteAgent,
+        model: str | None = None,
+    ) -> None:
+        self._model = model or os.getenv("ADK_MODEL", "gemini-2.5-flash")
+        self.billing = billing
+        self.support = support
+        self.returns = returns
+
+        self._router_llm = LlmAgent(
+            name="router",
+            model=self._model,
+            instruction=ROUTER_SYSTEM_INSTRUCTION,
+            output_schema=RouterDecision,
+        )
+
+    async def route_with_meta(self, customer_id: str, message: str) -> RouterOutcome:
+        """
+        Classify ``message``, dispatch to the right specialist, return answer + metadata.
+
+        Use this from the CLI and from APIs that need ``routed_to`` / ``escalated``.
+        """
+        router_input = (
+            "Classify this customer turn.\n\n"
+            f"customer_id: {customer_id}\n\n"
+            f"message:\n{message}\n"
+        )
+
+        decision: RouterDecision | None = None
+        if genai_api_configured():
+            decision = await run_router_structured(
+                agent=self._router_llm,
+                user_message=router_input,
+                schema_type=RouterDecision,
+                app_name="router",
+            )
+
+        if decision is None:
+            decision = classify_intent_fallback(message)
+
+        if decision.escalate:
+            text = (
+                "[ESCALATE]\n"
+                "This request was flagged for a human specialist.\n"
+                f"Routing note: {decision.rationale}\n"
+                "ESCALATE_FLAG: true"
+            )
+            return RouterOutcome(
+                answer=text,
+                routed_to="escalate",
+                escalated=True,
+                rationale=decision.rationale,
+            )
+
+        if decision.route == "billing":
+            ans = await self.billing.handle(customer_id, message)
+            return RouterOutcome(
+                answer=ans,
+                routed_to="billing",
+                escalated=False,
+                rationale=decision.rationale,
+            )
+
+        if decision.route == "returns":
+            ans = await self.returns.handle(customer_id, message)
+            return RouterOutcome(
+                answer=ans,
+                routed_to="returns",
+                escalated=False,
+                rationale=decision.rationale,
+            )
+
+        ans = await self.support.handle(customer_id, message)
+        return RouterOutcome(
+            answer=ans,
+            routed_to="support",
+            escalated=False,
+            rationale=decision.rationale,
+        )
+
+    async def route(self, customer_id: str, message: str) -> str:
+        """
+        Classify ``message`` and invoke the appropriate agent (answer text only).
+
+        Escalations return a body containing ``[ESCALATE]`` and ``ESCALATE_FLAG: true``.
+        """
+        return (await self.route_with_meta(customer_id, message)).answer

multi_agent_customer_support/src/agents/support_agent.py

@@ -0,0 +1,103 @@
+"""General support agent: reads tickets via MCP-parity tools and guides or escalates."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.tools.function_tool import FunctionTool
+
+from src.mcp.supabase_mcp_server import get_support_tickets
+
+from .adk_runtime import genai_api_configured, run_llm_agent_once
+from .customer_context import resolve_customer_email
+
+
+def _support_tools() -> list[Any]:
+    return [
+        FunctionTool(get_support_tickets),
+    ]
+
+
+_SUPPORT_INSTRUCTION = """You are a careful customer-support assistant.
+
+You have one factual tool:
+- ``get_support_tickets(email)`` — returns JSON with ``tickets`` for that customer.
+
+Guidelines:
+1. Use the **resolved email** provided in the user message for ``get_support_tickets``.
+2. Summarize ticket status at a high level (subject/category if present); do not fabricate ticket IDs.
+3. For abuse, threats, legal threats, suspected fraud, or account compromise, clearly recommend **human escalation**.
+4. Keep answers concise and professional.
+"""
+
+
+class SupportAgent:
+    """Generic support flow with optional Gemini; offline mode summarizes tickets without an LLM."""
+
+    def __init__(self, model: str | None = None) -> None:
+        self._model = model or os.getenv("ADK_MODEL", "gemini-2.5-flash")
+        self._agent = LlmAgent(
+            name="support_agent",
+            model=self._model,
+            instruction=_SUPPORT_INSTRUCTION,
+            tools=_support_tools(),
+        )
+
+    async def handle(self, customer_id: str, message: str) -> str:
+        email = resolve_customer_email(customer_id)
+        if not email:
+            return (
+                "We could not resolve an email for this customer id. "
+                "Please contact support with your registered email."
+            )
+
+        if not genai_api_configured():
+            tickets_json = get_support_tickets(email)
+            return _format_support_fallback(tickets_json, message)
+
+        user_prompt = (
+            f"Resolved customer email (use for tool calls): {email}\n"
+            f"Customer id (reference): {customer_id}\n\n"
+            f"User message:\n{message}\n"
+        )
+        return await run_llm_agent_once(
+            agent=self._agent,
+            user_message=user_prompt,
+            app_name="support",
+        )
+
+
+def _format_support_fallback(tickets_json: str, message: str) -> str:
+    try:
+        payload = json.loads(tickets_json)
+    except json.JSONDecodeError:
+        return "[SupportAgent] Unable to parse ticket data."
+
+    lines = [
+        "[SupportAgent — offline summary]",
+        f'Your message: "{message[:200]}"',
+        "",
+    ]
+
+    if payload.get("error") == "customer_not_found":
+        lines.append("No matching customer email in our records.")
+        return "\n".join(lines)
+
+    tickets = payload.get("tickets") or []
+    lines.append(f"Open/recent tickets in view: {len(tickets)}.")
+    for t in tickets[:5]:
+        subj = t.get("subject") or t.get("title") or "(no subject)"
+        cat = t.get("category", "")
+        stat = t.get("status", "")
+        lines.append(f"  - [{stat}] {cat}: {subj}")
+    if len(tickets) > 5:
+        lines.append(f"  … and {len(tickets) - 5} more.")
+
+    lines.append("")
+    lines.append(
+        "If this involves threats, legal action, or account security, request a human specialist."
+    )
+    return "\n".join(lines)

multi_agent_customer_support/src/main.py

@@ -0,0 +1,163 @@
+"""Multi-agent customer support: FastAPI API + optional interactive CLI.
+
+Run the HTTP API (from ``multi_agent_customer_support/``)::
+
+    uvicorn src.main:app --reload --port 8000
+
+Run the stdin CLI (same cwd; loads ``.env`` from the workspace)::
+
+    python -m src.main
+
+Environment:
+
+- ``RETURNS_SERVICE_URL`` — returns microservice base URL (default ``http://127.0.0.1:8081``).
+- ``CLI_CUSTOMER_ID`` — default customer id (email or UUID) for the CLI when set.
+- ``GEMINI_API_KEY`` / ``GOOGLE_API_KEY`` — router + specialists.
+- Supabase: ``SUPABASE_URL``, ``SUPABASE_ANON_KEY`` (see ``src/mcp/supabase_client.py``).
+
+Wiring:
+
+- ``RouterAgent`` receives ``BillingAgent``, ``SupportAgent``, and ``ReturnsRemoteAgent`` explicitly.
+- ``ReturnsRemoteAgent`` talks to the **A2A** returns service at ``RETURNS_SERVICE_URL``.
+- Billing/support use in-process tools matching the Supabase MCP server; ``get_supabase_mcp_toolset()`` builds an
+  ADK ``McpToolset`` for a **stdio** MCP connection to ``src.mcp.supabase_mcp_server`` when you need the real MCP client.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from dotenv import load_dotenv
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
+
+from .agents.billing_agent import BillingAgent
+from .agents.returns_remote_agent import ReturnsRemoteAgent
+from .agents.router_agent import RouterAgent
+from .agents.support_agent import SupportAgent
+from .mcp.supabase_mcp_connection import build_supabase_mcp_toolset
+from .mcp.supabase_mcp_server import SupabaseMCPServer
+
+load_dotenv()
+
+RETURNS_SERVICE_URL = os.getenv("RETURNS_SERVICE_URL", "http://127.0.0.1:8081")
+
+# --- Specialists + router (single shared graph for the API process) ---
+billing_agent = BillingAgent()
+support_agent = SupportAgent()
+returns_remote_agent = ReturnsRemoteAgent(RETURNS_SERVICE_URL)
+router_agent = RouterAgent(
+    billing=billing_agent,
+    support=support_agent,
+    returns=returns_remote_agent,
+)
+
+supabase_mcp = SupabaseMCPServer()
+
+# Lazy MCP stdio client (Supabase MCP server subprocess connects when tools are first resolved).
+_supabase_mcp_toolset: McpToolset | None = None
+
+
+def get_supabase_mcp_toolset() -> McpToolset:
+    """Return the shared ADK ``McpToolset`` for the Supabase MCP stdio server."""
+    global _supabase_mcp_toolset
+    if _supabase_mcp_toolset is None:
+        _supabase_mcp_toolset = build_supabase_mcp_toolset()
+    return _supabase_mcp_toolset
+
+
+app = FastAPI(title="Multi-Agent Customer Support")
+
+
+class SupportQuery(BaseModel):
+    customer_id: str
+    message: str
+
+
+@app.get("/health")
+async def health() -> dict[str, Any]:
+    return {
+        "status": "ok",
+        "returns_service_url": RETURNS_SERVICE_URL,
+        "supabase": supabase_mcp.health(),
+        "agents": {
+            "router": "RouterAgent",
+            "billing": "BillingAgent",
+            "support": "SupportAgent",
+            "returns": "ReturnsRemoteAgent (A2A)",
+        },
+        "mcp": {
+            "supabase_stdio_toolset": "lazy singleton via get_supabase_mcp_toolset()",
+            "tools": ["get_billing_info", "get_support_tickets"],
+        },
+    }
+
+
+@app.post("/support/query")
+async def support_query(payload: SupportQuery) -> dict[str, Any]:
+    """
+    Route ``message`` for ``customer_id`` through :meth:`RouterAgent.route_with_meta`.
+    """
+    out = await router_agent.route_with_meta(payload.customer_id, payload.message)
+    return {
+        "result": out.answer,
+        "routed_to": out.routed_to,
+        "escalated": out.escalated,
+        "rationale": out.rationale,
+    }
+
+
+def _cli_customer_id() -> str:
+    cid = (os.getenv("CLI_CUSTOMER_ID") or "").strip()
+    if cid:
+        return cid
+    try:
+        return input("Customer id (email or UUID) [demo@example.com]: ").strip() or "demo@example.com"
+    except EOFError:
+        return "demo@example.com"
+
+
+async def _cli_loop_async() -> None:
+    """
+    Simple REPL: stdin lines -> RouterAgent -> print answer + routing metadata.
+
+    Ensures the Supabase MCP toolset object is created so the MCP client wiring is initialized
+    (actual stdio subprocess may still start only when tools are loaded by a consumer).
+    """
+    load_dotenv()
+    _ = get_supabase_mcp_toolset()
+
+    customer_id = _cli_customer_id()
+    print("Interactive support CLI. Type quit / exit to stop.")
+    print(f"Using customer_id={customer_id!r} (set CLI_CUSTOMER_ID to skip prompt)\n")
+
+    while True:
+        try:
+            line = input("> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if not line:
+            continue
+        if line.lower() in ("quit", "exit", "q"):
+            break
+
+        out = await router_agent.route_with_meta(customer_id, line)
+        print(out.answer)
+        print(f"[meta] routed_to={out.routed_to!r} escalated={out.escalated}")
+        if out.rationale:
+            print(f"[meta] rationale={out.rationale!r}")
+        print()
+
+
+def run_cli() -> None:
+    """Entry for ``python -m src.main``."""
+    asyncio.run(_cli_loop_async())
+
+
+if __name__ == "__main__":
+    run_cli()

multi_agent_customer_support/src/mcp/__init__.py

@@ -0,0 +1 @@
+"""MCP-style integrations (Supabase server wrapper)."""

multi_agent_customer_support/src/mcp/python_mcp_server.py

@@ -0,0 +1,54 @@
+"""Local Python MCP server for project diagnostics."""
+
+from __future__ import annotations
+
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+
+from dotenv import load_dotenv
+from fastmcp import FastMCP
+
+
+def _load_env_files() -> None:
+    project_root = Path(__file__).resolve().parents[3]
+    workspace_root = Path(__file__).resolve().parents[4]
+
+    # Prefer explicit env files if present
+    load_dotenv(dotenv_path=workspace_root / ".env", override=False)
+    load_dotenv(dotenv_path=project_root / ".env", override=False)
+
+
+_load_env_files()
+
+mcp = FastMCP("multi-agent-python-mcp")
+
+
+@mcp.tool
+def ping() -> str:
+    """Return a simple heartbeat response."""
+    return "pong"
+
+
+@mcp.tool
+def project_info() -> dict[str, str]:
+    """Return quick project/runtime metadata."""
+    return {
+        "project": "multi_agent_customer_support",
+        "python": os.sys.version.split()[0],
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+@mcp.tool
+def supabase_env_status() -> dict[str, bool]:
+    """Tell whether Supabase env vars are present."""
+    return {
+        "has_supabase_url": bool(os.getenv("SUPABASE_URL")),
+        "has_supabase_key": bool(os.getenv("SUPABASE_KEY")),
+        "has_supabase_access_token": bool(os.getenv("SUPABASE_ACCESS_TOKEN")),
+    }
+
+
+if __name__ == "__main__":
+    mcp.run()

multi_agent_customer_support/src/mcp/supabase_client.py

@@ -0,0 +1,236 @@
+"""Supabase Postgres helpers for customer support data (supabase-py).
+
+Import from the ``src`` package to avoid clashing with the PyPI ``mcp`` SDK, for example:
+
+    from src.mcp.supabase_client import get_customer_by_email
+
+This matches running the API with ``uvicorn src.main:app`` from ``multi_agent_customer_support/``.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from dotenv import load_dotenv
+
+try:
+    from supabase import Client, create_client
+except ImportError as exc:  # pragma: no cover - env without supabase installed
+    Client = Any  # type: ignore[misc, assignment]
+    create_client = None
+    _IMPORT_ERROR = exc
+else:
+    _IMPORT_ERROR = None
+
+
+class SupabaseConfigurationError(RuntimeError):
+    """Raised when URL/key are missing or the Supabase SDK is unavailable."""
+
+
+def _load_dotenv() -> None:
+    """Load `.env` from typical locations (workspace root + package root)."""
+    try:
+        from pathlib import Path
+
+        here = Path(__file__).resolve()
+        package_root = here.parents[2]
+        workspace_root = here.parents[3]
+        load_dotenv(dotenv_path=workspace_root / ".env", override=False)
+        load_dotenv(dotenv_path=package_root / ".env", override=False)
+    except Exception:
+        load_dotenv(override=False)
+
+
+_load_dotenv()
+
+_client: Client | None = None
+
+
+def _resolve_anon_key() -> str:
+    """Prefer SUPABASE_ANON_KEY; fall back to SUPABASE_KEY for older configs."""
+    return (os.getenv("SUPABASE_ANON_KEY") or os.getenv("SUPABASE_KEY") or "").strip()
+
+
+def _require_sdk() -> None:
+    if create_client is None:
+        raise SupabaseConfigurationError(
+            "supabase-py is not installed or failed to import."
+        ) from _IMPORT_ERROR
+
+
+def get_supabase_client() -> Client:
+    """
+    Return a cached Supabase client using ``SUPABASE_URL`` and ``SUPABASE_ANON_KEY``.
+
+    ``SUPABASE_KEY`` is accepted as a fallback when ``SUPABASE_ANON_KEY`` is unset.
+    """
+    global _client
+    _require_sdk()
+
+    if _client is not None:
+        return _client
+
+    url = (os.getenv("SUPABASE_URL") or "").strip()
+    key = _resolve_anon_key()
+    if not url or not key:
+        raise SupabaseConfigurationError(
+            "Set SUPABASE_URL and SUPABASE_ANON_KEY (or SUPABASE_KEY) in the environment."
+        )
+
+    assert create_client is not None
+    _client = create_client(url, key)
+    return _client
+
+
+def reset_supabase_client_cache() -> None:
+    """Clear the cached client (mainly for tests)."""
+    global _client
+    _client = None
+
+
+def get_customer_by_email(email: str) -> dict[str, Any] | None:
+    """
+    Fetch a single customer row by unique email.
+
+    :param email: Customer email (trimmed); must be non-empty.
+    :returns: One row as a dict, or ``None`` if not found.
+    :raises SupabaseConfigurationError: If env or SDK is not usable.
+    :raises ValueError: If ``email`` is empty.
+    """
+    email_clean = (email or "").strip()
+    if not email_clean:
+        raise ValueError("email must be a non-empty string")
+
+    try:
+        client = get_supabase_client()
+        response = (
+            client.table("customers")
+            .select("*")
+            .eq("email", email_clean)
+            .limit(1)
+            .execute()
+        )
+        rows = response.data or []
+        return rows[0] if rows else None
+    except SupabaseConfigurationError:
+        raise
+    except Exception as exc:
+        raise RuntimeError(f"Failed to load customer by email: {exc}") from exc
+
+
+def get_customer_by_id(customer_id: str) -> dict[str, Any] | None:
+    """
+    Fetch a single customer row by primary key ``id`` (UUID string).
+
+    :param customer_id: ``customers.id`` as a string.
+    :returns: One row as a dict, or ``None`` if not found.
+    :raises SupabaseConfigurationError: If env or SDK is not usable.
+    :raises ValueError: If ``customer_id`` is empty.
+    """
+    cid = (customer_id or "").strip()
+    if not cid:
+        raise ValueError("customer_id must be a non-empty string")
+
+    try:
+        client = get_supabase_client()
+        response = (
+            client.table("customers")
+            .select("*")
+            .eq("id", cid)
+            .limit(1)
+            .execute()
+        )
+        rows = response.data or []
+        return rows[0] if rows else None
+    except SupabaseConfigurationError:
+        raise
+    except Exception as exc:
+        raise RuntimeError(f"Failed to load customer by id: {exc}") from exc
+
+
+def get_orders_by_customer(customer_id: str) -> list[dict[str, Any]]:
+    """
+    List orders for a customer (newest first by ``created_at``).
+
+    :param customer_id: UUID string for ``orders.customer_id``.
+    :returns: List of order rows (possibly empty).
+    :raises SupabaseConfigurationError: If env or SDK is not usable.
+    :raises ValueError: If ``customer_id`` is empty.
+    """
+    cid = (customer_id or "").strip()
+    if not cid:
+        raise ValueError("customer_id must be a non-empty string")
+
+    try:
+        client = get_supabase_client()
+        response = (
+            client.table("orders")
+            .select("*")
+            .eq("customer_id", cid)
+            .order("created_at", desc=True)
+            .execute()
+        )
+        return list(response.data or [])
+    except SupabaseConfigurationError:
+        raise
+    except Exception as exc:
+        raise RuntimeError(f"Failed to list orders for customer: {exc}") from exc
+
+
+def get_support_tickets_by_customer(customer_id: str) -> list[dict[str, Any]]:
+    """
+    List support tickets for a customer (newest first by ``created_at``).
+
+    :param customer_id: UUID string for ``support_tickets.customer_id``.
+    :returns: List of ticket rows (possibly empty).
+    :raises SupabaseConfigurationError: If env or SDK is not usable.
+    :raises ValueError: If ``customer_id`` is empty.
+    """
+    cid = (customer_id or "").strip()
+    if not cid:
+        raise ValueError("customer_id must be a non-empty string")
+
+    try:
+        client = get_supabase_client()
+        response = (
+            client.table("support_tickets")
+            .select("*")
+            .eq("customer_id", cid)
+            .order("created_at", desc=True)
+            .execute()
+        )
+        return list(response.data or [])
+    except SupabaseConfigurationError:
+        raise
+    except Exception as exc:
+        raise RuntimeError(f"Failed to list support tickets for customer: {exc}") from exc
+
+
+def get_support_tickets_by_category(category: str) -> list[dict[str, Any]]:
+    """
+    List support tickets matching a category (e.g. ``billing``, ``returns``, ``general``).
+
+    :param category: Ticket category string.
+    :returns: List of ticket rows (possibly empty).
+    :raises SupabaseConfigurationError: If env or SDK is not usable.
+    :raises ValueError: If ``category`` is empty.
+    """
+    cat = (category or "").strip()
+    if not cat:
+        raise ValueError("category must be a non-empty string")
+
+    try:
+        client = get_supabase_client()
+        response = (
+            client.table("support_tickets")
+            .select("*")
+            .eq("category", cat)
+            .order("created_at", desc=True)
+            .execute()
+        )
+        return list(response.data or [])
+    except SupabaseConfigurationError:
+        raise
+    except Exception as exc:
+        raise RuntimeError(f"Failed to list support tickets: {exc}") from exc

multi_agent_customer_support/src/mcp/supabase_mcp_connection.py

@@ -0,0 +1,39 @@
+"""ADK ``McpToolset`` factory for the Supabase MCP stdio server (separate process).
+
+Billing/support agents in this repo call the same tool implementations in-process
+(``FunctionTool`` + ``supabase_mcp_server``). This toolset is for hosts that want a **real**
+stdio MCP connection (e.g. future refactors, diagnostics).
+
+The server is started as::
+
+    python -m src.mcp.supabase_mcp_server
+
+from the ``multi_agent_customer_support`` package root (``cwd`` below).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from google.adk.tools.mcp_tool.mcp_session_manager import StdioConnectionParams
+from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
+from mcp import StdioServerParameters
+
+# src/mcp/supabase_mcp_connection.py -> parents[2] = multi_agent_customer_support
+_PACKAGE_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+def build_supabase_mcp_toolset() -> McpToolset:
+    """Configure MCP client for ``get_billing_info`` and ``get_support_tickets`` on the Supabase server."""
+    return McpToolset(
+        connection_params=StdioConnectionParams(
+            server_params=StdioServerParameters(
+                command=sys.executable,
+                args=["-m", "src.mcp.supabase_mcp_server"],
+                cwd=str(_PACKAGE_ROOT),
+            ),
+            timeout=30.0,
+        ),
+        tool_filter=["get_billing_info", "get_support_tickets"],
+    )

multi_agent_customer_support/src/mcp/supabase_mcp_server.py

@@ -0,0 +1,170 @@
+"""Supabase-backed MCP server for ADK agents (Model Context Protocol tools over stdio).
+
+This process exposes tools that query Postgres via ``supabase-py``. Run it as a **separate
+process** and point Google ADK / MCP clients at this server (stdio transport).
+
+How to run (from ``multi_agent_customer_support/``):
+
+    .venv\\Scripts\\activate
+    python -m src.mcp.supabase_mcp_server
+
+Environment (same as ``supabase_client``):
+
+- ``SUPABASE_URL``
+- ``SUPABASE_ANON_KEY`` (or legacy ``SUPABASE_KEY``)
+
+Ensure Row Level Security policies allow the ``anon`` role to read the relevant tables
+(see ``sql/fix_rls_and_verify.sql``).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from dotenv import load_dotenv
+from fastmcp import FastMCP
+
+from .supabase_client import (
+    SupabaseConfigurationError,
+    get_customer_by_email,
+    get_orders_by_customer,
+    get_support_tickets_by_customer,
+    get_supabase_client,
+)
+
+# Load workspace / package .env before tools run (FastMCP subprocess may not inherit shell env).
+try:
+    from pathlib import Path
+
+    _here = Path(__file__).resolve()
+    _pkg = _here.parents[2]
+    _ws = _here.parents[3]
+    load_dotenv(dotenv_path=_ws / ".env", override=False)
+    load_dotenv(dotenv_path=_pkg / ".env", override=False)
+except Exception:
+    load_dotenv(override=False)
+
+
+mcp = FastMCP("supabase-support-mcp")
+
+
+@mcp.tool()
+def get_billing_info(email: str) -> str:
+    """
+    Look up a customer by email and return a concise JSON summary of their orders
+    (billing-related: ``order_number``, ``total_amount``, ``status``).
+
+    Returns a JSON string for easy consumption by agents.
+    """
+    email_clean = (email or "").strip()
+    if not email_clean:
+        return json.dumps({"error": "invalid_email", "message": "email must be non-empty"})
+
+    customer = get_customer_by_email(email_clean)
+    if not customer:
+        return json.dumps(
+            {"error": "customer_not_found", "email": email_clean, "orders": []}
+        )
+
+    customer_id = str(customer.get("id", ""))
+    orders_raw = get_orders_by_customer(customer_id)
+
+    orders = []
+    for row in orders_raw:
+        amt = row.get("total_amount")
+        try:
+            total = float(amt) if amt is not None else None
+        except (TypeError, ValueError):
+            total = amt
+        orders.append(
+            {
+                "order_number": row.get("order_number"),
+                "total_amount": total,
+                "status": row.get("status"),
+            }
+        )
+
+    payload = {
+        "customer": {
+            "id": customer_id,
+            "name": customer.get("name"),
+            "email": customer.get("email"),
+        },
+        "orders": orders,
+        "order_count": len(orders),
+    }
+    return json.dumps(payload, default=str)
+
+
+@mcp.tool()
+def get_support_tickets(email: str) -> str:
+    """
+    Look up a customer by email and return all ``support_tickets`` for that customer.
+
+    Returns a JSON string containing ``customer`` metadata and a ``tickets`` list.
+    """
+    email_clean = (email or "").strip()
+    if not email_clean:
+        return json.dumps({"error": "invalid_email", "message": "email must be non-empty"})
+
+    customer = get_customer_by_email(email_clean)
+    if not customer:
+        return json.dumps(
+            {
+                "error": "customer_not_found",
+                "email": email_clean,
+                "tickets": [],
+            }
+        )
+
+    customer_id = str(customer.get("id", ""))
+    tickets = get_support_tickets_by_customer(customer_id)
+
+    payload = {
+        "customer": {
+            "id": customer_id,
+            "name": customer.get("name"),
+            "email": customer.get("email"),
+        },
+        "tickets": tickets,
+        "ticket_count": len(tickets),
+    }
+    return json.dumps(payload, default=str)
+
+
+class SupabaseMCPServer:
+    """Lightweight health helper used by ``src.main`` FastAPI (not the MCP stdio server)."""
+
+    def health(self) -> dict[str, Any]:
+        try:
+            get_supabase_client()
+            return {
+                "configured": True,
+                "sdk_available": True,
+                "supabase_url_set": bool(os.getenv("SUPABASE_URL")),
+                "anon_or_key_set": bool(
+                    os.getenv("SUPABASE_ANON_KEY") or os.getenv("SUPABASE_KEY")
+                ),
+            }
+        except SupabaseConfigurationError as exc:
+            return {
+                "configured": False,
+                "sdk_available": True,
+                "error": str(exc),
+            }
+
+
+def main() -> None:
+    """
+    Start the MCP server (default: **stdio** transport).
+
+    Run as a dedicated process; ADK / MCP hosts spawn this executable and communicate
+    over stdin/stdout per the Model Context Protocol.
+    """
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

multi_agent_customer_support/tests/__init__.py

@@ -0,0 +1 @@
+"""Project tests package."""

multi_agent_customer_support/tests/test_returns_remote_agent.py

@@ -0,0 +1,61 @@
+"""Unit tests for returns_remote_agent helpers (no live A2A server)."""
+
+import os
+import sys
+import unittest
+import unittest.mock
+
+_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, _ROOT)
+
+from src.agents.returns_remote_agent import (  # noqa: E402
+    ReturnsRemoteAgent,
+    _default_agent_card_url,
+    _parse_json_object,
+)
+
+
+class TestParseJsonObject(unittest.TestCase):
+    def test_plain_json(self) -> None:
+        d = _parse_json_object('{"eligible": true, "reason": "ok"}')
+        self.assertTrue(d["eligible"])
+        self.assertEqual(d["reason"], "ok")
+
+    def test_fenced_json(self) -> None:
+        d = _parse_json_object('```json\n{"a": 1}\n```')
+        self.assertEqual(d["a"], 1)
+
+    def test_embedded_braces(self) -> None:
+        d = _parse_json_object('Here you go: {"eligible": false, "reason": "x"} thanks')
+        self.assertFalse(d["eligible"])
+
+
+class TestDefaultAgentCardUrl(unittest.TestCase):
+    def test_override_env(self) -> None:
+        with unittest.mock.patch.dict(
+            os.environ,
+            {"RETURNS_A2A_AGENT_CARD_URL": "http://example.com/card.json"},
+        ):
+            self.assertEqual(
+                _default_agent_card_url("http://127.0.0.1:8081"),
+                "http://example.com/card.json",
+            )
+
+    def test_default_suffix(self) -> None:
+        with unittest.mock.patch.dict(os.environ, {"RETURNS_A2A_AGENT_CARD_URL": ""}):
+            url = _default_agent_card_url("http://127.0.0.1:8081")
+            self.assertEqual(
+                url,
+                "http://127.0.0.1:8081/.well-known/agent-card.json",
+            )
+
+
+class TestReturnsRemoteAgentInit(unittest.TestCase):
+    def test_builds_remote_a2a(self) -> None:
+        r = ReturnsRemoteAgent("http://127.0.0.1:8081")
+        self.assertEqual(r.base_url, "http://127.0.0.1:8081")
+        self.assertEqual(r._remote.name, "returns_service_a2a")
+
+
+if __name__ == "__main__":
+    unittest.main()

multi_agent_customer_support/tests/test_returns_service.py

@@ -0,0 +1,73 @@
+"""Tests for ``servers/returns_service/main.py`` (FastAPI + mock tools)."""
+
+import os
+import sys
+import unittest
+
+_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, _ROOT)
+
+from fastapi.testclient import TestClient  # noqa: E402
+
+from servers.returns_service import main as rs  # noqa: E402
+
+
+class TestReturnsTools(unittest.TestCase):
+    def test_eligibility_even_digit(self) -> None:
+        r = rs.check_return_eligibility("ORD-42")
+        self.assertTrue(r["eligible"])
+        self.assertIn("even", r["reason"].lower())
+
+    def test_eligibility_odd_digit(self) -> None:
+        r = rs.check_return_eligibility("X-41")
+        self.assertFalse(r["eligible"])
+
+    def test_eligibility_non_digit_suffix(self) -> None:
+        r = rs.check_return_eligibility("ABC")
+        self.assertFalse(r["eligible"])
+
+    def test_initiate_return_shape(self) -> None:
+        r = rs.initiate_return("ORD-1", "too big")
+        self.assertEqual(r["status"], "initiated")
+        self.assertTrue(r["return_id"].startswith("ret-"))
+        self.assertIn("ORD-1", r["message"])
+
+
+class TestReturnsFastAPI(unittest.TestCase):
+    """Use ``TestClient`` as a context manager so FastAPI ``lifespan`` runs (A2A route registration)."""
+
+    def test_health(self) -> None:
+        with TestClient(rs.app) as client:
+            res = client.get("/health")
+        self.assertEqual(res.status_code, 200)
+        self.assertEqual(res.json()["status"], "ok")
+
+    def test_agent_card(self) -> None:
+        with TestClient(rs.app) as client:
+            res = client.get("/.well-known/agent-card.json")
+        self.assertEqual(res.status_code, 200)
+        data = res.json()
+        self.assertIn("name", data)
+        self.assertEqual(data.get("name"), "returns_agent")
+
+    def test_tools_eligibility_endpoint(self) -> None:
+        with TestClient(rs.app) as client:
+            res = client.post(
+                "/tools/check_return_eligibility",
+                json={"order_number": "ORD-8"},
+            )
+        self.assertEqual(res.status_code, 200)
+        self.assertTrue(res.json()["eligible"])
+
+    def test_returns_process_legacy(self) -> None:
+        with TestClient(rs.app) as client:
+            res = client.post(
+                "/returns/process",
+                json={"customer_id": "c1", "message": "hello"},
+            )
+        self.assertEqual(res.status_code, 200)
+        self.assertIn("result", res.json())
+
+
+if __name__ == "__main__":
+    unittest.main()

multi_agent_customer_support/tests/test_router_fallback.py

@@ -0,0 +1,35 @@
+"""Tests for heuristic router classification (no Gemini required)."""
+
+import os
+import sys
+import unittest
+
+_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, _ROOT)
+
+from src.agents.router_agent import classify_intent_fallback  # noqa: E402
+
+
+class TestRouterFallback(unittest.TestCase):
+    def test_returns_keywords(self) -> None:
+        d = classify_intent_fallback("I need a return label for order 9")
+        self.assertEqual(d.route, "returns")
+        self.assertFalse(d.escalate)
+
+    def test_billing_keywords(self) -> None:
+        d = classify_intent_fallback("Duplicate charge on my Visa")
+        self.assertEqual(d.route, "billing")
+
+    def test_escalate_legal(self) -> None:
+        d = classify_intent_fallback("I will contact my lawyer tomorrow")
+        self.assertTrue(d.escalate)
+        self.assertEqual(d.route, "support")
+
+    def test_generic_support(self) -> None:
+        d = classify_intent_fallback("The notifications tab freezes")
+        self.assertEqual(d.route, "support")
+        self.assertFalse(d.escalate)
+
+
+if __name__ == "__main__":
+    unittest.main()

multi_agent_customer_support/tests/test_scenarios.py

@@ -0,0 +1,153 @@
+"""
+High-level scenario tests: billing (MCP tool functions), returns (A2A agent), escalation.
+
+Uses mocks so no live Supabase, Gemini, or returns microservice is required.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+sys.path.insert(0, _ROOT)
+
+from src.agents.billing_agent import BillingAgent  # noqa: E402
+from src.agents.router_agent import RouterAgent, RouterDecision  # noqa: E402
+from src.agents.support_agent import SupportAgent  # noqa: E402
+from src.agents.returns_remote_agent import ReturnsRemoteAgent  # noqa: E402
+
+
+def _make_router(
+    *,
+    billing: BillingAgent | None = None,
+    support: SupportAgent | None = None,
+    returns: ReturnsRemoteAgent | None = None,
+) -> RouterAgent:
+    return RouterAgent(
+        billing=billing or BillingAgent(),
+        support=support or SupportAgent(),
+        returns=returns or ReturnsRemoteAgent("http://127.0.0.1:8081"),
+    )
+
+
+@pytest.mark.asyncio
+async def test_billing_scenario_mcp_tools_used() -> None:
+    """
+    User asks about duplicate charges; router -> BillingAgent; offline path calls
+    ``get_billing_info`` / ``get_support_tickets`` (same functions as the Supabase MCP server).
+    """
+    query = "I was charged twice for my last order. Can you check my billing?"
+    customer_id = "billing-scenario@example.com"
+
+    billing_payload = {
+        "customer": {
+            "id": "c1",
+            "name": "Scenario User",
+            "email": customer_id,
+        },
+        "orders": [
+            {
+                "order_number": "ORD-1001",
+                "total_amount": 49.99,
+                "status": "paid",
+            }
+        ],
+        "order_count": 1,
+    }
+    tickets_payload = {"tickets": [], "ticket_count": 0}
+
+    with (
+        patch("src.agents.billing_agent.genai_api_configured", return_value=False),
+        patch(
+            "src.agents.billing_agent.get_billing_info",
+            return_value=json.dumps(billing_payload),
+        ) as mock_billing,
+        patch(
+            "src.agents.billing_agent.get_support_tickets",
+            return_value=json.dumps(tickets_payload),
+        ) as mock_tickets,
+    ):
+        router = _make_router()
+        out = await router.route_with_meta(customer_id, query)
+
+    assert out.routed_to == "billing"
+    assert out.escalated is False
+    mock_billing.assert_called_once()
+    mock_tickets.assert_called_once()
+    # Billing explanation from offline formatter
+    assert "billing" in out.answer.lower() or "BillingAgent" in out.answer
+    assert "ORD-1001" in out.answer or "order" in out.answer.lower()
+
+
+@pytest.mark.asyncio
+async def test_returns_scenario_eligibility_path() -> None:
+    """
+    Returns query -> router picks returns; ``ReturnsRemoteAgent.check_return_eligibility``
+    is exercised with A2A stack mocked.
+    """
+    query = "I want to return order 123456. Am I eligible?"
+    customer_id = "returns-user@example.com"
+
+    returns = ReturnsRemoteAgent("http://127.0.0.1:8081")
+    router = _make_router(returns=returns)
+
+    with patch.object(returns, "handle", new_callable=AsyncMock) as mock_handle:
+        mock_handle.return_value = (
+            "For order 123456, eligibility: yes — your order qualifies for a return."
+        )
+        routed = await router.route_with_meta(customer_id, query)
+
+    assert routed.routed_to == "returns"
+    assert routed.escalated is False
+    mock_handle.assert_called_once_with(customer_id, query)
+    assert "eligible" in routed.answer.lower() or "qualif" in routed.answer.lower()
+
+    with patch(
+        "src.agents.returns_remote_agent.run_llm_agent_once",
+        new_callable=AsyncMock,
+    ) as mock_run:
+        mock_run.return_value = '{"eligible": true, "reason": "last digit even"}'
+        result = await returns.check_return_eligibility("123456")
+    mock_run.assert_awaited()
+    assert result.get("eligible") is True
+    assert "reason" in result
+
+
+@pytest.mark.asyncio
+async def test_escalation_scenario_flag() -> None:
+    """
+    Security-sensitive message -> router escalates; metadata maps to ``escalated`` on
+    :class:`~src.agents.router_agent.RouterOutcome` (HTTP API uses ``escalated`` / ``routed_to``).
+    """
+    query = (
+        "My account was hacked and all my orders disappeared "
+        "and support is ignoring me."
+    )
+    decision = RouterDecision(
+        route="support",
+        escalate=True,
+        rationale="account security / suspected compromise",
+    )
+
+    with (
+        patch("src.agents.router_agent.genai_api_configured", return_value=True),
+        patch(
+            "src.agents.router_agent.run_router_structured",
+            new_callable=AsyncMock,
+            return_value=decision,
+        ),
+    ):
+        router = _make_router()
+        out = await router.route_with_meta("cust-1", query)
+
+    assert out.escalated is True
+    assert out.routed_to == "escalate"
+    assert "[ESCALATE]" in out.answer
+    # Example metadata shape consumers may mirror
+    metadata = {"escalate": out.escalated, "routed_to": out.routed_to}
+    assert metadata["escalate"] is True

multi_agent_customer_support/tests/test_supabase_client.py

@@ -0,0 +1,107 @@
+"""Unit tests for mcp.supabase_client (mocked Supabase)."""
+
+import os
+import sys
+import unittest
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+# Resolve `mcp` from src/ when tests are run without editable install.
+_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+# Import via the `src` package (`src.mcp`) so we do not clash with PyPI `mcp` SDK.
+sys.path.insert(0, _ROOT)
+
+from src.mcp import supabase_client as sc  # noqa: E402
+
+
+class TestSupabaseClient(unittest.TestCase):
+    def setUp(self) -> None:
+        sc.reset_supabase_client_cache()
+
+    def tearDown(self) -> None:
+        sc.reset_supabase_client_cache()
+
+    def test_get_customer_by_email_empty_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            sc.get_customer_by_email("  ")
+
+    @patch.object(sc, "get_supabase_client")
+    def test_get_customer_by_email_found(self, mock_get: MagicMock) -> None:
+        row = {"id": "1", "email": "a@b.com", "name": "A"}
+        chain = MagicMock()
+        mock_get.return_value.table.return_value = chain
+        chain.select.return_value.eq.return_value.limit.return_value.execute.return_value = (
+            SimpleNamespace(data=[row])
+        )
+
+        out = sc.get_customer_by_email("a@b.com")
+        self.assertEqual(out, row)
+        chain.select.assert_called_with("*")
+        chain.select.return_value.eq.assert_called_with("email", "a@b.com")
+
+    @patch.object(sc, "get_supabase_client")
+    def test_get_customer_by_email_not_found(self, mock_get: MagicMock) -> None:
+        chain = MagicMock()
+        mock_get.return_value.table.return_value = chain
+        chain.select.return_value.eq.return_value.limit.return_value.execute.return_value = (
+            SimpleNamespace(data=[])
+        )
+        self.assertIsNone(sc.get_customer_by_email("x@y.com"))
+
+    @patch.object(sc, "get_supabase_client")
+    def test_get_customer_by_id_found(self, mock_get: MagicMock) -> None:
+        row = {"id": "uuid-1", "email": "a@b.com", "name": "A"}
+        chain = MagicMock()
+        mock_get.return_value.table.return_value = chain
+        chain.select.return_value.eq.return_value.limit.return_value.execute.return_value = (
+            SimpleNamespace(data=[row])
+        )
+
+        out = sc.get_customer_by_id("uuid-1")
+        self.assertEqual(out, row)
+        chain.select.return_value.eq.assert_called_with("id", "uuid-1")
+
+    def test_get_customer_by_id_empty_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            sc.get_customer_by_id("  ")
+
+    @patch.object(sc, "get_supabase_client")
+    def test_get_orders_by_customer(self, mock_get: MagicMock) -> None:
+        rows = [{"id": "o1", "customer_id": "c1"}]
+        chain = MagicMock()
+        mock_get.return_value.table.return_value = chain
+        chain.select.return_value.eq.return_value.order.return_value.execute.return_value = (
+            SimpleNamespace(data=rows)
+        )
+
+        out = sc.get_orders_by_customer("c1")
+        self.assertEqual(out, rows)
+        chain.select.return_value.eq.assert_called_with("customer_id", "c1")
+        chain.select.return_value.eq.return_value.order.assert_called()
+
+    @patch.object(sc, "get_supabase_client")
+    def test_get_support_tickets_by_category(self, mock_get: MagicMock) -> None:
+        rows = [{"id": "t1", "category": "billing"}]
+        chain = MagicMock()
+        mock_get.return_value.table.return_value = chain
+        chain.select.return_value.eq.return_value.order.return_value.execute.return_value = (
+            SimpleNamespace(data=rows)
+        )
+
+        out = sc.get_support_tickets_by_category("billing")
+        self.assertEqual(out, rows)
+        chain.select.return_value.eq.assert_called_with("category", "billing")
+
+    @patch.dict(
+        os.environ,
+        {"SUPABASE_URL": "", "SUPABASE_ANON_KEY": "", "SUPABASE_KEY": ""},
+        clear=False,
+    )
+    def test_configuration_error_missing_env(self) -> None:
+        sc.reset_supabase_client_cache()
+        with self.assertRaises(sc.SupabaseConfigurationError):
+            sc.get_supabase_client()
+
+
+if __name__ == "__main__":
+    unittest.main()