Skip to content

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

Rust

add openai fast mode (#414)

ktfd1bd875dc20
diff --git a/packages/agent/CHANGELOG.md b/packages/agent/CHANGELOG.md
index e8ca8eac15..2e0c9e0b68 100644
--- a/packages/agent/CHANGELOG.md
+++ b/packages/agent/CHANGELOG.md
@@ -2,6 +2,8 @@
## [Unreleased]
+- Added provider service-tier propagation to agent requests.
+
## [0.3.0] - 2026-07-13
## [0.2.9] - 2026-07-13
diff --git a/packages/agent/src/agent.ts b/packages/agent/src/agent.ts
index 38cb5c4814..398538e27f 100644
--- a/packages/agent/src/agent.ts
+++ b/packages/agent/src/agent.ts
@@ -74,6 +74,7 @@ function createMutableAgentState(
systemPrompt: initialState?.systemPrompt ?? "",
model: initialState?.model ?? DEFAULT_MODEL,
thinkingLevel: initialState?.thinkingLevel ?? "off",
+ serviceTier: initialState?.serviceTier ?? "default",
get tools() {
return tools;
},
@@ -469,6 +470,7 @@ export class Agent {
return {
model: this._state.model,
reasoning: this._state.thinkingLevel === "off" ? undefined : this._state.thinkingLevel,
+ serviceTier: this._state.serviceTier,
sessionId: this.sessionId,
onPayload: this.onPayload,
onResponse: this.onResponse,
diff --git a/packages/agent/src/types.ts b/packages/agent/src/types.ts
index 87feed164f..51ada71f42 100644
--- a/packages/agent/src/types.ts
+++ b/packages/agent/src/types.ts
@@ -4,6 +4,7 @@ import type {
ImageContent,
Message,
Model,
+ ServiceTier,
SimpleStreamOptions,
streamSimple,
TextContent,
@@ -309,6 +310,8 @@ export interface AgentState {
model: Model<any>;
/** Requested reasoning level for future turns. */
thinkingLevel: ThinkingLevel;
+ /** Requested provider service tier for future turns. */
+ serviceTier: ServiceTier;
/** Available tools. Assigning a new array copies the top-level array. */
set tools(tools: AgentTool<any>[]);
get tools(): AgentTool<any>[];
diff --git a/packages/agent/test/agent.test.ts b/packages/agent/test/agent.test.ts
index 0e0dc707cf..80de8d8737 100644
--- a/packages/agent/test/agent.test.ts
+++ b/packages/agent/test/agent.test.ts
@@ -71,6 +71,7 @@ describe("Agent", () => {
expect(agent.state.systemPrompt).toBe("");
expect(agent.state.model).toBeDefined();
expect(agent.state.thinkingLevel).toBe("off");
+ expect(agent.state.serviceTier).toBe("default");
expect(agent.state.tools).toEqual([]);
expect(agent.state.messages).toEqual([]);
expect(agent.state.isStreaming).toBe(false);
@@ -86,12 +87,14 @@ describe("Agent", () => {
systemPrompt: "You are a helpful assistant.",
model: customModel,
thinkingLevel: "low",
+ serviceTier: "priority",
},
});
expect(agent.state.systemPrompt).toBe("You are a helpful assistant.");
expect(agent.state.model).toBe(customModel);
expect(agent.state.thinkingLevel).toBe("low");
+ expect(agent.state.serviceTier).toBe("priority");
});
it("should subscribe to events", () => {
@@ -680,4 +683,22 @@ describe("Agent", () => {
await agent.prompt("hello again");
expect(receivedSessionId).toBe("session-def");
});
+
+ it("forwards the service tier to streamFn options", async () => {
+ let receivedServiceTier: string | null | undefined;
+ const agent = new Agent({
+ initialState: { serviceTier: "priority" },
+ streamFn: (_model, _context, options) => {
+ receivedServiceTier = options?.serviceTier;
+ const stream = new MockAssistantStream();
+ queueMicrotask(() => {
+ stream.push({ type: "done", reason: "stop", message: createAssistantMessage("ok") });
+ });
+ return stream;
+ },
+ });
+
+ await agent.prompt("hello");
+ expect(receivedServiceTier).toBe("priority");
+ });
});
diff --git a/packages/ai/CHANGELOG.md b/packages/ai/CHANGELOG.md
index 3ba6bffab6..c91e4583d9 100644
--- a/packages/ai/CHANGELOG.md
+++ b/packages/ai/CHANGELOG.md
@@ -2,6 +2,7 @@
## [Unreleased]
+- Added provider service-tier forwarding to shared stream options.
- Removed team-gated internal Prime Inference routes from the public model catalog so clients can discover them from authenticated team catalogs instead.
## [0.3.0] - 2026-07-13
diff --git a/packages/ai/src/models.ts b/packages/ai/src/models.ts
index 144bd36913..2231a89f9b 100644
--- a/packages/ai/src/models.ts
+++ b/packages/ai/src/models.ts
@@ -36,6 +36,14 @@ 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 {
+ return (
+ model.provider === "openai-codex" &&
+ model.api === "openai-codex-responses" &&
+ (model.id === "gpt-5.4" || model.id === "gpt-5.5" || model.id === "gpt-5.6" || model.id.startsWith("gpt-5.6-"))
+ );
+}
+
export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
usage.cost.input = (model.cost.input / 1000000) * usage.input;
usage.cost.output = (model.cost.output / 1000000) * usage.output;
diff --git a/packages/ai/src/providers/openai-codex-responses.ts b/packages/ai/src/providers/openai-codex-responses.ts
index 2083fcf2d5..43c95d2690 100644
--- a/packages/ai/src/providers/openai-codex-responses.ts
+++ b/packages/ai/src/providers/openai-codex-responses.ts
@@ -397,7 +397,7 @@ function getServiceTierCostMultiplier(
case "flex":
return 0.5;
case "priority":
- return model.id === "gpt-5.5" ? 2.5 : 2;
+ return model.id.startsWith("gpt-5.5") || model.id.startsWith("gpt-5.6") ? 2.5 : 2;
default:
return 1;
}
diff --git a/packages/ai/src/providers/simple-options.ts b/packages/ai/src/providers/simple-options.ts
index 1e2e3303b7..6dced0f032 100644
--- a/packages/ai/src/providers/simple-options.ts
+++ b/packages/ai/src/providers/simple-options.ts
@@ -7,6 +7,7 @@ export function buildBaseOptions(model: Model<Api>, options?: SimpleStreamOption
signal: options?.signal,
apiKey: apiKey || options?.apiKey,
transport: options?.transport,
+ serviceTier: options?.serviceTier,
cacheRetention: options?.cacheRetention,
sessionId: options?.sessionId,
headers: options?.headers,
diff --git a/packages/ai/src/types.ts b/packages/ai/src/types.ts
index 4a36416164..f38c99c5c4 100644
--- a/packages/ai/src/types.ts
+++ b/packages/ai/src/types.ts
@@ -68,6 +68,8 @@ export type CacheRetention = "none" | "short" | "long";
export type Transport = "sse" | "websocket" | "websocket-cached" | "auto";
+export type ServiceTier = "auto" | "default" | "flex" | "scale" | "priority" | null;
+
export interface ProviderResponse {
status: number;
headers: Record<string, string>;
@@ -83,6 +85,7 @@ export interface StreamOptions {
* Providers that do not support this option ignore it.
*/
transport?: Transport;
+ serviceTier?: ServiceTier;
/**
* Prompt cache retention preference. Providers map this to their supported values.
* Default: "short".
diff --git a/packages/ai/test/fast-mode.test.ts b/packages/ai/test/fast-mode.test.ts
new file mode 100644
index 0000000000..3f2185ec0c
--- /dev/null
+++ b/packages/ai/test/fast-mode.test.ts
@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { supportsFastMode } from "../src/models.js";
+import { buildBaseOptions } from "../src/providers/simple-options.js";
+import type { Api, Model } from "../src/types.js";
+
+function model(provider: string, id: string, api: Api): Model<Api> {
+ return {
+ id,
+ name: id,
+ api,
+ provider,
+ baseUrl: "https://example.com",
+ reasoning: true,
+ input: ["text"],
+ cost: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0 },
+ contextWindow: 1000,
+ maxTokens: 100,
+ };
+}
+
+describe("Fast mode", () => {
+ it.each(["gpt-5.4", "gpt-5.5", "gpt-5.6-luna"])("supports %s through ChatGPT auth", (id) => {
+ expect(supportsFastMode(model("openai-codex", id, "openai-codex-responses"))).toBe(true);
+ });
+
+ it("rejects unsupported models and API-key providers", () => {
+ expect(supportsFastMode(model("openai-codex", "gpt-5.3-codex", "openai-codex-responses"))).toBe(false);
+ expect(supportsFastMode(model("openai-codex", "gpt-5.4-mini", "openai-codex-responses"))).toBe(false);
+ expect(supportsFastMode(model("openai", "gpt-5.5", "openai-responses"))).toBe(false);
+ });
+
+ it("forwards priority through simple stream options", () => {
+ const testModel = model("openai-codex", "gpt-5.5", "openai-codex-responses");
+ expect(buildBaseOptions(testModel, { serviceTier: "priority" }).serviceTier).toBe("priority");
+ });
+});
diff --git a/packages/ai/test/openai-codex-stream.test.ts b/packages/ai/test/openai-codex-stream.test.ts
index f3d1989697..ca26eb0715 100644
--- a/packages/ai/test/openai-codex-stream.test.ts
+++ b/packages/ai/test/openai-codex-stream.test.ts
@@ -566,8 +566,10 @@ describe("openai-codex streaming", () => {
it.each([
["gpt-5.1-codex", "flex", 0.5],
["gpt-5.1-codex", "priority", 2],
+ ["gpt-5.4", "priority", 2],
["gpt-5.5", "flex", 0.5],
["gpt-5.5", "priority", 2.5],
+ ["gpt-5.6-sol", "priority", 2.5],
] as const)(
"uses the client-sent %s service tier for %s when Codex echoes default",
async (modelId, serviceTier, multiplier) => {
@@ -614,7 +616,7 @@ describe("openai-codex streaming", () => {
},
});
- global.fetch = vi.fn(async (input: string | URL) => {
+ global.fetch = vi.fn(async (input: string | URL, init?: RequestInit) => {
const url = typeof input === "string" ? input : input.toString();
if (url === "https://api.github.com/repos/openai/codex/releases/latest") {
return new Response(JSON.stringify({ tag_name: "rust-v0.0.0" }), { status: 200 });
@@ -623,6 +625,8 @@ describe("openai-codex streaming", () => {
return new Response("PROMPT", { status: 200, headers: { etag: '"etag"' } });
}
if (url === "https://chatgpt.com/backend-api/codex/responses") {
+ const body = JSON.parse(String(init?.body)) as { service_tier?: string };
+ expect(body.service_tier).toBe(serviceTier);
return new Response(stream, {
status: 200,
headers: { "content-type": "text/event-stream" },
diff --git a/packages/coding-agent/CHANGELOG.md b/packages/coding-agent/CHANGELOG.md
index 18b0108fd4..31ee2ec5ff 100644
--- a/packages/coding-agent/CHANGELOG.md
+++ b/packages/coding-agent/CHANGELOG.md
@@ -2,6 +2,7 @@
## [Unreleased]
+- Added `/fast` for OpenAI Fast mode on supported ChatGPT models ([ENG-4620](https://linear.app/primeintellect/issue/ENG-4620/add-support-for-gpt-fast-mode-maybe-fast)).
- Changed wrapped diff rows to use a blank hanging gutter.
- Fixed team-gated Prime Inference routes being missing from model selectors by merging the authenticated team catalog during model refresh ([ENG-4645](https://linear.app/primeintellect/issue/ENG-4645/internalglm-52-fast-isnt-working)).
- Added confirmation when fullscreen text selection copies to the clipboard ([ENG-4644](https://linear.app/primeintellect/issue/ENG-4644/copy-issues)).
diff --git a/packages/coding-agent/src/core/agent-session-runtime.ts b/packages/coding-agent/src/core/agent-session-runtime.ts
index 3c3e1fa0e4..8eda0a5b05 100644
--- a/packages/coding-agent/src/core/agent-session-runtime.ts
+++ b/packages/coding-agent/src/core/agent-session-runtime.ts
@@ -356,6 +356,7 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
sessionOptions: {
model: options.model,
thinkingLevel: options.thinkingLevel,
+ serviceTier: options.serviceTier,
scopedModels: options.scopedModels,
initialActiveToolNames: options.activeToolNames,
allowedToolNames: options.allowedToolNames,
diff --git a/packages/coding-agent/src/core/agent-session-services.ts b/packages/coding-agent/src/core/agent-session-services.ts
index 94dd9c6191..15e99241d6 100644
--- a/packages/coding-agent/src/core/agent-session-services.ts
+++ b/packages/coding-agent/src/core/agent-session-services.ts
@@ -1,6 +1,6 @@
import { join } from "node:path";
import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { Model } from "@earendil-works/pi-ai";
+import type { Model, ServiceTier } from "@earendil-works/pi-ai";
import { getAgentDir } from "../config.js";
import type { AgentSessionMessageController } from "./agent-messages.js";
import type { AgentObserveController } from "./agent-observe.js";
@@ -57,6 +57,8 @@ export interface CreateAgentSessionServicesOptions {
export interface AgentSessionCreationOptions {
model?: Model<any>;
thinkingLevel?: ThinkingLevel;
+ /** Provider service tier. Fast mode uses "priority". */
+ serviceTier?: ServiceTier;
scopedModels?: Array<{ model: Model<any>; thinkingLevel?: ThinkingLevel }>;
tools?: string[];
noTools?: "all" | "builtin";
@@ -252,6 +254,7 @@ export async function createAgentSessionFromServices(
sessionManager: options.sessionManager,
model: options.model,
thinkingLevel: options.thinkingLevel,
+ serviceTier: options.serviceTier,
scopedModels: options.scopedModels,
tools: options.tools,
noTools: options.noTools,
diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts
index f93562ba8e..677de8f02c 100644
--- a/packages/coding-agent/src/core/agent-session.ts
+++ b/packages/coding-agent/src/core/agent-session.ts
@@ -29,7 +29,15 @@ import {
type ShouldStopAfterTurnContext,
type ThinkingLevel,
} from "@earendil-works/pi-agent-core";
-import type { AssistantMessage, ImageContent, Model, TextContent, Usage, UserMessage } from "@earendil-works/pi-ai";
+import type {
+ AssistantMessage,
+ ImageContent,
+ Model,
+ ServiceTier,
+ TextContent,
+ Usage,
+ UserMessage,
+} from "@earendil-works/pi-ai";
import {
clampThinkingLevel,
cleanupSessionResources,
@@ -37,6 +45,7 @@ import {
isContextOverflow,
modelsAreEqual,
resetApiProviders,
+ supportsFastMode,
} from "@earendil-works/pi-ai";
import { theme } from "../modes/interactive/theme/theme.js";
import { stripFrontmatter } from "../utils/frontmatter.js";
@@ -262,6 +271,7 @@ export type AgentSessionEvent =
| { type: "compaction_start"; reason: CompactionReason; customInstructions?: string }
| { type: "session_info_changed"; name: string | undefined }
| { type: "thinking_level_changed"; level: ThinkingLevel }
+ | { type: "service_tier_changed"; serviceTier: ServiceTier }
| {
type: "compaction_end";
reason: CompactionReason;
@@ -314,6 +324,7 @@ export interface AgentSessionConfig {
agent: Agent;
sessionManager: SessionManager;
settingsManager: SettingsManager;
+ serviceTierPreference?: ServiceTier;
cwd: string;
/** Config dir backing credentials (auth.json); exported to the kernel for skills. */
agentDir?: string;
@@ -615,6 +626,7 @@ interface AgentMessageDeliveryWaiter {
export interface ModelCycleResult {
model: Model<any>;
thinkingLevel: ThinkingLevel;
+ serviceTier: ServiceTier;
/** Whether cycling through scoped models (--models flag) or all available */
isScoped: boolean;
}
@@ -753,6 +765,7 @@ export class AgentSession {
readonly agent: Agent;
readonly sessionManager: SessionManager;
readonly settingsManager: SettingsManager;
+ private _serviceTierPreference: ServiceTier;
private _scopedModels: Array<{ model: Model<any>; thinkingLevel?: ThinkingLevel }>;
@@ -898,6 +911,7 @@ export class AgentSession {
this.agent = config.agent;
this.sessionManager = config.sessionManager;
this.settingsManager = config.settingsManager;
+ this._serviceTierPreference = config.serviceTierPreference ?? config.agent.state.serviceTier;
this._scopedModels = config.scopedModels ?? [];
this._resourceLoader = config.resourceLoader;
this._customTools = config.customTools ?? [];
@@ -2605,6 +2619,10 @@ export class AgentSession {
return this.agent.state.thinkingLevel;
}
+ get serviceTier(): ServiceTier {
+ return this.agent.state.serviceTier;
+ }
+
/** Whether agent is currently streaming a response */
get isStreaming(): boolean {
return this.agent.state.isStreaming;
@@ -4116,12 +4134,14 @@ export class AgentSession {
const previousModel = this.model;
const thinkingLevel = this._getThinkingLevelForModelSwitch();
+ const serviceTier = this._getServiceTierForModelSwitch();
this.agent.state.model = model;
this.sessionManager.appendModelChange(model.provider, model.id);
this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
// Re-clamp thinking level for new model's capabilities
this.setThinkingLevel(thinkingLevel);
+ this._clampServiceTierForModel(serviceTier);
const emitPromise = this._queueModelSelectEmit(model, previousModel, "set");
if (this._shouldWaitForModelSelectEmit(options)) {
@@ -4187,6 +4207,7 @@ export class AgentSession {
const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
const next = scopedModels[nextIndex];
const thinkingLevel = this._getThinkingLevelForModelSwitch(next.thinkingLevel);
+ const serviceTier = this._getServiceTierForModelSwitch();
// Apply model
this.agent.state.model = next.model;
@@ -4198,6 +4219,7 @@ export class AgentSession {
// - Undefined scoped model thinking level inherits the current session preference
// setThinkingLevel clamps to model capabilities.
this.setThinkingLevel(thinkingLevel);
+ this._clampServiceTierForModel(serviceTier);
const emitPromise = this._queueModelSelectEmit(next.model, currentModel, "cycle");
if (this._shouldWaitForModelSelectEmit(options)) {
@@ -4206,7 +4228,7 @@ export class AgentSession {
this._trackModelSelectEmitError(emitPromise);
}
- return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
+ return { model: next.model, thinkingLevel: this.thinkingLevel, serviceTier: this.serviceTier, isScoped: true };
}
private async _cycleAvailableModel(
@@ -4225,12 +4247,14 @@ export class AgentSession {
const nextModel = availableModels[nextIndex];
const thinkingLevel = this._getThinkingLevelForModelSwitch();
+ const serviceTier = this._getServiceTierForModelSwitch();
this.agent.state.model = nextModel;
this.sessionManager.appendModelChange(nextModel.provider, nextModel.id);
this.settingsManager.setDefaultModelAndProvider(nextModel.provider, nextModel.id);
// Re-clamp thinking level for new model's capabilities
this.setThinkingLevel(thinkingLevel);
+ this._clampServiceTierForModel(serviceTier);
const emitPromise = this._queueModelSelectEmit(nextModel, currentModel, "cycle");
if (this._shouldWaitForModelSelectEmit(options)) {
@@ -4239,7 +4263,7 @@ export class AgentSession {
this._trackModelSelectEmitError(emitPromise);
}
- return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
+ return { model: nextModel, thinkingLevel: this.thinkingLevel, serviceTier: this.serviceTier, isScoped: false };
}
// =========================================================================
@@ -4275,6 +4299,43 @@ export class AgentSession {
}
}
+ setServiceTier(serviceTier: ServiceTier): void {
+ const effectiveServiceTier = this._getEffectiveServiceTier(serviceTier);
+ const preferenceChanged = effectiveServiceTier !== this._serviceTierPreference;
+ const effectiveTierChanged = effectiveServiceTier !== this.agent.state.serviceTier;
+ if (!preferenceChanged && !effectiveTierChanged) {
+ return;
+ }
+ this._serviceTierPreference = effectiveServiceTier;
+ if (preferenceChanged) {
+ this.sessionManager.appendServiceTierChange(effectiveServiceTier);
+ if (this.model && supportsFastMode(this.model)) {
+ this.settingsManager.setDefaultServiceTier(effectiveServiceTier);
+ }
+ }
+ if (effectiveTierChanged) {
+ this.agent.state.serviceTier = effectiveServiceTier;
+ this._emit({ type: "service_tier_changed", serviceTier: effectiveServiceTier });
+ }
+ }
+
+ private _getEffectiveServiceTier(serviceTier: ServiceTier): ServiceTier {
+ return serviceTier === "priority" && (!this.model || !supportsFastMode(this.model)) ? "default" : serviceTier;
+ }
+
+ private _getServiceTierForModelSwitch(): ServiceTier {
+ return this._serviceTierPreference;
+ }
+
+ private _clampServiceTierForModel(serviceTier: ServiceTier = this.serviceTier): void {
+ const effectiveServiceTier = this._getEffectiveServiceTier(serviceTier);
+ if (effectiveServiceTier === this.agent.state.serviceTier) {
+ return;
+ }
+ this.agent.state.serviceTier = effectiveServiceTier;
+ this._emit({ type: "service_tier_changed", serviceTier: effectiveServiceTier });
+ }
+
/**
* Cycle to next thinking level.
* @returns New level, or undefined if model doesn't support thinking
@@ -6047,6 +6108,7 @@ export class AgentSession {
sessionDir: options.sessionDir,
model: options.model,
thinkingLevel: this.thinkingLevel,
+ serviceTier: this.serviceTier,
scopedModels: [...this._scopedModels],
activeToolNames: this.getActiveToolNames(),
allowedToolNames: this._allowedToolNames ? [...this._allowedToolNames] : undefined,
@@ -6097,12 +6159,16 @@ export class AgentSession {
}
childSessionManager.appendModelChange(options.model.provider, options.model.id);
childSessionManager.appendThinkingLevelChange(options.thinkingLevel);
+ const serviceTier =
+ options.serviceTier === "priority" && !supportsFastMode(options.model) ? "default" : options.serviceTier;
+ childSessionManager.appendServiceTierChange(serviceTier);
const childAgent = new Agent({
initialState: {
systemPrompt: "",
model: options.model,
thinkingLevel: options.thinkingLevel,
+ serviceTier,
tools: [],
},
convertToLlm: this.agent.convertToLlm,
diff --git a/packages/coding-agent/src/core/export-html/template.js b/packages/coding-agent/src/core/export-html/template.js
index cf28b935e8..68f2089c1d 100644
--- a/packages/coding-agent/src/core/export-html/template.js
+++ b/packages/coding-agent/src/core/export-html/template.js
@@ -357,6 +357,10 @@
case 'thinking_level_change':
parts.push('thinking', entry.thinkingLevel);
break;
+ case 'service_tier_change':
+ parts.push('service tier', entry.serviceTier || 'default');
+ if (entry.serviceTier === 'priority') parts.push('fast on');
+ break;
}
return parts.join(' ').toLowerCase();
@@ -385,7 +389,13 @@
}
// Apply filter mode
- const isSettingsEntry = ['label', 'custom', 'model_change', 'thinking_level_change'].includes(entry.type);
+ const isSettingsEntry = [
+ 'label',
+ 'custom',
+ 'model_change',
+ 'thinking_level_change',
+ 'service_tier_change'
+ ].includes(entry.type);
let passesFilter = true;
switch (filterMode) {
@@ -681,6 +691,8 @@
return labelHtml + `<span class="tree-muted">[model: ${escapeHtml(entry.modelId)}]</span>`;
case 'thinking_level_change':
return labelHtml + `<span class="tree-muted">[thinking: ${escapeHtml(entry.thinkingLevel)}]</span>`;
+ case 'service_tier_change':
+ return labelHtml + `<span class="tree-muted">[service tier: ${escapeHtml(entry.serviceTier || 'default')}]</span>`;
default:
return labelHtml + `<span class="tree-muted">[${escapeHtml(entry.type)}]</span>`;
}
diff --git a/packages/coding-agent/src/core/rlm-runtime.ts b/packages/coding-agent/src/core/rlm-runtime.ts
index b87a207b83..8cdabdf291 100644
--- a/packages/coding-agent/src/core/rlm-runtime.ts
+++ b/packages/coding-agent/src/core/rlm-runtime.ts
@@ -1,5 +1,5 @@
import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { Model, Usage } from "@earendil-works/pi-ai";
+import type { Model, ServiceTier, Usage } from "@earendil-works/pi-ai";
import type { AgentSession } from "./agent-session.js";
import type { ToolDefinition } from "./extensions/index.js";
import type { HostRequestHandler } from "./kernel/index.js";
@@ -57,6 +57,7 @@ export interface CreateRlmSubagentRuntimeOptions {
sessionDir: string;
model: Model<any>;
thinkingLevel: ThinkingLevel;
+ serviceTier: ServiceTier;
scopedModels: Array<{ model: Model<any>; thinkingLevel?: ThinkingLevel }>;
activeToolNames: string[];
allowedToolNames?: string[];
diff --git a/packages/coding-agent/src/core/sdk.ts b/packages/coding-agent/src/core/sdk.ts
index 91e5187605..0d73925bde 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 } from "@earendil-works/pi-ai";
+import { clampThinkingLevel, type Message, type Model, streamSimple, supportsFastMode } from "@earendil-works/pi-ai";
import { getAgentDir } from "../config.js";
import { AgentSession } from "./agent-session.js";
import type { AgentSessionCreationOptions } from "./agent-session-services.js";
@@ -187,6 +187,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
const existingSession = sessionManager.buildSessionContext();
const hasExistingSession = existingSession.messages.length > 0;
const hasThinkingEntry = sessionManager.getBranch().some((entry) => entry.type === "thinking_level_change");
+ const hasServiceTierEntry = sessionManager.getBranch().some((entry) => entry.type === "service_tier_change");
let model = options.model;
let modelFallbackMessage: string | undefined;
@@ -241,6 +242,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
thinkingLevel = clampThinkingLevel(model, thinkingLevel) as ThinkingLevel;
}
+ const serviceTierPreference =
+ options.serviceTier ??
+ (hasServiceTierEntry ? existingSession.serviceTier : settingsManager.getDefaultServiceTier());
+ const serviceTier =
+ serviceTierPreference === "priority" && (!model || !supportsFastMode(model)) ? "default" : serviceTierPreference;
+
const allowedToolNames = options.allowedToolNames ?? options.tools ?? (options.noTools === "all" ? [] : undefined);
const includeGoals = options.includeGoals ?? (options.tools !== undefined || options.noTools !== "all");
const initialActiveToolNames: string[] =
@@ -292,6 +299,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
systemPrompt: "",
model,
thinkingLevel,
+ serviceTier,
tools: [],
},
convertToLlm: convertToLlmWithBlockImages,
@@ -348,17 +356,21 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
sessionManager.appendThinkingLevelChange(thinkingLevel);
}
} else {
- // Save initial model and thinking level for new sessions so they can be restored on resume
+ // Save initial configuration for new sessions so it can be restored on resume.
if (model) {
sessionManager.appendModelChange(model.provider, model.id);
}
sessionManager.appendThinkingLevelChange(thinkingLevel);
}
+ if (!hasServiceTierEntry) {
+ sessionManager.appendServiceTierChange(serviceTierPreference);
+ }
const session = new AgentSession({
agent,
sessionManager,
settingsManager,
+ serviceTierPreference,
cwd,
// Only the explicit dir — the default may not match injected custom storage.
agentDir: options.agentDir,
diff --git a/packages/coding-agent/src/core/session-manager.ts b/packages/coding-agent/src/core/session-manager.ts
index 3b177bb7a0..00cafa8101 100644
--- a/packages/coding-agent/src/core/session-manager.ts
+++ b/packages/coding-agent/src/core/session-manager.ts
@@ -1,5 +1,5 @@
import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { AssistantMessage, ImageContent, Message, TextContent, Usage } from "@earendil-works/pi-ai";
+import type { AssistantMessage, ImageContent, Message, ServiceTier, TextContent, Usage } from "@earendil-works/pi-ai";
import { randomUUID } from "crypto";
import {
appendFileSync,
@@ -41,6 +41,7 @@ const CONTENT_ENTRY_TYPES = new Set([
"custom",
"model_change",
"thinking_level_change",
+ "service_tier_change",
"session_info",
"label",
"compaction",
@@ -83,6 +84,11 @@ export interface ThinkingLevelChangeEntry extends SessionEntryBase {
thinkingLevel: string;
}
+export interface ServiceTierChangeEntry extends SessionEntryBase {
+ type: "service_tier_change";
+ serviceTier: ServiceTier;
+}
+
export interface ModelChangeEntry extends SessionEntryBase {
type: "model_change";
provider: string;
@@ -214,6 +220,7 @@ export interface CustomMessageEntry<T = unknown> extends SessionEntryBase {
export type SessionEntry =
| SessionMessageEntry
| ThinkingLevelChangeEntry
+ | ServiceTierChangeEntry
| ModelChangeEntry
| CompactionEntry
| BranchSummaryEntry
@@ -242,6 +249,7 @@ export interface SessionTreeNode {
export interface SessionContext {
messages: AgentMessage[];
thinkingLevel: string;
+ serviceTier: ServiceTier;
model: { provider: string; modelId: string } | null;
}
@@ -449,7 +457,7 @@ export function buildSessionContext(
let leaf: SessionEntry | undefined;
if (leafId === null) {
// Explicitly null - return no messages (navigated to before first entry)
- return { messages: [], thinkingLevel: "off", model: null };
+ return { messages: [], thinkingLevel: "off", serviceTier: "default", model: null };
}
if (leafId) {
leaf = byId.get(leafId);
@@ -460,7 +468,7 @@ export function buildSessionContext(
}
if (!leaf) {
- return { messages: [], thinkingLevel: "off", model: null };
+ return { messages: [], thinkingLevel: "off", serviceTier: "default", model: null };
}
// push+reverse, not unshift-per-entry: unshift is O(n), making this O(n^2) on long sessions.
@@ -474,12 +482,15 @@ export function buildSessionContext(
// Extract settings and find compaction
let thinkingLevel = "off";
+ let serviceTier: ServiceTier = "default";
let model: { provider: string; modelId: string } | null = null;
let compaction: CompactionEntry | null = null;
for (const entry of path) {
if (entry.type === "thinking_level_change") {
thinkingLevel = entry.thinkingLevel;
+ } else if (entry.type === "service_tier_change") {
+ serviceTier = entry.serviceTier;
} else if (entry.type === "model_change") {
model = { provider: entry.provider, modelId: entry.modelId };
} else if (entry.type === "message" && entry.message.role === "assistant") {
@@ -546,7 +557,7 @@ export function buildSessionContext(
}
}
- return { messages, thinkingLevel, model };
+ return { messages, thinkingLevel, serviceTier, model };
}
/**
@@ -1321,6 +1332,19 @@ export class SessionManager {
return entry.id;
}
+ /** Append a service tier change as child of current leaf, then advance leaf. Returns entry id. */
+ appendServiceTierChange(serviceTier: ServiceTier): string {
+ const entry: ServiceTierChangeEntry = {
+ type: "service_tier_change",
+ id: generateId(this.byId),
+ parentId: this.leafId,
+ timestamp: new Date().toISOString(),
+ serviceTier,
+ };
+ this._appendEntry(entry);
+ return entry.id;
+ }
+
/** Append a model change as child of current leaf, then advance leaf. Returns entry id. */
appendModelChange(provider: string, modelId: string): string {
const entry: ModelChangeEntry = {
@@ -1458,8 +1482,8 @@ export class SessionManager {
* delete (that guard always also requires zero messages).
*
* createAgentSession opens a new session with an optional leading `model_change`
- * (only when a model is available) followed by `thinking_level_change`. That
- * creation prefix is skipped; anything beyond it is user content.
+ * followed by `thinking_level_change` and `service_tier_change`. That creation
+ * prefix is skipped; anything beyond it is user content.
*/
hasUserContent(): boolean {
const contentEntries = this.getEntries().filter((entry) => CONTENT_ENTRY_TYPES.has(entry.type));
@@ -1470,6 +1494,9 @@ export class SessionManager {
if (contentEntries[start]?.type === "thinking_level_change") {
start++;
}
+ if (contentEntries[start]?.type === "service_tier_change") {
+ start++;
+ }
return contentEntries.length > start;
}
diff --git a/packages/coding-agent/src/core/settings-manager.ts b/packages/coding-agent/src/core/settings-manager.ts
index 0c9f98bdd7..33241f690c 100644
--- a/packages/coding-agent/src/core/settings-manager.ts
+++ b/packages/coding-agent/src/core/settings-manager.ts
@@ -1,4 +1,4 @@
-import type { Transport } from "@earendil-works/pi-ai";
+import type { ServiceTier, Transport } from "@earendil-works/pi-ai";
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
import { homedir } from "os";
import { dirname, join } from "path";
@@ -126,6 +126,7 @@ export interface Settings {
defaultModel?: string;
recentModels?: string[]; // "provider/id" keys, most-recently-used first
defaultThinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+ defaultServiceTier?: ServiceTier;
transport?: TransportSetting; // default: "auto"
steeringMode?: "all" | "one-at-a-time";
followUpMode?: "all" | "one-at-a-time";
@@ -721,6 +722,16 @@ export class SettingsManager {
this.save();
}
+ getDefaultServiceTier(): ServiceTier {
+ return this.settings.defaultServiceTier ?? "default";
+ }
+
+ setDefaultServiceTier(serviceTier: ServiceTier): void {
+ this.globalSettings.defaultServiceTier = serviceTier;
+ this.markModified("defaultServiceTier");
+ this.save();
+ }
+
getTransport(): TransportSetting {
return this.settings.transport ?? "auto";
}
diff --git a/packages/coding-agent/src/core/side-question.ts b/packages/coding-agent/src/core/side-question.ts
index a619ce6600..d90765aa69 100644
--- a/packages/coding-agent/src/core/side-question.ts
+++ b/packages/coding-agent/src/core/side-question.ts
@@ -45,6 +45,7 @@ export function startSideQuestion(
systemPrompt: parent.state.systemPrompt,
messages: structuredClone(parent.state.messages),
thinkingLevel: "off",
+ serviceTier: parent.state.serviceTier,
tools: [],
},
convertToLlm: parent.convertToLlm,
diff --git a/packages/coding-agent/src/core/slash-commands.ts b/packages/coding-agent/src/core/slash-commands.ts
index d9da483f79..4aa8b8adc2 100644
--- a/packages/coding-agent/src/core/slash-commands.ts
+++ b/packages/coding-agent/src/core/slash-commands.ts
@@ -39,6 +39,7 @@ const CANONICAL_BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
{ name: "settings", description: "Open settings menu" },
{ name: "model", description: "Select model (opens selector UI)" },
{ name: "effort", description: "Set reasoning/thinking level", argumentHint: "[level]", takesArgument: true },
+ { name: "fast", description: "Toggle OpenAI Fast mode" },
{ name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
{ name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
{ name: "import", description: "Import and resume a session from a JSONL file" },
diff --git a/packages/coding-agent/src/main.ts b/packages/coding-agent/src/main.ts
index 56bdfe9d91..80ebffd07e 100644
--- a/packages/coding-agent/src/main.ts
+++ b/packages/coding-agent/src/main.ts
@@ -751,6 +751,7 @@ export function resolveRuntimeSessionOptions(
return {
model: runtimeSessionOptions?.model ?? sessionOptions.model,
thinkingLevel: runtimeSessionOptions?.thinkingLevel ?? sessionOptions.thinkingLevel,
+ serviceTier: runtimeSessionOptions?.serviceTier ?? sessionOptions.serviceTier,
scopedModels: runtimeSessionOptions?.scopedModels ?? sessionOptions.scopedModels,
tools: runtimeSessionOptions?.tools ?? sessionOptions.tools,
noTools: runtimeSessionOptions?.noTools ?? sessionOptions.noTools,
diff --git a/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts b/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts
index 19549a3d40..1bda600655 100644
--- a/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts
+++ b/packages/coding-agent/src/modes/agent-connection/daemon-agent-connection.ts
@@ -1,6 +1,6 @@
import { randomUUID } from "node:crypto";
import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { ImageContent, Transport } from "@earendil-works/pi-ai";
+import type { ImageContent, ServiceTier, Transport } from "@earendil-works/pi-ai";
import { getAgentLogPath, getDaemonLogPath } from "../../config.js";
import type { AgentSessionEvent } from "../../core/agent-session.js";
import type { CompactionResult } from "../../core/compaction/index.js";
@@ -677,6 +677,10 @@ export class DaemonAgentConnection implements AgentConnection {
await this.requestOk({ type: "set_thinking_level", activeSessionId: this.activeSessionId, level });
}
+ async setServiceTier(serviceTier: ServiceTier): Promise<void> {
+ await this.requestOk({ type: "set_service_tier", activeSessionId: this.activeSessionId, serviceTier });
+ }
+
async cycleThinkingLevel(): Promise<ThinkingLevel | undefined> {
const result = await this.requestData<{ level: ThinkingLevel } | null>({
type: "cycle_thinking_level",
diff --git a/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts b/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
index 7be8683cf4..4201fe9cbc 100644
--- a/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
+++ b/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
@@ -1,6 +1,6 @@
import { resolve } from "node:path";
import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { ImageContent, Transport } from "@earendil-works/pi-ai";
+import type { ImageContent, ServiceTier, Transport } from "@earendil-works/pi-ai";
import type { AgentSessionRuntime } from "../../core/agent-session-runtime.js";
import type { CompactionResult } from "../../core/compaction/index.js";
import type { ContextTreeNode } from "../../core/context-tree.js";
@@ -297,6 +297,10 @@ export class InProcessAgentConnection implements AgentConnection {
this.session.setThinkingLevel(level);
}
+ async setServiceTier(serviceTier: ServiceTier): Promise<void> {
+ this.session.setServiceTier(serviceTier);
+ }
+
async cycleThinkingLevel(): Promise<ThinkingLevel | undefined> {
return this.session.cycleThinkingLevel();
}
diff --git a/packages/coding-agent/src/modes/agent-connection/snapshot.ts b/packages/coding-agent/src/modes/agent-connection/snapshot.ts
index 82136e4a30..9f54b77a62 100644
--- a/packages/coding-agent/src/modes/agent-connection/snapshot.ts
+++ b/packages/coding-agent/src/modes/agent-connection/snapshot.ts
@@ -30,6 +30,7 @@ export function createAgentConnectionState(
cwd: sessionManager.getCwd(),
model: toConnectionModel(session.model),
thinkingLevel: session.thinkingLevel,
+ serviceTier: session.serviceTier,
availableThinkingLevels: session.getAvailableThinkingLevels(),
isStreaming: session.isStreaming,
isCompacting: session.isCompacting,
diff --git a/packages/coding-agent/src/modes/agent-connection/types.ts b/packages/coding-agent/src/modes/agent-connection/types.ts
index e419b2bf36..7ea3bf183c 100644
--- a/packages/coding-agent/src/modes/agent-connection/types.ts
+++ b/packages/coding-agent/src/modes/agent-connection/types.ts
@@ -1,5 +1,5 @@
import type { AgentEvent, AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { Api, ImageContent, Model, TextContent, Transport, Usage } from "@earendil-works/pi-ai";
+import type { Api, ImageContent, Model, ServiceTier, TextContent, Transport, Usage } from "@earendil-works/pi-ai";
import type { AuthSourceToken } from "../../core/auth-storage.js";
import type { CompactionResult } from "../../core/compaction/index.js";
import type { ContextTreeNode } from "../../core/context-tree.js";
@@ -122,6 +122,11 @@ export interface AgentConnectionThinkingLevelChangeEntry extends AgentConnection
thinkingLevel: string;
}
+export interface AgentConnectionServiceTierChangeEntry extends AgentConnectionSessionEntryBase {
+ type: "service_tier_change";
+ serviceTier: ServiceTier;
+}
+
export interface AgentConnectionModelChangeEntry extends AgentConnectionSessionEntryBase {
type: "model_change";
provider: string;
@@ -199,6 +204,7 @@ export interface AgentConnectionGitStateEntry extends AgentConnectionSessionEntr
export type AgentConnectionSessionEntry =
| AgentConnectionSessionMessageEntry
| AgentConnectionThinkingLevelChangeEntry
+ | AgentConnectionServiceTierChangeEntry
| AgentConnectionModelChangeEntry
| AgentConnectionCompactionEntry
| AgentConnectionBranchSummaryEntry
@@ -221,6 +227,7 @@ export interface AgentConnectionSessionTreeNode {
export interface AgentConnectionSessionContext {
messages: AgentMessage[];
thinkingLevel: string;
+ serviceTier: ServiceTier;
model: { provider: string; modelId: string } | null;
}
@@ -270,6 +277,7 @@ export interface AgentConnectionScopedModel {
export interface AgentConnectionModelCycleResult {
model: AgentConnectionModel;
thinkingLevel: ThinkingLevel;
+ serviceTier: ServiceTier;
isScoped: boolean;
}
@@ -278,6 +286,7 @@ export interface AgentConnectionState {
cwd: string;
model?: AgentConnectionModel;
thinkingLevel: ThinkingLevel;
+ serviceTier: ServiceTier;
availableThinkingLevels: ThinkingLevel[];
isStreaming: boolean;
isCompacting: boolean;
@@ -488,6 +497,7 @@ export type AgentConnectionSessionEvent =
}
| { type: "session_info_changed"; name: string | undefined }
| { type: "thinking_level_changed"; level: ThinkingLevel }
+ | { type: "service_tier_changed"; serviceTier: ServiceTier }
| {
type: "compaction_end";
reason: "manual" | "threshold" | "overflow" | "requested";
@@ -591,6 +601,7 @@ export interface AgentConnection {
cycleModel(direction?: "forward" | "backward"): Promise<AgentConnectionModelCycleResult | undefined>;
setScopedModels(scopedModels: AgentConnectionScopedModel[]): Promise<void>;
setThinkingLevel(level: ThinkingLevel): Promise<void>;
+ setServiceTier(serviceTier: ServiceTier): Promise<void>;
cycleThinkingLevel(): Promise<ThinkingLevel | undefined>;
setTransport(transport: Transport): Promise<void>;
setSteeringMode(mode: AgentConnectionQueueMode): Promise<void>;
diff --git a/packages/coding-agent/src/modes/daemon/daemon-client.ts b/packages/coding-agent/src/modes/daemon/daemon-client.ts
index a23a065b78..d4f72b00b9 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-client.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-client.ts
@@ -4,11 +4,13 @@ import { getDaemonLogPath } from "../../config.js";
import { attachJsonlLineReader, serializeJsonLine } from "../rpc/jsonl.js";
import {
createDaemonCommandEnvelope,
+ DAEMON_COMMAND_ENVELOPE_MIN_PROTOCOL_VERSION,
DAEMON_PROTOCOL_VERSION,
type DaemonClosingReason,
type DaemonCommand,
type DaemonCommandEnvelope,
type DaemonOutbound,
+ type DaemonProtocolVersion,
type DaemonRequestProgress,
type DaemonResponse,
type DaemonSavedSessionInfo,
@@ -275,7 +277,13 @@ export class DaemonClient {
);
}
const hello = this.helloMessage ?? (await this.waitForHello());
- return this.requestWire(command, timeoutMs, options, hello.protocol.version >= DAEMON_PROTOCOL_VERSION);
+ const envelopeProtocolVersion = Math.min(hello.protocol.version, DAEMON_PROTOCOL_VERSION);
+ return this.requestWire(
+ command,
+ timeoutMs,
+ options,
+ envelopeProtocolVersion >= DAEMON_COMMAND_ENVELOPE_MIN_PROTOCOL_VERSION ? envelopeProtocolVersion : undefined,
+ );
}
/** One-release compatibility path for preparing and stopping a v1 daemon. */
@@ -284,26 +292,26 @@ export class DaemonClient {
timeoutMs = 30000,
options: DaemonClientRequestOptions = {},
): Promise<DaemonResponse> {
- return this.requestWire(command, timeoutMs, options, false);
+ return this.requestWire(command, timeoutMs, options);
}
async authenticateWorker(token: string, timeoutMs = 3000): Promise<void> {
const legacyAuthentication = { type: "worker_auth", token } as DaemonWorkerCommandBody;
- const response = await this.requestWire(legacyAuthentication, timeoutMs, {}, false);
+ const response = await this.requestWire(legacyAuthentication, timeoutMs);
if (!response.success) {
throw new Error(response.error);
}
}
async requestWorker(command: DaemonWorkerCommandBody, timeoutMs = 30000): Promise<DaemonResponse> {
- return this.requestWire(command, timeoutMs, {}, false);
+ return this.requestWire(command, timeoutMs);
}
private async requestWire(
command: DaemonWireCommandBody,
timeoutMs: number,
options: DaemonClientRequestOptions = {},
- usePublicEnvelope: boolean,
+ publicEnvelopeProtocolVersion?: DaemonProtocolVersion,
): Promise<DaemonResponse> {
if (!this.socket || this.socket.destroyed) {
throw new Error(
@@ -313,11 +321,17 @@ export class DaemonClient {
const id = `daemon_${++this.requestId}`;
const fullCommand = { ...command, id } as DaemonCommand | DaemonWorkerCommand;
- const wireCommand: DaemonCommand | DaemonWorkerCommand | DaemonCommandEnvelope = usePublicEnvelope
- ? createDaemonCommandEnvelope(fullCommand as DaemonCommand, id, this.protocolClientId)
+ const wireCommand: DaemonCommand | DaemonWorkerCommand | DaemonCommandEnvelope = publicEnvelopeProtocolVersion
+ ? createDaemonCommandEnvelope(
+ fullCommand as DaemonCommand,
+ id,
+ this.protocolClientId,
+ publicEnvelopeProtocolVersion,
+ )
: fullCommand;
const wireData = serializeJsonLine(wireCommand);
- const acknowledgeResult = usePublicEnvelope && isDaemonMutatingCommand(fullCommand as DaemonCommand);
+ const acknowledgeResult =
+ publicEnvelopeProtocolVersion !== undefined && isDaemonMutatingCommand(fullCommand as DaemonCommand);
return new Promise((resolve, reject) => {
const pending: PendingDaemonRequest = {
@@ -429,12 +443,21 @@ export class DaemonClient {
}
private acknowledgeCommandResult(commandId: string): void {
- if (!this.socket || this.socket.destroyed || (this.helloMessage?.protocol.version ?? 0) < 2) {
+ const hello = this.helloMessage;
+ if (
+ !this.socket ||
+ this.socket.destroyed ||
+ !hello ||
+ hello.protocol.version < DAEMON_COMMAND_ENVELOPE_MIN_PROTOCOL_VERSION
+ ) {
return;
}
const id = `daemon_ack_${++this.requestId}`;
const command: DaemonCommand = { id, type: "ack_result", commandId };
- this.socket.write(serializeJsonLine(createDaemonCommandEnvelope(command, id, this.protocolClientId)));
+ const protocolVersion = Math.min(hello.protocol.version, DAEMON_PROTOCOL_VERSION);
+ this.socket.write(
+ serializeJsonLine(createDaemonCommandEnvelope(command, id, this.protocolClientId, protocolVersion)),
+ );
}
private rejectAll(error: Error, preservePendingRequests = false): void {
diff --git a/packages/coding-agent/src/modes/daemon/daemon-mode.ts b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
index 47f341a843..23e262a8b2 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-mode.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
@@ -228,6 +228,7 @@ const DAEMON_COMMAND_TYPES: ReadonlySet<string> = new Set([
"cycle_model",
"set_scoped_models",
"set_thinking_level",
+ "set_service_tier",
"cycle_thinking_level",
"set_transport",
"set_steering_mode",
@@ -1561,6 +1562,7 @@ export class AgentDaemon {
sessionOptions: {
model: options.model,
thinkingLevel: options.thinkingLevel,
+ serviceTier: options.serviceTier,
scopedModels: options.scopedModels,
initialActiveToolNames: options.activeToolNames,
allowedToolNames: options.allowedToolNames,
@@ -2658,6 +2660,12 @@ export class AgentDaemon {
return success(command.id, "set_thinking_level");
}
+ case "set_service_tier": {
+ const state = this.getSessionState(command.activeSessionId);
+ state.runtime.session.setServiceTier(command.serviceTier);
+ return success(command.id, "set_service_tier");
+ }
+
case "cycle_thinking_level": {
const state = this.getSessionState(command.activeSessionId);
const level = state.runtime.session.cycleThinkingLevel();
diff --git a/packages/coding-agent/src/modes/daemon/daemon-protocol.ts b/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
index cb0455a7c3..fccf3a9aa7 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
@@ -1,5 +1,5 @@
import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
-import type { ImageContent, TextContent, Transport } from "@earendil-works/pi-ai";
+import type { ImageContent, ServiceTier, TextContent, Transport } from "@earendil-works/pi-ai";
import type {
AgentSessionMessageDeliveryMode,
AgentSessionMessageReceipt,
@@ -37,10 +37,11 @@ import type { SessionSummary } from "./daemon-session-list.js";
*/
export const DAEMON_PROTOCOL_NAME = "prime-agent.daemon";
-export const DAEMON_PROTOCOL_VERSION = 2;
+export const DAEMON_PROTOCOL_VERSION = 3;
+export const DAEMON_COMMAND_ENVELOPE_MIN_PROTOCOL_VERSION = 2;
export type DaemonProtocolName = typeof DAEMON_PROTOCOL_NAME;
-export type DaemonProtocolVersion = typeof DAEMON_PROTOCOL_VERSION;
+export type DaemonProtocolVersion = number;
export type DaemonCommandId = string;
export type DaemonEventId = string;
export type DaemonEventSequence = number;
@@ -388,6 +389,7 @@ export type DaemonCommand =
| { id?: string; type: "cycle_model"; activeSessionId: string; direction?: "forward" | "backward" }
| { id?: string; type: "set_scoped_models"; activeSessionId: string; scopedModels: AgentConnectionScopedModel[] }
| { id?: string; type: "set_thinking_level"; activeSessionId: string; level: ThinkingLevel }
+ | { id?: string; type: "set_service_tier"; activeSessionId: string; serviceTier: ServiceTier }
| { id?: string; type: "cycle_thinking_level"; activeSessionId: string }
| { id?: string; type: "set_transport"; activeSessionId: string; transport: Transport }
| { id?: string; type: "set_steering_mode"; activeSessionId: string; mode: AgentConnectionQueueMode }
@@ -623,11 +625,12 @@ export function createDaemonCommandEnvelope<TCommand extends DaemonCommand>(
command: TCommand,
id: DaemonCommandId,
clientId?: DaemonClientId,
+ protocolVersion: DaemonProtocolVersion = DAEMON_PROTOCOL_VERSION,
): DaemonCommandEnvelope<TCommand> {
return {
type: "command",
id,
- protocol: DAEMON_PROTOCOL_INFO,
+ protocol: { name: DAEMON_PROTOCOL_NAME, version: protocolVersion },
...(clientId ? { clientId } : {}),
command,
};
@@ -648,7 +651,9 @@ export function isDaemonCommandEnvelope(value: unknown): value is DaemonCommandE
candidate.type === "command" &&
typeof candidate.id === "string" &&
candidate.protocol?.name === DAEMON_PROTOCOL_NAME &&
- candidate.protocol.version === DAEMON_PROTOCOL_VERSION &&
+ typeof candidate.protocol.version === "number" &&
+ candidate.protocol.version >= DAEMON_COMMAND_ENVELOPE_MIN_PROTOCOL_VERSION &&
+ candidate.protocol.version <= DAEMON_PROTOCOL_VERSION &&
(candidate.clientId === undefined || typeof candidate.clientId === "string") &&
typeof candidate.command === "object" &&
candidate.command !== null
diff --git a/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts b/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts
index 831253f705..7c3ff6350d 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-supervisor.ts
@@ -148,6 +148,7 @@ const DAEMON_COMMAND_TYPES: ReadonlySet<string> = new Set([
"set_scoped_models",
"set_thinking_level",
"cycle_thinking_level",
+ "set_service_tier",
"set_transport",
"set_steering_mode",
"set_follow_up_mode",
diff --git a/packages/coding-agent/src/modes/interactive/components/tree-selector.ts b/packages/coding-agent/src/modes/interactive/components/tree-selector.ts
index 559c9643da..48a2837474 100644
--- a/packages/coding-agent/src/modes/interactive/components/tree-selector.ts
+++ b/packages/coding-agent/src/modes/interactive/components/tree-selector.ts
@@ -303,6 +303,7 @@ class TreeList implements Component {
entry.type === "custom" ||
entry.type === "model_change" ||
entry.type === "thinking_level_change" ||
+ entry.type === "service_tier_change" ||
entry.type === "session_info" ||
entry.type === "child_usage_attributed";
@@ -547,6 +548,10 @@ class TreeList implements Component {
case "thinking_level_change":
parts.push("thinking", entry.thinkingLevel);
break;
+ case "service_tier_change":
+ parts.push("service tier", entry.serviceTier ?? "default");
+ if (entry.serviceTier === "priority") parts.push("fast on");
+ break;
case "custom":
parts.push("custom", entry.customType);
break;
@@ -770,6 +775,9 @@ class TreeList implements Component {
case "thinking_level_change":
result = theme.fg("dim", `[thinking: ${entry.thinkingLevel}]`);
break;
+ case "service_tier_change":
+ result = theme.fg("dim", `[service tier: ${entry.serviceTier ?? "default"}]`);
+ break;
case "custom":
result = theme.fg("dim", `[custom: ${entry.customType}]`);
break;
diff --git a/packages/coding-agent/src/modes/interactive/interactive-mode.ts b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
index 6af29d9f67..3c01d638cf 100644
--- a/packages/coding-agent/src/modes/interactive/interactive-mode.ts
+++ b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
@@ -11,10 +11,11 @@ import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core"
import {
type Api,
type AssistantMessage,
- getSupportedThinkingLevels,
type ImageContent,
type Message,
type Model,
+ type ServiceTier,
+ supportsFastMode,
type ToolCall,
} from "@earendil-works/pi-ai";
import { BUILTIN_MCP_CATALOG } from "@earendil-works/pi-ai/mcp";
@@ -729,6 +730,7 @@ export class InteractiveMode {
// Serializes session event handling; see subscribeToAgent
private sessionEventQueue: Promise<void> = Promise.resolve();
+ private fastModeToggleQueue: Promise<void> = Promise.resolve();
// Tool execution tracking: toolCallId -> component
private pendingTools = new Map<string, ToolExecutionComponent>();
@@ -987,7 +989,9 @@ export class InteractiveMode {
private createBaseAutocompleteProvider(): AutocompleteProvider {
// Define commands for autocomplete
- const slashCommands: SlashCommand[] = BUILTIN_SLASH_COMMANDS.map((command) => ({
+ const slashCommands: SlashCommand[] = BUILTIN_SLASH_COMMANDS.filter(
+ (command) => command.name !== "fast" || this.currentModelSupportsFastMode(),
+ ).map((command) => ({
name: command.name,
aliases: command.aliases,
description: command.description,
@@ -2284,6 +2288,9 @@ export class InteractiveMode {
case "thinking_level_changed":
this.patchConnectionState({ thinkingLevel: event.level });
break;
+ case "service_tier_changed":
+ this.patchConnectionState({ serviceTier: event.serviceTier });
+ break;
case "auto_retry_start":
this.patchConnectionState({ retryAttempt: event.attempt });
break;
@@ -3886,6 +3893,15 @@ export class InteractiveMode {
this.handleEffortCommand(commandArgs);
return;
}
+ if (commandName === "fast") {
+ this.editor.setText("");
+ if (commandArgs) {
+ this.showError("Usage: /fast");
+ } else {
+ this.handleFastCommand();
+ }
+ return;
+ }
if (commandName === "export") {
await this.handleExportCommand(canonicalCommandText);
this.editor.setText("");
@@ -4422,9 +4438,15 @@ export class InteractiveMode {
case "thinking_level_changed":
this.footer.invalidate();
+ this.childAgentSummary.invalidate();
this.updateEditorBorderColor();
break;
+ case "service_tier_changed":
+ this.footer.invalidate();
+ this.childAgentSummary.invalidate();
+ break;
+
case "bash_start": {
const component = new BashExecutionComponent(event.command, this.ui, event.excludeFromContext);
if (this.isAgentStreaming()) {
@@ -5091,11 +5113,17 @@ export class InteractiveMode {
if (!model) {
return "—";
}
- if (!model.reasoning) {
- return model.name;
+ const parts = [model.name];
+ if (model.reasoning) {
+ const level = this.connectionState?.thinkingLevel ?? "off";
+ if (level !== "off") {
+ parts.push(level);
+ }
+ }
+ if (this.connectionState?.serviceTier === "priority") {
+ parts.push("fast");
}
- const level = this.connectionState?.thinkingLevel ?? "off";
- return level === "off" ? model.name : `${model.name} • ${level}`;
+ return parts.join(" • ");
}
private getAgentsViewTrayHint(): string | undefined {
@@ -5765,6 +5793,7 @@ export class InteractiveMode {
return {
messages: snapshot.messages,
thinkingLevel: snapshot.state.thinkingLevel,
+ serviceTier: snapshot.state.serviceTier,
model: snapshot.state.model
? { provider: snapshot.state.model.provider, modelId: snapshot.state.model.id }
: null,
@@ -6777,13 +6806,25 @@ export class InteractiveMode {
}
private async applySelectedModel(model: AgentConnectionModel): Promise<void> {
- await this.agentConnection.setModel(model.provider, model.id);
+ const connection = this.agentConnection;
+ const sessionId = this.connectionState?.sessionId;
+ await connection.setModel(model.provider, model.id);
+ const state = await connection.getState();
+ if (
+ this.agentConnection !== connection ||
+ this.connectionState?.sessionId !== sessionId ||
+ (sessionId !== undefined && state.sessionId !== sessionId)
+ ) {
+ return;
+ }
this.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
this.patchConnectionState({
- model,
- availableThinkingLevels: getSupportedThinkingLevels(model) as ThinkingLevel[],
+ model: state.model ?? model,
+ serviceTier: state.serviceTier,
+ availableThinkingLevels: state.availableThinkingLevels,
});
this.footer.invalidate();
+ this.childAgentSummary.invalidate();
this.updateEditorBorderColor();
// Rebuild so the /effort argument hint reflects the new model's levels.
this.setupAutocompleteProvider();
@@ -6946,6 +6987,52 @@ export class InteractiveMode {
return filtered.length === 0 ? null : filtered;
}
+ private currentModelSupportsFastMode(): boolean {
+ const model = this.getCurrentModel();
+ return model !== undefined && supportsFastMode(model);
+ }
+
+ private handleFastCommand(): void {
+ const unavailableMessage = "Fast mode requires GPT-5.4, GPT-5.5, or GPT-5.6 with ChatGPT authentication";
+ if (!this.currentModelSupportsFastMode()) {
+ this.showStatus(unavailableMessage);
+ return;
+ }
+ const connection = this.agentConnection;
+ const sessionId = this.connectionState?.sessionId;
+ this.fastModeToggleQueue = this.fastModeToggleQueue
+ .then(async () => {
+ if (this.agentConnection !== connection || this.connectionState?.sessionId !== sessionId) {
+ return;
+ }
+ if (!this.currentModelSupportsFastMode()) {
+ this.showStatus(unavailableMessage);
+ 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;
+ }
+ const state = await connection.getState();
+ if (
+ this.agentConnection !== connection ||
+ this.connectionState?.sessionId !== sessionId ||
+ state.sessionId !== sessionId
+ ) {
+ return;
+ }
+ this.patchConnectionState({ serviceTier: state.serviceTier });
+ this.footer.invalidate();
+ this.childAgentSummary.invalidate();
+ this.showStatus(`Fast mode: ${state.serviceTier === "priority" ? "on" : "off"}`);
+ })
+ .catch((error) => {
+ this.showError(error instanceof Error ? error.message : String(error));
+ });
+ }
+
private handleEffortCommand(arg: string): void {
const levels = this.getAvailableThinkingLevels();
if (levels.length === 0) {
diff --git a/packages/coding-agent/test/agent-connection-daemon.test.ts b/packages/coding-agent/test/agent-connection-daemon.test.ts
index a4428d3ccb..a180d9af8e 100644
--- a/packages/coding-agent/test/agent-connection-daemon.test.ts
+++ b/packages/coding-agent/test/agent-connection-daemon.test.ts
@@ -457,6 +457,7 @@ function createConnectionState(activeSessionId: string, sessionId: string): Agen
cwd: "/tmp/project",
model: undefined,
thinkingLevel: "medium",
+ serviceTier: "default",
availableThinkingLevels: ["minimal", "low", "medium", "high", "xhigh"],
isStreaming: false,
isCompacting: false,
@@ -539,6 +540,7 @@ function createAttachResult(
({
messages,
thinkingLevel: state.thinkingLevel,
+ serviceTier: state.serviceTier,
model: state.model ? { provider: state.model.provider, modelId: state.model.id } : null,
} satisfies NonNullable<DaemonAttachResult["snapshot"]["sessionContext"]>),
}),
@@ -1116,6 +1118,7 @@ describe("DaemonAgentConnection", () => {
sessionContext: {
messages,
thinkingLevel: "medium",
+ serviceTier: "default",
model: null,
},
sessionTree: {
@@ -1598,6 +1601,7 @@ describe("DaemonAgentConnection", () => {
sessionContext: {
messages: reconnectedMessages,
thinkingLevel: "medium",
+ serviceTier: "default",
model: null,
},
replay: {
diff --git a/packages/coding-agent/test/daemon-client.test.ts b/packages/coding-agent/test/daemon-client.test.ts
index 15be3b12c6..77b488fe13 100644
--- a/packages/coding-agent/test/daemon-client.test.ts
+++ b/packages/coding-agent/test/daemon-client.test.ts
@@ -1,5 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { DaemonClient, getDaemonSocketCloseReason } from "../src/modes/daemon/daemon-client.js";
+import { DAEMON_PROTOCOL_VERSION } from "../src/modes/daemon/daemon-protocol.js";
const netMock = vi.hoisted(() => {
type Listener = (...args: unknown[]) => void;
@@ -85,7 +86,7 @@ vi.mock("node:net", () => ({
createConnection: netMock.createConnection,
}));
-function emitHello(socket: (typeof netMock.sockets)[number], version = 2): void {
+function emitHello(socket: (typeof netMock.sockets)[number], version = DAEMON_PROTOCOL_VERSION): void {
socket.emit(
"data",
`${JSON.stringify({
@@ -213,7 +214,7 @@ describe("DaemonClient", () => {
expect(envelope).toMatchObject({
type: "command",
clientId: expect.any(String),
- protocol: { name: "prime-agent.daemon", version: 2 },
+ protocol: { name: "prime-agent.daemon", version: DAEMON_PROTOCOL_VERSION },
command: { type: "attach", activeSessionId: "active-1" },
});
expect(envelope.command).not.toHaveProperty("daemonSessionId");
@@ -310,6 +311,38 @@ describe("DaemonClient", () => {
client.close();
});
+ it("keeps durable command envelopes when connected to a v2 daemon", async () => {
+ const client = new DaemonClient("/tmp/prime-agent.sock");
+ const connect = client.connect();
+ const socket = netMock.sockets[0]!;
+ socket.emit("connect");
+ await connect;
+ emitHello(socket, 2);
+
+ const response = client.request({ type: "create" });
+ const request = JSON.parse(socket.writes[0]!.trim()) as {
+ id: string;
+ protocol: { version: number };
+ };
+ expect(request.protocol.version).toBe(2);
+
+ socket.emit(
+ "data",
+ `${JSON.stringify({ id: request.id, type: "response", command: "create", success: true })}\n`,
+ );
+ await response;
+
+ const acknowledgement = JSON.parse(socket.writes[1]!.trim()) as {
+ protocol: { version: number };
+ command: { type: string; commandId: string };
+ };
+ expect(acknowledgement).toMatchObject({
+ protocol: { version: 2 },
+ command: { type: "ack_result", commandId: request.id },
+ });
+ client.close();
+ });
+
it("routes request progress by response id without notifying general listeners", async () => {
const client = new DaemonClient("/tmp/prime-agent.sock");
@@ -468,7 +501,7 @@ describe("DaemonClient", () => {
client.close();
});
- it("acknowledges durable mutating-command results on protocol v2", async () => {
+ it("acknowledges durable mutating-command results on the current protocol", async () => {
const client = new DaemonClient("/tmp/prime-agent.sock");
const connect = client.connect();
const socket = netMock.sockets[0]!;
@@ -639,7 +672,7 @@ describe("DaemonClient", () => {
`${JSON.stringify({
type: "daemon_hello",
socketPath: "/tmp/prime-agent.sock",
- protocol: { name: "prime-agent.daemon", version: 2 },
+ protocol: { name: "prime-agent.daemon", version: DAEMON_PROTOCOL_VERSION },
clientId: "server-client-2",
serverCapabilities: [],
})}\n`,
@@ -721,7 +754,7 @@ describe("DaemonClient", () => {
`${JSON.stringify({
type: "daemon_hello",
socketPath: "/tmp/prime-agent.sock",
- protocol: { name: "prime-agent.daemon", version: 2 },
+ protocol: { name: "prime-agent.daemon", version: DAEMON_PROTOCOL_VERSION },
clientId: "server-client-2",
serverCapabilities: [],
})}\n`,
diff --git a/packages/coding-agent/test/daemon-protocol.test.ts b/packages/coding-agent/test/daemon-protocol.test.ts
index d3720142f0..e15de7cbbe 100644
--- a/packages/coding-agent/test/daemon-protocol.test.ts
+++ b/packages/coding-agent/test/daemon-protocol.test.ts
@@ -6,6 +6,7 @@ import {
createDaemonReplayInfo,
DAEMON_PROTOCOL_INFO,
type DaemonOutbound,
+ isDaemonCommandEnvelope,
} from "../src/modes/daemon/daemon-protocol.js";
describe("daemon protocol helpers", () => {
@@ -40,6 +41,13 @@ describe("daemon protocol helpers", () => {
expect(eventMeta.cursor).toEqual({ generation: "active-1", sequence: 3 });
});
+ it("accepts command envelopes from the compatible v2 protocol", () => {
+ const command = { id: "cmd-1", type: "attach", activeSessionId: "active-1" } as const;
+
+ expect(isDaemonCommandEnvelope(createDaemonCommandEnvelope(command, "cmd-1", "client-1", 2))).toBe(true);
+ expect(isDaemonCommandEnvelope(createDaemonCommandEnvelope(command, "cmd-1", "client-1", 1))).toBe(false);
+ });
+
it("reports replay availability from resume cursors", () => {
expect(createDaemonReplayInfo(undefined, 5, "generation-1")).toEqual({
status: "complete",
diff --git a/packages/coding-agent/test/export-html-xss.test.ts b/packages/coding-agent/test/export-html-xss.test.ts
index 5c6ffe8721..d19d9fed56 100644
--- a/packages/coding-agent/test/export-html-xss.test.ts
+++ b/packages/coding-agent/test/export-html-xss.test.ts
@@ -46,11 +46,13 @@ describe("export HTML markdown link sanitization", () => {
expect(templateJs).not.toMatch(/\[\$\{msg\.role\}\]/);
expect(templateJs).not.toMatch(/\[model: \$\{entry\.modelId\}\]/);
expect(templateJs).not.toMatch(/\[thinking: \$\{entry\.thinkingLevel\}\]/);
+ expect(templateJs).not.toMatch(/\[service tier: \$\{entry\.serviceTier\}\]/);
expect(templateJs).not.toMatch(/\[\$\{entry\.type\}\]/);
expect(templateJs).toMatch(/\$\{escapeHtml\(msg\.toolName \|\| 'tool'\)\}/);
expect(templateJs).toMatch(/\$\{escapeHtml\(msg\.role\)\}/);
expect(templateJs).toMatch(/\$\{escapeHtml\(entry\.modelId\)\}/);
expect(templateJs).toMatch(/\$\{escapeHtml\(entry\.thinkingLevel\)\}/);
+ expect(templateJs).toMatch(/\$\{escapeHtml\(entry\.serviceTier \|\| 'default'\)\}/);
expect(templateJs).toMatch(/\$\{escapeHtml\(entry\.type\)\}/);
});
diff --git a/packages/coding-agent/test/interactive-mode-effort-command.test.ts b/packages/coding-agent/test/interactive-mode-effort-command.test.ts
index 8589e497e5..b1edb9cb88 100644
--- a/packages/coding-agent/test/interactive-mode-effort-command.test.ts
+++ b/packages/coding-agent/test/interactive-mode-effort-command.test.ts
@@ -1,4 +1,5 @@
import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Api, Model, ServiceTier } from "@earendil-works/pi-ai";
import type { AutocompleteItem } from "@earendil-works/pi-tui";
import { beforeAll, describe, expect, it, vi } from "vitest";
import { InteractiveMode } from "../src/modes/interactive/interactive-mode.js";
@@ -28,6 +29,72 @@ type InteractiveModePrototype = {
const interactiveModePrototype = InteractiveMode.prototype as unknown as InteractiveModePrototype;
+type FastCommandContext = {
+ connectionState?: { sessionId: string; serviceTier: ServiceTier; thinkingLevel: ThinkingLevel };
+ fastModeToggleQueue: Promise<void>;
+ agentConnection: {
+ setServiceTier: (serviceTier: ServiceTier) => Promise<void>;
+ getState: () => Promise<{ sessionId: string; serviceTier: ServiceTier }>;
+ };
+ footer: { invalidate: () => void };
+ childAgentSummary: { invalidate: () => void };
+ showStatus: (message: string) => void;
+ showError: (message: string) => void;
+ patchConnectionState: (patch: Record<string, unknown>) => void;
+ getCurrentModel: () => Model<Api> | undefined;
+ currentModelSupportsFastMode: () => boolean;
+};
+
+type FastInteractiveModePrototype = {
+ currentModelSupportsFastMode(this: FastCommandContext): boolean;
+ handleFastCommand(this: FastCommandContext): void;
+ getModelTrayLabel(this: FastCommandContext): string;
+};
+
+const fastInteractiveModePrototype = InteractiveMode.prototype as unknown as FastInteractiveModePrototype;
+
+function testModel(provider: string, id: string, api: Api): Model<Api> {
+ return {
+ id,
+ name: id,
+ api,
+ provider,
+ baseUrl: "https://example.com",
+ reasoning: true,
+ input: ["text"],
+ cost: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0 },
+ contextWindow: 1000,
+ maxTokens: 100,
+ };
+}
+
+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(),
+ agentConnection: undefined as never,
+ footer: { invalidate: vi.fn() },
+ childAgentSummary: { invalidate: vi.fn() },
+ showStatus: vi.fn(),
+ showError: vi.fn(),
+ patchConnectionState: vi.fn((patch: Record<string, unknown>) => {
+ context.connectionState = { ...context.connectionState, ...patch } as FastCommandContext["connectionState"];
+ }),
+ getCurrentModel: () => model,
+ currentModelSupportsFastMode: () => fastInteractiveModePrototype.currentModelSupportsFastMode.call(context),
+ };
+ context.agentConnection = {
+ setServiceTier: vi.fn(async (serviceTier) => {
+ context.connectionState = { ...context.connectionState!, serviceTier };
+ }),
+ getState: vi.fn(async () => ({
+ sessionId: context.connectionState!.sessionId,
+ serviceTier: context.connectionState!.serviceTier,
+ })),
+ };
+ return context;
+}
+
function makeContext(overrides: Partial<EffortCommandContext> = {}): EffortCommandContext {
const context: EffortCommandContext = {
connectionState: {
@@ -142,12 +209,23 @@ describe("InteractiveMode /effort", () => {
});
describe("model switch refresh", () => {
- it("refreshes availableThinkingLevels from the newly selected model", async () => {
+ it("refreshes model-dependent state from the connection", async () => {
+ type ModelState = {
+ sessionId: string;
+ model: unknown;
+ serviceTier: ServiceTier;
+ availableThinkingLevels: ThinkingLevel[];
+ };
type ModelContext = {
- agentConnection: { setModel: (provider: string, id: string) => Promise<void> };
+ connectionState: { sessionId: string };
+ agentConnection: {
+ setModel: (provider: string, id: string) => Promise<void>;
+ getState: () => Promise<ModelState>;
+ };
settingsManager: { setDefaultModelAndProvider: (provider: string, id: string) => void };
patchConnectionState: (patch: Record<string, unknown>) => void;
footer: { invalidate: () => void };
+ childAgentSummary: { invalidate: () => void };
updateEditorBorderColor: () => void;
setupAutocompleteProvider: () => void;
};
@@ -158,24 +236,164 @@ describe("InteractiveMode /effort", () => {
).applySelectedModel;
const patchConnectionState = vi.fn();
const setupAutocompleteProvider = vi.fn();
+ const model = { provider: "openai-codex", id: "gpt-5.5", reasoning: true };
const context: ModelContext = {
- agentConnection: { setModel: vi.fn(async () => {}) },
+ connectionState: { sessionId: "session-1" },
+ agentConnection: {
+ setModel: vi.fn(async () => {}),
+ getState: vi.fn(
+ async (): Promise<ModelState> => ({
+ sessionId: "session-1",
+ model,
+ serviceTier: "priority",
+ availableThinkingLevels: ["off", "low", "medium", "high"],
+ }),
+ ),
+ },
settingsManager: { setDefaultModelAndProvider: vi.fn() },
patchConnectionState,
footer: { invalidate: vi.fn() },
+ childAgentSummary: { invalidate: vi.fn() },
updateEditorBorderColor: vi.fn(),
setupAutocompleteProvider,
};
- const model = { provider: "anthropic", id: "claude-opus", reasoning: true };
await applySelectedModel.call(context, model);
const patch = patchConnectionState.mock.calls[0][0];
expect(patch.model).toBe(model);
+ expect(patch.serviceTier).toBe("priority");
expect(patch.availableThinkingLevels).toContain("high");
expect(patch.availableThinkingLevels.length).toBeGreaterThan(1);
// Provider rebuild keeps the /effort argument hint in sync with the model.
expect(setupAutocompleteProvider).toHaveBeenCalledTimes(1);
});
});
+
+ describe("Fast mode", () => {
+ it("enables Fast mode and refreshes the model tray", async () => {
+ const context = makeFastContext();
+
+ fastInteractiveModePrototype.handleFastCommand.call(context);
+ await vi.waitFor(() => expect(context.showStatus).toHaveBeenCalledWith("Fast mode: on"));
+
+ expect(context.agentConnection.setServiceTier).toHaveBeenCalledWith("priority");
+ expect(context.patchConnectionState).toHaveBeenCalledWith({ serviceTier: "priority" });
+ expect(context.footer.invalidate).toHaveBeenCalledWith();
+ expect(context.childAgentSummary.invalidate).toHaveBeenCalledWith();
+ });
+
+ it("disables Fast mode when it is already enabled", async () => {
+ const context = makeFastContext();
+ context.connectionState = { sessionId: "session-1", serviceTier: "priority", thinkingLevel: "high" };
+
+ fastInteractiveModePrototype.handleFastCommand.call(context);
+ await vi.waitFor(() => expect(context.showStatus).toHaveBeenCalledWith("Fast mode: off"));
+
+ expect(context.agentConnection.setServiceTier).toHaveBeenCalledWith("default");
+ expect(context.patchConnectionState).toHaveBeenCalledWith({ serviceTier: "default" });
+ });
+
+ it("serializes rapid toggles", async () => {
+ const context = makeFastContext();
+
+ fastInteractiveModePrototype.handleFastCommand.call(context);
+ fastInteractiveModePrototype.handleFastCommand.call(context);
+
+ await vi.waitFor(() => expect(context.agentConnection.setServiceTier).toHaveBeenCalledTimes(2));
+ expect(context.agentConnection.setServiceTier).toHaveBeenNthCalledWith(1, "priority");
+ expect(context.agentConnection.setServiceTier).toHaveBeenNthCalledWith(2, "default");
+ });
+
+ it("uses the effective service tier returned by the connection", async () => {
+ const context = makeFastContext();
+ context.agentConnection.getState = vi.fn(
+ async (): Promise<{ sessionId: string; serviceTier: ServiceTier }> => ({
+ sessionId: "session-1",
+ serviceTier: "default",
+ }),
+ );
+
+ fastInteractiveModePrototype.handleFastCommand.call(context);
+ await vi.waitFor(() => expect(context.showStatus).toHaveBeenCalledWith("Fast mode: off"));
+
+ expect(context.agentConnection.setServiceTier).toHaveBeenCalledWith("priority");
+ expect(context.patchConnectionState).toHaveBeenCalledWith({ serviceTier: "default" });
+ });
+
+ it("drops a queued toggle after switching sessions", async () => {
+ let releaseQueue!: () => void;
+ const context = makeFastContext();
+ const originalConnection = context.agentConnection;
+ context.fastModeToggleQueue = new Promise<void>((resolve) => {
+ releaseQueue = resolve;
+ });
+
+ fastInteractiveModePrototype.handleFastCommand.call(context);
+ context.agentConnection = {
+ setServiceTier: vi.fn(async () => {}),
+ getState: vi.fn(
+ async (): Promise<{ sessionId: string; serviceTier: ServiceTier }> => ({
+ sessionId: "session-2",
+ serviceTier: "default",
+ }),
+ ),
+ };
+ context.connectionState = { sessionId: "session-2", serviceTier: "default", thinkingLevel: "high" };
+ releaseQueue();
+ await context.fastModeToggleQueue;
+
+ expect(originalConnection.setServiceTier).not.toHaveBeenCalled();
+ expect(context.agentConnection.setServiceTier).not.toHaveBeenCalled();
+ });
+
+ it("does not apply an in-flight toggle result to a replacement session", async () => {
+ let finishToggle!: () => void;
+ const context = makeFastContext();
+ const originalConnection = context.agentConnection;
+ originalConnection.setServiceTier = vi.fn(
+ () =>
+ new Promise<void>((resolve) => {
+ finishToggle = resolve;
+ }),
+ );
+
+ fastInteractiveModePrototype.handleFastCommand.call(context);
+ await vi.waitFor(() => expect(originalConnection.setServiceTier).toHaveBeenCalledWith("priority"));
+
+ context.agentConnection = {
+ setServiceTier: vi.fn(async () => {}),
+ getState: vi.fn(
+ async (): Promise<{ sessionId: string; serviceTier: ServiceTier }> => ({
+ sessionId: "session-2",
+ serviceTier: "default",
+ }),
+ ),
+ };
+ context.connectionState = { sessionId: "session-2", serviceTier: "default", thinkingLevel: "high" };
+ finishToggle();
+ await context.fastModeToggleQueue;
+
+ expect(context.patchConnectionState).not.toHaveBeenCalled();
+ expect(context.showStatus).not.toHaveBeenCalled();
+ });
+
+ it("reports unsupported models without changing the service tier", () => {
+ const context = makeFastContext(testModel("anthropic", "claude-opus", "anthropic-messages"));
+
+ fastInteractiveModePrototype.handleFastCommand.call(context);
+
+ expect(context.agentConnection.setServiceTier).not.toHaveBeenCalled();
+ expect(context.showStatus).toHaveBeenCalledWith(
+ "Fast mode requires GPT-5.4, GPT-5.5, or GPT-5.6 with ChatGPT authentication",
+ );
+ });
+
+ it("shows Fast mode beside the model and effort level", () => {
+ const context = makeFastContext();
+ context.connectionState = { sessionId: "session-1", serviceTier: "priority", thinkingLevel: "high" };
+
+ expect(fastInteractiveModePrototype.getModelTrayLabel.call(context)).toBe("gpt-5.5 • high • fast");
+ });
+ });
});
diff --git a/packages/coding-agent/test/interactive-mode-status.test.ts b/packages/coding-agent/test/interactive-mode-status.test.ts
index 5c8f7f941e..6e615057e2 100644
--- a/packages/coding-agent/test/interactive-mode-status.test.ts
+++ b/packages/coding-agent/test/interactive-mode-status.test.ts
@@ -86,6 +86,7 @@ function createConnectionState(overrides: Partial<AgentConnectionState> = {}): A
activeSessionId: "active-1",
cwd: "/tmp/project",
thinkingLevel: "medium",
+ serviceTier: "default",
availableThinkingLevels: ["minimal", "low", "medium", "high", "xhigh"],
isStreaming: false,
isCompacting: false,
@@ -1232,11 +1233,15 @@ describe("InteractiveMode model candidates", () => {
describe("InteractiveMode model selection persistence", () => {
type ModelSelectionHarness = {
- agentConnection: { setModel(provider: string, modelId: string): Promise<void> };
+ agentConnection: {
+ setModel(provider: string, modelId: string): Promise<void>;
+ getState(): Promise<AgentConnectionState>;
+ };
uiServices: {
settingsManager: { setDefaultModelAndProvider(provider: string, modelId: string): void };
};
footer: { invalidate(): void };
+ childAgentSummary: { invalidate(): void };
patchConnectionState(patch: Partial<AgentConnectionState>): void;
updateEditorBorderColor(): void;
showStatus(message: string): void;
@@ -1397,6 +1402,9 @@ describe("InteractiveMode model selection persistence", () => {
setModel: vi.fn(async () => {
order.push("connection");
}),
+ getState: vi.fn(async () =>
+ createConnectionState({ model, serviceTier: "default", availableThinkingLevels: ["off"] }),
+ ),
};
fakeThis.uiServices = {
settingsManager: {
@@ -1406,6 +1414,7 @@ describe("InteractiveMode model selection persistence", () => {
},
};
fakeThis.footer = { invalidate: vi.fn() };
+ fakeThis.childAgentSummary = { invalidate: vi.fn() };
fakeThis.patchConnectionState = vi.fn();
fakeThis.updateEditorBorderColor = vi.fn();
fakeThis.setupAutocompleteProvider = vi.fn();
@@ -1415,7 +1424,11 @@ describe("InteractiveMode model selection persistence", () => {
expect(fakeThis.agentConnection.setModel).toHaveBeenCalledWith("openai", "gpt-5.5");
expect(fakeThis.uiServices.settingsManager.setDefaultModelAndProvider).toHaveBeenCalledWith("openai", "gpt-5.5");
expect(order).toEqual(["connection", "settings"]);
- expect(fakeThis.patchConnectionState).toHaveBeenCalledWith({ model, availableThinkingLevels: ["off"] });
+ expect(fakeThis.patchConnectionState).toHaveBeenCalledWith({
+ model,
+ serviceTier: "default",
+ availableThinkingLevels: ["off"],
+ });
expect(fakeThis.footer.invalidate).toHaveBeenCalledTimes(1);
expect(fakeThis.updateEditorBorderColor).toHaveBeenCalledTimes(1);
});
@@ -1427,6 +1440,7 @@ describe("InteractiveMode model selection persistence", () => {
setModel: vi.fn(async () => {
throw new Error("model unavailable");
}),
+ getState: vi.fn(async () => createConnectionState()),
};
fakeThis.uiServices = {
settingsManager: {
@@ -1434,6 +1448,7 @@ describe("InteractiveMode model selection persistence", () => {
},
};
fakeThis.footer = { invalidate: vi.fn() };
+ fakeThis.childAgentSummary = { invalidate: vi.fn() };
fakeThis.patchConnectionState = vi.fn();
fakeThis.updateEditorBorderColor = vi.fn();
@@ -1448,13 +1463,19 @@ describe("InteractiveMode model selection persistence", () => {
test("persists exact /model command selections after the connection accepts them", async () => {
const model = createModel("openai", "gpt-5.5");
const fakeThis = Object.create(InteractiveMode.prototype) as ModelSelectionHarness;
- fakeThis.agentConnection = { setModel: vi.fn(async () => {}) };
+ fakeThis.agentConnection = {
+ setModel: vi.fn(async () => {}),
+ getState: vi.fn(async () =>
+ createConnectionState({ model, serviceTier: "default", availableThinkingLevels: ["off"] }),
+ ),
+ };
fakeThis.uiServices = {
settingsManager: {
setDefaultModelAndProvider: vi.fn(),
},
};
fakeThis.footer = { invalidate: vi.fn() };
+ fakeThis.childAgentSummary = { invalidate: vi.fn() };
fakeThis.patchConnectionState = vi.fn();
fakeThis.updateEditorBorderColor = vi.fn();
fakeThis.showStatus = vi.fn();
@@ -1468,7 +1489,11 @@ describe("InteractiveMode model selection persistence", () => {
expect(fakeThis.agentConnection.setModel).toHaveBeenCalledWith("openai", "gpt-5.5");
expect(fakeThis.uiServices.settingsManager.setDefaultModelAndProvider).toHaveBeenCalledWith("openai", "gpt-5.5");
- expect(fakeThis.patchConnectionState).toHaveBeenCalledWith({ model, availableThinkingLevels: ["off"] });
+ expect(fakeThis.patchConnectionState).toHaveBeenCalledWith({
+ model,
+ serviceTier: "default",
+ availableThinkingLevels: ["off"],
+ });
expect(fakeThis.showStatus).toHaveBeenCalledWith("Model: gpt-5.5");
expect(fakeThis.showError).not.toHaveBeenCalled();
});
diff --git a/packages/coding-agent/test/package-self-update-daemon.test.ts b/packages/coding-agent/test/package-self-update-daemon.test.ts
index bfd71be7b8..9ddb1f82d6 100644
--- a/packages/coding-agent/test/package-self-update-daemon.test.ts
+++ b/packages/coding-agent/test/package-self-update-daemon.test.ts
@@ -10,6 +10,7 @@ import {
SELF_UPDATE_NOT_ATTEMPTED_EXIT_CODE,
} from "../src/config.js";
import type { AgentSessionRuntimeMetadata } from "../src/core/agent-session-runtime.js";
+import { DAEMON_PROTOCOL_VERSION } from "../src/modes/daemon/daemon-protocol.js";
import type * as DaemonSocketModule from "../src/modes/daemon/daemon-socket.js";
import { handlePackageCommand, prepareDaemonUpdateRestart } from "../src/package-manager-cli.js";
@@ -91,7 +92,7 @@ const mockState = vi.hoisted(() => ({
createThrowSessionPaths: [] as string[],
daemonProbe: { reachable: true, activeSessions: [] } as MockRunningDaemonProbe,
globalPackageRoot: "",
- hello: { protocol: { version: 2 } } as {
+ hello: { protocol: { version: 0 } } as {
protocol: { version: number };
supervisorGeneration?: string;
supervisorOwnerToken?: string;
@@ -114,7 +115,7 @@ const mockState = vi.hoisted(() => ({
function useFixedOwnerHello(): void {
mockState.hello = {
- protocol: { version: 2 },
+ protocol: { version: DAEMON_PROTOCOL_VERSION },
supervisorGeneration: "fixed-owner",
supervisorOwnerToken: "owner-token",
supervisorPid: process.pid,
@@ -259,7 +260,7 @@ describe("self-update daemon restart", () => {
projectDir = join(tempDir, "project");
packageDir = join(tempDir, "global-prefix", "lib", "node_modules", PACKAGE_NAME);
mockState.globalPackageRoot = join(tempDir, "global-prefix", "lib", "node_modules");
- mockState.hello = { protocol: { version: 2 } };
+ mockState.hello = { protocol: { version: DAEMON_PROTOCOL_VERSION } };
mockState.listResponse = undefined;
mockState.socketPath = join(tempDir, "daemon.sock");
mockState.calls = [];
diff --git a/packages/coding-agent/test/session-manager/build-context.test.ts b/packages/coding-agent/test/session-manager/build-context.test.ts
index d8cc95c0a3..4a64a73457 100644
--- a/packages/coding-agent/test/session-manager/build-context.test.ts
+++ b/packages/coding-agent/test/session-manager/build-context.test.ts
@@ -4,6 +4,7 @@ import {
buildSessionContext,
type CompactionEntry,
type ModelChangeEntry,
+ type ServiceTierChangeEntry,
type SessionEntry,
type SessionMessageEntry,
type ThinkingLevelChangeEntry,
@@ -60,12 +61,17 @@ function modelChange(id: string, parentId: string | null, provider: string, mode
return { type: "model_change", id, parentId, timestamp: "2025-01-01T00:00:00Z", provider, modelId };
}
+function serviceTier(id: string, parentId: string | null, tier: "default" | "priority"): ServiceTierChangeEntry {
+ return { type: "service_tier_change", id, parentId, timestamp: "2025-01-01T00:00:00Z", serviceTier: tier };
+}
+
describe("buildSessionContext", () => {
describe("trivial cases", () => {
it("empty entries returns empty context", () => {
const ctx = buildSessionContext([]);
expect(ctx.messages).toEqual([]);
expect(ctx.thinkingLevel).toBe("off");
+ expect(ctx.serviceTier).toBe("default");
expect(ctx.model).toBeNull();
});
@@ -99,6 +105,18 @@ describe("buildSessionContext", () => {
expect(ctx.messages).toHaveLength(2);
});
+ it("tracks service tier changes on the active branch", () => {
+ const entries: SessionEntry[] = [
+ msg("1", null, "user", "hello"),
+ serviceTier("2", "1", "priority"),
+ msg("3", "2", "assistant", "fast response"),
+ serviceTier("4", "1", "default"),
+ ];
+
+ expect(buildSessionContext(entries, "3").serviceTier).toBe("priority");
+ expect(buildSessionContext(entries, "4").serviceTier).toBe("default");
+ });
+
it("tracks model from assistant message", () => {
const entries: SessionEntry[] = [msg("1", null, "user", "hello"), msg("2", "1", "assistant", "hi")];
const ctx = buildSessionContext(entries);
diff --git a/packages/coding-agent/test/session-manager/has-user-content.test.ts b/packages/coding-agent/test/session-manager/has-user-content.test.ts
index 1dbb908791..773acbe4bd 100644
--- a/packages/coding-agent/test/session-manager/has-user-content.test.ts
+++ b/packages/coding-agent/test/session-manager/has-user-content.test.ts
@@ -15,11 +15,12 @@ describe("SessionManager.hasUserContent", () => {
}
}
- it("is false for a fresh session with only the default model and thinking entries", () => {
+ it("is false for a fresh session with only the default configuration entries", () => {
withSession((session) => {
// What createAgentSession writes for every new session.
session.appendModelChange("anthropic", "claude-opus-4-8");
session.appendThinkingLevelChange("off");
+ session.appendServiceTierChange("default");
expect(session.hasUserContent()).toBe(false);
});
});
@@ -42,6 +43,16 @@ describe("SessionManager.hasUserContent", () => {
});
});
+ it("is true once the user enables Fast mode after creation", () => {
+ withSession((session) => {
+ session.appendModelChange("openai-codex", "gpt-5.5");
+ session.appendThinkingLevelChange("medium");
+ session.appendServiceTierChange("default");
+ session.appendServiceTierChange("priority");
+ expect(session.hasUserContent()).toBe(true);
+ });
+ });
+
it("is false for a fresh session created with no model available (thinking entry only)", () => {
withSession((session) => {
// createAgentSession skips the model_change when no model is configured,
diff --git a/packages/coding-agent/test/suite/harness.ts b/packages/coding-agent/test/suite/harness.ts
index 8a6e63152f..0e52ff4b49 100644
--- a/packages/coding-agent/test/suite/harness.ts
+++ b/packages/coding-agent/test/suite/harness.ts
@@ -58,6 +58,7 @@ export function getAssistantTexts(harness: Harness): string[] {
}
export interface HarnessOptions {
+ api?: string;
provider?: string;
models?: FauxModelDefinition[];
settings?: Partial<Settings>;
@@ -100,6 +101,7 @@ function createTempDir(): string {
export async function createHarness(options: HarnessOptions = {}): Promise<Harness> {
const tempDir = createTempDir();
const fauxProvider: FauxProviderRegistration = registerFauxProvider({
+ api: options.api,
provider: options.provider,
models: options.models,
});
diff --git a/packages/coding-agent/test/suite/regressions/4167-thinking-toggle-pending-tool-render.test.ts b/packages/coding-agent/test/suite/regressions/4167-thinking-toggle-pending-tool-render.test.ts
index 6080fb4f4f..62b4a55667 100644
--- a/packages/coding-agent/test/suite/regressions/4167-thinking-toggle-pending-tool-render.test.ts
+++ b/packages/coding-agent/test/suite/regressions/4167-thinking-toggle-pending-tool-render.test.ts
@@ -141,6 +141,7 @@ function createSessionContext(messages: AgentMessage[]): AgentConnectionSessionC
return {
messages,
thinkingLevel: "off",
+ serviceTier: "default",
model: null,
};
}
diff --git a/packages/coding-agent/test/suite/regressions/4620-fast-mode-child-agents.test.ts b/packages/coding-agent/test/suite/regressions/4620-fast-mode-child-agents.test.ts
new file mode 100644
index 0000000000..7739805c05
--- /dev/null
+++ b/packages/coding-agent/test/suite/regressions/4620-fast-mode-child-agents.test.ts
@@ -0,0 +1,94 @@
+import { fauxAssistantMessage } from "@earendil-works/pi-ai";
+import { describe, expect, it, vi } from "vitest";
+import { SessionManager } from "../../../src/core/session-manager.js";
+import { startSideQuestion } from "../../../src/core/side-question.js";
+import type { DaemonSocketClient } from "../../../src/modes/daemon/active-session-state.js";
+import type { DaemonCommand, DaemonResponse } from "../../../src/modes/daemon/daemon-protocol.js";
+import { DaemonSupervisor } from "../../../src/modes/daemon/daemon-supervisor.js";
+import { createHarness } from "../harness.js";
+
+const fastModel = {
+ api: "openai-codex-responses",
+ provider: "openai-codex",
+ models: [{ id: "gpt-5.4" }],
+};
+
+interface SupervisorHarness {
+ handleLine(client: DaemonSocketClient, line: string): Promise<void>;
+}
+
+describe("ENG-4620 fast mode child agents", () => {
+ it("allows service-tier changes through the daemon supervisor", async () => {
+ const handleCommand = vi.fn(
+ async (_client: DaemonSocketClient, command: DaemonCommand): Promise<DaemonResponse> => ({
+ id: command.id,
+ type: "response",
+ command: command.type,
+ success: true,
+ }),
+ );
+ const write = vi.fn();
+ const supervisor = Object.assign(Object.create(DaemonSupervisor.prototype), {
+ ready: Promise.resolve(),
+ ownership: { assertCurrent: vi.fn(async () => undefined) },
+ handleCommand,
+ write,
+ log: vi.fn(),
+ }) as SupervisorHarness;
+ const client = { id: "client-1" } as DaemonSocketClient;
+ const command = {
+ id: "tier-1",
+ type: "set_service_tier",
+ activeSessionId: "active-1",
+ serviceTier: "priority",
+ } satisfies DaemonCommand;
+
+ await supervisor.handleLine(client, JSON.stringify(command));
+
+ expect(handleCommand).toHaveBeenCalledWith(client, command);
+ expect(write).toHaveBeenCalledWith(
+ client,
+ expect.objectContaining({ command: "set_service_tier", success: true }),
+ );
+ });
+
+ it("passes fast mode to side questions", async () => {
+ const harness = await createHarness(fastModel);
+ try {
+ harness.session.setServiceTier("priority");
+ harness.setResponses([
+ (_context, options) => {
+ expect(options?.serviceTier).toBe("priority");
+ return fauxAssistantMessage("side answer");
+ },
+ ]);
+
+ const run = startSideQuestion(harness.session.agent, "question-1", "Check fast mode", () => {});
+ await run.done;
+ } finally {
+ harness.cleanup();
+ }
+ });
+
+ it("passes and persists fast mode for inline RLM children", async () => {
+ const harness = await createHarness({ ...fastModel, persistSession: true });
+ try {
+ harness.session.setServiceTier("priority");
+ harness.setResponses([
+ (_context, options) => {
+ expect(options?.serviceTier).toBe("priority");
+ return fauxAssistantMessage("child answer");
+ },
+ ]);
+
+ const result = await harness.session.runRlmChild("Check fast mode");
+ expect(result.answer).toBe("child answer");
+ expect(result.session_dir).not.toBeNull();
+ const childSessions = await SessionManager.list(harness.tempDir, result.session_dir!);
+ const childSession = SessionManager.open(childSessions[0]!.path, result.session_dir!);
+ expect(childSession.buildSessionContext().serviceTier).toBe("priority");
+ } finally {
+ harness.cleanup();
+ }
+ });
+});
diff --git a/packages/coding-agent/test/suite/regressions/4620-fast-mode-empty-resume.test.ts b/packages/coding-agent/test/suite/regressions/4620-fast-mode-empty-resume.test.ts
new file mode 100644
index 0000000000..ef82c957f9
--- /dev/null
+++ b/packages/coding-agent/test/suite/regressions/4620-fast-mode-empty-resume.test.ts
@@ -0,0 +1,55 @@
+import type { Model } from "@earendil-works/pi-ai";
+import { afterEach, describe, expect, it } from "vitest";
+import type { AgentSession } from "../../../src/core/agent-session.js";
+import { createAgentSession } from "../../../src/core/sdk.js";
+import { createTestResourceLoader } from "../../utilities.js";
+import { createHarness, type Harness } from "../harness.js";
+
+describe("ENG-4620 fast mode empty resume", () => {
+ let harness: Harness | undefined;
+ const sessions: AgentSession[] = [];
+
+ afterEach(() => {
+ for (const session of sessions.splice(0)) {
+ session.dispose();
+ }
+ harness?.cleanup();
+ harness = undefined;
+ });
+
+ it("restores fast mode before the first message", async () => {
+ harness = await createHarness({
+ provider: "openai-codex",
+ models: [{ id: "gpt-5.4" }],
+ persistSession: true,
+ });
+ harness.session.dispose();
+ const currentHarness = harness;
+
+ const model: Model<"openai-codex-responses"> = {
+ ...currentHarness.getModel(),
+ api: "openai-codex-responses",
+ };
+ const createSession = () =>
+ createAgentSession({
+ cwd: currentHarness.tempDir,
+ authStorage: currentHarness.authStorage,
+ model,
+ resourceLoader: createTestResourceLoader(),
+ sessionManager: currentHarness.sessionManager,
+ settingsManager: currentHarness.settingsManager,
+ });
+
+ const { session } = await createSession();
+ sessions.push(session);
+ session.setServiceTier("priority");
+ expect(session.messages).toHaveLength(0);
+ session.dispose();
+
+ const { session: resumedSession } = await createSession();
+ sessions.push(resumedSession);
+
+ expect(resumedSession.serviceTier).toBe("priority");
+ expect(resumedSession.sessionManager.buildSessionContext().serviceTier).toBe("priority");
+ });
+});
diff --git a/packages/coding-agent/test/suite/regressions/4620-fast-mode-settings.test.ts b/packages/coding-agent/test/suite/regressions/4620-fast-mode-settings.test.ts
new file mode 100644
index 0000000000..4511723670
--- /dev/null
+++ b/packages/coding-agent/test/suite/regressions/4620-fast-mode-settings.test.ts
@@ -0,0 +1,177 @@
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import type { AgentSession } from "../../../src/core/agent-session.js";
+import { createAgentSession } from "../../../src/core/sdk.js";
+import { SessionManager } from "../../../src/core/session-manager.js";
+import { SettingsManager } from "../../../src/core/settings-manager.js";
+import { assistantMsg, createTestResourceLoader, userMsg } from "../../utilities.js";
+import { createHarness, type Harness } from "../harness.js";
+
+describe("ENG-4620 fast mode settings", () => {
+ let harness: Harness | undefined;
+ const sessions: AgentSession[] = [];
+
+ afterEach(() => {
+ for (const session of sessions.splice(0)) {
+ session.dispose();
+ }
+ harness?.cleanup();
+ harness = undefined;
+ });
+
+ it("uses the saved fast mode preference for new sessions", async () => {
+ harness = await createHarness({
+ api: "openai-codex-responses",
+ provider: "openai-codex",
+ models: [{ id: "gpt-5.4" }],
+ });
+ const currentHarness = harness;
+
+ currentHarness.session.setServiceTier("priority");
+ expect(currentHarness.settingsManager.getDefaultServiceTier()).toBe("priority");
+
+ const createSession = () =>
+ createAgentSession({
+ cwd: currentHarness.tempDir,
+ authStorage: currentHarness.authStorage,
+ model: currentHarness.getModel(),
+ resourceLoader: createTestResourceLoader(),
+ sessionManager: SessionManager.inMemory(currentHarness.tempDir),
+ settingsManager: currentHarness.settingsManager,
+ });
+
+ const { session } = await createSession();
+ sessions.push(session);
+ expect(session.serviceTier).toBe("priority");
+
+ session.setServiceTier("default");
+ const { session: nextSession } = await createSession();
+ sessions.push(nextSession);
+ expect(nextSession.serviceTier).toBe("default");
+ });
+
+ it("persists the preference across settings manager restarts", async () => {
+ harness = await createHarness();
+ const agentDir = join(harness.tempDir, "agent");
+ const settingsManager = SettingsManager.create(harness.tempDir, agentDir);
+
+ settingsManager.setDefaultServiceTier("priority");
+ await settingsManager.flush();
+
+ const reloadedSettingsManager = SettingsManager.create(harness.tempDir, agentDir);
+ expect(reloadedSettingsManager.getDefaultServiceTier()).toBe("priority");
+ });
+
+ it("restores the saved preference after leaving an unsupported model", async () => {
+ harness = await createHarness({
+ api: "openai-codex-responses",
+ provider: "openai-codex",
+ models: [{ id: "gpt-5.4" }, { id: "gpt-5.3" }],
+ });
+
+ harness.session.setServiceTier("priority");
+ await harness.session.setModel(harness.getModel("gpt-5.3")!);
+
+ expect(harness.session.serviceTier).toBe("default");
+ expect(harness.settingsManager.getDefaultServiceTier()).toBe("priority");
+
+ await harness.session.setModel(harness.getModel("gpt-5.4")!);
+ expect(harness.session.serviceTier).toBe("priority");
+ });
+
+ it("returns the effective service tier when cycling models", async () => {
+ harness = await createHarness({
+ api: "openai-codex-responses",
+ provider: "openai-codex",
+ models: [{ id: "gpt-5.4" }, { id: "gpt-5.3" }],
+ });
+
+ harness.session.setServiceTier("priority");
+ const unsupportedResult = await harness.session.cycleModel();
+ expect(unsupportedResult?.model.id).toBe("gpt-5.3");
+ expect(unsupportedResult?.serviceTier).toBe("default");
+
+ const supportedResult = await harness.session.cycleModel();
+ expect(supportedResult?.model.id).toBe("gpt-5.4");
+ expect(supportedResult?.serviceTier).toBe("priority");
+ });
+
+ it("preserves fast mode while navigating session history", async () => {
+ harness = await createHarness({
+ api: "openai-codex-responses",
+ provider: "openai-codex",
+ models: [{ id: "gpt-5.4" }],
+ });
+
+ const targetId = harness.sessionManager.appendMessage(userMsg("first"));
+ harness.sessionManager.appendMessage(assistantMsg("reply"));
+ harness.session.setServiceTier("priority");
+ harness.sessionManager.appendMessage(userMsg("second"));
+
+ await harness.session.navigateTree(targetId, { summarize: false });
+
+ expect(harness.session.serviceTier).toBe("priority");
+ });
+
+ it("does not persist a temporary clamp from an unsupported model", async () => {
+ harness = await createHarness({
+ api: "openai-codex-responses",
+ provider: "openai-codex",
+ models: [{ id: "gpt-5.4" }, { id: "gpt-5.3" }],
+ persistSession: true,
+ });
+ const currentHarness = harness;
+
+ currentHarness.sessionManager.appendMessage(userMsg("hello"));
+ currentHarness.session.setServiceTier("priority");
+ await currentHarness.session.setModel(currentHarness.getModel("gpt-5.3")!);
+ expect(currentHarness.session.serviceTier).toBe("default");
+ expect(currentHarness.sessionManager.buildSessionContext().serviceTier).toBe("priority");
+ currentHarness.session.dispose();
+
+ const createSession = (modelId: string) =>
+ createAgentSession({
+ cwd: currentHarness.tempDir,
+ authStorage: currentHarness.authStorage,
+ model: currentHarness.getModel(modelId),
+ resourceLoader: createTestResourceLoader(),
+ sessionManager: currentHarness.sessionManager,
+ settingsManager: currentHarness.settingsManager,
+ });
+
+ const { session: supportedSession } = await createSession("gpt-5.4");
+ sessions.push(supportedSession);
+ expect(supportedSession.serviceTier).toBe("priority");
+ });
+
+ it("stores the preference when a new session starts on an unsupported model", async () => {
+ harness = await createHarness({
+ api: "openai-codex-responses",
+ provider: "openai-codex",
+ models: [{ id: "gpt-5.4" }, { id: "gpt-5.3" }],
+ });
+ const currentHarness = harness;
+ const sessionManager = SessionManager.inMemory(currentHarness.tempDir);
+ currentHarness.settingsManager.setDefaultServiceTier("priority");
+
+ const createSession = (modelId: string) =>
+ createAgentSession({
+ cwd: currentHarness.tempDir,
+ authStorage: currentHarness.authStorage,
+ model: currentHarness.getModel(modelId),
+ resourceLoader: createTestResourceLoader(),
+ sessionManager,
+ settingsManager: currentHarness.settingsManager,
+ });
+
+ const { session: unsupportedSession } = await createSession("gpt-5.3");
+ sessions.push(unsupportedSession);
+ expect(unsupportedSession.serviceTier).toBe("default");
+ expect(sessionManager.buildSessionContext().serviceTier).toBe("priority");
+ unsupportedSession.dispose();
+
+ const { session: supportedSession } = await createSession("gpt-5.4");
+ sessions.push(supportedSession);
+ expect(supportedSession.serviceTier).toBe("priority");
+ });
+});
diff --git a/packages/coding-agent/test/tree-selector.test.ts b/packages/coding-agent/test/tree-selector.test.ts
index d3206b20c4..345102ba62 100644
--- a/packages/coding-agent/test/tree-selector.test.ts
+++ b/packages/coding-agent/test/tree-selector.test.ts
@@ -99,6 +99,20 @@ function modelChange(id: string, parentId: string | null): AgentConnectionModelC
};
}
+function serviceTierChange(
+ id: string,
+ parentId: string | null,
+ serviceTier: "default" | "priority",
+): Extract<AgentConnectionSessionEntry, { type: "service_tier_change" }> {
+ return {
+ type: "service_tier_change",
+ id,
+ parentId,
+ timestamp: new Date().toISOString(),
+ serviceTier,
+ };
+}
+
// Helper to build a tree from entries using parentId relationships
function buildTree(entries: Array<AgentConnectionSessionEntry>): AgentConnectionSessionTreeNode[] {
if (entries.length === 0) return [];
@@ -192,6 +206,54 @@ describe("TreeSelectorComponent", () => {
const list = selector.getTreeList();
expect(list.getSelectedNode()?.entry.id).toBe("user-2");
});
+
+ test("focuses nearest visible ancestor when currentLeafId is a service_tier_change entry", () => {
+ const entries = [
+ userMessage("user-1", null, "hello"),
+ assistantMessage("asst-1", "user-1", "hi"),
+ userMessage("user-2", "asst-1", "active branch"),
+ serviceTierChange("tier-1", "user-2", "priority"),
+ userMessage("user-3", "asst-1", "sibling branch"),
+ ];
+ const selector = new TreeSelectorComponent(
+ buildTree(entries),
+ "tier-1",
+ 24,
+ () => {},
+ () => {},
+ );
+
+ expect(selector.getTreeList().getSelectedNode()?.entry.id).toBe("user-2");
+ });
+
+ test("renders and searches service tier changes in the all filter", () => {
+ const entries = [
+ userMessage("user-1", null, "hello"),
+ serviceTierChange("tier-1", "user-1", "priority"),
+ serviceTierChange("tier-2", "tier-1", "default"),
+ userMessage("user-2", "tier-2", "done"),
+ ];
+ const selector = new TreeSelectorComponent(
+ buildTree(entries),
+ "user-2",
+ 24,
+ () => {},
+ () => {},
+ undefined,
+ undefined,
+ "all",
+ );
+ const list = selector.getTreeList();
+
+ let render = list.render(200).join("\n");
+ expect(render).toContain("[service tier: priority]");
+ expect(render).toContain("[service tier: default]");
+
+ selector.handleInput("fast");
+ render = list.render(200).join("\n");
+ expect(render).toContain("[service tier: priority]");
+ expect(render).not.toContain("[service tier: default]");
+ });
});
describe("filter switching with parent traversal", () => {