agentenv-framework 0.9.1254__py3-none-any.whl

agent_env/env/gateway/clock.py

@@ -0,0 +1,184 @@
+"""Wall-clock-derived virtual clock for the env gateway (urn:agentenv:clock/v1).
+
+Reads compute t0 + real_elapsed * rate, so virtual time advances on its own (independent of
+tool calls) and reads never mutate it. Off by default: an unarmed clock 404s.
+"""
+from __future__ import annotations
+
+import math
+import re
+import threading
+import time
+from datetime import datetime, timedelta, timezone
+
+
+class ClockError(ValueError):
+    """Invalid clock configuration (surfaced as HTTP 400)."""
+
+
+MAX_RATE = 86400.0  # 1 real second = 1 virtual day (the max virtual-time speed)
+
+# Fast-fail a t0 that would overflow within a real day of advancement at `rate` (frozen clocks
+# exempt). Not the overflow guarantee — reads still saturate (_advance) if the gateway outlives it.
+_OVERFLOW_HORIZON_S = 86400.0
+_MAX_T0 = datetime.max.replace(tzinfo=timezone.utc)
+
+
+def _parse_rate(rate) -> float:
+    if isinstance(rate, bool) or not isinstance(rate, (int, float)):
+        raise ClockError(f"rate must be a number, got {type(rate).__name__}")
+    # NaN passes both ordered bounds below, then poisons every later read with an uncatchable 500.
+    if not math.isfinite(rate):
+        raise ClockError(f"rate must be a finite number, got {rate}")
+    if rate < 0:
+        raise ClockError("rate must be non-negative")
+    if rate > MAX_RATE:
+        raise ClockError(f"rate {rate:g} exceeds max {MAX_RATE:g} (1 real s = 1 virtual day)")
+    return float(rate)
+
+
+# fromisoformat is looser than RFC3339 (accepts basic format, week/ordinal dates, sub-minute
+# offsets), so gate on the grammar first and let it do only the arithmetic. A space separator is ok.
+_RFC3339_RE = re.compile(
+    r"""^\d{4}-\d{2}-\d{2}
+        [Tt ]
+        \d{2}:\d{2}:\d{2}           # seconds are mandatory
+        (?:\.\d+)?
+        (?:[Zz]|[+-]\d{2}:\d{2})$   # offset is hours:minutes only, or Z
+    """,
+    re.VERBOSE,
+)
+_RFC3339_SHAPE = "YYYY-MM-DDThh:mm:ss[.fff](Z|+hh:mm)"
+
+
+def _parse_rfc3339(text: str) -> datetime:
+    if not isinstance(text, str):
+        raise ClockError(f"virtual_time must be an RFC3339 string, got {type(text).__name__}")
+    # Don't strip: a whitespace-wrapped value would slip through the anchored grammar (a 200 the contract calls a 400).
+    raw = text
+    if not _RFC3339_RE.match(raw):
+        raise ClockError(f"invalid RFC3339 virtual_time {text!r}: expected {_RFC3339_SHAPE}")
+    if raw.endswith(("Z", "z")):
+        raw = raw[:-1] + "+00:00"
+    try:
+        dt = datetime.fromisoformat(raw)
+    except ValueError as e:
+        raise ClockError(f"invalid RFC3339 virtual_time {text!r}: {e}")
+    try:
+        return dt.astimezone(timezone.utc)
+    except OverflowError:
+        raise ClockError(f"invalid RFC3339 virtual_time {text!r}: out of representable range")
+
+
+def _iso(dt: datetime) -> str:
+    return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+# Calendar Y/M are absent on purpose: a month is not a fixed span. Empty ("P"/"PT") is caught by the
+# any-group check in _parse_duration, not here.
+_ISO8601_DURATION_RE = re.compile(
+    r"""^P (?:(\d+)W)? (?:(\d+)D)?           # weeks / days
+          (?: T (?:(\d+)H)? (?:(\d+)M)?      # hours / minutes ('M' is months before T, minutes after)
+                (?:(\d+(?:\.\d+)?)S)? )? $   # seconds, optionally fractional
+    """,
+    re.VERBOSE,
+)
+
+
+def _parse_duration(text) -> timedelta:
+    if not isinstance(text, str):
+        raise ClockError(f"duration must be an ISO-8601 string, got {type(text).__name__}")
+    m = _ISO8601_DURATION_RE.match(text)
+    if m is None or not any(m.groups()):
+        raise ClockError(f"invalid ISO-8601 duration {text!r}: expected e.g. 'PT24H', 'P1DT6H', 'PT30M'")
+    weeks, days, hours, minutes, seconds = m.groups()
+    try:
+        return timedelta(weeks=int(weeks or 0), days=int(days or 0), hours=int(hours or 0),
+                         minutes=int(minutes or 0), seconds=float(seconds or 0))
+    except (OverflowError, ValueError):
+        raise ClockError(f"invalid ISO-8601 duration {text!r}: out of representable range")
+
+
+def _advance(t0: datetime, seconds: float) -> datetime:
+    """t0 + seconds, saturating at datetime.min/max instead of raising.
+
+    set_time's horizon check can't bound a gateway that outlives _OVERFLOW_HORIZON_S, so reads
+    saturate rather than 500 — an armed clock always returns a (monotonic) time.
+    """
+    try:
+        return t0 + timedelta(seconds=seconds)
+    except (OverflowError, ValueError, OSError):
+        return _MAX_T0 if seconds > 0 else datetime.min.replace(tzinfo=timezone.utc)
+
+
+class Clock:
+    """Gateway-owned virtual clock — wall-clock-driven, monotonic, threadsafe; `now_fn` injectable for tests."""
+
+    def __init__(self, now_fn=time.monotonic):
+        self._now = now_fn
+        self._lock = threading.Lock()
+        self._armed = False
+        self._t0: datetime | None = None
+        self._anchor: float | None = None
+        self._rate = 1.0
+        self._generation = 0
+
+    @property
+    def armed(self) -> bool:
+        return self._armed
+
+    @property
+    def generation(self) -> int:
+        """Bumped on every arm/clear — lets consumers detect a re-anchor and drop stale derived state."""
+        return self._generation
+
+    def t0(self) -> datetime | None:
+        """The armed anchor virtual time (None when unarmed) — for time-trigger mark resolution."""
+        with self._lock:
+            return self._t0
+
+    def set_time(self, virtual_time: str, rate=1.0) -> dict:
+        """Arm/re-arm: anchor t0=virtual_time to now, advancing at `rate` virtual s per real s."""
+        t0 = _parse_rfc3339(virtual_time)
+        r = _parse_rate(1.0 if rate is None else rate)
+        if t0 > _MAX_T0 - timedelta(seconds=_OVERFLOW_HORIZON_S * r):
+            raise ClockError(f"virtual_time {virtual_time!r} at rate {r:g} would overflow datetime near the max")
+        with self._lock:
+            self._t0 = t0
+            self._anchor = self._now()
+            self._rate = r
+            self._armed = True
+            self._generation += 1
+        return self.state()
+
+    def clear(self) -> dict:
+        """Disarm (idempotent). Afterwards reads 404."""
+        with self._lock:
+            self._armed = False
+            self._t0 = None
+            self._anchor = None
+            self._rate = 1.0
+            self._generation += 1
+        return {"ok": True, "armed": False}
+
+    def now(self) -> datetime | None:
+        with self._lock:
+            if not self._armed or self._t0 is None:
+                return None
+            elapsed = self._now() - self._anchor
+            return _advance(self._t0, elapsed * self._rate)
+
+    def read(self) -> dict:
+        """The frozen consumer contract: {"virtual_time": "<RFC3339>"} — pure read, never advances."""
+        current = self.now()
+        if current is None:
+            raise ClockError("clock is not armed")
+        return {"virtual_time": _iso(current)}
+
+    def state(self) -> dict:
+        with self._lock:
+            if not self._armed or self._t0 is None:
+                return {"armed": False}
+            elapsed = self._now() - self._anchor
+            return {"armed": True, "t0": _iso(self._t0), "virtual_seconds_per_real_second": self._rate,
+                    "virtual_time": _iso(_advance(self._t0, elapsed * self._rate))}

