Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

add codex fast model aliases

Raine Virta83cae8d3b947
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 089cd43..a2a70f8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,8 @@
- Added `codex.serviceTier` / `CCP_CODEX_SERVICE_TIER` to request Codex service
tiers. The Codex-style `fast` value is sent upstream as `priority`, matching
the first-party Codex client.
+- Added `-fast` Codex model aliases such as `gpt-5.4-fast[1m]`, which request
+ fast mode per request without restarting the proxy.
## v0.0.9 (2026-05-03)
diff --git a/README.md b/README.md
index b44c6e2..511ae71 100644
--- a/README.md
+++ b/README.md
@@ -88,7 +88,7 @@ upstream for each request is chosen from `ANTHROPIC_MODEL`.
`ANTHROPIC_MODEL` selects the provider:
-- `gpt-5.4`, `gpt-5.3-codex`, `gpt-5.4-mini`, `gpt-5.2` → **codex**
+- `gpt-5.5`, `gpt-5.4`, `gpt-5.3-codex`, `gpt-5.4-mini`, `gpt-5.2` → **codex**
- `kimi-for-coding`, `kimi-k2.6`, `k2.6` → **kimi**
An unknown model returns a 400 listing the supported ids. There is no
@@ -217,6 +217,11 @@ the change immediately; existing sessions keep whatever they started with.
Upstream: `https://chatgpt.com/backend-api/codex/responses` (Responses API).
Set `ANTHROPIC_MODEL` to a model your ChatGPT subscription is allowed to use.
+Append `-fast` to a Codex model name to request Codex fast mode for that request
+without restarting the proxy. For example, `gpt-5.4-fast[1m]` is sent upstream as
+model `gpt-5.4` with `service_tier: "priority"`. An explicit
+`codex.serviceTier` / `CCP_CODEX_SERVICE_TIER` override still takes precedence.
+
Confirmed working on **Plus**:
- `gpt-5.4`
@@ -475,9 +480,9 @@ directory the auth tokens use, deliberately not `~/Library`) and at
| `CCP_LOG_VERBOSE` | `log.verbose` | unset | Log full request/response bodies + every SSE event |
| `CCP_KIMI_OAUTH_HOST` | `kimi.oauthHost` | `https://auth.kimi.com` | Override Kimi's OAuth host (debugging only) |
| `CCP_KIMI_BASE_URL` | `kimi.baseUrl` | `https://api.kimi.com/coding/v1` | Override Kimi's API base URL |
-| `CCP_CODEX_MODEL` | `codex.model` | unset | Force all Codex requests to this model (`gpt-5.2`, `gpt-5.3-codex`, `gpt-5.4`, `gpt-5.4-mini`) |
+| `CCP_CODEX_MODEL` | `codex.model` | unset | Force all Codex requests to this model (`gpt-5.2`, `gpt-5.3-codex`, `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.5`) |
| `CCP_CODEX_EFFORT` | `codex.effort` | unset | Force all Codex requests to this reasoning effort (`none`, `low`, `medium`, `high`, `xhigh`) |
-| `CCP_CODEX_SERVICE_TIER` | `codex.serviceTier` | unset | Force all Codex requests to this service tier (`fast`, `priority`, `flex`) |
+| `CCP_CODEX_SERVICE_TIER` | `codex.serviceTier` | unset | Force all Codex requests to this service tier (`fast`/`priority`, `flex`; `fast` is sent upstream as `priority`) |
| `CCP_CODEX_ORIGINATOR` | `codex.originator` | `claude-code-proxy` | Override the `originator` header sent to Codex |
| `CCP_CODEX_USER_AGENT` | `codex.userAgent` | `claude-code-proxy/<version>` | Override the `User-Agent` header sent to Codex |
| `CCP_KIMI_USER_AGENT` | `kimi.userAgent` | `KimiCLI/1.37.0` | Override the `User-Agent` header sent to Kimi |
diff --git a/src/providers/codex/index.test.ts b/src/providers/codex/index.test.ts
new file mode 100644
index 0000000..d00a7d4
--- /dev/null
+++ b/src/providers/codex/index.test.ts
@@ -0,0 +1,60 @@
+import { afterEach, describe, expect, it } from "bun:test"
+import type { RequestContext } from "../types.ts"
+import { loadConfig } from "../../config.ts"
+import { codexProvider } from "./index.ts"
+
+const ctx: RequestContext = {
+ reqId: "test-req",
+ signal: new AbortController().signal,
+ childLogger: () => ({
+ debug() {},
+ info() {},
+ warn() {},
+ error() {},
+ child() {
+ return this
+ },
+ }),
+}
+
+afterEach(() => {
+ loadConfig({ forceReload: true })
+})
+
+describe("codexProvider", () => {
+ it("returns 400 for invalid service tier config during token counting", async () => {
+ loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true })
+
+ const resp = await codexProvider.handleCountTokens(
+ { model: "gpt-5.4", messages: [{ role: "user", content: "hello" }] },
+ ctx,
+ )
+
+ expect(resp.status).toBe(400)
+ expect(await resp.json()).toEqual({
+ type: "error",
+ error: {
+ type: "invalid_request_error",
+ message: 'Invalid service tier override: "standard". Must be one of: fast, priority, flex',
+ },
+ })
+ })
+
+ it("returns 400 for invalid forced model during token counting", async () => {
+ loadConfig({ env: { CCP_CODEX_MODEL: "gpt-4.1" }, forceReload: true })
+
+ const resp = await codexProvider.handleCountTokens(
+ { model: "gpt-5.4", messages: [{ role: "user", content: "hello" }] },
+ ctx,
+ )
+
+ expect(resp.status).toBe(400)
+ expect(await resp.json()).toEqual({
+ type: "error",
+ error: {
+ type: "invalid_request_error",
+ message: 'Model "gpt-5.4" resolves to unsupported model "gpt-4.1"',
+ },
+ })
+ })
+})
diff --git a/src/providers/codex/index.ts b/src/providers/codex/index.ts
index b41ff79..3676c4d 100644
--- a/src/providers/codex/index.ts
+++ b/src/providers/codex/index.ts
@@ -1,11 +1,13 @@
import type { AnthropicRequest } from "../../anthropic/schema.ts"
import type { Provider, RequestContext, CliHandlers } from "../types.ts"
import {
+ ALLOWED_MODELS,
assertAllowedModel,
+ FAST_MODEL_ALIASES,
ModelNotAllowedError,
- resolveModel,
+ resolveModelRequest,
} from "./translate/model-allowlist.ts"
-import { translateRequest } from "./translate/request.ts"
+import { InvalidServiceTierError, translateRequest } from "./translate/request.ts"
import { translateStream } from "./translate/stream.ts"
import { accumulateResponse, UpstreamStreamError } from "./translate/accumulate.ts"
import { mapUsageToAnthropic } from "./translate/reducer.ts"
@@ -82,10 +84,29 @@ function jsonError(status: number, type: string, message: string): Response {
})
}
+function invalidServiceTierResponse(err: InvalidServiceTierError): Response {
+ return jsonError(400, "invalid_request_error", err.message)
+}
+
async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
const log = ctx.childLogger("provider.codex")
- const resolvedModel = resolveModel(body.model)
- const translated = translateRequest({ ...body, model: resolvedModel })
+ const resolved = resolveModelRequest(body.model)
+ const resolvedModel = resolved.model
+ let translated
+ try {
+ assertAllowedModel(resolvedModel)
+ translated = translateRequest({ ...body, model: resolvedModel }, { serviceTier: resolved.serviceTier })
+ } catch (err) {
+ if (err instanceof ModelNotAllowedError) {
+ return jsonError(
+ 400,
+ "invalid_request_error",
+ `Model "${body.model}" resolves to unsupported model "${err.model}"`,
+ )
+ }
+ if (err instanceof InvalidServiceTierError) return invalidServiceTierResponse(err)
+ throw err
+ }
const tokens = countTranslatedTokens(translated)
const messageCount = body.messages?.length ?? 0
const toolCount = body.tools?.length ?? 0
@@ -141,10 +162,16 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
})
if (logVerbose()) log.debug("anthropic request body", { body })
- const resolvedModel = resolveModel(body.model)
+ const resolved = resolveModelRequest(body.model)
+ const resolvedModel = resolved.model
+ let translated
try {
assertAllowedModel(resolvedModel)
+ translated = translateRequest(
+ { ...body, model: resolvedModel },
+ { sessionId: ctx.sessionId, serviceTier: resolved.serviceTier },
+ )
} catch (err) {
if (err instanceof ModelNotAllowedError) {
return jsonError(
@@ -153,10 +180,9 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
`Model "${body.model}" resolves to unsupported model "${err.model}"`,
)
}
+ if (err instanceof InvalidServiceTierError) return invalidServiceTierResponse(err)
throw err
}
-
- const translated = translateRequest({ ...body, model: resolvedModel }, { sessionId: ctx.sessionId })
const localInputTokens = logVerbose() ? countTokens(body) : undefined
const translatedInputTokens = logVerbose() ? countTranslatedTokens(translated) : undefined
if (state) {
@@ -361,7 +387,7 @@ const cli: CliHandlers = {
export const codexProvider: Provider = {
name: "codex",
- supportedModels: new Set(["gpt-5.2", "gpt-5.3-codex", "gpt-5.4", "gpt-5.4-mini", "gpt-5.5"]),
+ supportedModels: new Set([...ALLOWED_MODELS, ...FAST_MODEL_ALIASES]),
handleMessages,
handleCountTokens,
cli,
diff --git a/src/providers/codex/translate/model-allowlist.test.ts b/src/providers/codex/translate/model-allowlist.test.ts
index c16fbfc..2137d69 100644
--- a/src/providers/codex/translate/model-allowlist.test.ts
+++ b/src/providers/codex/translate/model-allowlist.test.ts
@@ -2,7 +2,7 @@ import { describe, expect, it, afterEach } from "bun:test"
import { mkdtempSync, writeFileSync, rmSync } from "node:fs"
import { tmpdir } from "node:os"
import { join } from "node:path"
-import { resolveModel } from "./model-allowlist.ts"
+import { resolveModel, resolveModelRequest } from "./model-allowlist.ts"
import { loadConfig } from "../../../config.ts"
afterEach(() => {
@@ -53,4 +53,25 @@ describe("resolveModel", () => {
loadConfig({ env: { CCP_CODEX_MODEL: "" }, forceReload: true })
expect(resolveModel("sonnet")).toBe("gpt-5.4")
})
+
+ it("detects fast model aliases", () => {
+ loadConfig({ env: {}, forceReload: true })
+ expect(resolveModelRequest("gpt-5.4-fast")).toEqual({
+ model: "gpt-5.4",
+ serviceTier: "priority",
+ })
+ })
+
+ it("model override preserves fast model alias service tier", () => {
+ loadConfig({ env: { CCP_CODEX_MODEL: "gpt-5.5" }, forceReload: true })
+ expect(resolveModelRequest("gpt-5.4-fast")).toEqual({
+ model: "gpt-5.5",
+ serviceTier: "priority",
+ })
+ })
+
+ it("does not strip unsupported fast-looking model names", () => {
+ loadConfig({ env: {}, forceReload: true })
+ expect(resolveModelRequest("gpt-4.1-fast")).toEqual({ model: "gpt-4.1-fast" })
+ })
})
diff --git a/src/providers/codex/translate/model-allowlist.ts b/src/providers/codex/translate/model-allowlist.ts
index 213b5f1..e045763 100644
--- a/src/providers/codex/translate/model-allowlist.ts
+++ b/src/providers/codex/translate/model-allowlist.ts
@@ -1,4 +1,5 @@
import { codexModel } from "../../../config.ts"
+import type { ServiceTier } from "./request.ts"
export const ALLOWED_MODELS = new Set([
"gpt-5.2",
@@ -8,6 +9,10 @@ export const ALLOWED_MODELS = new Set([
"gpt-5.5",
])
+export const FAST_MODEL_ALIASES = new Set(
+ Array.from(ALLOWED_MODELS, (model) => `${model}-fast`),
+)
+
export const MODEL_ALIASES = new Map<string, string>([
["haiku", "gpt-5.4-mini"],
["claude-haiku-4-5", "gpt-5.4-mini"],
@@ -18,15 +23,29 @@ export const MODEL_ALIASES = new Map<string, string>([
["claude-opus-4-7", "gpt-5.5"],
])
+export interface ResolvedModel {
+ model: string
+ serviceTier?: ServiceTier
+}
+
export function resolveModel(model: string): string {
+ return resolveModelRequest(model).model
+}
+
+export function resolveModelRequest(model: string): ResolvedModel {
// CCP_CODEX_MODEL (env) or codex.model (config.json) overrides the model
// so that regardless of whatever model is requested by the harness, the
// provided model is always used. Empty values fall through to alias
// resolution.
+ const alias = MODEL_ALIASES.get(model) ?? model
+ const isFastAlias = FAST_MODEL_ALIASES.has(alias)
+ const modelWithoutTier = isFastAlias ? alias.slice(0, -"-fast".length) : alias
const override = codexModel()
- if (override !== undefined) return override
- return MODEL_ALIASES.get(model) ?? model
+ return {
+ model: override ?? modelWithoutTier,
+ ...(isFastAlias ? { serviceTier: "priority" } : {}),
+ }
}
export function assertAllowedModel(model: string): void {
diff --git a/src/providers/codex/translate/request.test.ts b/src/providers/codex/translate/request.test.ts
index ceb5739..efb4f96 100644
--- a/src/providers/codex/translate/request.test.ts
+++ b/src/providers/codex/translate/request.test.ts
@@ -1,8 +1,7 @@
import { afterEach, describe, expect, it } from "bun:test"
import { loadConfig } from "../../../config.ts"
import type { AnthropicRequest } from "../../../anthropic/schema.ts"
-import { translateRequest } from "./request.ts"
-
+import { InvalidServiceTierError, translateRequest } from "./request.ts"
const baseRequest: AnthropicRequest = {
model: "claude-sonnet-4-6",
messages: [{ role: "user", content: "hello" }],
@@ -46,9 +45,26 @@ describe("translateRequest", () => {
expect(translated.service_tier).toBe("flex")
})
+ it("uses model service tier when no override is set", () => {
+ loadConfig({ env: {}, forceReload: true })
+
+ const translated = translateRequest(baseRequest, { serviceTier: "priority" })
+
+ expect(translated.service_tier).toBe("priority")
+ })
+
+ it("service tier override takes precedence over model service tier", () => {
+ loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "flex" }, forceReload: true })
+
+ const translated = translateRequest(baseRequest, { serviceTier: "priority" })
+
+ expect(translated.service_tier).toBe("flex")
+ })
+
it("rejects invalid service tier overrides", () => {
loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true })
+ expect(() => translateRequest(baseRequest)).toThrow(InvalidServiceTierError)
expect(() => translateRequest(baseRequest)).toThrow('Invalid service tier override: "standard"')
})
diff --git a/src/providers/codex/translate/request.ts b/src/providers/codex/translate/request.ts
index 58824ea..74ddf08 100644
--- a/src/providers/codex/translate/request.ts
+++ b/src/providers/codex/translate/request.ts
@@ -11,6 +11,15 @@ import { codexEffort, codexServiceTier } from "../../../config.ts"
export type Effort = "none" | "low" | "medium" | "high" | "xhigh"
export type ServiceTier = "priority" | "flex"
+export class InvalidServiceTierError extends Error {
+ constructor(public serviceTier: string) {
+ super(
+ `Invalid service tier override: "${serviceTier}". Must be one of: ${Array.from(VALID_SERVICE_TIERS).join(", ")}`,
+ )
+ this.name = "InvalidServiceTierError"
+ }
+}
+
// Keep this aligned to the upstream Codex ResponsesApiRequest field set.
// Do not add plausible-looking top-level fields without source support or a confirmed live test.
export interface ResponsesRequest {
@@ -73,6 +82,7 @@ export interface ResponsesTool {
export interface TranslateOptions {
sessionId?: string
+ serviceTier?: ServiceTier
}
const VALID_EFFORTS = new Set<Effort>(["none", "low", "medium", "high", "xhigh"])
@@ -109,17 +119,19 @@ function resolveEffort(effort?: Effort): Effort | undefined {
return override as Effort
}
-function resolveServiceTier(): ServiceTier | undefined {
- const tier = codexServiceTier()
- if (tier === undefined) return undefined
+function normalizeServiceTier(tier: string): ServiceTier {
if (!VALID_SERVICE_TIERS.has(tier)) {
- throw new Error(
- `Invalid service tier override: "${tier}". Must be one of: ${Array.from(VALID_SERVICE_TIERS).join(", ")}`,
- )
+ throw new InvalidServiceTierError(tier)
}
return tier === "flex" ? "flex" : "priority"
}
+function resolveServiceTier(modelServiceTier?: ServiceTier): ServiceTier | undefined {
+ const tier = codexServiceTier()
+ if (tier === undefined) return modelServiceTier
+ return normalizeServiceTier(tier)
+}
+
export function translateRequest(req: AnthropicRequest, opts: TranslateOptions = {}): ResponsesRequest {
const instructions = buildInstructions(req.system)
const input = buildInput(req.messages)
@@ -148,7 +160,7 @@ export function translateRequest(req: AnthropicRequest, opts: TranslateOptions =
if (instructions) out.instructions = instructions
if (tools && tools.length) out.tools = tools
if (opts.sessionId) out.prompt_cache_key = opts.sessionId
- const serviceTier = resolveServiceTier()
+ const serviceTier = resolveServiceTier(opts.serviceTier)
if (serviceTier) out.service_tier = serviceTier
assertValidEffort(req.output_config?.effort)
const effort = resolveEffort(toCodexEffort(req.output_config?.effort))
diff --git a/src/providers/registry.test.ts b/src/providers/registry.test.ts
new file mode 100644
index 0000000..bd318f5
--- /dev/null
+++ b/src/providers/registry.test.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "bun:test"
+import { providerForModel } from "./registry.ts"
+import { normalizeIncomingModel } from "../server.ts"
+
+describe("provider routing", () => {
+ it("routes fast Codex model aliases after context suffix normalization", () => {
+ const model = normalizeIncomingModel("gpt-5.4-fast[1m]")
+
+ expect(model).toBe("gpt-5.4-fast")
+ expect(providerForModel(model)?.name).toBe("codex")
+ })
+})
diff --git a/src/server.ts b/src/server.ts
index 960847b..7fa73e3 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -105,7 +105,7 @@ function buildCtx(req: Request, reqId: string, providerName: string): RequestCon
// window. Claude Code normalizes this away before sending requests to
// the API, but we strip it here too as defense-in-depth in case a
// future version or a different client includes it.
-function normalizeIncomingModel(model: string): string {
+export function normalizeIncomingModel(model: string): string {
return model.replace(/\[1m\]$/i, "")
}