feat: Add GPT-5.4 mini and fast support.

Added GPT-5.4 mini along with correct reasoning level and fast mode.
Fast is translated to priority in the payload upstream. We also include handling now
around if clients send normal OpenAI service levels (flex/priority), and all endpoint
coverage tests surrounding it.

Author: Ra's al Ghul

DOCKER.md

@@ -24,6 +24,7 @@ Set options in `.env` or pass environment variables:
 - `CHATGPT_LOCAL_REASONING_EFFORT`: minimal|low|medium|high|xhigh
 - `CHATGPT_LOCAL_REASONING_SUMMARY`: auto|concise|detailed|none
 - `CHATGPT_LOCAL_REASONING_COMPAT`: legacy|o3|think-tags|current
+- `CHATGPT_LOCAL_SERVICE_TIER`: fast to set the default upstream service tier / Fast mode
 - `CHATGPT_LOCAL_DEBUG_MODEL`: force model override (e.g., `gpt-5.4`)
 - `CHATGPT_LOCAL_CLIENT_ID`: OAuth client id override (rarely needed)
 - `CHATGPT_LOCAL_EXPOSE_REASONING_MODELS`: `true|false` to add reasoning model variants to `/v1/models`

README.md

@@ -101,6 +101,7 @@ curl http://127.0.0.1:8000/v1/chat/completions \
 - Vision/Image understanding
 - Thinking summaries (through thinking tags)
 - Thinking effort
+- Fast mode / service tier
 
 ## Notes & Limits
 
@@ -110,6 +111,7 @@ curl http://127.0.0.1:8000/v1/chat/completions \
 
 # Supported models
 - `gpt-5.4`
+- `gpt-5.4-mini`
 - `gpt-5.2`
 - `gpt-5.1`
 - `gpt-5`
@@ -134,6 +136,12 @@ GPT-5 has a configurable amount of "effort" it can put into thinking, which may
 - `--reasoning-summary` (choice of auto,concise,detailed,none)<br>
 Models like GPT-5 do not return raw thinking content, but instead return thinking summaries. These can also be customised by you.
 
+### Fast mode / Service tier
+
+- `--service-tier` (choice of fast)<br>
+ChatMock can forward a default `service_tier` to the upstream ChatGPT/Codex backend. This mirrors Codex Fast mode, where `fast` requests the faster tier. You can also override the default per request by sending `"service_tier": "fast"` in either the OpenAI-compatible or Ollama-compatible request body.<br>
+This is also configurable through `CHATGPT_LOCAL_SERVICE_TIER`. ChatMock translates `fast` to the upstream tier name internally. For client compatibility, request values like `"auto"`, `"default"`, and `"flex"` are treated as normal mode and are not forwarded upstream.
+
 ### OpenAI Tools
 
 - `--enable-web-search`<br>
@@ -160,7 +168,7 @@ You can enable it by starting the server with this parameter, which will allow O
 If your preferred app doesn’t support selecting reasoning effort, or you just want a simpler approach, this parameter exposes each reasoning level as a separate, queryable model. Each reasoning level also appears individually under ⁠/v1/models, so model pickers in your favorite chat apps will list all reasoning options as distinct models you can switch between.
 
 ## Notes
-If you wish to have the fastest responses, I'd recommend setting `--reasoning-effort` to low, and `--reasoning-summary` to none. <br>
+If you wish to have the fastest responses, I'd recommend setting `--reasoning-effort` to low, `--reasoning-summary` to none, and enabling `--service-tier fast` on supported upstream combinations. <br>
 All parameters and choices can be seen by sending `python chatmock.py serve --h`<br>
 The context size of this route is also larger than what you get access to in the regular ChatGPT app.<br>
 

chatmock/app.py

@@ -6,6 +6,7 @@
 from .http import build_cors_headers
 from .routes_openai import openai_bp
 from .routes_ollama import ollama_bp