agent_env/env/gateway/constants.py

@@ -0,0 +1,190 @@
+"""Gateway constants shared with the data-plane client call sites.
+
+Lives inside the gateway package so gateway.py can reach it with a relative
+import — the gateway runs as a standalone container with no `agent_env` package.
+Client call sites (MCPServerEnv/WebsiteEnv) import it by absolute path. One
+source of truth keeps the layers ordered: client add_data >= gateway REST
+proxy >= actual load time.
+"""
+
+import os
+from enum import Enum
+from uuid import uuid4
+import secrets
+
+# Max end-to-end time for a single service's data load (seconds).
+#
+# The previous value of 600 was sized above a then-slowest prod load of ~430s.
+# That is no longer the ceiling: a large universe's gmail component now takes 498s and slack
+# 499s, leaving under 20% headroom on a number chosen to have plenty.
+#
+# The margin matters more than the average because of how a load fails. A
+# component that exceeds this does not retry — the environment comes up, reports
+# healthy, and serves zero rows, which is indistinguishable from a component that
+# is legitimately empty. Paying a few extra minutes on a genuine hang is much
+# cheaper than that.
+#
+# The real fix is capacity, not patience: a universe loads all its components
+# through one asyncio.gather onto a VM defaulting to a single vCPU, and the
+# loaders are CPU-bound. This value should come back down once that is sized
+# properly.
+DATA_PLANE_LOAD_TIMEOUT_S = 900
+
+# Extra seconds granted per GB of payload, on top of the floor.
+#
+# Explicitly a heuristic, not a model. Measured load cost tracks RECORD COUNT, not bytes:
+# github moved 3.5GB in 89s while gmail took 206s for 409MB and slack 207s for 86.6MB (~20x
+# and ~94x worse per byte). So size is a weak proxy -- it over-grants to the big-blob
+# services that never needed it and under-grants to the small record-heavy ones that do.
+# It is still strictly better than a flat cap, because the flat cap's failure mode was
+# killing healthy work. A real fix is a stall timeout (fail on no progress rather than on
+# elapsed time), which needs the server to report progress mid-ingest.
+DATA_PLANE_LOAD_TIMEOUT_PER_GB_S = 1200
+
+# Ceiling, so a genuinely hung load on a huge payload still surfaces in bounded time
+# instead of holding a worker slot and a billable VM for hours.
+DATA_PLANE_LOAD_TIMEOUT_MAX_S = 3600
+
+
+def data_plane_load_timeout_s(size_bytes: int | None) -> int:
+    """Read timeout for one service's data load, scaled by payload size.
+
+    ``None``/0 (size unknown) yields the floor, which is today's behaviour -- an
+    unmeasurable payload must not silently get an unbounded wait.
+    """
+    if not size_bytes or size_bytes <= 0:
+        return DATA_PLANE_LOAD_TIMEOUT_S
+    gb = size_bytes / 1_000_000_000
+    return int(min(
+        DATA_PLANE_LOAD_TIMEOUT_MAX_S,
+        DATA_PLANE_LOAD_TIMEOUT_S + gb * DATA_PLANE_LOAD_TIMEOUT_PER_GB_S,
+    ))
+
+# Hand-rolled mirror of agentenv_protocol.types — the gateway container has no
+# agentenv_protocol dependency. Keep byte-identical to that module.
+WELL_KNOWN_PATH = "/.well-known/agent-env.json"
+RPC_PATH = "/agentenv"
+PROTOCOL_VERSION = "1.0"
+METHOD_RESET = "data/reset"
+METHOD_ADD = "data/add"
+METHOD_GET = "data/get"
+MCP_TRANSPORT = "mcp"
+
+# Env/gateway-level extensions the gateway itself owns (tool gating + triggers).
+EXT_DISABLE_TOOL_URI = "urn:agentenv:disable-tool/v1"
+EXT_ENABLE_TOOL_URI = "urn:agentenv:enable-tool/v1"
+EXT_TRIGGERS_URI = "urn:agentenv:triggers/v1"
+EXT_CLOCK_URI = "urn:agentenv:clock/v1"
+EXT_TRAJECTORY_URI = "urn:agentenv:trajectory/v1"
+EXT_STEP_URI = "urn:agentenv:step/v1"
+EXT_STATE_URI = "urn:agentenv:state/v1"
+
+# Gateway's compose service name — how backing servers reach it to build env_get_time_url (compose path).
+GATEWAY_COMPOSE_HOST = "gateway"
+
+# Per-child card fetch budget (seconds) when composing the env card.
+CARD_FETCH_TIMEOUT_S = 5.0
+
+# Trigger status vocabulary, part of the GET /triggers/state contract; `state` asserts against it.
+TRIGGER_STATUSES = ("armed", "firing", "queued", "fired", "failed")
+
+# A fire is in flight; `queued` also has further provoking calls already waiting to be drained.
+TRIGGER_IN_FLIGHT_STATUSES = ("firing", "queued")
+
+GATEWAY_TRAJECTORY_FILE = os.environ.get(
+    "GATEWAY_TRAJECTORY_FILE",
+    f"/tmp/agentenv/{uuid4().hex[:8]}-trajectory.jsonl",
+)
+
+AGENT_ENV_ROLE_HEADER = "AgentEnv-Role"
+DEFAULT_ROLE = "default"
+WILDCARD = "*"
+TOOL_DISABLE_ACTION = "disable"
+TOOL_ENABLE_ACTION = "enable"
+
+
+class GatewayMode(str, Enum):
+    PERFORMANCE = "performance"
+    CONSISTENT = "consistent"
+
+
+DEFAULT_MCP_SERVER_NAME = "env"
+
+
+def random_mcp_server_name() -> str:
+    """`env` + 4 random digits: undeclared envs on one agent never collide; declare a MultiEnv name for a stable one."""
+    return f"env{secrets.randbelow(10000):04d}"
+
+
+# The gateway's own extensions, as its env card advertises them; here so kernel code can read them without importing gateway.py.
+_TOOLS_REQUEST = {
+    "type": "object",
+    "properties": {
+        "role": {"type": "string"},
+        "tools": {"anyOf": [{"type": "array", "items": {"type": "string"}}, {"const": WILDCARD}]},
+    },
+    "required": ["role", "tools"],
+}
+# call_tool also needs a tool_name; if/then rather than oneOf keeps the fields top-level, where card viewers read them
+_STEP_REQUEST = {
+    "type": "object",
+    "properties": {"action": {"enum": ["list_tools", "call_tool"]}, "tool_name": {"type": "string", "minLength": 1}, "arguments": {"type": "object"}},
+    "required": ["action"],
+    "if": {"properties": {"action": {"const": "call_tool"}}},
+    "then": {"required": ["tool_name"]},
+}
+GATEWAY_EXTENSIONS = [
+    {
+        "uri": EXT_DISABLE_TOOL_URI,
+        "description": "Disable tools for a role.",
+        "params": {"endpoint": f"/tools/{TOOL_DISABLE_ACTION}", "methods": {TOOL_DISABLE_ACTION: {"method": "POST", "request": _TOOLS_REQUEST}}},
+        "required": False,
+    },
+    {
+        "uri": EXT_ENABLE_TOOL_URI,
+        "description": "Enable tools for a role.",
+        "params": {"endpoint": f"/tools/{TOOL_ENABLE_ACTION}", "methods": {TOOL_ENABLE_ACTION: {"method": "POST", "request": _TOOLS_REQUEST}}},
+        "required": False,
+    },
+    {
+        "uri": EXT_TRIGGERS_URI,
+        "description": "Register (additive add-by-id), remove, clear, or read (state) typed Action/State triggers + the firing log (harness control path).",
+        "params": {"endpoint": "/triggers/register", "methods": {
+            "register": {"method": "POST", "endpoint": "/triggers/register", "request": {"type": "object", "properties": {"watch_roles": {"type": "array", "items": {"type": "string"}}, "executor": {"type": "object"}, "triggers": {"type": "array"}}, "required": ["triggers"]}},
+            "remove": {"method": "POST", "endpoint": "/triggers/remove", "request": {"type": "object", "properties": {"ids": {"type": "array", "items": {"type": "string"}}}, "required": ["ids"]}},
+            "clear": {"method": "POST", "endpoint": "/triggers/clear", "request": {"type": "object", "properties": {}}},
+            "state": {"method": "GET", "endpoint": "/triggers/state", "request": {"type": "object", "properties": {}}}}},
+        "required": False,
+    },
+    {
+        "uri": EXT_CLOCK_URI,
+        "description": "Virtual clock (urn:agentenv:clock/v1): read the gateway's virtual time (wall-clock-derived, rate-scaled) via get_time; set-time/clear are the harness control path.",
+        "params": {"endpoint": "/clock/time", "methods": {
+            "get_time": {"method": "GET", "endpoint": "/clock/time"},
+            "set_time": {"method": "PUT", "endpoint": "/clock/set-time", "request": {"type": "object", "properties": {"virtual_time": {"type": "string"}, "virtual_seconds_per_real_second": {"type": "number"}}, "required": ["virtual_time"]}},
+            "clear": {"method": "POST", "endpoint": "/clock/clear", "request": {"type": "object", "properties": {}}},
+            "state": {"method": "GET", "endpoint": "/clock/state", "request": {"type": "object", "properties": {}}}}},
+        "required": False,
+    },
+    {
+        "uri": EXT_TRAJECTORY_URI,
+        "description": "Env trajectory (urn:agentenv:trajectory/v1): the env's append-only JSONL record of tool calls, results, and trigger firings, virtual_time-stamped while the clock is armed.",
+        "params": {"endpoint": "/trajectory", "methods": {
+            "get": {"method": "GET", "endpoint": "/trajectory"}}},
+        "required": False,
+    },
+    {
+        "uri": EXT_STEP_URI,
+        "description": "Step (urn:agentenv:step/v1): list or call the env's tools over REST, filtered by the AgentEnv-Role header.",
+        "params": {"endpoint": "/step", "methods": {
+            "step": {"method": "POST", "endpoint": "/step", "request": _STEP_REQUEST}}},
+        "required": False,
+    },
+    {
+        "uri": EXT_STATE_URI,
+        "description": "State (urn:agentenv:state/v1): the env's MCP servers and their tools, its changelog id and its role rules.",
+        "params": {"endpoint": "/state", "methods": {
+            "get": {"method": "GET", "endpoint": "/state"}}},
+        "required": False,
+    },
+]

