mirror aicodebox env var rename + add PIBOX_MCP_MODE

aicodebox v0.2.0 normalized every mode env var to <MODE>_MODE /
<MODE>_MODE_<KNOB>. The pibox alias map and README follow:

  PIBOX_MODE_API           → PIBOX_API_MODE
  PIBOX_MODE_API_PORT      → PIBOX_API_MODE_PORT
  PIBOX_MODE_API_TOKEN     → PIBOX_API_MODE_TOKEN
  PIBOX_MODE_TELEGRAM      → PIBOX_TELEGRAM_MODE
  PIBOX_TELEGRAM_BOT_TOKEN → PIBOX_TELEGRAM_MODE_TOKEN
  PIBOX_TELEGRAM_CONFIG    → PIBOX_TELEGRAM_MODE_CONFIG
  PIBOX_TELEGRAM_OVERRIDES → PIBOX_TELEGRAM_MODE_OVERRIDES
  PIBOX_MODE_CRON          → PIBOX_CRON_MODE
  PIBOX_MODE_CRON_FILE     → PIBOX_CRON_MODE_FILE
  PIBOX_CRON_HISTORY_DIR   → PIBOX_CRON_MODE_HISTORY_DIR

MCP is now its own toggle (PIBOX_MCP_MODE=1) on top of the foreground
mode. In API mode it stays mounted at /mcp (gated on MCP_MODE=1 now,
not always-on); in telegram/cron/passthrough it spawns as a sidecar
uvicorn on PIBOX_MCP_MODE_PORT (default 8081). Auth via
PIBOX_MCP_MODE_TOKEN — own bearer, no fallback to API_MODE_TOKEN.

E2E tests updated to the new AICODEBOX_* names they pass to docker
run, and the API test fixture now enables MCP_MODE + shares the API
bearer with MCP so the existing /mcp handshake + auth assertions
stay valid.

.env.test.example bumps AICODEBOX_TELEGRAM_BOT_TOKEN to
AICODEBOX_TELEGRAM_MODE_TOKEN. README rewritten around the new shape
with explicit MCP mode + coexistence sections.

Author: psyb0t

.env.test.example

@@ -11,7 +11,7 @@ ANTHROPIC_API_KEY=your-token-here
 
 # Telegram e2e tests (test_telegram.sh, test_cron_telegram.sh, test_e2e_telegram.sh).
 # Leave blank to skip those tests.
-AICODEBOX_TELEGRAM_BOT_TOKEN=
+AICODEBOX_TELEGRAM_MODE_TOKEN=
 TELEGRAM_CHAT_ID=
 
 # Telethon userbot — drives the user side of the Telegram e2e tests.

README.md

@@ -33,8 +33,8 @@ docker run --rm \
 
 # API server
 docker run -d --network host \
-  -e PIBOX_MODE_API=1 \
-  -e PIBOX_MODE_API_TOKEN=your-secret \
+  -e PIBOX_API_MODE=1 \
+  -e PIBOX_API_MODE_TOKEN=your-secret \
   -e ANTHROPIC_AUTH_TOKEN=your-token \
   -e ANTHROPIC_BASE_URL=https://api.z.ai/api/anthropic \
   -e ANTHROPIC_MODEL=glm-4.6 \
@@ -44,11 +44,13 @@ docker run -d --network host \
 
 ## Modes
 
-One mode per container, with one exception: `PIBOX_MODE_TELEGRAM=1` and `PIBOX_MODE_CRON=1` can run together — cron runs in-thread inside the telegram process. API mode always takes priority if set alongside anything else.
+**Foreground modes** (API / Telegram / Cron) are mutually exclusive — except `PIBOX_TELEGRAM_MODE=1` + `PIBOX_CRON_MODE=1`, which run together (cron in-thread inside telegram). API wins if set alongside anything else.
+
+**MCP mode** (`PIBOX_MCP_MODE=1`) is independent — it coexists with whatever foreground mode is running. In API mode it's mounted at `/mcp` on the API port; in other modes it runs as a sidecar uvicorn on its own port.
 
 ### API mode
 
-`PIBOX_MODE_API=1`. FastAPI server on `:8080` (override with `PIBOX_MODE_API_PORT`).
+`PIBOX_API_MODE=1`. FastAPI server on `:8080` (override with `PIBOX_API_MODE_PORT`).
 
 | Method | Path | What it does |
 |--------|------|--------------|
