feat(openai-codex): add Fast priority mode

Author: WebMad

packages/types/src/__tests__/provider-settings.test.ts

@@ -1,4 +1,43 @@
-import { getApiProtocol } from "../provider-settings.js"
+import {
+	getApiProtocol,
+	PROVIDER_SETTINGS_KEYS,
+	providerSettingsSchema,
+	providerSettingsSchemaDiscriminated,
+} from "../provider-settings.js"
+
+describe("OpenAI Codex provider settings", () => {
+	it("preserves the Fast preference in general and provider-specific schemas", () => {
+		const settings = {
+			apiProvider: "openai-codex" as const,
+			apiModelId: "gpt-5.6-sol",
+			openAiCodexServiceTier: "priority" as const,
+		}
+
+		expect(providerSettingsSchema.parse(settings)).toEqual(settings)
+		expect(providerSettingsSchemaDiscriminated.parse(settings)).toEqual(settings)
+		expect(PROVIDER_SETTINGS_KEYS).toContain("openAiCodexServiceTier")
+	})
+
+	it.each([undefined, "default"])("accepts %s as the Standard preference", (openAiCodexServiceTier) => {
+		const standardSettings = {
+			apiProvider: "openai-codex" as const,
+			apiModelId: "gpt-5.6-sol",
+			...(openAiCodexServiceTier ? { openAiCodexServiceTier } : {}),
+		}
+
+		expect(providerSettingsSchemaDiscriminated.parse(standardSettings)).toEqual(standardSettings)
+	})
+
+	it("rejects unsupported service tiers", () => {
+		expect(
+			providerSettingsSchemaDiscriminated.safeParse({
+				apiProvider: "openai-codex",
+				apiModelId: "gpt-5.6-sol",
+				openAiCodexServiceTier: "flex",
+			}).success,
+		).toBe(false)
+	})
+})
 
 describe("getApiProtocol", () => {
 	describe("Anthropic-style providers", () => {

packages/types/src/provider-settings.ts

@@ -277,7 +277,8 @@ const geminiCliSchema = apiModelIdProviderModelSchema.extend({
 })
 
 const openAiCodexSchema = apiModelIdProviderModelSchema.extend({
-	// No additional settings needed - uses OAuth authentication
+	// Codex "Fast" mode maps to the Responses API priority service tier.
+	openAiCodexServiceTier: z.enum(["default", "priority"]).optional(),
 })
 
 const openAiNativeSchema = apiModelIdProviderModelSchema.extend({

src/api/providers/__tests__/openai-codex.spec.ts

@@ -76,6 +76,78 @@ describe("OpenAiCodexHandler.getModel", () => {
 })
 
 describe("OpenAiCodexHandler.createMessage", () => {
+	afterEach(() => {
+		vitest.restoreAllMocks()
+		vitest.unstubAllGlobals()
+	})
+
+	it("sends the priority service tier in streaming SDK requests when Fast is selected", async () => {
+		const handler = new OpenAiCodexHandler({
+			apiModelId: "gpt-5.6-sol",
+			openAiCodexServiceTier: "priority",
+		})
+		vitest.spyOn(openAiCodexOAuthManager, "getAccessToken").mockResolvedValue("test-token")
+		vitest.spyOn(openAiCodexOAuthManager, "getAccountId").mockResolvedValue("acct_test")
+		const mockCreate = vitest.fn().mockResolvedValue(createCompletedStream())
+		Reflect.set(handler, "client", { responses: { create: mockCreate } })
+
+		await drainStream(handler.createMessage("System prompt", []))
+
+		const [body] = mockCreate.mock.calls[0]
+		expect(body).toMatchObject({ stream: true, service_tier: "priority" })
+	})
+
+	it.each([
+		["an absent preference", {}],
+		["an explicit Standard preference from an older profile", { openAiCodexServiceTier: "default" }],
+	])("omits the service tier in streaming SDK requests for %s", async (_description, serviceTierOptions) => {
+		const handler = new OpenAiCodexHandler({
+			apiModelId: "gpt-5.6-sol",
+			...serviceTierOptions,
+		} as ConstructorParameters<typeof OpenAiCodexHandler>[0])
+		vitest.spyOn(openAiCodexOAuthManager, "getAccessToken").mockResolvedValue("test-token")
+		vitest.spyOn(openAiCodexOAuthManager, "getAccountId").mockResolvedValue("acct_test")
+		const mockCreate = vitest.fn().mockResolvedValue(createCompletedStream())
+		Reflect.set(handler, "client", { responses: { create: mockCreate } })
+
+		await drainStream(handler.createMessage("System prompt", []))
+
+		expect(mockCreate.mock.calls[0][0]).not.toHaveProperty("service_tier")
+	})
+
+	it("preserves the priority service tier in the manual streaming fallback", async () => {
+		const handler = new OpenAiCodexHandler({
+			apiModelId: "gpt-5.6-sol",
+			openAiCodexServiceTier: "priority",
+		})
+		vitest.spyOn(openAiCodexOAuthManager, "getAccessToken").mockResolvedValue("test-token")
+		vitest.spyOn(openAiCodexOAuthManager, "getAccountId").mockResolvedValue("acct_test")
+		Reflect.set(handler, "client", {
+			responses: { create: vitest.fn().mockRejectedValue(new Error("SDK unavailable")) },
+		})
+		const mockFetch = vitest.fn().mockResolvedValue({
+			ok: true,
+			body: new ReadableStream({
+				start(controller) {
+					controller.enqueue(
+						new TextEncoder().encode(
+							'data: {"type":"response.completed","response":{"output":[],"usage":{"input_tokens":1,"output_tokens":1}}}\n\n',
+						),
+					)
+					controller.close()
+				},
+			}),
+		})
+		vitest.stubGlobal("fetch", mockFetch)
+
+		await drainStream(handler.createMessage("System prompt", []))
+
+		expect(JSON.parse(mockFetch.mock.calls[0][1].body)).toMatchObject({
+			stream: true,
+			service_tier: "priority",
+		})
+	})
+
 	it("should skip URL-sourced images in formatFullConversation (only base64 emits input_image)", async () => {
 		const handler = new OpenAiCodexHandler({ apiModelId: "gpt-5.1-codex" })
 
@@ -176,6 +248,40 @@ describe("OpenAiCodexHandler.createMessage", () => {
 	})
 })
 
+describe("OpenAiCodexHandler.completePrompt service tier", () => {
+	afterEach(() => {
+		vitest.restoreAllMocks()
+		vitest.unstubAllGlobals()
+	})
+
+	it.each([
+		["Fast", "priority", "priority"],
+		["Standard", undefined, undefined],
+	])("uses the %s preference in non-streaming requests", async (_mode, configuredTier, expectedTier) => {
+		const handler = new OpenAiCodexHandler({
+			apiModelId: "gpt-5.6-sol",
+			...(configuredTier ? { openAiCodexServiceTier: configuredTier as "priority" } : {}),
+		})
+		vitest.spyOn(openAiCodexOAuthManager, "getAccessToken").mockResolvedValue("test-token")
+		vitest.spyOn(openAiCodexOAuthManager, "getAccountId").mockResolvedValue("acct_test")
+		const mockFetch = vitest.fn().mockResolvedValue({
+			ok: true,
+			json: vitest.fn().mockResolvedValue({ text: "Complete" }),
+		})
+		vitest.stubGlobal("fetch", mockFetch)
+
+		await expect(handler.completePrompt("Hello")).resolves.toBe("Complete")
+
+		const body = JSON.parse(mockFetch.mock.calls[0][1].body)
+		expect(body.stream).toBe(false)
+		if (expectedTier) {
+			expect(body.service_tier).toBe(expectedTier)
+		} else {
+			expect(body).not.toHaveProperty("service_tier")
+		}
+	})
+})
+
 describe("transformLunaResponsesLiteBody", () => {
 	it("creates the exact Responses Lite body while preserving unrelated fields and reasoning", () => {
 		const tools = [{ type: "function", name: "read_file", parameters: { type: "object" } }]

src/api/providers/openai-codex.ts

@@ -29,6 +29,8 @@ import { t } from "../../i18n"
 
 export type OpenAiCodexModel = ReturnType<OpenAiCodexHandler["getModel"]>
 
+type OpenAiCodexRequestServiceTier = "priority"
+
 /**
  * OpenAI Codex base URL for API requests
  * Per the implementation guide: requests are routed to chatgpt.com/backend-api/codex
@@ -37,6 +39,10 @@ const CODEX_API_BASE_URL = "https://chatgpt.com/backend-api/codex"
 const LUNA_MODEL_ID = "gpt-5.6-luna"
 const LUNA_CODEX_VERSION = "0.144.0"
 
+function getOpenAiCodexServiceTier(options: ApiHandlerOptions): OpenAiCodexRequestServiceTier | undefined {
+	return options.openAiCodexServiceTier === "priority" ? "priority" : undefined
+}
+
 function stripInputImageDetail(value: any): any {
 	if (Array.isArray(value)) {
 		return value.map(stripInputImageDetail)
@@ -365,6 +371,7 @@ export class OpenAiCodexHandler extends BaseProvider implements SingleCompletion
 			model: string
 			input: Array<{ role: "user" | "assistant"; content: any[] } | { type: string; content: string }>
 			stream: boolean
+			service_tier?: OpenAiCodexRequestServiceTier
 			reasoning?: { effort?: ReasoningEffortExtended; summary?: "auto" }
 			temperature?: number
 			store?: boolean
@@ -383,12 +390,14 @@ export class OpenAiCodexHandler extends BaseProvider implements SingleCompletion
 
 		// Per the implementation guide: Codex backend may reject max_output_tokens
 		// and prompt_cache_retention, so we omit them
+		const serviceTier = getOpenAiCodexServiceTier(this.options)
 		const body: ResponsesRequestBody = {
 			model: model.id,
 			input: formattedInput,
 			stream: true,
 			store: false,
 			instructions: systemPrompt,
+			...(serviceTier ? { service_tier: serviceTier } : {}),
 			// Only include encrypted reasoning content when reasoning effort is set
 			...(reasoningEffort ? { include: ["reasoning.encrypted_content"] } : {}),
 			...(reasoningEffort
@@ -1261,6 +1270,7 @@ export class OpenAiCodexHandler extends BaseProvider implements SingleCompletion
 			}
 
 			const reasoningEffort = this.getReasoningEffort(model)
+			const serviceTier = getOpenAiCodexServiceTier(this.options)
 
 			const baseRequestBody: any = {
 				model: model.id,
@@ -1272,6 +1282,7 @@ export class OpenAiCodexHandler extends BaseProvider implements SingleCompletion
 				],
 				stream: false,
 				store: false,
+				...(serviceTier ? { service_tier: serviceTier } : {}),
 				...(reasoningEffort ? { include: ["reasoning.encrypted_content"] } : {}),
 			}
 

src/core/config/__tests__/ProviderSettingsManager.spec.ts

@@ -451,6 +451,32 @@ describe("ProviderSettingsManager", () => {
 			expect(storedConfig).toEqual(expectedConfig)
 		})
 
+		it.each(["default", "priority"] as const)(
+			"should persist the OpenAI Codex %s speed preference",
+			async (openAiCodexServiceTier) => {
+				mockSecrets.get.mockResolvedValue(
+					JSON.stringify({
+						currentApiConfigName: "default",
+						apiConfigs: { default: {} },
+						modeApiConfigs: {},
+					}),
+				)
+
+				await providerSettingsManager.saveConfig("codex", {
+					apiProvider: "openai-codex",
+					apiModelId: "gpt-5.6-sol",
+					openAiCodexServiceTier,
+				})
+
+				const storedProfiles = JSON.parse(mockSecrets.store.mock.calls.at(-1)?.[1])
+				expect(storedProfiles.apiConfigs.codex).toMatchObject({
+					apiProvider: "openai-codex",
+					apiModelId: "gpt-5.6-sol",
+					openAiCodexServiceTier,
+				})
+			},
+		)
+
 		it("should only save provider relevant settings", async () => {
 			mockSecrets.get.mockResolvedValue(
 				JSON.stringify({

webview-ui/src/components/settings/providers/OpenAICodex.tsx

@@ -3,7 +3,15 @@ import React from "react"
 import { type ProviderSettings, openAiCodexDefaultModelId, openAiCodexModels } from "@roo-code/types"
 
 import { useAppTranslation } from "@src/i18n/TranslationContext"
-import { Button } from "@src/components/ui"
+import {
+	Button,
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+	StandardTooltip,
+} from "@src/components/ui"
 import { vscode } from "@src/utils/vscode"
 
 import { ModelPicker } from "../ModelPicker"
@@ -66,6 +74,31 @@ export const OpenAICodex: React.FC<OpenAICodexProps> = ({
 				simplifySettings={simplifySettings}
 				hidePricing
 			/>
+
+			<div className="flex flex-col gap-1" data-testid="openai-codex-service-tier">
+				<div className="flex items-center gap-1">
+					<label className="block font-medium">{t("settings:openAiCodexSpeed.label")}</label>
+					<StandardTooltip content={t("settings:openAiCodexSpeed.tooltip")}>
+						<i className="codicon codicon-info text-vscode-descriptionForeground text-xs" />
+					</StandardTooltip>
+				</div>
+				<Select
+					value={apiConfiguration.openAiCodexServiceTier ?? "default"}
+					onValueChange={(value) =>
+						setApiConfigurationField(
+							"openAiCodexServiceTier",
+							value as ProviderSettings["openAiCodexServiceTier"],
+						)
+					}>
+					<SelectTrigger className="w-full">
+						<SelectValue placeholder={t("settings:common.select")} />
+					</SelectTrigger>
+					<SelectContent>
+						<SelectItem value="default">{t("settings:openAiCodexSpeed.standard")}</SelectItem>
+						<SelectItem value="priority">{t("settings:openAiCodexSpeed.fast")}</SelectItem>
+					</SelectContent>
+				</Select>
+			</div>
 		</div>
 	)
 }

webview-ui/src/components/settings/providers/__tests__/OpenAICodex.spec.tsx

@@ -0,0 +1,83 @@
+import React from "react"
+
+import type { ProviderSettings } from "@roo-code/types"
+
+import { fireEvent, render, screen } from "@/utils/test-utils"
+
+import { OpenAICodex } from "../OpenAICodex"
+
+vi.mock("@src/i18n/TranslationContext", () => ({
+	useAppTranslation: () => ({
+		t: (key: string) =>
+			({
+				"settings:openAiCodexSpeed.label": "Speed",
+				"settings:openAiCodexSpeed.tooltip":
+					"Fast uses Codex priority processing for about 1.5x speed and consumes more subscription quota.",
+				"settings:openAiCodexSpeed.standard": "Standard",
+				"settings:openAiCodexSpeed.fast": "Fast (1.5x speed, increased usage)",
+			})[key] ?? key,
+	}),
+}))
+
+vi.mock("@src/components/ui", () => ({
+	Button: ({ children, ...props }: React.ButtonHTMLAttributes<HTMLButtonElement>) => (
+		<button {...props}>{children}</button>
+	),
+	Select: ({ children, value, onValueChange }: any) => (
+		<select aria-label="Speed" value={value} onChange={(event) => onValueChange(event.target.value)}>
+			{children}
+		</select>
+	),
+	SelectContent: ({ children }: any) => <>{children}</>,
+	SelectItem: ({ children, value }: any) => <option value={value}>{children}</option>,
+	SelectTrigger: ({ children }: any) => <>{children}</>,
+	SelectValue: () => null,
+	StandardTooltip: ({ children, content }: any) => <span title={content}>{children}</span>,
+}))
+
+vi.mock("../../ModelPicker", () => ({
+	ModelPicker: () => <div data-testid="model-picker" />,
+}))
+
+vi.mock("../OpenAICodexRateLimitDashboard", () => ({
+	OpenAICodexRateLimitDashboard: () => null,
+}))
+
+vi.mock("@src/utils/vscode", () => ({
+	vscode: { postMessage: vi.fn() },
+}))
+
+describe("OpenAICodex speed selector", () => {
+	const renderSelector = (apiConfiguration: ProviderSettings, setApiConfigurationField = vi.fn()) => {
+		render(<OpenAICodex apiConfiguration={apiConfiguration} setApiConfigurationField={setApiConfigurationField} />)
+		return { setApiConfigurationField, selector: screen.getByRole("combobox", { name: "Speed" }) }
+	}
+
+	it("defaults to Standard and clearly explains the Fast quota trade-off", () => {
+		const { selector } = renderSelector({ apiProvider: "openai-codex" })
+
+		expect(selector).toHaveValue("default")
+		expect(screen.getByRole("option", { name: "Standard" })).toBeInTheDocument()
+		expect(screen.getByRole("option", { name: "Fast (1.5x speed, increased usage)" })).toBeInTheDocument()
+		expect(
+			screen.getByTitle(
+				"Fast uses Codex priority processing for about 1.5x speed and consumes more subscription quota.",
+			),
+		).toBeInTheDocument()
+	})
+
+	it("selects Fast from a saved preference and persists changes through the settings callback", () => {
+		const { selector, setApiConfigurationField } = renderSelector({
+			apiProvider: "openai-codex",
+			openAiCodexServiceTier: "priority",
+		})
+
+		expect(selector).toHaveValue("priority")
+
+		fireEvent.change(selector, { target: { value: "default" } })
+		expect(setApiConfigurationField).toHaveBeenLastCalledWith("openAiCodexServiceTier", "default")
+
+		fireEvent.change(selector, { target: { value: "priority" } })
+		expect(setApiConfigurationField).toHaveBeenLastCalledWith("openAiCodexServiceTier", "priority")
+	})
+})