Merge branch 'main' into fix/router-provider-context-window

Author: JamesRobert20

apps/vscode-e2e/AGENTS.md

@@ -121,6 +121,17 @@ Example:
 
 The `model` field can be added to either match when a test targets a specific model.
 
+## Delaying a fixture response (simulating a slow or hung provider)
+
+Use `streamingProfile: { ttft: <ms> }` on a fixture, not a flat `latency: <ms>`, when a test needs
+to simulate a slow or hung provider (e.g. to cancel an in-flight request mid-stream). `ttft` delays
+only the first SSE chunk, so the pending window is exactly the configured value. Flat `latency`
+delays _every_ chunk, and aimock never observes client disconnects — after a test cancels the
+request, a flat-latency stream keeps flushing chunks server-side for `chunks × latency` before
+reaching the dead socket, which can interleave with the next test's request against the same mock
+server. See `SUBTASK_API_HANG_RESPONSE_LATENCY_MS` in `fixtures/subtasks.ts` for an example,
+including the bounded post-test drain the calling suite uses to wait out that window.
+
 ## 404 errors in logs are expected
 
 Background API calls from the extension (usage collection, initialization) hit aimock with no matching fixture and return 404. These do **not** affect test results — the tests still pass. You'll see `[OpenRouter] API error: { message: '404 No fixture matched' }` in the output; this is normal.

apps/vscode-e2e/src/fixtures/subtasks.ts

@@ -33,6 +33,12 @@ export const SUBTASK_API_HANG_RESUME_MESSAGE = "Continue after provider hang."
 export const SUBTASK_API_HANG_CHILD_RESULT = "Hung child completed"
 export const SUBTASK_API_HANG_PARENT_RESULT = "API hang parent resumed"
 
+// How long the API-hang child's first mocked response stays pending before its first SSE
+// chunk. Shared with the subtask suite so its post-test drain waits exactly one window.
+// Correctness depends on no flat `latency` (fixture or LLMock default) being set on that
+// fixture — a flat latency would apply to every chunk after the first, not just the ttft.
+export const SUBTASK_API_HANG_RESPONSE_LATENCY_MS = 15_000
+
 // Abandon-subtask scenario (#559) — separate markers to avoid sequenceIndex collisions with the
 // interrupted-child-resumes tests above, which exhaust the sequence count for INTERRUPT markers.
 const SUBTASK_ABANDON_PARENT_MARKER = "SUBTASK_PARENT_ABANDON_SEVER"
@@ -261,8 +267,14 @@ export function addSubtaskFixtures(mock: InstanceType<typeof LLMock>) {
 			userMessage: apiHangChildMatch,
 			sequenceIndex: 0,
 		},