+from .service_tier import normalize_service_tier
 
 
 def create_app(
@@ -14,6 +15,7 @@ def create_app(
     reasoning_effort: str = "medium",
     reasoning_summary: str = "auto",
     reasoning_compat: str = "think-tags",
+    service_tier: str | None = None,
     debug_model: str | None = None,
     expose_reasoning_models: bool = False,
     default_web_search: bool = False,
@@ -26,6 +28,7 @@ def create_app(
         REASONING_EFFORT=reasoning_effort,
         REASONING_SUMMARY=reasoning_summary,
         REASONING_COMPAT=reasoning_compat,
+        SERVICE_TIER=normalize_service_tier(service_tier),
         DEBUG_MODEL=debug_model,
         BASE_INSTRUCTIONS=BASE_INSTRUCTIONS,
         GPT5_CODEX_INSTRUCTIONS=GPT5_CODEX_INSTRUCTIONS,

chatmock/cli.py

@@ -12,6 +12,7 @@
 from .config import CLIENT_ID_DEFAULT
 from .limits import RateLimitWindow, compute_reset_at, load_rate_limit_snapshot
 from .oauth import OAuthHTTPServer, OAuthHandler, REQUIRED_PORT, URL_BASE
+from .service_tier import normalize_service_tier
 from .utils import eprint, get_home_dir, load_chatgpt_tokens, parse_jwt_claims, read_auth_file
 
 
@@ -267,6 +268,7 @@ def cmd_serve(
     reasoning_effort: str,
     reasoning_summary: str,
     reasoning_compat: str,
+    service_tier: str | None,
     debug_model: str | None,
     expose_reasoning_models: bool,
     default_web_search: bool,
@@ -277,6 +279,7 @@ def cmd_serve(
         reasoning_effort=reasoning_effort,
         reasoning_summary=reasoning_summary,
         reasoning_compat=reasoning_compat,
+        service_tier=service_tier,
         debug_model=debug_model,
         expose_reasoning_models=expose_reasoning_models,
         default_web_search=default_web_search,
@@ -330,6 +333,15 @@ def main() -> None:
             "'current' is accepted as an alias for 'legacy'"
         ),
     )
+    p_serve.add_argument(
+        "--service-tier",
+        choices=["fast"],
+        default=normalize_service_tier(os.getenv("CHATGPT_LOCAL_SERVICE_TIER")),
+        help=(
+            "Default service tier for upstream ChatGPT requests. "
+            "Set to 'fast' for Codex-style Fast mode."
+        ),
+    )
     p_serve.add_argument(
         "--expose-reasoning-models",
         action="store_true",
@@ -366,6 +378,7 @@ def main() -> None:
                 reasoning_effort=args.reasoning_effort,
                 reasoning_summary=args.reasoning_summary,
                 reasoning_compat=args.reasoning_compat,
+                service_tier=args.service_tier,
                 debug_model=args.debug_model,
                 expose_reasoning_models=args.expose_reasoning_models,
                 default_web_search=args.enable_web_search,

chatmock/model_registry.py

@@ -47,6 +47,13 @@ class ModelSpec:
         allowed_efforts=frozenset(("none", "low", "medium", "high", "xhigh")),
         variant_efforts=("xhigh", "high", "medium", "low", "none"),
     ),
+    ModelSpec(
+        public_id="gpt-5.4-mini",
+        upstream_id="gpt-5.4-mini",
+        aliases=("gpt5.4-mini", "gpt-5.4-mini-latest"),
+        allowed_efforts=frozenset(("none", "low", "medium", "high", "xhigh")),
+        variant_efforts=("xhigh", "high", "medium", "low", "none"),
+    ),
     ModelSpec(
         public_id="gpt-5.3-codex",
         upstream_id="gpt-5.3-codex",

chatmock/routes_ollama.py

@@ -16,6 +16,7 @@
     build_reasoning_param,
     extract_reasoning_from_model_name,
 )
+from .service_tier import resolve_service_tier, service_tier_error_message
 from .transform import convert_ollama_messages, normalize_ollama_tools
 from .upstream import normalize_model_name, start_upstream_request
 from .utils import convert_chat_messages_to_responses_input, convert_tools_chat_to_responses
@@ -187,6 +188,16 @@ def ollama_chat() -> Response:
             _log_json("OUT POST /api/chat", err)
         return jsonify(err), 400
 
+    service_tier, invalid_service_tier = resolve_service_tier(
+        payload.get("service_tier"),
+        current_app.config.get("SERVICE_TIER"),
+    )
+    if invalid_service_tier:
+        err = {"error": service_tier_error_message()}
+        if verbose:
+            _log_json("OUT POST /api/chat", err)
+        return jsonify(err), 400
+
     model = payload.get("model")
     raw_messages = payload.get("messages")
     messages = convert_ollama_messages(
@@ -267,6 +278,7 @@ def ollama_chat() -> Response:
             model_reasoning,
             allowed_efforts=allowed_efforts_for_model(model),
         ),
+        service_tier=service_tier,
     )
     if error_resp is not None:
         if verbose:
@@ -307,6 +319,7 @@ def ollama_chat() -> Response:
                     model_reasoning,
                     allowed_efforts=allowed_efforts_for_model(model),
                 ),
+                service_tier=service_tier,
             )
             record_rate_limits_from_response(upstream2)
             if err2 is None and upstream2 is not None and upstream2.status_code < 400:
@@ -558,7 +571,7 @@ def _gen():
             full_text = f"<think>{rtxt}</think>" + (full_text or "")
 
     out_json = {
-        "model": normalize_model_name(model),
+        "model": model_out,
         "created_at": created_at,
         "message": {"role": "assistant", "content": full_text, **({"tool_calls": tool_calls} if tool_calls else {})},
         "done": True,

chatmock/routes_openai.py

@@ -16,6 +16,7 @@
     build_reasoning_param,
     extract_reasoning_from_model_name,
 )
