deploy: unified ZAI marine agent

DEPLOY.md

@@ -13,6 +13,18 @@ Recommended Space Secret:
 Required Space Variable:
 - `MARINE_API_URL`
 
+For the school deployment, keep `MARINE_API_URL=http://127.0.0.1:8000` and set
+`MARINE_PROXY_UPSTREAM_URL=http://127.0.0.1:8000`. The fixed ngrok web domain
+continues to point to port 7861; requests sent to `/marine/...` are forwarded
+to the local Marine API. On Hugging Face, set `MARINE_API_URL` to the public
+web URL with the `/marine` suffix, for example:
+`https://subway-unbiased-barcode.ngrok-free.dev/marine`.
+
+When the school network cannot reach Hugging Face, set these school-only
+variables so fisheries inventory and downloads use the local mirror:
+- `LOCAL_SQUID_DATA_ROOT=/data0/zqyan/squid_data/raw`
+- `LOCAL_TUNA_DATA_ROOT=/data0/zqyan/tuna_data/raw`
+
 Optional Space Variables:
 - `HF_SQUID_DATASET_REPO` (default `globalsquiddatabase/squid_dataset`)
 - `HF_TUNA_DATASET_REPO` (default `globalsquiddatabase/Tuna-Fisheries-Dataset`)

DEPLOY_UNIFIED.md

@@ -0,0 +1,46 @@
+# Unified deployment notes
+
+This package is intentionally the same source tree for the Hugging Face Space
+and the school server.  Deployment settings, not separate code branches,
+select the data plane.
+
+## School server
+
+Set `MARINE_API_URL=http://127.0.0.1:8000` and
+`MARINE_PROXY_UPSTREAM_URL=http://127.0.0.1:8000`.  If local data mirrors are
+available, set `LOCAL_SQUID_DATA_ROOT=/data0/zqyan/squid_data/raw` and
+`LOCAL_TUNA_DATA_ROOT=/data0/zqyan/tuna_data/raw`.
+
+The public ngrok URL exposes the UI on `/` and the Marine API through
+`/marine/*`.  Therefore its health endpoint is `/marine/health`, not `/health`.
+
+## Hugging Face Space
+
+Set the following Variables:
+
+- `MARINE_API_URL=https://subway-unbiased-barcode.ngrok-free.dev/marine`
+- `CODEX_PROVIDER=zai`
+- `CODEX_MODEL=glm-5.3`
+- `CODEX_HARNESS_RUNTIME=native`
+- `REQUIRE_CODEX_HARNESS=1`
+
+Set these Secrets:
+
+- `ZAI_API_KEY`
+- `CODEWHALE_RUNTIME_TOKEN`
+- `HF_TOKEN` when the fisheries datasets require authenticated reads
+
+Do not set `MARINE_PROXY_UPSTREAM_URL` or local data-root variables in the
+Space.  They belong only to the school server.
+
+## Runtime behavior
+
+The following read-only requests bypass the model and are returned by the
+application directly: greetings, runtime identity, Marine health, and
+metadata-only Tuna/Squid file inventories.  This makes these operations fast
+and avoids the non-interactive MCP approval problem.
+
+Actual Ocean exports and fisheries content analysis remain guarded operations
+through the official Codex CLI Harness.  Do not enable
+`CODEX_ALLOW_MCP_BYPASS` by default: it passes the Codex CLI's dangerous
+approval-and-sandbox bypass flag and is not suitable for a public deployment.

README.md

@@ -5,11 +5,12 @@ colorFrom: blue
 colorTo: indigo
 sdk: docker
 app_port: 7860
+pinned: false
 ---
 
 # Global Marine Foundation Data Agent
 
-Current UI release: **v4.3.0**.
+Current UI release: **v4.3.2**.
 
 
 ## v3.4.0 稳定性重构（第一阶段）

codex_native_harness.py

@@ -105,6 +105,15 @@ class CodexNativeHarness:
             command.extend(
                 ["--disable", "responses_websockets", "--disable", "responses_websockets_v2"]
             )
+        # Current Codex CLI releases may still cancel stdio MCP calls from
+        # non-interactive `codex exec` after stdin is closed, even when the
+        # MCP server's default_tools_approval_mode is `approve`.  Keep the
+        # broader bypass opt-in and disabled by default; it is only for a
+        # trusted deployment whose operator explicitly accepts the tradeoff.
+        if os.environ.get("CODEX_ALLOW_MCP_BYPASS", "").strip().lower() in {
+            "1", "true", "yes", "on"
+        }:
+            command.append("--dangerously-bypass-approvals-and-sandbox")
         command.extend(
             [
                 "--skip-git-repo-check",

fisheries_hf.py

@@ -40,6 +40,9 @@ HF_DATASET_REPOS = {
 }
 # Backwards-compatible default used when old callers omit a repository.
 HF_DATASET_REPO = HF_SQUID_DATASET_REPO
+LOCAL_SQUID_DATA_ROOT = Path(os.environ.get("LOCAL_SQUID_DATA_ROOT", "").strip()).expanduser() if os.environ.get("LOCAL_SQUID_DATA_ROOT", "").strip() else None
+LOCAL_TUNA_DATA_ROOT = Path(os.environ.get("LOCAL_TUNA_DATA_ROOT", "").strip()).expanduser() if os.environ.get("LOCAL_TUNA_DATA_ROOT", "").strip() else None
+LOCAL_DATA_ROOTS = {"squid": LOCAL_SQUID_DATA_ROOT, "tuna": LOCAL_TUNA_DATA_ROOT}
 HF_SQUID_DATASET_REVISION = (
     os.environ.get("HF_SQUID_DATASET_REVISION")
     or os.environ.get("HF_DATASET_REVISION")
@@ -87,7 +90,37 @@ def normalize_repository(repository: str | None = None) -> str:
     raise ValueError("repository must be squid, tuna, or an exact configured repository id")
 
 
+def local_root_for_repository(repository: str | None = None) -> Path | None:
+    """Return the configured local mirror root for a logical repository."""
+    value = str(repository or "squid").strip()
+    domain = value.lower() if value.lower() in LOCAL_DATA_ROOTS else None
+    if domain is None:
+        for key, repo in HF_DATASET_REPOS.items():
+            if value == repo:
+                domain = key
+                break
+    root = LOCAL_DATA_ROOTS.get(domain or "")
+    if root and root.is_dir():
+        return root.resolve()
+    return None
+
+
+def local_dataset_tree(repository: str | None = None) -> list[dict[str, Any]]:
+    """List supported files from a local school-server mirror."""
+    root = local_root_for_repository(repository)
+    if root is None:
+        return []
+    items: list[dict[str, Any]] = []
+    for path in root.rglob("*"):
+        if not path.is_file() or path.suffix.lower() not in {".csv", ".tsv", ".zip"}:
+            continue
+        items.append({"path": path.relative_to(root).as_posix(), "type": "file", "size": path.stat().st_size})
+    return sorted(items, key=lambda item: str(item["path"]))
+
+
 def _revision(repository: str) -> str:
+    if local_root_for_repository(repository) is not None:
+        return "local"
     pinned = (
         HF_TUNA_DATASET_REVISION
         if repository == HF_TUNA_DATASET_REPO
@@ -143,6 +176,17 @@ def download_dataset_file(
 
     repository = normalize_repository(repository)
     revision = _revision(repository)
+    local_root = local_root_for_repository(repository)
+    if local_root is not None:
+        candidate = (local_root / clean).resolve()
+        if local_root not in candidate.parents and candidate != local_root:
+            raise ValueError("invalid local dataset path")
+        if not candidate.is_file():
+            raise FileNotFoundError(f"本地数据文件不存在：{clean}")
+        actual_size = candidate.stat().st_size
+        if expected_size and actual_size != expected_size:
+            raise RuntimeError(f"本地文件大小不一致：expected={expected_size}, actual={actual_size}")
+        return candidate, revision
     target = _safe_cache_path(repository, clean, revision)
     if target.exists() and target.stat().st_size == expected_size:
         return target, revision

marine_mcp.py

@@ -4,7 +4,7 @@ import os, re, time
 from typing import Any
 import httpx
 from mcp.server.mcpserver import MCPServer
-from fisheries_hf import analyze_and_export, download_dataset_file
+from fisheries_hf import analyze_and_export, download_dataset_file, local_dataset_tree
 
 API_URL = os.environ.get("MARINE_API_URL", "").strip().rstrip("/")
 if not API_URL:
@@ -326,6 +326,9 @@ def _hf_headers() -> dict[str, str]:
 
 def _hf_tree(repo: str, force: bool = False) -> list[dict[str, Any]]:
     repo = repo.strip()
+    local_items = local_dataset_tree(repo)
+    if local_items:
+        return local_items
     now = time.time()
     cache = _HF_TREE_CACHE.get(repo) or {}
     if (

services/chat_runtime.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import os
+
 # P0 chat runtime service.
 # Dependencies are injected once from ui_server during app assembly so the
 # large streaming/runtime logic is no longer owned by the entry module.
@@ -636,6 +638,204 @@ async def harness_stream_chat(tid,prompt):
 DATA_REQUEST_TTL_SECONDS = 6 * 3600
 
 
+def _is_runtime_info_prompt(prompt: str) -> bool:
+    """Recognize the read-only deployment-info question locally."""
+    text = str(prompt or "").strip().lower()
+    return (
+        ("供应商" in text or "provider" in text)
+        and ("模型" in text or "model" in text)
+        and ("运行时" in text or "runtime" in text)
+        and not _needs_ocean_mcp(text)
+        and not _is_fisheries_prompt(text)
+    )
+
+
+def _is_marine_health_prompt(prompt: str) -> bool:
+    """Recognize a live Marine API status question without invoking the model."""
+    text = str(prompt or "").strip().lower()
+    health_terms = (
+        "海洋数据服务器连接", "检查海洋数据服务器", "数据服务器连接",
+        "三个数据域", "三个域是否在线", "ocean、tuna、squid",
+        "ocean, tuna, squid", "marine health", "marine server health",
+    )
+    return any(term in text for term in health_terms)
+
+
+def _is_fisheries_inventory_prompt(prompt: str) -> bool:
+    """Recognize file-list requests that do not need an agent turn.
+
+    A repository inventory is a read-only server operation.  Sending this
+    request through the Codex CLI is both slow and, in headless deployments,
+    vulnerable to the interactive-MCP approval limitation.  Keep actual file
+    reads, analysis and exports on their normal guarded paths.
+    """
+    text = str(prompt or "").strip().lower()
+    if not _is_fisheries_prompt(text):
+        return False
+    inventory_terms = (
+        "可用数据集", "当前可用", "文件来源", "文件清单", "列出",
+        "有哪些文件", "入库", "目录", "inventory", "catalog",
+    )
+    if not any(term in text for term in inventory_terms):
+        return False
+    # “不读取文件内容” is explicitly a metadata-only request, rather than a
+    # request to open a file.  Remove these negated phrases before testing for
+    # real content work.
+    metadata_text = text
+    for phrase in (
+        "不读取文件内容", "不读文件内容", "不读取内容", "不读内容",
+        "不读取文件", "不读文件", "无需读取", "不要读取",
+    ):
+        metadata_text = metadata_text.replace(phrase, "")
+    content_terms = (
+        "字段", "记录数", "缺失", "重复", "筛选", "汇总", "聚合",
+        "导出", "下载", "实际读取", "读取csv", "读取 csv",
+    )
+    return not any(term in metadata_text for term in content_terms)
+
+
+async def _direct_fisheries_inventory_answer(prompt: str) -> str:
+    """Return a live fisheries file inventory without invoking the LLM/MCP."""
+    text = str(prompt or "").lower()
+    wants_tuna = any(term in text for term in ("tuna", "金枪鱼"))
+    wants_squid = any(term in text for term in ("squid", "鱿鱼", "柔鱼"))
+    domains = []
+    if wants_squid or not wants_tuna:
+        domains.append("squid")
+    if wants_tuna:
+        domains.append("tuna")
+
+    repo_map = globals().get("HF_DATASET_REPOS") or {}
+    tree_reader = globals().get("hf_live_tree")
+    files_only = globals().get("_hf_live_files")
+    human_bytes = globals().get("_human_bytes")
+    local_tree = globals().get("local_dataset_tree")
+    if not callable(tree_reader) or not callable(files_only) or not callable(human_bytes):
+        return "渔业数据清单服务尚未就绪。"
+
+    source_terms = {
+        "GFW": ("gfw", "global_fishing_watch", "global-fishing-watch"),
+        "SPRFMO": ("sprfmo",),
+        "NPFC": ("npfc",),
+        "WCPFC": ("wcpfc",),
+        "IATTC": ("iattc",),
+        "ICCAT": ("iccat",),
+        "IOTC": ("iotc",),
+        "CCSBT": ("ccsbt",),
+        "FAO": ("fao",),
+        "Sea Around Us": ("sea_around", "sea-around", "sea around"),
+        "RAM Legacy": ("ram",),
+        "VIIRS": ("viirs",),
+    }
+    lines = []
+    for domain in domains:
+        repo = str(repo_map.get(domain) or "").strip()
+        if not repo:
+            lines.append(f"- {domain.title()}：未配置数据仓库。")
+            continue
+        try:
+            raw_items = await tree_reader(repo)
+            files = files_only(raw_items)
+        except Exception as exc:
+            lines.append(f"- {domain.title()}：清单读取失败（{str(exc)[:220]}）。")
+            continue
+
+        total = sum(int(item.get("size_bytes") or 0) for item in files)
+        is_local = False
+        try:
+            is_local = bool(callable(local_tree) and local_tree(repo))
+        except Exception:
+            pass
+        origin = "学校服务器本地镜像" if is_local else "Hugging Face main 分支"
+        lines.extend([
+            f"## {domain.title()} 数据清单",
+            f"- 仓库：`{repo}`",
+            f"- 来源：{origin}",
+            f"- 可用文件：{len(files)} 个，约 {human_bytes(total)}",
+        ])
+
+        groups = []
+        for name, terms in source_terms.items():
+            matched = [
+                item for item in files
+                if any(term in str(item.get("path") or "").lower() for term in terms)
+            ]
+            if matched:
+                groups.append(
+                    f"- {name}：{len(matched)} 个文件，约 "
+                    f"{human_bytes(sum(int(item.get('size_bytes') or 0) for item in matched))}"
+                )
+        if groups:
+            lines.append("- 按来源：")
+            lines.extend(groups)
+        else:
+            lines.append("- 按来源：当前文件路径未匹配到可识别来源标签。")
+
+        preview = files[:12]
+        if preview:
+            lines.append("- 文件示例：")
+            lines.extend(
+                f"  - `{item.get('path')}`（{human_bytes(item.get('size_bytes') or 0)}）"
+                for item in preview
+            )
+        lines.append("- 本次仅读取文件清单元数据，未打开或分析文件内容。")
+
+    return "\n".join(lines) if lines else "未找到可查询的渔业数据域。"
+
+
+async def _direct_marine_health_answer():
+    """Query the configured Marine API directly for a deterministic status answer."""
+    httpx_module = globals().get("httpx")
+    if httpx_module is None:
+        try:
+            import httpx as httpx_module
+        except Exception as exc:
+            return f"海洋数据服务器连接检查失败：HTTP 客户端不可用（{exc}）"
+    base = str(globals().get("MARINE_API_URL") or "").rstrip("/")
+    if not base:
+        return "海洋数据服务器未配置 MARINE_API_URL。"
+
+    candidates = [f"{base}/health"]
+    # HF may expose the school API below the app's /marine reverse-proxy path.
+    if not base.endswith("/marine"):
+        candidates.append(f"{base}/marine/health")
+
+    last_error = ""
+    async with httpx_module.AsyncClient(timeout=12.0, follow_redirects=True) as client:
+        for url in candidates:
+            try:
+                response = await client.get(url)
+                if response.is_success:
+                    payload = response.json()
+                    domains = payload.get("domains") if isinstance(payload, dict) else None
+                    labels = {
+                        "ocean": "在线",
+                        "tuna": "在线",
+                        "squid": "在线",
+                    }
+                    if isinstance(domains, dict):
+                        for key in labels:
+                            value = domains.get(key)
+                            if isinstance(value, dict):
+                                value = value.get("status") or value.get("online")
+                            if value in (False, "offline", "未连接", "不可用"):
+                                labels[key] = "离线/不可用"
+                    elif isinstance(domains, list):
+                        for key in labels:
+                            if key not in {str(item).lower() for item in domains}:
+                                labels[key] = "未在健康响应中列出"
+                    return (
+                        "海洋数据服务器连接正常。\n"
+                        f"- Ocean：{labels['ocean']}\n"
+                        f"- Tuna：{labels['tuna']}\n"
+                        f"- Squid：{labels['squid']}"
+                    )
+                last_error = f"HTTP {response.status_code}"
+            except Exception as exc:
+                last_error = str(exc)
+    return f"海洋数据服务器连接检查失败：{last_error[:240]}"
+
+
 def _context_spec_has_data(spec) -> bool:
     if not isinstance(spec, dict):
         return False
@@ -653,10 +853,50 @@ async def dispatch_chat_stream(tid,prompt):
     # bootstrap.  Keep data requests on the official Codex Harness path, but
     # answer these deterministic prompts immediately so a simple "你好" does
     # not pay the full CLI/network startup cost.
+    if _is_runtime_info_prompt(prompt):
+        provider = str(globals().get("CODEX_PROVIDER_NAME") or os.environ.get("CODEX_PROVIDER", "ZAI")).upper()
+        model = str(globals().get("HARNESS_MODEL") or os.environ.get("CODEX_MODEL", "glm-5.3"))
+        runtime = "官方 Codex CLI Harness（native）"
+        answer = f"- 供应商：{provider}\n- 模型名称：{model}\n- 运行时：{runtime}"
+        yield out("token", {"text": answer})
+        yield out("done", {"text": answer, "runtime": "local-fastpath", "model": model, "finish_reason": "completed"})
+        return
+
+    if _is_marine_health_prompt(prompt):
+        answer = await _direct_marine_health_answer()
+        yield out("token", {"text": answer})
+        yield out("done", {"text": answer, "runtime": "direct-marine-health", "model": "none", "finish_reason": "completed"})
+        return
+
+    if _is_fisheries_inventory_prompt(prompt):
+        answer = await _direct_fisheries_inventory_answer(prompt)
+        yield out("token", {"text": answer})
+        yield out(
+            "done",
+            {
+                "text": answer,
+                "runtime": "direct-fisheries-inventory",
+                "model": "none",
+                "finish_reason": "completed",
+            },
+        )
+        return
+
     greeting = str(prompt or "").strip().lower()
+    # Keep short conversational greetings local.  Variants such as
+    # "你好不好" must not start the full Codex/MCP network path.
+    greeting = greeting.replace("！", "!").replace("？", "?")
     greeting_replies = {
         "你好": "你好！有什么可以帮你的吗？",
+        "你好!": "你好！有什么可以帮你的吗？",
+        "你好?": "你好！有什么可以帮你的吗？",
+        "你好不好": "你好！我很好，谢谢关心。有什么可以帮你的吗？",
+        "你好吗": "你好！我很好，谢谢关心。有什么可以帮你的吗？",
+        "你好啊": "你好！有什么可以帮你的吗？",
+        "你好呀": "你好！有什么可以帮你的吗？",
         "您好": "您好！有什么可以帮你的吗？",
+        "您好!": "您好！有什么可以帮你的吗？",
+        "您好?": "您好！有什么可以帮你的吗？",
         "嗨": "你好！有什么可以帮你的吗？",
         "hello": "Hello！有什么可以帮你的吗？",
         "hi": "你好！有什么可以帮你的吗？",

start.sh

@@ -115,6 +115,9 @@ env = {
 hf_token = os.environ.get("HF_TOKEN", "").strip()
 if hf_token:
     env["HF_TOKEN"] = hf_token
+for name in ("LOCAL_SQUID_DATA_ROOT", "LOCAL_TUNA_DATA_ROOT"):
+    if os.environ.get(name, "").strip():
+        env[name] = os.environ[name]
 
 cfg = {
     "timeouts": {
@@ -168,6 +171,9 @@ marine_env = {
 for name in ("HF_TOKEN", "HF_SQUID_DATASET_REVISION", "HF_TUNA_DATASET_REVISION"):
     if os.environ.get(name, "").strip():
         marine_env[name] = os.environ[name]
+for name in ("LOCAL_SQUID_DATA_ROOT", "LOCAL_TUNA_DATA_ROOT"):
+    if os.environ.get(name, "").strip():
+        marine_env[name] = os.environ[name]
 
 auth_line = (
     "experimental_bearer_token = " + q(os.environ["OPENAI_API_KEY"])
@@ -193,6 +199,11 @@ lines = [
     "command = \"python3\"",
     "args = [" + q(os.path.join(os.environ["APP_ROOT"], "marine_mcp.py")) + "]",
     "required = false",
+    # Native/headless Codex runs cannot display an interactive MCP approval
+    # prompt.  Marine is the deployment's explicitly configured, read-only
+    # data server, so approve its tool calls in the CLI config instead of
+    # leaving requests pending until the harness timeout.
+    "default_tools_approval_mode = \"approve\"",
     "startup_timeout_sec = 30",
     "tool_timeout_sec = 900",
     "env = { " + ", ".join(f"{k} = {q(v)}" for k, v in marine_env.items()) + " }",

static/js/app.js

@@ -961,7 +961,7 @@ async function renderServices(){
     const [appState,data]=await Promise.all([j("/api/status"),j("/api/sidebar/services")]);
     const marine=data.marine||{},hf=data.huggingface||{},d=data.diagnostic||{};
     const rows=[
-      {name:appState.harness_available?"Codex Harness · ZAI GLM-5.3":"Codex Runtime fallback",ok:!!(appState.harness_available),detail:"模型："+(appState.harness_model||appState.model||"-"),ms:null},
+      {name:appState.harness_available?"Codex Harness · ZAI GLM-5.3":"AI 服务待连接",ok:!!(appState.harness_available),detail:"模型："+(appState.harness_model||appState.model||"-"),ms:null},
       {name:"学校 Marine API",ok:!!marine.health?.ok,detail:serviceText(marine.health),ms:marine.health?.response_ms},
       {name:"Ocean 数据域",ok:!!marine.ocean?.ok,detail:serviceText(marine.ocean),ms:marine.ocean?.response_ms},
       {name:"Tuna 渔业数据",ok:!!hf.ok&&Number(hf.tuna_file_count||0)>0,detail:hf.ok?("Hugging Face Dataset · "+(hf.tuna_file_count||0)+" 个匹配文件 · "+formatBytes(hf.tuna_size_bytes)):(hf.error||"读取失败"),ms:hf.response_ms},
@@ -1545,7 +1545,7 @@ async function status(){
     $("dot").className="dot "+(ok?"ok":"warn");
     const runtimeName=s.harness_available
       ? "Codex Harness · ZAI GLM-5.3"
-      : "Codex Runtime fallback";
+      : "AI 服务待连接";
     $("st").textContent=ok
       ? runtimeName+" · "+(s.marine_mcp_active_for_thread?"Ocean MCP 已连接":"数据服务在线")
       : "部分服务不可用";

ui_server.py

@@ -49,6 +49,7 @@ from services.context_compressor import (
 from fisheries_hf import (
     download_dataset_file,
     HF_DATASET_REPOS,
+    local_dataset_tree,
 )
 
 from sidebar_catalog import (
@@ -68,6 +69,12 @@ from sidebar_catalog import (
 CW_URL = os.environ.get("CODEWHALE_INTERNAL_URL","http://127.0.0.1:7878").rstrip("/")
 CW_TOKEN = os.environ["CODEWHALE_RUNTIME_TOKEN"]
 MARINE_API_URL = os.environ["MARINE_API_URL"].rstrip("/")
+# Optional public reverse-proxy upstream.  Set this only on the school UI
+# process (normally http://127.0.0.1:8000).  HF points MARINE_API_URL at the
+# public /marine prefix and must not proxy that prefix back into itself.
+MARINE_PROXY_UPSTREAM_URL = os.environ.get(
+    "MARINE_PROXY_UPSTREAM_URL", ""
+).strip().rstrip("/")
 # v4.3.1: remote memory is optional and must never block chat creation.
 # Do not silently reuse MARINE_API_URL: it is a different service and may be a
 # temporary tunnel.  Enable memory only when both dedicated settings exist.
@@ -1957,6 +1964,9 @@ async def hf_live_tree(repo: str | None = None, force: bool = False) -> list[dic
     incorrectly reporting ``0 files``.
     """
     repo = (repo or HF_SQUID_DATASET_REPO).strip()
+    local_items = local_dataset_tree(repo)
+    if local_items:
+        return local_items
     now = time.time()
     cache = HF_TREE_CACHE.get(repo) or {}
     cached = cache.get("items") or []
@@ -2729,6 +2739,63 @@ app=FastAPI(title="Global Marine Foundation Data Agent",lifespan=lifespan)
 STATIC_DIR = Path(__file__).with_name("static")
 app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
 
+# The school server exposes this UI through the single fixed ngrok endpoint.
+# Keep the UI on the root while forwarding /marine/* to the private Marine API
+# on 127.0.0.1:8000.  This lets HF use one stable public URL without requiring
+# a second ngrok domain.  MARINE_API_URL is intentionally not reused here:
+# on the school server it remains the local API URL, while on HF it points to
+# this public /marine prefix.
+_PROXY_HOP_BY_HOP = {
+    "connection", "keep-alive", "proxy-authenticate",
+    "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade",
+}
+
+
+async def _proxy_marine_request(request: Request, suffix: str = "") -> Response:
+    if not MARINE_PROXY_UPSTREAM_URL:
+        raise HTTPException(status_code=404, detail="Marine proxy is not enabled")
+    suffix = "/" + suffix.lstrip("/") if suffix else ""
+    target = f"{MARINE_PROXY_UPSTREAM_URL}{suffix}"
+    if request.url.query:
+        target = f"{target}?{request.url.query}"
+
+    headers = {
+        key: value
+        for key, value in request.headers.items()
+        if key.lower() not in _PROXY_HOP_BY_HOP and key.lower() != "host"
+    }
+    body = await request.body()
+    try:
+        async with httpx.AsyncClient(
+            timeout=httpx.Timeout(connect=8, read=90, write=30, pool=8),
+            follow_redirects=True,
+        ) as client:
+            upstream = await client.request(
+                request.method,
+                target,
+                headers=headers,
+                content=body or None,
+            )
+    except httpx.HTTPError as exc:
+        raise HTTPException(status_code=502, detail=f"Marine API proxy failed: {exc}") from exc
+
+    response_headers = {
+        key: value
+        for key, value in upstream.headers.items()
+        if key.lower() not in _PROXY_HOP_BY_HOP and key.lower() != "content-length"
+    }
+    return Response(
+        content=upstream.content,
+        status_code=upstream.status_code,
+        headers=response_headers,
+        media_type=upstream.headers.get("content-type"),
+    )
+
+
+_MARINE_PROXY_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+app.api_route("/marine", methods=_MARINE_PROXY_METHODS)(_proxy_marine_request)
+app.api_route("/marine/{suffix:path}", methods=_MARINE_PROXY_METHODS)(_proxy_marine_request)
+