@@ -64,7 +66,7 @@ One mode per container, with one exception: `PIBOX_MODE_TELEGRAM=1` and `PIBOX_M
 | `DELETE` | `/files/{path}` | delete a file (refuses directories — 400) |
 | `POST` | `/v1/chat/completions` | OpenAI-compatible (streaming + non-streaming) |
 | `GET` | `/v1/models` | model list |
-| `POST` | `/mcp` | MCP server (streamable HTTP) |
+| `POST` | `/mcp` | MCP server (streamable HTTP) — mounted only when `PIBOX_MCP_MODE=1` |
 
 All `/files/*` paths are resolved against the workspace root with traversal checking — `..` segments that escape the root return 400. Same `Authorization: Bearer ...` token gates them as the rest of the API.
 
@@ -99,15 +101,15 @@ curl -s http://localhost:8080/run \
 
 ### Telegram mode
 
-`PIBOX_MODE_TELEGRAM=1` + `PIBOX_TELEGRAM_BOT_TOKEN=<token>`.
+`PIBOX_TELEGRAM_MODE=1` + `PIBOX_TELEGRAM_MODE_TOKEN=<token>`.
 
 - Text in → pi runs → Markdown→HTML rendered response back.
 - File uploads land in the chat's workspace. `[SEND_FILE: path]` in pi's output delivers workspace files as Telegram attachments.
 - Per-chat overrides: `/model`, `/effort` (maps to pi's `--thinking` levels), `/system_prompt`, `/append_system_prompt`. Persisted across restarts.
 - `/cancel` kills the in-flight run. `/reload` re-reads config. `/config` dumps merged settings. `/fetch <path>` downloads a file.
 - Replies to cron messages inject the job's instruction + result so pi has full context for follow-ups.
 
-Config at `$HOME/.aicodebox/telegram.yml` (override via `PIBOX_TELEGRAM_CONFIG`):
+Config at `$HOME/.aicodebox/telegram.yml` (override via `PIBOX_TELEGRAM_MODE_CONFIG`):
 
 ```yaml
 allowed_chats: [-100123, 42]
@@ -122,7 +124,7 @@ chats:
 
 ### Cron mode
 
-`PIBOX_MODE_CRON=1` + `PIBOX_MODE_CRON_FILE=/path/to/cron.yaml`. 6-field schedules via croniter. Each job fires pi with the given instruction.
+`PIBOX_CRON_MODE=1` + `PIBOX_CRON_MODE_FILE=/path/to/cron.yaml`. 6-field schedules via croniter. Each job fires pi with the given instruction.
 
 ```yaml
 jobs:
@@ -139,28 +141,60 @@ jobs:
 
 Each run gets a history dir at `$HOME/.aicodebox/cron/history/<workspace>/<timestamp>-<job>/` with `meta.json`, `stdout.log`, `stderr.log`, `result.txt`. If telegram is configured, `telegram.json` lands there too and the next run's prompt gets a "prior run" hint so pi can reference its own history without you wiring it up.
 
+### MCP mode
+
+`PIBOX_MCP_MODE=1`. Exposes the MCP (Model Context Protocol) surface — `run_prompt`, `list_files`, `read_file`, `write_file`, `delete_file` as tools. Coexists with any foreground mode:
+
+| Foreground | MCP placement |
+|---|---|
+| API mode (`PIBOX_API_MODE=1`) | mounted at `/mcp` on the API port — no extra process |
+| Telegram / Cron / passthrough | sidecar uvicorn on `PIBOX_MCP_MODE_PORT` (default `8081`) |
+
+Auth: `PIBOX_MCP_MODE_TOKEN=<token>` — bearer in the `Authorization: Bearer …` header, or `?apiToken=…` for clients that can't set headers. Empty = no auth. **No fallback to `API_MODE_TOKEN`** — MCP has its own bearer.
+
 ## Configuration
 
-Every var below is `PIBOX_*`. The image is built on top of [aicodebox](https://github.com/psyb0t/docker-aicodebox), so the original `AICODEBOX_*` names also work — the entrypoint translates `PIBOX_X` to `AICODEBOX_X` when only the pibox-prefixed one is set. If you set both, `AICODEBOX_*` wins.
+Naming convention: `PIBOX_<MODE>_MODE=1` is the on/off flag, `PIBOX_<MODE>_MODE_<KNOB>=...` is its config. Non-mode-scoped vars (workspace, container name, available models) are bare.
+
+The image is built on top of [aicodebox](https://github.com/psyb0t/docker-aicodebox), so the equivalent `AICODEBOX_*` names also work — the entrypoint translates `PIBOX_X` to `AICODEBOX_X` when only the pibox-prefixed one is set. If you set both, `AICODEBOX_*` wins.
+
+### Mode flags
+
+| Var | Default | What it does |
+|-----|---------|--------------|
+| `PIBOX_API_MODE` | `0` | Boot the HTTP API server (foreground) |
+| `PIBOX_TELEGRAM_MODE` | `0` | Boot the Telegram bot (foreground) |
+| `PIBOX_CRON_MODE` | `0` | Boot the cron scheduler (foreground; in-thread when telegram is also on) |
+| `PIBOX_MCP_MODE` | `0` | Expose MCP — mounted at `/mcp` in API mode, or as a sidecar elsewhere |
+
+### API mode config
+
+| Var | Default | What it does |
+|-----|---------|--------------|
+| `PIBOX_API_MODE_PORT` | `8080` | Port the API server binds to |
+| `PIBOX_API_MODE_TOKEN` | empty | Bearer token for the API surface. Empty = no auth |
+
+### Telegram mode config
+
+| Var | Default | What it does |
+|-----|---------|--------------|
+| `PIBOX_TELEGRAM_MODE_TOKEN` | — | Bot token from @BotFather |
+| `PIBOX_TELEGRAM_MODE_CONFIG` | `~/.aicodebox/telegram.yml` | Path to the telegram config yaml |
+| `PIBOX_TELEGRAM_MODE_OVERRIDES` | `~/.aicodebox/telegram_overrides.json` | Per-chat override store (model/effort/system prompts) |
 
-### Modes
+### Cron mode config
 
 | Var | Default | What it does |
 |-----|---------|--------------|
-| `PIBOX_MODE_API` | `0` | Boot the HTTP API server |
-| `PIBOX_MODE_API_PORT` | `8080` | Port the API server binds to |
-| `PIBOX_MODE_API_TOKEN` | empty | Bearer token required on every API + MCP request. Unset = no auth |
-| `PIBOX_MODE_TELEGRAM` | `0` | Boot the Telegram bot |
-| `PIBOX_MODE_CRON` | `0` | Boot the cron scheduler (also runs in-thread when telegram mode is on) |
-| `PIBOX_MODE_CRON_FILE` | — | Path to the cron yaml |
+| `PIBOX_CRON_MODE_FILE` | — | Path to the cron yaml |
+| `PIBOX_CRON_MODE_HISTORY_DIR` | `~/.aicodebox/cron/history` | Where cron writes per-run history dirs (`meta.json`, `stdout.log`, `stderr.log`, `result.txt`, `telegram.json`) |
 
-### Telegram
+### MCP mode config
 
 | Var | Default | What it does |
 |-----|---------|--------------|
-| `PIBOX_TELEGRAM_BOT_TOKEN` | — | Bot token from @BotFather |
-| `PIBOX_TELEGRAM_CONFIG` | `~/.aicodebox/telegram.yml` | Path to the telegram config yaml |
-| `PIBOX_TELEGRAM_OVERRIDES` | `~/.aicodebox/telegram-overrides.json` | Path to the per-chat override store (model/effort/system prompts) |
+| `PIBOX_MCP_MODE_PORT` | `8081` | Port the sidecar MCP server binds to (ignored when mounted inside API) |
+| `PIBOX_MCP_MODE_TOKEN` | empty | Bearer token for MCP. Empty = no auth. **No fallback to `API_MODE_TOKEN`** |
 
 ### Workspace & runtime
 
@@ -170,7 +204,6 @@ Every var below is `PIBOX_*`. The image is built on top of [aicodebox](https://g
 | `PIBOX_CONTAINER_NAME` | `aicodebox` | Used to scope per-container state files (auth, etc.) |
 | `PIBOX_AVAILABLE_MODELS` | adapter list | Override the model list returned by `/v1/models` and the telegram `/model` picker (comma-separated) |
 | `PIBOX_AVAILABLE_EFFORTS` | adapter list | Override the effort/`--thinking` list shown by the telegram `/effort` picker (comma-separated) |
-| `PIBOX_CRON_HISTORY_DIR` | `~/.aicodebox/cron/history` | Where cron writes per-run history dirs (`meta.json`, `stdout.log`, `stderr.log`, `result.txt`, `telegram.json`) |
 
 ## Auth
 
@@ -209,7 +242,7 @@ $EDITOR .env.test   # fill in ANTHROPIC_* and optionally Telegram creds
 make test
 ```
 
-Telegram tests auto-skip if `PIBOX_TELEGRAM_BOT_TOKEN` is empty. Everything else only needs `ANTHROPIC_AUTH_TOKEN` + `ANTHROPIC_BASE_URL`.
+Telegram tests auto-skip if `AICODEBOX_TELEGRAM_MODE_TOKEN` is empty. Everything else only needs `ANTHROPIC_AUTH_TOKEN` + `ANTHROPIC_BASE_URL`.
 
 ## License
 

pibox-entrypoint.sh

@@ -10,19 +10,22 @@ set -e
 # PIBOX_X is set, copy the value across. Internal vars (ADAPTER, AGENT_BINARY)
 # are NOT exposed — the pibox Dockerfile pins those.
 _PIBOX_ALIASES=(
-    MODE_API
-    MODE_API_PORT
-    MODE_API_TOKEN
-    MODE_TELEGRAM
-    MODE_CRON
-    MODE_CRON_FILE
-    TELEGRAM_BOT_TOKEN
-    TELEGRAM_CONFIG
-    TELEGRAM_OVERRIDES
+    API_MODE
+    API_MODE_PORT
+    API_MODE_TOKEN
+    TELEGRAM_MODE
+    TELEGRAM_MODE_TOKEN
+    TELEGRAM_MODE_CONFIG
+    TELEGRAM_MODE_OVERRIDES
+    CRON_MODE
+    CRON_MODE_FILE
+    CRON_MODE_HISTORY_DIR
+    MCP_MODE
+    MCP_MODE_PORT
+    MCP_MODE_TOKEN
     WORKSPACE
     AVAILABLE_MODELS
     AVAILABLE_EFFORTS
-    CRON_HISTORY_DIR
     CONTAINER_NAME
 )
 

tests/test_api.sh

@@ -33,14 +33,17 @@ _api_start() {
 
     local extra=()
     if [ -n "$token" ]; then
-        extra+=(-e "AICODEBOX_MODE_API_TOKEN=$token")
+        extra+=(-e "AICODEBOX_API_MODE_TOKEN=$token")
+        # Share the same bearer with MCP for these tests — keeps curl one-token.
+        extra+=(-e "AICODEBOX_MCP_MODE_TOKEN=$token")
     fi
 
     docker rm -f "$cname" >/dev/null 2>&1 || true
     docker run -d --name "$cname" \
         --network host \
-        -e "AICODEBOX_MODE_API=1" \
-        -e "AICODEBOX_MODE_API_PORT=$port" \
+        -e "AICODEBOX_API_MODE=1" \
+        -e "AICODEBOX_API_MODE_PORT=$port" \
+        -e "AICODEBOX_MCP_MODE=1" \
         -e "ANTHROPIC_AUTH_TOKEN=$ANTHROPIC_AUTH_TOKEN" \
         -e "ANTHROPIC_API_KEY=$ANTHROPIC_AUTH_TOKEN" \
         -e "ANTHROPIC_BASE_URL=$ANTHROPIC_BASE_URL" \

tests/test_cron.sh

@@ -24,8 +24,8 @@ _cron_start() {
     docker run -d --name "$cname" \
         --network host \
         -v "$hostdir:/workspace" \
-        -e "AICODEBOX_MODE_CRON=1" \
-        -e "AICODEBOX_MODE_CRON_FILE=/workspace/cron.yaml" \
+        -e "AICODEBOX_CRON_MODE=1" \
+        -e "AICODEBOX_CRON_MODE_FILE=/workspace/cron.yaml" \
         -e "AICODEBOX_WORKSPACE=/workspace" \
         -e "ANTHROPIC_AUTH_TOKEN=$ANTHROPIC_AUTH_TOKEN" \
         -e "ANTHROPIC_API_KEY=$ANTHROPIC_AUTH_TOKEN" \
@@ -53,8 +53,8 @@ test_cron_yaml_parse() {
     local rc
     rc=$(docker run --rm \
         -v "$hostdir:/workspace" \
-        -e "AICODEBOX_MODE_CRON=1" \
-        -e "AICODEBOX_MODE_CRON_FILE=/workspace/cron.yaml" \
+        -e "AICODEBOX_CRON_MODE=1" \
+        -e "AICODEBOX_CRON_MODE_FILE=/workspace/cron.yaml" \
         -e "AICODEBOX_WORKSPACE=/workspace" \
         "$IMAGE" >/dev/null 2>&1; echo $?)
     if [ "$rc" = "0" ]; then

tests/test_cron_telegram.sh

@@ -5,7 +5,7 @@
 
 _ct_check_env() {
     local missing=()
-    for v in AICODEBOX_TELEGRAM_BOT_TOKEN TELEGRAM_CHAT_ID \
+    for v in AICODEBOX_TELEGRAM_MODE_TOKEN TELEGRAM_CHAT_ID \
              TELETHON_API_ID TELETHON_API_HASH TELETHON_SESSION TELETHON_AUTH_KEY; do
         if [ -z "${!v:-}" ]; then
             missing+=("$v")
@@ -62,7 +62,7 @@ CT_BOT_REF=""
 _ct_resolve_bot() {
     [ -n "$CT_BOT_REF" ] && return 0
     local resp username
-    resp=$(curl -sf "https://api.telegram.org/bot${AICODEBOX_TELEGRAM_BOT_TOKEN}/getMe")
+    resp=$(curl -sf "https://api.telegram.org/bot${AICODEBOX_TELEGRAM_MODE_TOKEN}/getMe")
     username=$(echo "$resp" | python3 -c 'import json,sys
 print((json.load(sys.stdin).get("result") or {}).get("username", ""))')
     if [ -z "$username" ]; then
@@ -73,7 +73,7 @@ print((json.load(sys.stdin).get("result") or {}).get("username", ""))')
     log "  OK: bot resolved as $CT_BOT_REF"
 }
 
-_ct_bot_user_id() { echo "${AICODEBOX_TELEGRAM_BOT_TOKEN%%:*}"; }
+_ct_bot_user_id() { echo "${AICODEBOX_TELEGRAM_MODE_TOKEN%%:*}"; }
 
 _ct_curl() {
     curl -sS -H "Authorization: Bearer $TELETHON_AUTH_KEY" "$@"
@@ -161,11 +161,11 @@ _ct_start_container() {
         -v "$hostdir/workspace:/workspace" \
         -v "$hostdir/home/.aicodebox:/home/aicode/.aicodebox" \
         -v "$hostdir/cron.yaml:/cron.yaml:ro" \
-        -e "AICODEBOX_MODE_CRON=1" \
-        -e "AICODEBOX_MODE_TELEGRAM=1" \
-        -e "AICODEBOX_MODE_CRON_FILE=/cron.yaml" \
+        -e "AICODEBOX_CRON_MODE=1" \
+        -e "AICODEBOX_TELEGRAM_MODE=1" \
+        -e "AICODEBOX_CRON_MODE_FILE=/cron.yaml" \
         -e "AICODEBOX_WORKSPACE=/workspace" \
-        -e "AICODEBOX_TELEGRAM_BOT_TOKEN=$AICODEBOX_TELEGRAM_BOT_TOKEN" \
+        -e "AICODEBOX_TELEGRAM_MODE_TOKEN=$AICODEBOX_TELEGRAM_MODE_TOKEN" \
         -e "TELEGRAM_CHAT_ID=$TELEGRAM_CHAT_ID" \
         -e "ANTHROPIC_AUTH_TOKEN=$ANTHROPIC_AUTH_TOKEN" \
         -e "ANTHROPIC_API_KEY=$ANTHROPIC_AUTH_TOKEN" \

tests/test_e2e_telegram.sh

@@ -17,7 +17,7 @@
 # wrapper, container lifecycle). Required env (loaded by common.sh from
 # .env.test, which is gitignored):
 #
-#   AICODEBOX_TELEGRAM_BOT_TOKEN
+#   AICODEBOX_TELEGRAM_MODE_TOKEN
 #   TELEGRAM_CHAT_ID
 #   TELETHON_API_ID, TELETHON_API_HASH, TELETHON_SESSION, TELETHON_AUTH_KEY
 #

tests/test_smoke.sh

@@ -61,9 +61,9 @@ test_jsonschema_pi() {
 
     docker run -d --name "$cname" "${DOCKER_RUN_BASE[@]}" \
         -e "AICODEBOX_CONTAINER_NAME=$cname" \
-        -e "AICODEBOX_MODE_API=1" \
-        -e "AICODEBOX_MODE_API_PORT=$port" \
-        -e "AICODEBOX_MODE_API_TOKEN=$token" \
+        -e "AICODEBOX_API_MODE=1" \
+        -e "AICODEBOX_API_MODE_PORT=$port" \
+        -e "AICODEBOX_API_MODE_TOKEN=$token" \
         -p "127.0.0.1:$port:$port" \
         "$IMAGE" >/dev/null
 

tests/test_telegram.sh

@@ -6,7 +6,7 @@ TELETHON_IMAGE="psyb0t/telethon-plus"
 
 _tg_check_env() {
     local missing=()
-    for v in AICODEBOX_TELEGRAM_BOT_TOKEN TELEGRAM_CHAT_ID \
+    for v in AICODEBOX_TELEGRAM_MODE_TOKEN TELEGRAM_CHAT_ID \
              TELETHON_API_ID TELETHON_API_HASH TELETHON_SESSION TELETHON_AUTH_KEY; do
         if [ -z "${!v:-}" ]; then
             missing+=("$v")
@@ -63,7 +63,7 @@ TG_BOT_REF=""
 _tg_resolve_bot() {
     [ -n "$TG_BOT_REF" ] && return 0
     local resp username
-    resp=$(curl -sf "https://api.telegram.org/bot${AICODEBOX_TELEGRAM_BOT_TOKEN}/getMe")
+    resp=$(curl -sf "https://api.telegram.org/bot${AICODEBOX_TELEGRAM_MODE_TOKEN}/getMe")
     username=$(echo "$resp" | python3 -c 'import json,sys
 print((json.load(sys.stdin).get("result") or {}).get("username", ""))')
     if [ -z "$username" ]; then
@@ -74,7 +74,7 @@ print((json.load(sys.stdin).get("result") or {}).get("username", ""))')
     log "  OK: bot resolved as $TG_BOT_REF"
 }
 
-_tg_bot_user_id() { echo "${AICODEBOX_TELEGRAM_BOT_TOKEN%%:*}"; }
+_tg_bot_user_id() { echo "${AICODEBOX_TELEGRAM_MODE_TOKEN%%:*}"; }
 
 _tg_curl() {
     curl -sS -H "Authorization: Bearer $TELETHON_AUTH_KEY" "$@"
@@ -154,9 +154,9 @@ _tg_start_bot() {
         --network host \
         -v "$TG_TMP/workspace:/workspace" \
         -v "$TG_TMP/home/.aicodebox:/home/aicode/.aicodebox" \
-        -e "AICODEBOX_MODE_TELEGRAM=1" \
+        -e "AICODEBOX_TELEGRAM_MODE=1" \
         -e "AICODEBOX_WORKSPACE=/workspace" \
-        -e "AICODEBOX_TELEGRAM_BOT_TOKEN=$AICODEBOX_TELEGRAM_BOT_TOKEN" \
+        -e "AICODEBOX_TELEGRAM_MODE_TOKEN=$AICODEBOX_TELEGRAM_MODE_TOKEN" \
         -e "TELEGRAM_CHAT_ID=$TELEGRAM_CHAT_ID" \
         -e "ANTHROPIC_AUTH_TOKEN=$ANTHROPIC_AUTH_TOKEN" \
         -e "ANTHROPIC_API_KEY=$ANTHROPIC_AUTH_TOKEN" \
@@ -197,7 +197,7 @@ test_tg_unit_md_to_html() {
     local cname="${CONTAINER_PREFIX}-tg-unit-$$"
     local rc out
     out=$(docker run --rm --name "$cname" \
-        -e "AICODEBOX_TELEGRAM_BOT_TOKEN=dummy:dummy" \
+        -e "AICODEBOX_TELEGRAM_MODE_TOKEN=dummy:dummy" \
         --entrypoint python3 \
         "$IMAGE" -c '
 from aicodebox.modes.telegram.utils import md_to_tg_html
@@ -293,7 +293,7 @@ test_tg_long_response() {
     local cname="${CONTAINER_PREFIX}-tg-long-$$"
     local rc out
     out=$(docker run --rm --name "$cname" \
-        -e "AICODEBOX_TELEGRAM_BOT_TOKEN=dummy:dummy" \
+        -e "AICODEBOX_TELEGRAM_MODE_TOKEN=dummy:dummy" \
         --entrypoint python3 \
         "$IMAGE" -c '
 import asyncio