Make your agent eval-ready

# Commit once. No Hue SDK is needed.
import json
import os
import shutil
import tempfile
from collections.abc import Callable, Iterator
from contextlib import contextmanager


def in_hue_eval() -> bool:
    """True only in the process `hue eval` started for a case with a world.

    `hue eval --command` always sets HUE_EXECUTION_ID; a case it started without HUE_WORLD_TOKEN
    has no world (the simulation gateway does not serve it), so running the agent would reach
    the real app: refuse.
    """
    if os.environ.get("HUE_WORLD_TOKEN"):
        return True
    if os.environ.get("HUE_EXECUTION_ID"):
        raise RuntimeError(
            "Hue eval: this case has no world handoff (HUE_WORLD_TOKEN is not set); "
            "refusing to run the agent against the real app"
        )
    return False


def app_endpoint(variable: str, production: Callable[[], tuple[str, str]]) -> tuple[str, str]:
    """One app's (url, bearer): the Hue mirror during an evaluation, production otherwise.

    `production` is a function so the real credential is never read during an evaluation.
    """
    if not in_hue_eval():
        return production()
    url = os.environ.get(variable)
    if not url:
        raise RuntimeError(
            f"Hue eval: {variable} is not set, so this world has no mirror for the app; "
            "refusing to call the real one"
        )
    return url, os.environ["HUE_WORLD_TOKEN"]


@contextmanager
def mcp_servers_file(production: str, mirrors: dict[str, str]) -> Iterator[str]:
    """An `mcpServers` file for a framework that loads one, as a context manager.

    Production: yields your file, untouched. Evaluation: yields a private copy that keeps your
    server names, so tool names stay what production has, and replaces each server's url and
    headers with its mirror's, then removes the copy and the world token in it when the block
    ends. `mirrors` maps every server name to its `HUE_SIM_<SURFACE>_URL` variable; an unmapped
    server fails closed.
    """
    if not in_hue_eval():
        yield production
        return
    with open(production, encoding="utf-8") as file:
        config = json.load(file)
    # Only the common shape (`url` or `command`) is rewritten. A client-specific field such as
    # `serverUrl` or `httpUrl` would keep pointing at the real app, so any other key fails closed.
    known = {"type", "url", "headers", "command", "args", "env"}
    for name, server in config["mcpServers"].items():
        variable = mirrors.get(name)
        if not variable:
            raise RuntimeError(f"Hue eval: MCP server {name} has no mirror variable; refusing to reach the real one")
        unknown = sorted(set(server) - known)
        if unknown:
            raise RuntimeError(f"Hue eval: MCP server {name} uses {', '.join(unknown)}; rewrite that field for your client")
        url, token = app_endpoint(variable, lambda: ("", ""))
        config["mcpServers"][name] = {"type": "http", "url": url, "headers": {"Authorization": f"Bearer {token}"}}
    directory = tempfile.mkdtemp(prefix="hue-mcp-")
    try:
        path = os.path.join(directory, "mcp.json")
        with open(os.open(path, os.O_WRONLY | os.O_CREAT, 0o600), "w", encoding="utf-8") as file:
            json.dump(config, file)
        yield path
    finally:
        shutil.rmtree(directory, ignore_errors=True)

from agents import Agent
from agents.mcp import MCPServerStreamableHttp
from hue_eval import app_endpoint

url, token = app_endpoint(
    "HUE_SIM_GOOGLE_GMAIL_MCP_URL",
    lambda: ("https://gmailmcp.googleapis.com/mcp/v1", read_google_access_token()),
)
async with MCPServerStreamableHttp(
    name="gmail",
    params={"url": url, "headers": {"Authorization": f"Bearer {token}"}},
) as server:
    agent = Agent(name="Inbox agent", instructions=instructions, mcp_servers=[server])

import Anthropic from "@anthropic-ai/sdk";
import { appEndpoint } from "./hue-eval";

const gmail = appEndpoint("HUE_SIM_GOOGLE_GMAIL_MCP_URL", () => ({
  url: "https://gmailmcp.googleapis.com/mcp/v1",
  token: readGoogleAccessToken(),
}));
const response = await new Anthropic().beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 16000,
  betas: ["mcp-client-2025-11-20"],
  mcp_servers: [{ type: "url", url: gmail.url, name: "gmail", authorization_token: gmail.token }],
  tools: [{ type: "mcp_toolset", mcp_server_name: "gmail" }],
  messages: [{ role: "user", content: task }],
});