agent_env/env/gateway/entrypoint.py

@@ -0,0 +1,156 @@
+"""Entry point for the Gateway container."""
+import asyncio
+import logging
+import os
+import time
+
+import httpx
+
+from . import AGENT_ENV_GATEWAY_MCP_PORT, GatewayMode, InternalMCPServer
+from .constants import DEFAULT_MCP_SERVER_NAME
+from .gateway import Gateway
+
+logger = logging.getLogger(__name__)
+
+
+def parse_internal_servers(spec: str, port: int) -> list[InternalMCPServer]:
+    servers: list[InternalMCPServer] = []
+    seen_names: set[str] = set()
+    if not spec.strip():
+        return servers
+    for entry in spec.split(","):
+        entry = entry.strip()
+        if not entry:
+            continue
+        if "=" in entry:
+            name, url = entry.split("=", 1)
+            name = name.strip()
+            url = url.strip()
+            if not name or not url:
+                raise ValueError(f"Invalid INTERNAL_MCP_SERVERS entry: '{entry}' (expected 'name=url' or 'name')")
+        else:
+            name = entry
+            url = f"http://{name}:{port}/mcp"
+        if name in seen_names:
+            raise ValueError(f"Duplicate internal server name: '{name}'")
+        seen_names.add(name)
+        servers.append(InternalMCPServer(name=name, mcp_url=url))
+    return servers
+
+
+# How long to wait for each internal MCP server to become ready before giving
+# up. Generous + configurable so a slow-starting server (image pull, DB
+# migration, warmup) doesn't trip a premature failure that crash-loops the
+# gateway. In Modal/container mode this is the *only* readiness gate (there's no
+# docker-compose `depends_on`), so the old 30s ceiling was far too short.
+_INTERNAL_SERVER_TIMEOUT_S = int(os.environ.get("GATEWAY_INTERNAL_SERVER_TIMEOUT_S", "180"))
+_INTERNAL_SERVER_POLL_S = 2
+
+
+def _ready_url(mcp_url: str) -> str:
+    """The server's /ready URL (root sibling of /mcp)."""
+    base = mcp_url.rstrip("/")
+    if base.endswith("/mcp"):
+        base = base[: -len("/mcp")]
+    return f"{base}/ready"
+
+
+async def _wait_for_server(name: str, mcp_url: str, timeout_s: int = _INTERNAL_SERVER_TIMEOUT_S) -> bool:
+    """Wait until an internal MCP server is ready.
+
+    Prefer the server's ``/ready`` endpoint (HTTP 200 = fully initialised). If
+    the server has no ``/ready`` (older image → 404), fall back to the ``/mcp``
+    endpoint merely responding (<500). Poll up to ``timeout_s`` so a slow server
+    doesn't make the gateway give up and crash-loop.
+    """
+    ready_url = _ready_url(mcp_url)
+    deadline = time.monotonic() + timeout_s
+    last = "no response"
+    async with httpx.AsyncClient() as client:
+        while time.monotonic() < deadline:
+            try:
+                r = await client.get(ready_url, timeout=5)
+                if r.status_code == 200:
+                    logger.info(f"  {name} ready via /ready (200)")
+                    return True
+                # No usable /ready: 404 = no such route; some MCP servers (e.g.
+                # @playwright/mcp, used by the website-browser companion) answer
+                # 400 to a plain GET /ready. In every non-200 case fall back to
+                # /mcp liveness and keep waiting.
+                m = await client.get(mcp_url, timeout=5)
+                if m.status_code < 500:
+                    logger.info(f"  {name} ready via /mcp fallback (/ready={r.status_code}, /mcp={m.status_code})")
+                    return True
+                last = f"/ready={r.status_code} /mcp={m.status_code}"
+            except Exception as e:
+                last = type(e).__name__
+            logger.info(f"  {name} not ready yet ({last}); retrying...")
+            await asyncio.sleep(_INTERNAL_SERVER_POLL_S)
+    logger.error(f"{name} not ready after {timeout_s}s (last: {last})")
+    return False
+
+
+async def wait_for_internal_servers(servers: list[InternalMCPServer]) -> None:
+    """Wait for all internal servers to be ready. Raises if any never come up."""
+    t0 = time.monotonic()
+    for server in servers:
+        logger.info(f"Waiting for {server.name} at {server.mcp_url} (timeout {_INTERNAL_SERVER_TIMEOUT_S}s)...")
+    results = await asyncio.gather(*[_wait_for_server(s.name, s.mcp_url) for s in servers])
+    for server, ready in zip(servers, results):
+        if not ready:
+            raise RuntimeError(f"Internal server '{server.name}' not ready at {server.mcp_url}")
+        logger.info(f"Internal MCP server {server.name} is ready")
+    logger.info(f"All {len(servers)} internal MCP server(s) ready in {time.monotonic() - t0:.1f}s")
+
+
+def parse_name_url_map(env_str: str) -> dict[str, str]:
+    # Expected format: 'slack=http://slack-website-backend:8000,email=http://email-website-backend:8000'
+    urls: dict[str, str] = {}
+    if not env_str.strip():
+        return urls
+    for entry in env_str.split(","):
+        entry = entry.strip()
+        if not entry:
+            continue
+        if "=" not in entry:
+            raise ValueError(f"Invalid REST_PROXY_URLS entry: '{entry}' (expected 'name=url')")
+        name, url = entry.split("=", 1)
+        name = name.strip()
+        url = url.strip()
+        if not name:
+            raise ValueError(f"Empty service name in REST_PROXY_URLS entry: '{entry}'")
+        if not url.startswith(("http://", "https://")):
+            raise ValueError(f"Invalid URL in REST_PROXY_URLS: '{url}' (must start with http:// or https://)")
+        if name in urls:
+            raise ValueError(f"Duplicate service name in REST_PROXY_URLS: '{name}'")
+        urls[name] = url
+    return urls
+
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+    internal_mcp_servers = parse_internal_servers(
+        spec=os.environ.get("INTERNAL_MCP_SERVERS", ""),
+        port=int(os.environ.get("INTERNAL_MCP_PORT", str(AGENT_ENV_GATEWAY_MCP_PORT))),
+    )
+    asyncio.run(wait_for_internal_servers(internal_mcp_servers))
+
+    website_urls = parse_name_url_map(os.environ.get("WEBSITE_URLS", ""))
+    rest_proxy_urls = parse_name_url_map(os.environ.get("REST_PROXY_URLS", ""))
+    gateway_mode = GatewayMode(os.environ.get("GATEWAY_MODE", GatewayMode.PERFORMANCE.value))
+    service_db_url = os.environ.get("SERVICE_DB_URL")
+    gateway = Gateway(
+        host=os.environ.get("MCP_HOST", "0.0.0.0"),
+        port=int(os.environ.get("MCP_PORT", str(AGENT_ENV_GATEWAY_MCP_PORT))),
+        server_name=os.environ.get("MCP_SERVER_NAME") or DEFAULT_MCP_SERVER_NAME,
+        internal_mcp_servers=internal_mcp_servers,
+        website_urls=website_urls,
+        rest_proxy_urls=rest_proxy_urls,
+        gateway_mode=gateway_mode,
+        service_db_url=service_db_url,
+    )
+    gateway.run()