-		// Keep the first child response pending long enough for the e2e test to cancel an in-flight API request.
-		latency: 15_000,
+		// Keep the first child response pending long enough for the e2e test to cancel an in-flight
+		// API request. Delay only the first chunk (ttft) rather than using flat `latency`: aimock
+		// applies `latency` to EVERY chunk and never observes client disconnects, so after the test
+		// cancels, a flat-latency stream would stay pending server-side for chunks × latency before
+		// flushing to the dead socket. With ttft the pending window is exactly
+		// SUBTASK_API_HANG_RESPONSE_LATENCY_MS (see its doc comment for the no-flat-latency
+		// invariant this relies on), which is what the suite's post-test drain waits out.
+		streamingProfile: { ttft: SUBTASK_API_HANG_RESPONSE_LATENCY_MS },
 		response: {
 			toolCalls: [
 				{

apps/vscode-e2e/src/suite/subtasks.test.ts

@@ -16,6 +16,7 @@ import {
 	SUBTASK_API_HANG_PARENT_MARKER,
 	SUBTASK_API_HANG_PARENT_PROMPT,
 	SUBTASK_API_HANG_PARENT_RESULT,
+	SUBTASK_API_HANG_RESPONSE_LATENCY_MS,
 	SUBTASK_API_HANG_RESUME_MESSAGE,
 	SUBTASK_CHILD_FOLLOWUP_ANSWER,
 	SUBTASK_FAST_CHILD_RESULT,
@@ -33,6 +34,7 @@ import {
 type AimockMessageContent = string | Array<{ type?: string; text?: string }>
 
 type AimockJournalEntry = {
+	timestamp?: number
 	body?: {
 		messages?: Array<{
 			role?: string
@@ -49,24 +51,67 @@ const messageContentText = (content?: AimockMessageContent) => {
 	return content?.map((part) => part.text ?? "").join("") ?? ""
 }
 
-const waitForAimockRequestContaining = async (expectedText: string, excludeText?: string) => {
+const fetchAimockJournal = async () => {
 	const aimockUrl = process.env.AIMOCK_URL
 	assert.ok(aimockUrl, "AIMOCK_URL must be set for aimock journal assertions")
 
+	const response = await fetch(`${aimockUrl}/__aimock/journal`)
+	return (await response.json()) as AimockJournalEntry[]
+}
+
+const findAimockRequest = (entries: AimockJournalEntry[], expectedText: string, excludeText?: string) =>
+	entries.find((entry) => {
+		const messages = entry.body?.messages
+		if (!messages) return false
+		const entryText = messages.map((m) => messageContentText(m.content)).join("")
+		if (excludeText && entryText.includes(excludeText)) return false
+		return messages.some(
+			(message) => message.role === "user" && messageContentText(message.content).includes(expectedText),
+		)
+	})
+
+// Waits for a matching request to appear in the aimock journal and returns its journal
+// timestamp, so callers can anchor post-test drains to the exact request this test created.
+const waitForAimockRequestContaining = async (
+	expectedText: string,
+	excludeText?: string,
+): Promise<number | undefined> => {
+	let matchedAt: number | undefined
+
 	await waitFor(async () => {
-		const response = await fetch(`${aimockUrl}/__aimock/journal`)
-		const entries = (await response.json()) as AimockJournalEntry[]
-
-		return entries.some((entry) => {
-			const messages = entry.body?.messages
-			if (!messages) return false
-			const entryText = messages.map((m) => messageContentText(m.content)).join("")
-			if (excludeText && entryText.includes(excludeText)) return false
-			return messages.some(
-				(message) => message.role === "user" && messageContentText(message.content).includes(expectedText),
-			)
-		})
+		matchedAt = findAimockRequest(await fetchAimockJournal(), expectedText, excludeText)?.timestamp
+		return matchedAt !== undefined
 	})
+
+	return matchedAt
+}
+
+// Grace period after the delayed window for aimock to flush the stream's remaining chunks to
+// the dead socket. 500ms is an empirical margin for that flush plus socket teardown; if this
+// suite becomes flaky again on slow CI runners, widen this value first.
+const SUBTASK_API_HANG_DRAIN_GRACE_MS = 500
+
+// aimock does not observe client disconnects: after the API-hang child request is cancelled,
+// the mock keeps the delayed stream pending server-side until the fixture's ttft has fully
+// elapsed, then flushes the remaining chunks to the dead socket. A streamed request opened by
+// the next test can interleave with that late flush, so wait out the remainder of the delayed
+// window before the next test runs. The deadline is anchored to the journal timestamp of the
+// request this test created (never earlier traffic), and bounded by one latency window plus
+// grace, so it cannot hide a genuine hang.
+const waitForDelayedSubtaskStreamDrain = async (delayedRequestStartedAt: number | undefined) => {
+	if (delayedRequestStartedAt === undefined) {
+		// The delayed request never reached the mock (the test failed before cancelling
+		// an in-flight request), so there is no delayed stream to drain.
+		return
+	}
+
+	const drainDeadlineMs =
+		delayedRequestStartedAt + SUBTASK_API_HANG_RESPONSE_LATENCY_MS + SUBTASK_API_HANG_DRAIN_GRACE_MS
+	const remainingMs = drainDeadlineMs - Date.now()
+
+	if (remainingMs > 0) {
+		await sleep(remainingMs)
+	}
 }
 
 suite("Roo Code Subtasks", function () {
@@ -482,6 +527,7 @@ suite("Roo Code Subtasks", function () {
 		const api = globalThis.api
 		const asks: Record<string, ClineMessage[]> = {}
 		const says: Record<string, ClineMessage[]> = {}
+		let delayedChildRequestStartedAt: number | undefined
 
 		const messageHandler = ({ taskId, message }: { taskId: string; message: ClineMessage }) => {
 			if (message.type === "ask") {
@@ -519,7 +565,10 @@ suite("Roo Code Subtasks", function () {
 				return false
 			})
 
-			await waitForAimockRequestContaining(SUBTASK_API_HANG_CHILD_MARKER, SUBTASK_API_HANG_PARENT_MARKER)
+			delayedChildRequestStartedAt = await waitForAimockRequestContaining(
+				SUBTASK_API_HANG_CHILD_MARKER,
+				SUBTASK_API_HANG_PARENT_MARKER,
+			)
 
 			await api.cancelCurrentTask()
 
@@ -580,6 +629,9 @@ suite("Roo Code Subtasks", function () {
 				await api.clearCurrentTask()
 			}
 			await waitFor(() => api.getCurrentTaskStack().length === 0).catch(() => {})
+			// Drain the cancelled delayed stream before the next test can open another
+			// streamed request against the mock.
+			await waitForDelayedSubtaskStreamDrain(delayedChildRequestStartedAt)
 		}
 	})
 

packages/types/package.json

@@ -11,6 +11,14 @@
 				"types": "./dist/index.d.cts",
 				"default": "./dist/index.cjs"
 			}
+		},
+		"./model": {
+			"types": "./src/model.ts",
+			"import": "./src/model.ts"
+		},
+		"./provider-identifiers": {
+			"types": "./src/provider-identifiers.ts",
+			"import": "./src/provider-identifiers.ts"
 		}
 	},
 	"scripts": {

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

@@ -1,4 +1,49 @@
-import { ANTHROPIC_API_PROTOCOL, getApiProtocol, OPENAI_API_PROTOCOL, providerIdentifiers } from "../index.js"
+import { ANTHROPIC_API_PROTOCOL, OPENAI_API_PROTOCOL, providerIdentifiers } from "../index.js"
+import {
+	getApiProtocol,
+	OPEN_AI_CODEX_SERVICE_TIER_KEY,
+	PROVIDER_SETTINGS_KEYS,
+	providerSettingsSchema,
+	providerSettingsSchemaDiscriminated,
+} from "../provider-settings.js"
+import { OpenAiCodexServiceTier, OpenAiServiceTier } from "../model.js"
+
+describe("OpenAI Codex provider settings", () => {
+	it("preserves the Fast preference in general and provider-specific schemas", () => {
+		const settings = {
+			apiProvider: providerIdentifiers.openaiCodex,
+			apiModelId: "gpt-5.6-sol",
+			[OPEN_AI_CODEX_SERVICE_TIER_KEY]: OpenAiCodexServiceTier.Priority,
+		}
+
+		expect(providerSettingsSchema.parse(settings)).toEqual(settings)
+		expect(providerSettingsSchemaDiscriminated.parse(settings)).toEqual(settings)
+		expect(PROVIDER_SETTINGS_KEYS).toContain(OPEN_AI_CODEX_SERVICE_TIER_KEY)
+	})
+
+	it.each([undefined, OpenAiCodexServiceTier.Default])(
+		"accepts %s as the Standard preference",
+		(openAiCodexServiceTier) => {
+			const standardSettings = {
+				apiProvider: providerIdentifiers.openaiCodex,
+				apiModelId: "gpt-5.6-sol",
+				...(openAiCodexServiceTier ? { [OPEN_AI_CODEX_SERVICE_TIER_KEY]: openAiCodexServiceTier } : {}),
+			}
+
+			expect(providerSettingsSchemaDiscriminated.parse(standardSettings)).toEqual(standardSettings)
+		},
+	)
+
+	it("rejects unsupported service tiers", () => {
+		expect(
+			providerSettingsSchemaDiscriminated.safeParse({
+				apiProvider: providerIdentifiers.openaiCodex,
+				apiModelId: "gpt-5.6-sol",
+				[OPEN_AI_CODEX_SERVICE_TIER_KEY]: OpenAiServiceTier.Flex,
+			}).success,
+		).toBe(false)
+	})
+})
 
 describe("getApiProtocol", () => {
 	it("preserves API protocol wire values", () => {

packages/types/src/model.ts

@@ -54,13 +54,34 @@ export const verbosityLevelsSchema = z.enum(verbosityLevels)
 
 export type VerbosityLevel = z.infer<typeof verbosityLevelsSchema>
 
+/** Serialized service tier field used in provider request payloads and responses. */
+export const SERVICE_TIER_KEY = "service_tier"
+
 /**
- * Service tiers (OpenAI Responses API)
+ * Service tiers for the public OpenAI Responses API.
  */
-export const serviceTiers = ["default", "flex", "priority"] as const
+export const OpenAiServiceTier = {
+	Default: "default",
+	Flex: "flex",
+	Priority: "priority",
+} as const
+
+export const serviceTiers = [OpenAiServiceTier.Default, OpenAiServiceTier.Flex, OpenAiServiceTier.Priority] as const
 export const serviceTierSchema = z.enum(serviceTiers)
 export type ServiceTier = z.infer<typeof serviceTierSchema>
 
+/**
+ * Service tiers for Codex requests authenticated through a ChatGPT subscription.
+ */
+export const OpenAiCodexServiceTier = {
+	Default: "default",
+	Priority: "priority",
+} as const
+
+export const openAiCodexServiceTiers = [OpenAiCodexServiceTier.Default, OpenAiCodexServiceTier.Priority] as const
+export const openAiCodexServiceTierSchema = z.enum(openAiCodexServiceTiers)
+export type OpenAiCodexServiceTier = z.infer<typeof openAiCodexServiceTierSchema>
+
 /**
  * ModelParameter
  */

packages/types/src/provider-settings.ts

@@ -1,6 +1,12 @@
 import { z } from "zod"
 
-import { modelInfoSchema, reasoningEffortSettingSchema, verbosityLevelsSchema, serviceTierSchema } from "./model.js"
+import {
+	modelInfoSchema,
+	openAiCodexServiceTierSchema,
+	reasoningEffortSettingSchema,
+	verbosityLevelsSchema,
+	serviceTierSchema,
+} from "./model.js"
 import { codebaseIndexProviderSchema } from "./codebase-index.js"
 import {
 	providerIdentifiers,
@@ -38,6 +44,7 @@ import {
  */
 
 export const DEFAULT_CONSECUTIVE_MISTAKE_LIMIT = 3
+export const OPEN_AI_CODEX_SERVICE_TIER_KEY = "openAiCodexServiceTier"
 
 /**
  * DynamicProvider
@@ -279,7 +286,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.
+	[OPEN_AI_CODEX_SERVICE_TIER_KEY]: openAiCodexServiceTierSchema.optional(),
 })
 
 const openAiNativeSchema = apiModelIdProviderModelSchema.extend({

src/api/providers/__tests__/bedrock.spec.ts

@@ -58,6 +58,7 @@ import {
 	BEDROCK_1M_CONTEXT_MODEL_IDS,
 	BEDROCK_SERVICE_TIER_MODEL_IDS,
 	bedrockModels,
+	SERVICE_TIER_KEY,
 	ApiProviderError,
 } from "@roo-code/types"
 
@@ -1233,10 +1234,10 @@ describe("AwsBedrockHandler", () => {
 				const commandArg = mockConverseStreamCommand.mock.calls[0][0] as any
 
 				// service_tier should be at the top level of the payload
-				expect(commandArg.service_tier).toBe("PRIORITY")
+				expect(commandArg[SERVICE_TIER_KEY]).toBe("PRIORITY")
 				// service_tier should NOT be in additionalModelRequestFields
 				if (commandArg.additionalModelRequestFields) {
-					expect(commandArg.additionalModelRequestFields.service_tier).toBeUndefined()
+					expect(commandArg.additionalModelRequestFields[SERVICE_TIER_KEY]).toBeUndefined()
 				}
 			})
 
@@ -1263,10 +1264,10 @@ describe("AwsBedrockHandler", () => {
 				const commandArg = mockConverseStreamCommand.mock.calls[0][0] as any
 
 				// service_tier should be at the top level of the payload
-				expect(commandArg.service_tier).toBe("FLEX")
+				expect(commandArg[SERVICE_TIER_KEY]).toBe("FLEX")
 				// service_tier should NOT be in additionalModelRequestFields
 				if (commandArg.additionalModelRequestFields) {
-					expect(commandArg.additionalModelRequestFields.service_tier).toBeUndefined()
+					expect(commandArg.additionalModelRequestFields[SERVICE_TIER_KEY]).toBeUndefined()
 				}
 			})
 
@@ -1294,9 +1295,9 @@ describe("AwsBedrockHandler", () => {
 				const commandArg = mockConverseStreamCommand.mock.calls[0][0] as any
 
 				// Service tier should NOT be included for unsupported models (at top level or in additionalModelRequestFields)
-				expect(commandArg.service_tier).toBeUndefined()
+				expect(commandArg[SERVICE_TIER_KEY]).toBeUndefined()
 				if (commandArg.additionalModelRequestFields) {
-					expect(commandArg.additionalModelRequestFields.service_tier).toBeUndefined()
+					expect(commandArg.additionalModelRequestFields[SERVICE_TIER_KEY]).toBeUndefined()
 				}
 			})
 
@@ -1323,9 +1324,9 @@ describe("AwsBedrockHandler", () => {
 				const commandArg = mockConverseStreamCommand.mock.calls[0][0] as any
 
 				// Service tier should NOT be included when not specified (at top level or in additionalModelRequestFields)
-				expect(commandArg.service_tier).toBeUndefined()
+				expect(commandArg[SERVICE_TIER_KEY]).toBeUndefined()
 				if (commandArg.additionalModelRequestFields) {
-					expect(commandArg.additionalModelRequestFields.service_tier).toBeUndefined()
+					expect(commandArg.additionalModelRequestFields[SERVICE_TIER_KEY]).toBeUndefined()
 				}
 			})
 		})