+from .service_tier import resolve_service_tier, service_tier_error_message
 from .upstream import normalize_model_name, start_upstream_request
 from .utils import (
     convert_chat_messages_to_responses_input,
@@ -93,6 +94,16 @@ def chat_completions() -> Response:
                 _log_json("OUT POST /v1/chat/completions", err)
             return jsonify(err), 400
 
+    service_tier, invalid_service_tier = resolve_service_tier(
+        payload.get("service_tier"),
+        current_app.config.get("SERVICE_TIER"),
+    )
+    if invalid_service_tier:
+        err = {"error": {"message": service_tier_error_message()}}
+        if verbose:
+            _log_json("OUT POST /v1/chat/completions", err)
+        return jsonify(err), 400
+
     requested_model = payload.get("model")
     model = normalize_model_name(requested_model, debug_model)
     messages = payload.get("messages")
@@ -187,6 +198,7 @@ def chat_completions() -> Response:
         tool_choice=tool_choice,
         parallel_tool_calls=parallel_tool_calls,
         reasoning_param=reasoning_param,
+        service_tier=service_tier,
     )
     if error_resp is not None:
         if verbose:
@@ -224,6 +236,7 @@ def chat_completions() -> Response:
                 tool_choice=safe_choice,
                 parallel_tool_calls=parallel_tool_calls,
                 reasoning_param=reasoning_param,
+                service_tier=service_tier,
             )
             record_rate_limits_from_response(upstream2)
             if err2 is None and upstream2 is not None and upstream2.status_code < 400:
@@ -391,6 +404,16 @@ def completions() -> Response:
             _log_json("OUT POST /v1/completions", err)
         return jsonify(err), 400
 
+    service_tier, invalid_service_tier = resolve_service_tier(
+        payload.get("service_tier"),
+        current_app.config.get("SERVICE_TIER"),
+    )
+    if invalid_service_tier:
+        err = {"error": {"message": service_tier_error_message()}}
+        if verbose:
+            _log_json("OUT POST /v1/completions", err)
+        return jsonify(err), 400
+
     requested_model = payload.get("model")
     model = normalize_model_name(requested_model, debug_model)
     prompt = payload.get("prompt")
@@ -418,6 +441,7 @@ def completions() -> Response:
         input_items,
         instructions=_instructions_for_model(model),
         reasoning_param=reasoning_param,
+        service_tier=service_tier,
     )
     if error_resp is not None:
         if verbose:

chatmock/service_tier.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+VALID_SERVICE_TIERS = ("fast",)
+_VALID_SERVICE_TIERS = frozenset(VALID_SERVICE_TIERS)
+_NORMAL_SERVICE_TIERS = frozenset(("auto", "default", "flex"))
+
+
+def normalize_service_tier(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    tier = value.strip().lower()
+    if tier == "priority":
+        return "fast"
+    if tier in _VALID_SERVICE_TIERS:
+        return tier
+    return None
+
+
+def parse_service_tier(value: Any) -> tuple[str | None, bool]:
+    if value is None:
+        return None, False
+    if isinstance(value, str) and value.strip().lower() in _NORMAL_SERVICE_TIERS:
+        return None, False
+    tier = normalize_service_tier(value)
+    return tier, tier is None
+
+
+def resolve_service_tier(request_value: Any, default_value: Any) -> tuple[str | None, bool]:
+    if isinstance(request_value, str) and request_value.strip().lower() in _NORMAL_SERVICE_TIERS:
+        return None, False
+    request_tier, invalid = parse_service_tier(request_value)
+    if invalid:
+        return None, True
+    return request_tier or normalize_service_tier(default_value), False
+
+
+def upstream_service_tier(value: Any) -> str | None:
+    tier = normalize_service_tier(value)
+    if tier == "fast":
+        return "priority"
+    return tier
+
+
+def service_tier_error_message() -> str:
+    return "Invalid service_tier. Expected: fast"

chatmock/upstream.py

@@ -11,6 +11,7 @@
 from .http import build_cors_headers
 from .model_registry import normalize_model_name
 from .session import ensure_session_id
+from .service_tier import upstream_service_tier
 from flask import request as flask_request
 from .utils import get_effective_chatgpt_auth
 
@@ -33,6 +34,7 @@ def start_upstream_request(
     tool_choice: Any | None = None,
     parallel_tool_calls: bool = False,
     reasoning_param: Dict[str, Any] | None = None,
+    service_tier: str | None = None,
 ):
     access_token, account_id = get_effective_chatgpt_auth()
     if not access_token or not account_id:
@@ -81,6 +83,9 @@ def start_upstream_request(
 
     if reasoning_param is not None:
         responses_payload["reasoning"] = reasoning_param
+    upstream_tier = upstream_service_tier(service_tier)
+    if upstream_tier is not None:
+        responses_payload["service_tier"] = upstream_tier
 
     verbose = False
     try: