Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

feat: service-tier control (/tier, default-tier setting, completions forwarding, shared tier pricing) (#2144)

Sebastian Müllera1792bea4db3
diff --git a/packages/ai/.changes/res-1326-service-tier-control.md b/packages/ai/.changes/res-1326-service-tier-control.md
new file mode 100644
index 0000000000..77c078068a
--- /dev/null
+++ b/packages/ai/.changes/res-1326-service-tier-control.md
@@ -0,0 +1 @@
+- Added `supportsServiceTier`/`clampServiceTier` as the single service-tier eligibility predicate, service_tier forwarding on the OpenAI-completions path for OpenAI and OpenRouter, and shared service-tier pricing: direct-OpenAI completions costs adjust by the tier the response reports as served, while OpenRouter completions record OpenRouter's reported billed cost (including the upstream bill for BYOK requests) ([RES-1326](https://linear.app/primeintellect/issue/RES-1326)).
diff --git a/packages/ai/src/models.ts b/packages/ai/src/models.ts
index 892fd608fb..9fdc7b04f6 100644
--- a/packages/ai/src/models.ts
+++ b/packages/ai/src/models.ts
@@ -1,5 +1,5 @@
import { MODELS } from "./models.generated.js";
-import type { Api, KnownProvider, Model, ModelThinkingLevel, Usage } from "./types.js";
+import type { Api, KnownProvider, Model, ModelThinkingLevel, ServiceTier, Usage } from "./types.js";
const modelRegistry: Map<string, Map<string, Model<Api>>> = new Map();
@@ -35,14 +35,44 @@ export function getModels<TProvider extends KnownProvider>(
return models ? (Array.from(models.values()) as Model<ModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[]) : [];
}
-export function supportsFastMode<TApi extends Api>(model: Model<TApi>): boolean {
+/** Whether a model's provider accepts (and honors) a requested service tier. */
+export function supportsServiceTier<TApi extends Api>(model: Model<TApi>, tier: ServiceTier): boolean {
+ if (tier === null || tier === "default") return true;
+ // OpenRouter accepts top-level service_tier (flex|priority) for every model,
+ // routes to matching tier endpoints where they exist, and bills by the tier
+ // that actually served the request:
+ // https://openrouter.ai/docs/guides/features/service-tiers
+ if (model.provider === "openrouter" && model.api === "openai-completions") {
+ return tier === "flex" || tier === "priority";
+ }
+ const openaiResponses = model.provider === "openai" && model.api === "openai-responses";
+ const codexResponses = model.provider === "openai-codex" && model.api === "openai-codex-responses";
+ if (!openaiResponses && !codexResponses) return false;
+ // "auto" defers the tier choice to OpenAI and is valid for every model there;
+ // "scale" is entitlement-gated, so pass it through for callers that have it.
+ if (tier === "auto" || tier === "scale") return true;
const eligibleId =
- model.id === "gpt-5.4" || model.id === "gpt-5.5" || model.id === "gpt-5.6" || model.id.startsWith("gpt-5.6-");
- return (
- eligibleId &&
- ((model.provider === "openai-codex" && model.api === "openai-codex-responses") ||
- (model.provider === "openai" && model.api === "openai-responses"))
- );
+ model.id === "gpt-5.4" ||
+ model.id === "gpt-5.5" ||
+ model.id === "gpt-5.6" ||
+ model.id === "gpt-6-astra" ||
+ model.id.startsWith("gpt-5.6-");
+ if (tier === "priority") return eligibleId;
+ // Flex processing is an API-key feature; the ChatGPT (Codex OAuth) backend has no flex tier.
+ return tier === "flex" && eligibleId && openaiResponses;
+}
+
+/** Clamp a requested tier to "default" when the model does not support it. */
+export function clampServiceTier<TApi extends Api>(
+ model: Model<TApi> | null | undefined,
+ tier: ServiceTier,
+): ServiceTier {
+ if (tier === null || tier === "default") return tier;
+ return model && supportsServiceTier(model, tier) ? tier : "default";
+}
+
+export function supportsFastMode<TApi extends Api>(model: Model<TApi>): boolean {
+ return supportsServiceTier(model, "priority");
}
export interface CostOverrides {
diff --git a/packages/ai/src/providers/openai-codex-responses.ts b/packages/ai/src/providers/openai-codex-responses.ts
index f373812c9f..fcf09a704e 100644
--- a/packages/ai/src/providers/openai-codex-responses.ts
+++ b/packages/ai/src/providers/openai-codex-responses.ts
@@ -31,7 +31,6 @@ import type {
SimpleStreamOptions,
StreamFunction,
StreamOptions,
- Usage,
} from "../types.js";
import {
appendAssistantMessageDiagnostic,
@@ -42,6 +41,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
import { headersToRecord } from "../utils/headers.js";
import { parseRetryAfterMs, recordStreamFailure } from "../utils/stream-failure.js";
import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
+import { applyServiceTierPricing } from "./service-tier-pricing.js";
import { buildBaseOptions } from "./simple-options.js";
const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
@@ -332,36 +332,6 @@ function buildRequestBody(
return body;
}
-// Multipliers per https://developers.openai.com/api/docs/pricing (retrieved 2026-08-21)
-function getServiceTierCostMultiplier(
- model: Pick<Model<"openai-codex-responses">, "id">,
- serviceTier: ResponseCreateParamsStreaming["service_tier"] | undefined,
-): number {
- switch (serviceTier) {
- case "flex":
- return 0.5;
- case "priority":
- return model.id.startsWith("gpt-5.5") ? 2.5 : 2;
- default:
- return 1;
- }
-}
-
-function applyServiceTierPricing(
- usage: Usage,
- serviceTier: ResponseCreateParamsStreaming["service_tier"] | undefined,
- model: Pick<Model<"openai-codex-responses">, "id">,
-) {
- const multiplier = getServiceTierCostMultiplier(model, serviceTier);
- if (multiplier === 1) return;
-
- usage.cost.input *= multiplier;
- usage.cost.output *= multiplier;
- usage.cost.cacheRead *= multiplier;
- usage.cost.cacheWrite *= multiplier;
- usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
-
function resolveCodexServiceTier(
responseServiceTier: ResponseCreateParamsStreaming["service_tier"] | undefined,
requestServiceTier: ResponseCreateParamsStreaming["service_tier"] | undefined,
@@ -397,7 +367,7 @@ async function processStream(
await processResponsesStream(mapCodexEvents(parseSSE(response)), output, stream, model, {
serviceTier: options?.serviceTier,
resolveServiceTier: resolveCodexServiceTier,
- applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
+ applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model.id),
});
}
@@ -1182,7 +1152,7 @@ async function processWebSocketStream(
{
serviceTier: options?.serviceTier,
resolveServiceTier: resolveCodexServiceTier,
- applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
+ applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model.id),
},
);
if (options?.signal?.aborted) {
diff --git a/packages/ai/src/providers/openai-completions.ts b/packages/ai/src/providers/openai-completions.ts
index f38ce477ff..a84ece515b 100644
--- a/packages/ai/src/providers/openai-completions.ts
+++ b/packages/ai/src/providers/openai-completions.ts
@@ -39,6 +39,7 @@ import { recordStreamFailure } from "../utils/stream-failure.js";
import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js";
import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
import { withOpenCodeHeaders } from "./opencode-headers.js";
+import { applyServiceTierPricing } from "./service-tier-pricing.js";
import { buildBaseOptions } from "./simple-options.js";
import { transformMessages } from "./transform-messages.js";
@@ -305,12 +306,16 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
return block;
};
+ let responseServiceTier: ChatCompletionChunk["service_tier"] | undefined;
for await (const chunk of openaiStream) {
if (!chunk || typeof chunk !== "object") continue;
// OpenAI documents ChatCompletionChunk.id as the unique chat completion identifier,
// and each chunk in a streamed completion carries the same id.
output.responseId ||= chunk.id;
+ if (typeof chunk.service_tier === "string") {
+ responseServiceTier = chunk.service_tier;
+ }
if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) {
output.responseModel ||= chunk.model;
}
@@ -457,6 +462,12 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
}
}
+ // The multiplier table is OpenAI's own; gateways price tiers per endpoint
+ // (OpenRouter reports its cost in usage instead, see parseChunkUsage).
+ if (model.provider === "openai") {
+ applyServiceTierPricing(output.usage, responseServiceTier, model.id);
+ }
+
for (const block of blocks) {
finishBlock(block);
}
@@ -674,6 +685,14 @@ function buildParams(
}
}
+ // OpenAI and OpenRouter accept a top-level service_tier (OpenRouter: flex and
+ // priority, https://openrouter.ai/docs/guides/features/service-tiers). Prime
+ // Inference tolerates but ignores the field (probed 2026-09-01), so it is not
+ // forwarded; other OpenAI-compatible gateways may reject unknown fields.
+ if (options?.serviceTier != null && (model.provider === "openai" || model.provider === "openrouter")) {
+ params.service_tier = options.serviceTier;
+ }
+
if (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) {
(params as any).provider = model.compat.openRouterRouting;
}
@@ -1094,6 +1113,9 @@ function parseChunkUsage(
completion_tokens?: number;
prompt_cache_hit_tokens?: number;
prompt_tokens_details?: { cached_tokens?: number; cache_write_tokens?: number };
+ cost?: number;
+ is_byok?: boolean;
+ cost_details?: { upstream_inference_cost?: number };
},
model: Model<"openai-completions">,
cacheWriteCost?: number,
@@ -1122,9 +1144,51 @@ function parseChunkUsage(
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
};
calculateCost(model, usage, cacheWriteCost === undefined ? undefined : { cacheWrite: cacheWriteCost });
+ // OpenRouter reports billing truth in usage, already priced by the endpoint
+ // and service tier that served the request
+ // (https://openrouter.ai/docs/api-reference/overview). Trust it over the
+ // catalog-rate estimate, scaling the component breakdown to match.
+ const reportedCost = model.provider === "openrouter" ? openRouterReportedCost(rawUsage) : undefined;
+ if (reportedCost !== undefined) {
+ if (usage.cost.total > 0) {
+ const scale = reportedCost / usage.cost.total;
+ usage.cost.input *= scale;
+ usage.cost.output *= scale;
+ usage.cost.cacheRead *= scale;
+ usage.cost.cacheWrite *= scale;
+ } else if (usage.totalTokens > 0) {
+ // No catalog rates to apportion by: attribute by token counts instead.
+ usage.cost.input = (reportedCost * usage.input) / usage.totalTokens;
+ usage.cost.output = (reportedCost * usage.output) / usage.totalTokens;
+ usage.cost.cacheRead = (reportedCost * usage.cacheRead) / usage.totalTokens;
+ usage.cost.cacheWrite = (reportedCost * usage.cacheWrite) / usage.totalTokens;
+ }
+ usage.cost.total = reportedCost;
+ }
return usage;
}
+/**
+ * The user's real spend for an OpenRouter request, or undefined to keep the
+ * catalog estimate. usage.cost only carries what OpenRouter charged the
+ * account's credits: for BYOK requests that is just OpenRouter's fee, so real
+ * spend is the upstream provider's bill plus that fee. A cost of 0 can mean
+ * not-billed-via-credits (e.g. :free endpoints) rather than free, so it keeps
+ * the catalog estimate.
+ */
+function openRouterReportedCost(rawUsage: {
+ cost?: number;
+ is_byok?: boolean;
+ cost_details?: { upstream_inference_cost?: number };
+}): number | undefined {
+ const credits = typeof rawUsage.cost === "number" && rawUsage.cost > 0 ? rawUsage.cost : undefined;
+ if (rawUsage.is_byok === true) {
+ const upstream = rawUsage.cost_details?.upstream_inference_cost;
+ return typeof upstream === "number" && upstream > 0 ? upstream + (credits ?? 0) : undefined;
+ }
+ return credits;
+}
+
function mapStopReason(reason: ChatCompletionChunk.Choice["finish_reason"] | string): {
stopReason: StopReason;
errorMessage?: string;
diff --git a/packages/ai/src/providers/openai-responses.ts b/packages/ai/src/providers/openai-responses.ts
index 945d889471..829726075b 100644
--- a/packages/ai/src/providers/openai-responses.ts
+++ b/packages/ai/src/providers/openai-responses.ts
@@ -12,7 +12,6 @@ import type {
SimpleStreamOptions,
StreamFunction,
StreamOptions,
- Usage,
} from "../types.js";
import { AssistantMessageEventStream } from "../utils/event-stream.js";
import { headersToRecord } from "../utils/headers.js";
@@ -25,6 +24,7 @@ import { isCloudflareProvider, resolveCloudflareBaseUrl } from "./cloudflare.js"
import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
import { withOpenCodeHeaders } from "./opencode-headers.js";
+import { applyServiceTierPricing } from "./service-tier-pricing.js";
import { buildBaseOptions } from "./simple-options.js";
const OPENAI_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
@@ -110,7 +110,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIRes
await processResponsesStream(openaiStream, output, stream, model, {
serviceTier: options?.serviceTier,
- applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),
+ applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model.id),
});
if (options?.signal?.aborted) {
@@ -269,33 +269,3 @@ function buildParams(model: Model<"openai-responses">, context: Context, options
return params;
}
-
-// Multipliers per https://developers.openai.com/api/docs/pricing (retrieved 2026-08-21)
-function getServiceTierCostMultiplier(
- model: Pick<Model<"openai-responses">, "id">,
- serviceTier: ResponseCreateParamsStreaming["service_tier"] | undefined,
-): number {
- switch (serviceTier) {
- case "flex":
- return 0.5;
- case "priority":
- return model.id === "gpt-5.5" ? 2.5 : 2;
- default:
- return 1;
- }
-}
-
-function applyServiceTierPricing(
- usage: Usage,
- serviceTier: ResponseCreateParamsStreaming["service_tier"] | undefined,
- model: Pick<Model<"openai-responses">, "id">,
-) {
- const multiplier = getServiceTierCostMultiplier(model, serviceTier);
- if (multiplier === 1) return;
-
- usage.cost.input *= multiplier;
- usage.cost.output *= multiplier;
- usage.cost.cacheRead *= multiplier;
- usage.cost.cacheWrite *= multiplier;
- usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
diff --git a/packages/ai/src/providers/service-tier-pricing.ts b/packages/ai/src/providers/service-tier-pricing.ts
new file mode 100644
index 0000000000..9736a92eab
--- /dev/null
+++ b/packages/ai/src/providers/service-tier-pricing.ts
@@ -0,0 +1,30 @@
+import type { ServiceTier, Usage } from "../types.js";
+
+/**
+ * Shared OpenAI service-tier pricing, used by the responses, codex-responses,
+ * and completions streaming paths so the multiplier table has one owner. The
+ * table is authoritative ONLY for OpenAI's own surfaces; gateways price their
+ * tiers per endpoint, so callers must not apply it to gateway-served requests.
+ * Multipliers per https://developers.openai.com/api/docs/pricing (retrieved 2026-08-21).
+ */
+function getServiceTierCostMultiplier(modelId: string, serviceTier: ServiceTier | undefined): number {
+ switch (serviceTier) {
+ case "flex":
+ return 0.5;
+ case "priority":
+ return modelId === "gpt-5.5" ? 2.5 : 2;
+ default:
+ return 1;
+ }
+}
+
+export function applyServiceTierPricing(usage: Usage, serviceTier: ServiceTier | undefined, modelId: string): void {
+ const multiplier = getServiceTierCostMultiplier(modelId, serviceTier);
+ if (multiplier === 1) return;
+
+ usage.cost.input *= multiplier;
+ usage.cost.output *= multiplier;
+ usage.cost.cacheRead *= multiplier;
+ usage.cost.cacheWrite *= multiplier;
+ usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
diff --git a/packages/ai/test/openai-codex-stream.test.ts b/packages/ai/test/openai-codex-stream.test.ts
index 3073b1e210..f9889b25b4 100644
--- a/packages/ai/test/openai-codex-stream.test.ts
+++ b/packages/ai/test/openai-codex-stream.test.ts
@@ -3,7 +3,7 @@ import { tmpdir } from "node:os";
import { join } from "node:path";
import type { ResponseStreamEvent } from "openai/resources/responses/responses.js";
import { afterEach, describe, expect, it, vi } from "vitest";
-import { supportsFastMode } from "../src/models.js";
+import { clampServiceTier, supportsFastMode } from "../src/models.js";
import {
getOpenAICodexWebSocketDebugStats,
resetOpenAICodexWebSocketDebugStats,
@@ -1610,6 +1610,7 @@ describe("fast mode", () => {
{ provider: "openai-codex", id: "gpt-5.4", api: "openai-codex-responses" as Api, supported: true },
{ provider: "openai-codex", id: "gpt-5.5", api: "openai-codex-responses" as Api, supported: true },
{ provider: "openai-codex", id: "gpt-5.6-luna", api: "openai-codex-responses" as Api, supported: true },
+ { provider: "openai-codex", id: "gpt-6-astra", api: "openai-codex-responses" as Api, supported: true },
{ provider: "openai-codex", id: "gpt-5.3-codex", api: "openai-codex-responses" as Api, supported: false },
{ provider: "openai-codex", id: "gpt-5.4-mini", api: "openai-codex-responses" as Api, supported: false },
{ provider: "openai", id: "gpt-5.1", api: "openai-responses" as Api, supported: false },
@@ -1625,4 +1626,23 @@ describe("fast mode", () => {
"priority",
);
});
+
+ it.each([
+ { provider: "openai", id: "gpt-5.5", api: "openai-responses", tier: "flex", expected: "flex" },
+ {
+ provider: "openrouter",
+ id: "anthropic-claude-opus-5",
+ api: "openai-completions",
+ tier: "flex",
+ expected: "flex",
+ },
+ { provider: "openai-codex", id: "gpt-5.5", api: "openai-codex-responses", tier: "flex", expected: "default" },
+ { provider: "groq", id: "llama-4", api: "openai-completions", tier: "flex", expected: "default" },
+ { provider: "groq", id: "llama-4", api: "openai-completions", tier: "default", expected: "default" },
+ { provider: "openai", id: "gpt-4o", api: "openai-responses", tier: "scale", expected: "scale" },
+ { provider: "no", id: "model", api: undefined, tier: "priority", expected: "default" },
+ ] as const)("clamps $tier to $expected for $provider/$id", ({ provider, id, api, tier, expected }) => {
+ const model = api ? fastModeModel(provider, id, api) : undefined;
+ expect(clampServiceTier(model, tier)).toBe(expected);
+ });
});
diff --git a/packages/ai/test/openai-completions-tool-choice.test.ts b/packages/ai/test/openai-completions-tool-choice.test.ts
index a4521332af..a9acaf6066 100644
--- a/packages/ai/test/openai-completions-tool-choice.test.ts
+++ b/packages/ai/test/openai-completions-tool-choice.test.ts
@@ -23,12 +23,16 @@ const mockState = vi.hoisted(() => ({
| Array<null | {
id?: string;
model?: string;
+ service_tier?: string;
choices?: Array<{ delta: Record<string, unknown>; finish_reason: string | null; usage?: unknown }>;
usage?: {
prompt_tokens: number;
completion_tokens: number;
prompt_tokens_details: { cached_tokens: number; cache_write_tokens?: number };
completion_tokens_details: { reasoning_tokens: number };
+ cost?: number;
+ is_byok?: boolean;
+ cost_details?: { upstream_inference_cost?: number };
};
}>
| undefined,
@@ -1518,6 +1522,108 @@ describe("openai-completions tool-result content", () => {
});
});
+describe("openai-completions service tier", () => {
+ function serviceTierModel(provider: string): Model<"openai-completions"> {
+ const { compat: _compat, ...base } = getModel("openai", "gpt-4o-mini")!;
+ return {
+ ...base,
+ api: "openai-completions",
+ id: "anthropic/claude-opus-5",
+ provider,
+ baseUrl: "https://openrouter.ai/api/v1",
+ cost: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0 },
+ };
+ }
+
+ it.each([
+ ["openrouter", "flex"],
+ ["openai", "flex"],
+ ["prime-inference", undefined],
+ ])("forwards a requested tier only for openai and openrouter: $0", async (provider, forwarded) => {
+ await streamSimple(
+ serviceTierModel(provider),
+ { messages: [{ role: "user", content: "Hi", timestamp: Date.now() }] },
+ { apiKey: "test", serviceTier: "flex" },
+ ).result();
+
+ expect((mockState.lastParams as { service_tier?: string }).service_tier).toBe(forwarded);
+ });
+
+ it.each([
+ {
+ name: "uses OpenRouter's reported cost, already priced by the serving tier",
+ provider: "openrouter",
+ requestedTier: "priority",
+ responseServiceTier: "priority",
+ reported: { cost: 0.0009 },
+ expectedTotal: 0.0009,
+ },
+ {
+ name: "records BYOK spend from the upstream bill plus OpenRouter's fee",
+ provider: "openrouter",
+ requestedTier: undefined,
+ responseServiceTier: undefined,
+ reported: { cost: 0.95, is_byok: true, cost_details: { upstream_inference_cost: 19 } },
+ expectedTotal: 19.95,
+ },
+ {
+ name: "keeps catalog rates when OpenRouter reports a cost of 0",
+ provider: "openrouter",
+ requestedTier: undefined,
+ responseServiceTier: undefined,
+ reported: { cost: 0 },
+ expectedTotal: 0.00015,
+ },
+ {
+ name: "keeps unmultiplied catalog rates for a gateway tier echo without reported cost",
+ provider: "openrouter",
+ requestedTier: "priority",
+ responseServiceTier: "priority",
+ reported: undefined,
+ expectedTotal: 0.00015,
+ },
+ {
+ name: "multiplies direct OpenAI usage by the tier OpenAI echoes as served",
+ provider: "openai",
+ requestedTier: "flex",
+ responseServiceTier: "flex",
+ reported: undefined,
+ expectedTotal: 0.000075,
+ },
+ {
+ name: "never multiplies from the requested tier when no served tier is echoed",
+ provider: "openai",
+ requestedTier: "flex",
+ responseServiceTier: undefined,
+ reported: undefined,
+ expectedTotal: 0.00015,
+ },
+ ] as const)("$name", async ({ provider, requestedTier, responseServiceTier, reported, expectedTotal }) => {
+ mockState.chunks = [
+ {
+ id: "chatcmpl-1",
+ service_tier: responseServiceTier,
+ choices: [{ delta: {}, finish_reason: "stop" }],
+ usage: {
+ prompt_tokens: 100,
+ completion_tokens: 50,
+ prompt_tokens_details: { cached_tokens: 0 },
+ completion_tokens_details: { reasoning_tokens: 0 },
+ ...reported,
+ },
+ },
+ ];
+
+ const response = await streamSimple(
+ serviceTierModel(provider),
+ { messages: [{ role: "user", content: "Hi", timestamp: Date.now() }] },
+ { apiKey: "test", serviceTier: requestedTier },
+ ).result();
+
+ expect(response.usage.cost.total).toBeCloseTo(expectedTotal, 10);
+ });
+});
+
describe("OpenRouter reasoning metadata", () => {
function supportedLevels(thinkingLevelMap: Model<"openai-completions">["thinkingLevelMap"]) {
return getSupportedThinkingLevels({ reasoning: true, thinkingLevelMap } as Model<"openai-completions">);
diff --git a/packages/coding-agent/.changes/res-1326-service-tier-control.md b/packages/coding-agent/.changes/res-1326-service-tier-control.md
new file mode 100644
index 0000000000..6d4c273294
--- /dev/null
+++ b/packages/coding-agent/.changes/res-1326-service-tier-control.md
@@ -0,0 +1 @@
+- Added `/tier` to show or set the session service tier (default, flex, priority, auto), a `Default service tier` row in `/settings` that also applies to the running session, and a footer badge for any non-default tier ([RES-1326](https://linear.app/primeintellect/issue/RES-1326)).
diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts
index 806570fd61..388c29f2ab 100644
--- a/packages/coding-agent/src/core/agent-session.ts
+++ b/packages/coding-agent/src/core/agent-session.ts
@@ -27,13 +27,14 @@ import type {
UserMessage,
} from "@earendil-works/pi-ai";
import {
+ clampServiceTier,
clampThinkingLevel,
cleanupSessionResources,
getSupportedThinkingLevels,
isContextOverflow,
modelsAreEqual,
resetApiProviders,
- supportsFastMode,
+ supportsServiceTier,
} from "@earendil-works/pi-ai";
import { theme } from "../modes/interactive/theme/theme.js";
import { stripFrontmatter } from "../utils/frontmatter.js";
@@ -8460,16 +8461,19 @@ export class AgentSession {
setServiceTier(serviceTier: ServiceTier): void {
const effectiveServiceTier = this._getEffectiveServiceTier(serviceTier);
- const preferenceChanged = effectiveServiceTier !== this._serviceTierPreference;
+ const preferenceChanged = serviceTier !== this._serviceTierPreference;
const effectiveTierChanged = effectiveServiceTier !== this.agent.state.serviceTier;
if (!preferenceChanged && !effectiveTierChanged) {
return;
}
- this._serviceTierPreference = effectiveServiceTier;
+ // The preference and the session entry keep the REQUESTED tier (only the
+ // active state clamps), so switching to or resuming on a capable model
+ // re-activates it instead of a clamped "default" shadowing it.
+ this._serviceTierPreference = serviceTier;
if (preferenceChanged) {
- this.sessionManager.appendServiceTierChange(effectiveServiceTier);
- if (this.model && supportsFastMode(this.model)) {
- this.settingsManager.setDefaultServiceTier(effectiveServiceTier);
+ this.sessionManager.appendServiceTierChange(serviceTier);
+ if (this.model && supportsServiceTier(this.model, serviceTier)) {
+ this.settingsManager.setDefaultServiceTier(serviceTier);
}
}
if (effectiveTierChanged) {
@@ -8482,7 +8486,7 @@ export class AgentSession {
}
private _getEffectiveServiceTier(serviceTier: ServiceTier): ServiceTier {
- return serviceTier === "priority" && (!this.model || !supportsFastMode(this.model)) ? "default" : serviceTier;
+ return clampServiceTier(this.model, serviceTier);
}
private _getServiceTierForModelSwitch(): ServiceTier {
@@ -11130,8 +11134,7 @@ export class AgentSession {
model: options.model,
thinkingLevel:
options.thinkingLevel ?? (clampThinkingLevel(options.model, this.thinkingLevel) as ThinkingLevel),
- serviceTier:
- this.serviceTier === "priority" && !supportsFastMode(options.model) ? "default" : this.serviceTier,
+ serviceTier: this._serviceTierPreference,
scopedModels: [...this._scopedModels],
activeToolNames: this.getActiveToolNames(),
allowedToolNames: this._allowedToolNames ? [...this._allowedToolNames] : undefined,
@@ -11170,7 +11173,7 @@ export class AgentSession {
systemPrompt: "",
model: options.model,
thinkingLevel: options.thinkingLevel,
- serviceTier: options.serviceTier,
+ serviceTier: clampServiceTier(options.model, options.serviceTier),
tools: [],
},
convertToLlm: this.agent.convertToLlm,
@@ -11191,6 +11194,7 @@ export class AgentSession {
agent: childAgent,
sessionManager: childSessionManager,
settingsManager: this.settingsManager,
+ serviceTierPreference: options.serviceTier,
cwd: this._cwd,
agentDir: this._agentDir,
scopedModels: options.scopedModels,
diff --git a/packages/coding-agent/src/core/image-model-routing.ts b/packages/coding-agent/src/core/image-model-routing.ts
index 64cf133d31..9d6d25dd36 100644
--- a/packages/coding-agent/src/core/image-model-routing.ts
+++ b/packages/coding-agent/src/core/image-model-routing.ts
@@ -3,7 +3,7 @@
*/
import type { AgentModelOverride, ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { type Api, clampThinkingLevel, type Model, type ServiceTier, supportsFastMode } from "@earendil-works/pi-ai";
+import { type Api, clampServiceTier, clampThinkingLevel, type Model, type ServiceTier } from "@earendil-works/pi-ai";
import { formatImageModelRequiredMessage, formatImageModelUnusableMessage } from "./auth-guidance.js";
import { findExactModelReferenceMatch } from "./model-resolver.js";
@@ -45,6 +45,6 @@ export function resolveImageModelOverride(inputs: ImageModelRoutingInputs): Agen
return {
model: imageModel,
thinkingLevel: clampThinkingLevel(imageModel, inputs.thinkingLevel) as ThinkingLevel,
- serviceTier: inputs.serviceTier === "priority" && !supportsFastMode(imageModel) ? "default" : inputs.serviceTier,
+ serviceTier: clampServiceTier(imageModel, inputs.serviceTier),
};
}
diff --git a/packages/coding-agent/src/core/sdk.ts b/packages/coding-agent/src/core/sdk.ts
index 761113fd99..763da2c55a 100644
--- a/packages/coding-agent/src/core/sdk.ts
+++ b/packages/coding-agent/src/core/sdk.ts
@@ -1,6 +1,6 @@
import { join } from "node:path";
import { Agent, type AgentMessage, type ThinkingLevel } from "@earendil-works/pi-agent-core";
-import { clampThinkingLevel, type Message, type Model, streamSimple, supportsFastMode } from "@earendil-works/pi-ai";
+import { clampServiceTier, clampThinkingLevel, type Message, type Model, streamSimple } from "@earendil-works/pi-ai";
import { getAgentDir } from "../config.js";
import { AgentSession } from "./agent-session.js";
import type { AgentSessionCreationOptions } from "./agent-session-services.js";
@@ -243,8 +243,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
const serviceTierPreference =
options.serviceTier ??
(hasServiceTierEntry ? existingSession.serviceTier : settingsManager.getDefaultServiceTier());
- const serviceTier =
- serviceTierPreference === "priority" && (!model || !supportsFastMode(model)) ? "default" : serviceTierPreference;
+ const serviceTier = clampServiceTier(model, serviceTierPreference);
const allowedToolNames = options.allowedToolNames ?? options.tools ?? (options.noTools === "all" ? [] : undefined);
const includeGoals = options.includeGoals ?? (options.tools !== undefined || options.noTools !== "all");
diff --git a/packages/coding-agent/src/core/slash-commands.ts b/packages/coding-agent/src/core/slash-commands.ts
index 4243ab59dc..dad5953749 100644
--- a/packages/coding-agent/src/core/slash-commands.ts
+++ b/packages/coding-agent/src/core/slash-commands.ts
@@ -89,6 +89,7 @@ const CANONICAL_BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
{ name: "model", description: "Select model (opens selector UI)", argumentHint: "[search]" },
{ name: "effort", description: "Select reasoning/thinking level (opens selector UI)", argumentHint: "[level]" },
{ name: "fast", description: "Toggle OpenAI Fast mode" },
+ { name: "tier", description: "Show or set the service tier", argumentHint: "[default|flex|priority|auto]" },
{ name: "scoped-models", description: "Enable/disable models for Alt+M cycling" },
{
name: "export",
diff --git a/packages/coding-agent/src/modes/interactive/components/settings-selector.ts b/packages/coding-agent/src/modes/interactive/components/settings-selector.ts
index 2820ba1597..b9e451347f 100644
--- a/packages/coding-agent/src/modes/interactive/components/settings-selector.ts
+++ b/packages/coding-agent/src/modes/interactive/components/settings-selector.ts
@@ -1,5 +1,5 @@
import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { Transport } from "@earendil-works/pi-ai";
+import type { ServiceTier, Transport } from "@earendil-works/pi-ai";
import {
Container,
type SelectItem,
@@ -20,6 +20,13 @@ const SETTINGS_SUBMENU_SELECT_LIST_LAYOUT: SelectListLayoutOptions = {
maxPrimaryColumnWidth: 32,
};
+const SERVICE_TIER_OPTIONS: SelectItem[] = [
+ { value: "default", label: "default", description: "Standard processing" },
+ { value: "flex", label: "flex", description: "Cheaper, slower, may hit capacity limits" },
+ { value: "priority", label: "priority", description: "Faster, more expensive (fast mode)" },
+ { value: "auto", label: "auto", description: "Provider picks the tier" },
+];
+
const THINKING_DESCRIPTIONS: Record<ThinkingLevel, string> = {
off: "No reasoning",
minimal: "Very brief reasoning",
@@ -41,6 +48,7 @@ export interface SettingsConfig {
steeringMode: "all" | "one-at-a-time";
followUpMode: "all" | "one-at-a-time";
transport: Transport;
+ defaultServiceTier: Exclude<ServiceTier, null>;
thinkingLevel: ThinkingLevel;
availableThinkingLevels: ThinkingLevel[];
currentTheme: string;
@@ -68,6 +76,7 @@ export interface SettingsCallbacks {
onSteeringModeChange: (mode: "all" | "one-at-a-time") => void;
onFollowUpModeChange: (mode: "all" | "one-at-a-time") => void;
onTransportChange: (transport: Transport) => void;
+ onDefaultServiceTierChange: (serviceTier: Exclude<ServiceTier, null>) => void;
onThinkingLevelChange: (level: ThinkingLevel) => void;
onThemeChange: (theme: string) => void;
onThemePreview?: (theme: string) => void;
@@ -235,6 +244,21 @@ export class SettingsSelectorComponent extends Container {
currentValue: config.transport,
values: ["sse", "websocket", "websocket-cached", "auto"],
},
+ {
+ id: "default-service-tier",
+ label: "Default service tier",
+ description: "Service tier for new sessions; applies to the current session when the model supports it",
+ currentValue: config.defaultServiceTier,
+ submenu: (currentValue, done) =>
+ new SelectSubmenu(
+ "Default Service Tier",
+ "Service tier for new sessions; applies to the current session when the model supports it",
+ SERVICE_TIER_OPTIONS,
+ currentValue,
+ (value) => done(value),
+ () => done(),
+ ),
+ },
{
id: "mermaid-rendering",
label: "Mermaid diagrams",
@@ -469,6 +493,9 @@ export class SettingsSelectorComponent extends Container {
case "transport":
callbacks.onTransportChange(newValue as Transport);
break;
+ case "default-service-tier":
+ callbacks.onDefaultServiceTierChange(newValue as Exclude<ServiceTier, null>);
+ break;
case "mermaid-rendering":
callbacks.onMermaidRenderingModeChange(newValue as MermaidRenderingMode);
break;
diff --git a/packages/coding-agent/src/modes/interactive/interactive-mode.ts b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
index 5ad529c91e..7173f7bdc1 100644
--- a/packages/coding-agent/src/modes/interactive/interactive-mode.ts
+++ b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
@@ -11,6 +11,7 @@ import {
type Model,
type ServiceTier,
supportsFastMode,
+ supportsServiceTier,
type ToolCall,
} from "@earendil-works/pi-ai";
import { BUILTIN_MCP_CATALOG } from "@earendil-works/pi-ai/mcp";
@@ -691,6 +692,16 @@ const THINKING_LEVEL_DESCRIPTIONS: Record<ThinkingLevel, string> = {
max: "Maximum reasoning",
};
+const SERVICE_TIER_CHOICES = ["default", "flex", "priority", "auto"] as const satisfies ServiceTier[];
+type ServiceTierChoice = (typeof SERVICE_TIER_CHOICES)[number];
+
+const SERVICE_TIER_DESCRIPTIONS: Record<ServiceTierChoice, string> = {
+ default: "Standard processing",
+ flex: "Cheaper, slower, may hit capacity limits",
+ priority: "Faster, more expensive (fast mode)",
+ auto: "Provider picks the tier",
+};
+
const HEARTBEAT_ARGUMENT_COMPLETIONS: AutocompleteItem[] = [
{
value: "every ",
@@ -1308,7 +1319,7 @@ export class InteractiveMode {
// renders await it so they never interleave with a half-built transcript.
private initialRenderPromise: Promise<void> | undefined = undefined;
private sessionEventGeneration = 0;
- private fastModeToggleQueue: Promise<void> = Promise.resolve();
+ private serviceTierChangeQueue: Promise<void> = Promise.resolve();
private pendingTools = new Map<string, ToolExecutionComponent>();
private ipythonToolComponents = new Map<string, ToolExecutionComponent>();
@@ -1694,6 +1705,12 @@ export class InteractiveMode {
}
}
+ const tierCommand = slashCommands.find((command) => command.name === "tier");
+ if (tierCommand) {
+ tierCommand.getArgumentCompletions = (prefix: string): AutocompleteItem[] | null =>
+ this.getServiceTierCompletions(prefix);
+ }
+
const heartbeatCommand = slashCommands.find((command) => command.name === "heartbeat");
if (heartbeatCommand) {
heartbeatCommand.getArgumentCompletions = (prefix: string): AutocompleteItem[] | null =>
@@ -5238,6 +5255,11 @@ export class InteractiveMode {
}
return;
}
+ if (commandName === "tier") {
+ this.editor.setText("");
+ this.handleTierCommand(commandArgs);
+ return;
+ }
if (commandName === "export") {
await this.handleExportCommand(canonicalCommandText);
this.editor.setText("");
@@ -6770,8 +6792,11 @@ export class InteractiveMode {
const modelId = model.id.startsWith(providerPrefix) ? model.id.slice(providerPrefix.length) : model.id;
const effort = model.reasoning ? this.connectionState?.thinkingLevel : undefined;
parts.push(effort ? `${modelId}:${effort.toLowerCase()}` : modelId);
- if (this.connectionState?.serviceTier === "priority") {
+ const serviceTier = this.connectionState?.serviceTier;
+ if (serviceTier === "priority") {
parts.push("fast");
+ } else if (serviceTier && serviceTier !== "default") {
+ parts.push(serviceTier);
}
}
const usage = this.getConnectionContextUsage();
@@ -8300,6 +8325,7 @@ export class InteractiveMode {
steeringMode: state.steeringMode,
followUpMode: state.followUpMode,
transport: this.settingsManager.getTransport(),
+ defaultServiceTier: this.settingsManager.getDefaultServiceTier() ?? "default",
thinkingLevel: state.thinkingLevel,
availableThinkingLevels: state.availableThinkingLevels,
currentTheme: this.settingsManager.getTheme() || "prime",
@@ -8360,6 +8386,13 @@ export class InteractiveMode {
this.showError(error instanceof Error ? error.message : String(error));
});
},
+ onDefaultServiceTierChange: (serviceTier) => {
+ this.settingsManager.setDefaultServiceTier(serviceTier);
+ this.enqueueServiceTierChange(
+ () => serviceTier,
+ (applied) => `Default service tier: ${serviceTier} (session: ${applied ?? "default"})`,
+ );
+ },
onTransportChange: (transport) => {
void this.agentConnection.setTransport(transport).catch((error) => {
this.showError(error instanceof Error ? error.message : String(error));
@@ -8762,25 +8795,83 @@ export class InteractiveMode {
}
private handleFastCommand(): void {
- const unavailableMessage =
- "Fast mode requires GPT-5.4, GPT-5.5, or GPT-5.6 with ChatGPT or OpenAI API key authentication";
+ const unavailableMessage = "Current model does not support fast mode (priority tier)";
if (!this.currentModelSupportsFastMode()) {
this.showStatus(unavailableMessage);
return;
}
+ this.enqueueServiceTierChange(
+ () => {
+ if (!this.currentModelSupportsFastMode()) {
+ this.showStatus(unavailableMessage);
+ return undefined;
+ }
+ return this.connectionState?.serviceTier === "priority" ? "default" : "priority";
+ },
+ (serviceTier) => `Fast mode: ${serviceTier === "priority" ? "on" : "off"}`,
+ );
+ }
+
+ private getAvailableServiceTiers(): ServiceTierChoice[] {
+ const model = this.getCurrentModel();
+ return SERVICE_TIER_CHOICES.filter(
+ (tier) => tier === "default" || (model !== undefined && supportsServiceTier(model, tier)),
+ );
+ }
+
+ private getServiceTierCompletions(prefix: string): AutocompleteItem[] | null {
+ const tiers = this.getAvailableServiceTiers();
+ const current = this.connectionState?.serviceTier ?? "default";
+ const term = prefix.trim().toLowerCase();
+ const matches = term ? tiers.filter((tier) => tier.startsWith(term)) : tiers;
+ if (matches.length === 0) return null;
+ return matches.map((tier) => ({
+ value: tier,
+ label: tier,
+ description:
+ tier === current ? `${SERVICE_TIER_DESCRIPTIONS[tier]} (current)` : SERVICE_TIER_DESCRIPTIONS[tier],
+ }));
+ }
+
+ private handleTierCommand(arg: string): void {
+ const tiers = this.getAvailableServiceTiers();
+ const requested = arg.trim().toLowerCase();
+ if (!requested) {
+ const current = this.connectionState?.serviceTier ?? "default";
+ this.showStatus(`Service tier: ${current} (available: ${tiers.join(", ")})`);
+ return;
+ }
+ if (!tiers.includes(requested as ServiceTierChoice)) {
+ this.showError(
+ `Service tier '${requested}' is not available for the current model. Available: ${tiers.join(", ")}`,
+ );
+ return;
+ }
+ this.enqueueServiceTierChange(
+ () => requested as ServiceTier,
+ (serviceTier) => `Service tier: ${serviceTier ?? "default"}`,
+ );
+ }
+
+ /**
+ * Serializes tier changes (/fast, /tier, settings row) through one queue so
+ * rapid commands apply in order against the same session.
+ */
+ private enqueueServiceTierChange(
+ computeTier: () => ServiceTier | undefined,
+ formatStatus: (serviceTier: ServiceTier) => string,
+ ): void {
const connection = this.agentConnection;
const sessionId = this.connectionState?.sessionId;
- this.fastModeToggleQueue = this.fastModeToggleQueue
+ this.serviceTierChangeQueue = this.serviceTierChangeQueue
.then(async () => {
if (this.agentConnection !== connection || this.connectionState?.sessionId !== sessionId) {
return;
}
- if (!this.currentModelSupportsFastMode()) {
- this.showStatus(unavailableMessage);
+ const serviceTier = computeTier();
+ if (serviceTier === undefined) {
return;
}
- const enabled = this.connectionState?.serviceTier === "priority";
- const serviceTier: ServiceTier = enabled ? "default" : "priority";
await connection.setServiceTier(serviceTier);
if (this.agentConnection !== connection || this.connectionState?.sessionId !== sessionId) {
return;
@@ -8796,7 +8887,7 @@ export class InteractiveMode {
this.patchConnectionState({ serviceTier: state.serviceTier });
this.footer.invalidate();
this.subagentSummaryLine.invalidate();
- this.showStatus(`Fast mode: ${state.serviceTier === "priority" ? "on" : "off"}`);
+ this.showStatus(formatStatus(state.serviceTier));
})
.catch((error) => {
this.showError(error instanceof Error ? error.message : String(error));
diff --git a/packages/coding-agent/test/interactive-mode-status.test.ts b/packages/coding-agent/test/interactive-mode-status.test.ts
index a6886a4987..256814dd68 100644
--- a/packages/coding-agent/test/interactive-mode-status.test.ts
+++ b/packages/coding-agent/test/interactive-mode-status.test.ts
@@ -1179,7 +1179,7 @@ describe("InteractiveMode live context usage", () => {
describe("InteractiveMode Fast mode concurrency", () => {
type FastCommandContext = {
connectionState?: { sessionId: string; serviceTier: ServiceTier; thinkingLevel: ThinkingLevel };
- fastModeToggleQueue: Promise<void>;
+ serviceTierChangeQueue: Promise<void>;
agentConnection: {
setServiceTier: (serviceTier: ServiceTier) => Promise<void>;
getState: () => Promise<{ sessionId: string; serviceTier: ServiceTier }>;
@@ -1192,11 +1192,23 @@ describe("InteractiveMode Fast mode concurrency", () => {
getCurrentModel: () => Model<Api> | undefined;
currentModelSupportsFastMode: () => boolean;
getConnectionContextUsage: () => undefined;
+ getAvailableServiceTiers: () => ServiceTier[];
+ enqueueServiceTierChange: (
+ computeTier: () => ServiceTier | undefined,
+ formatStatus: (t: ServiceTier) => string,
+ ) => void;
};
type FastInteractiveModePrototype = {
currentModelSupportsFastMode(this: FastCommandContext): boolean;
handleFastCommand(this: FastCommandContext): void;
+ handleTierCommand(this: FastCommandContext, arg: string): void;
+ getAvailableServiceTiers(this: FastCommandContext): ServiceTier[];
+ enqueueServiceTierChange(
+ this: FastCommandContext,
+ computeTier: () => ServiceTier | undefined,
+ formatStatus: (serviceTier: ServiceTier) => string,
+ ): void;
getModelContextLabel(this: FastCommandContext, maxWidth: number): string;
};
@@ -1220,7 +1232,7 @@ describe("InteractiveMode Fast mode concurrency", () => {
function makeFastContext(model: Model<Api> = testModel("openai-codex", "gpt-5.5", "openai-codex-responses")) {
const context: FastCommandContext = {
connectionState: { sessionId: "session-1", serviceTier: "default", thinkingLevel: "high" },
- fastModeToggleQueue: Promise.resolve(),
+ serviceTierChangeQueue: Promise.resolve(),
agentConnection: undefined as never,
footer: { invalidate: vi.fn() },
subagentSummaryLine: { invalidate: vi.fn() },
@@ -1232,6 +1244,9 @@ describe("InteractiveMode Fast mode concurrency", () => {
getCurrentModel: () => model,
getConnectionContextUsage: () => undefined,
currentModelSupportsFastMode: () => fastInteractiveModePrototype.currentModelSupportsFastMode.call(context),
+ getAvailableServiceTiers: () => fastInteractiveModePrototype.getAvailableServiceTiers.call(context),
+ enqueueServiceTierChange: (computeTier, formatStatus) =>
+ fastInteractiveModePrototype.enqueueServiceTierChange.call(context, computeTier, formatStatus),
};
context.agentConnection = {
setServiceTier: vi.fn(async (serviceTier) => {
@@ -1263,7 +1278,7 @@ describe("InteractiveMode Fast mode concurrency", () => {
expect(context.agentConnection.setServiceTier).toHaveBeenCalledWith("priority");
firstToggle.resolve();
- await context.fastModeToggleQueue;
+ await context.serviceTierChangeQueue;
expect(context.agentConnection.setServiceTier).toHaveBeenNthCalledWith(1, "priority");
expect(context.agentConnection.setServiceTier).toHaveBeenNthCalledWith(2, "default");
@@ -1277,7 +1292,7 @@ describe("InteractiveMode Fast mode concurrency", () => {
let releaseQueue!: () => void;
const context = makeFastContext();
const originalConnection = context.agentConnection;
- context.fastModeToggleQueue = new Promise<void>((resolve) => {
+ context.serviceTierChangeQueue = new Promise<void>((resolve) => {
releaseQueue = resolve;
});
@@ -1293,7 +1308,7 @@ describe("InteractiveMode Fast mode concurrency", () => {
};
context.connectionState = { sessionId: "session-2", serviceTier: "default", thinkingLevel: "high" };
releaseQueue();
- await context.fastModeToggleQueue;
+ await context.serviceTierChangeQueue;
expect(originalConnection.setServiceTier).not.toHaveBeenCalled();
expect(context.agentConnection.setServiceTier).not.toHaveBeenCalled();
@@ -1323,9 +1338,29 @@ describe("InteractiveMode Fast mode concurrency", () => {
};
context.connectionState = { sessionId: "session-2", serviceTier: "default", thinkingLevel: "high" };
finishToggle.resolve();
- await context.fastModeToggleQueue;
+ await context.serviceTierChangeQueue;
expect(context.patchConnectionState).not.toHaveBeenCalled();
expect(context.showStatus).not.toHaveBeenCalled();
});
+
+ test.each([
+ ["openai", "openai-responses", true],
+ ["openai-codex", "openai-codex-responses", false],
+ ] as const)("/tier flex on $0 reaches the connection: $2", async (provider, api, reaches) => {
+ const context = makeFastContext(testModel(provider, "gpt-5.5", api));
+
+ fastInteractiveModePrototype.handleTierCommand.call(context, "flex");
+ await context.serviceTierChangeQueue;
+
+ if (reaches) {
+ expect(context.agentConnection.setServiceTier).toHaveBeenCalledWith("flex");
+ expect(context.patchConnectionState).toHaveBeenCalledWith({ serviceTier: "flex" });
+ expect(context.showError).not.toHaveBeenCalled();
+ } else {
+ expect(context.agentConnection.setServiceTier).not.toHaveBeenCalled();
+ expect(context.patchConnectionState).not.toHaveBeenCalled();
+ expect(context.showError).toHaveBeenCalledOnce();
+ }
+ });
});
diff --git a/packages/coding-agent/test/suite/agent-session-runtime.test.ts b/packages/coding-agent/test/suite/agent-session-runtime.test.ts
index 3df5bdf035..810c8a6bd5 100644
--- a/packages/coding-agent/test/suite/agent-session-runtime.test.ts
+++ b/packages/coding-agent/test/suite/agent-session-runtime.test.ts
@@ -1285,6 +1285,35 @@ describe("ENG-4620 fast mode settings", () => {
expect(await switchTo(current, supported)).toBe("priority");
});
+ it("a clamped tier request keeps the requested preference for the parent and its children", async () => {
+ const current = await createFastModeHarness(["gpt-5.5", "gpt-4-turbo"], {
+ api: "openai-responses",
+ provider: "openai",
+ });
+
+ current.session.setServiceTier("priority");
+ expect(current.settingsManager.getDefaultServiceTier()).toBe("priority");
+
+ await current.session.setModel(current.getModel("gpt-4-turbo")!);
+ expect(current.session.serviceTier).toBe("default");
+
+ current.session.setServiceTier("flex");
+ expect(current.session.serviceTier).toBe("default");
+ expect(current.settingsManager.getDefaultServiceTier()).toBe("priority");
+
+ current.setResponses([fauxAssistantMessage("child answer")]);
+ const published = new Promise<string>((resolve) =>
+ current.session.subscribe((event) => {
+ if (event.type === "rlm_child_update" && event.child.status === "running") resolve(event.child.id);
+ }),
+ );
+ void current.session.runRlmChild("do the work", { model: "openai/gpt-5.5" });
+ const child = current.session.getRlmChildSession(await published);
+ expect(child!.sessionManager.buildSessionContext().serviceTier).toBe("flex");
+ await current.session.setModel(current.getModel("gpt-5.5")!);
+ expect(current.session.serviceTier).toBe("flex");
+ });
+
it("persists the preference across settings manager restarts", async () => {
const current = await createFastModeHarness(["gpt-5.4"]);
const agentDir = join(current.tempDir, "agent");