@benvargas/pi-openai-fast 1.0.0 → 1.0.2

package/README.md

@@ -1,8 +1,8 @@
 # @benvargas/pi-openai-fast
 
-Session-scoped `/fast` toggle for pi that enables OpenAI priority service tier on supported GPT-5.4 models.
+`/fast` toggle for pi that enables OpenAI priority service tier on configured models.
 
-This extension does not change the model, thinking level, tools, or prompts. It only adds `service_tier=priority` to provider requests when fast mode is active and the current model supports it.
+This extension does not change the model, thinking level, tools, or prompts. It only adds `service_tier=priority` to provider requests when fast mode is active and the current model matches the configured supported-model list.
 
 Requires pi `0.57.0` or newer.
 
@@ -25,6 +25,8 @@ pi -e npm:@benvargas/pi-openai-fast
 - `/fast off` explicitly disables fast mode.
 - `/fast status` reports the current fast-mode state.
 - `--fast` starts the session with fast mode enabled.
+- By default, fast mode persists across new pi sessions via a JSON config file.
+- Startup state comes from the selected config file, not from resumed session/thread history.
 
 Example:
 
@@ -32,17 +34,41 @@ Example:
 pi -e npm:@benvargas/pi-openai-fast --fast
 ```
 
-## Supported Models
+## Config
 
-- `openai/gpt-5.4`
-- `openai-codex/gpt-5.4`
+Config files follow the same project-over-global pattern as the other packages:
 
-If fast mode is enabled on an unsupported model, the setting stays on but requests are left unchanged until you switch back to a supported model.
+- Project: `<repo>/.pi/extensions/pi-openai-fast.json`
+- Global: `~/.pi/agent/extensions/pi-openai-fast.json`
+
+If neither exists, the extension writes a default global config on first run.
+
+Default config:
+
+```json
+{
+  "persistState": true,
+  "active": false,
+  "supportedModels": [
+    "openai/gpt-5.4",
+    "openai-codex/gpt-5.4"
+  ]
+}
+```
+
+Settings:
+
+- `persistState`: when `true`, `/fast` writes the current on/off state to config so it resumes in new pi sessions. Default: `true`.
+- `active`: persisted fast-mode state used on startup when `persistState` is enabled.
+- `supportedModels`: list of `provider/model-id` strings that should receive `service_tier=priority`.
+
+Project config overrides global config. `/fast on` and `/fast off` write to the selected config file, so if a project config exists the remembered state is project-specific. If fast mode is enabled on a model that is not in `supportedModels`, the setting stays on but requests are left unchanged until you switch back to a configured model.
 
 ## Notes
 
-- Fast mode is stored as session state, so it persists with the session branch.
-- On supported models, fast mode maps to OpenAI `service_tier=priority`.
+- When `persistState` is enabled, the last `/fast` setting also carries across brand-new pi sessions.
+- Resumed sessions do not override the config-backed startup state.
+- On configured models, fast mode maps to OpenAI `service_tier=priority`.
 
 ## Uninstall
 

package/extensions/index.ts

@@ -1,44 +1,200 @@
+/**
+ * OpenAI fast mode for pi.
+ *
+ * `/fast` and `--fast` toggle `service_tier=priority` for configured models.
+ * This extension does not change the selected model, thinking level, tools, or prompts.
+ *
+ * Startup state comes from `pi-openai-fast.json`, not resumed session history.
+ * Config precedence is project `.pi/extensions/pi-openai-fast.json` over
+ * global `~/.pi/agent/extensions/pi-openai-fast.json`.
+ *
+ * `supportedModels` controls which `provider/model-id` pairs receive the flag.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 
 const FAST_COMMAND = "fast";
 const FAST_FLAG = "fast";
-const FAST_STATE_ENTRY = "pi-openai-fast.state";
+const FAST_CONFIG_BASENAME = "pi-openai-fast.json";
 const FAST_COMMAND_ARGS = ["on", "off", "status"] as const;
 const FAST_SERVICE_TIER = "priority";
-const FAST_SUPPORTED_MODELS = [
-	{ provider: "openai", id: "gpt-5.4" },
-	{ provider: "openai-codex", id: "gpt-5.4" },
-] as const;
+const DEFAULT_SUPPORTED_MODEL_KEYS = ["openai/gpt-5.4", "openai-codex/gpt-5.4"] as const;
 
 interface FastModeState {
 	active: boolean;
 }
 
+interface FastSupportedModel {
+	provider: string;
+	id: string;
+}
+
+interface FastConfigFile {
+	persistState?: boolean;
+	active?: boolean;
+	supportedModels?: string[];
+}
+
+interface ResolvedFastConfig {
+	configPath: string;
+	persistState: boolean;
+	active: boolean | undefined;
+	supportedModels: FastSupportedModel[];
+}
+
 type FastPayload = {
 	service_tier?: string;
 	[key: string]: unknown;
 };
 
+const DEFAULT_CONFIG_FILE: FastConfigFile = {
+	persistState: true,
+	active: false,
+	supportedModels: [...DEFAULT_SUPPORTED_MODEL_KEYS],
+};
+
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function parseFastModeState(value: unknown): FastModeState | undefined {
-	if (!isRecord(value) || typeof value.active !== "boolean") {
+function getConfigCwd(ctx: ExtensionContext): string {
+	return ctx.cwd || process.cwd();
+}
+
+function getConfigPaths(
+	cwd: string,
+	homeDir: string = homedir(),
+): {
+	projectConfigPath: string;
+	globalConfigPath: string;
+} {
+	return {
+		projectConfigPath: join(cwd, ".pi", "extensions", FAST_CONFIG_BASENAME),
+		globalConfigPath: join(homeDir, ".pi", "agent", "extensions", FAST_CONFIG_BASENAME),
+	};
+}
+
+function parseSupportedModelKey(value: string): FastSupportedModel | undefined {
+	const trimmed = value.trim();
+	if (!trimmed) {
 		return undefined;
 	}
-	return { active: value.active };
+	const slashIndex = trimmed.indexOf("/");
+	if (slashIndex <= 0 || slashIndex >= trimmed.length - 1) {
+		return undefined;
+	}
+	const provider = trimmed.slice(0, slashIndex).trim();
+	const id = trimmed.slice(slashIndex + 1).trim();
+	if (!provider || !id) {
+		return undefined;
+	}
+	return { provider, id };
+}
+
+function normalizeSupportedModelKeys(value: unknown): string[] | undefined {
+	if (value === undefined) {
+		return undefined;
+	}
+	if (!Array.isArray(value)) {
+		return undefined;
+	}
+	const normalized: string[] = [];
+	for (const entry of value) {
+		if (typeof entry !== "string") {
+			continue;
+		}
+		const parsed = parseSupportedModelKey(entry);
+		if (!parsed) {
+			continue;
+		}
+		normalized.push(`${parsed.provider}/${parsed.id}`);
+	}
+	return normalized;
 }
 
-function getSavedFastModeState(ctx: ExtensionContext): FastModeState | undefined {
-	const entries = ctx.sessionManager.getBranch();
-	for (let i = entries.length - 1; i >= 0; i--) {
-		const entry = entries[i];
-		if (entry.type === "custom" && entry.customType === FAST_STATE_ENTRY) {
-			return parseFastModeState(entry.data);
+function parseSupportedModels(value: readonly string[]): FastSupportedModel[];
+function parseSupportedModels(value: unknown): FastSupportedModel[] | undefined;
+function parseSupportedModels(value: unknown): FastSupportedModel[] | undefined {
+	const normalized = normalizeSupportedModelKeys(value);
+	if (normalized === undefined) {
+		return undefined;
+	}
+	const models: FastSupportedModel[] = [];
+	for (const entry of normalized) {
+		const parsed = parseSupportedModelKey(entry);
+		if (!parsed) {
+			continue;
 		}
+		models.push(parsed);
 	}
-	return undefined;
+	return models;
+}
+
+function readConfigFile(filePath: string): FastConfigFile | null {
+	if (!existsSync(filePath)) {
+		return null;
+	}
+	try {
+		const raw = readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw) as unknown;
+		if (!isRecord(parsed)) {
+			return {};
+		}
+		const config: FastConfigFile = {};
+		if (typeof parsed.persistState === "boolean") {
+			config.persistState = parsed.persistState;
+		}
+		if (typeof parsed.active === "boolean") {
+			config.active = parsed.active;
+		}
+		const supportedModels = normalizeSupportedModelKeys(parsed.supportedModels);
+		if (supportedModels !== undefined) {
+			config.supportedModels = supportedModels;
+		}
+		return config;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`[pi-openai-fast] Failed to read ${filePath}: ${message}`);
+		return null;
+	}
+}
+
+function writeConfigFile(filePath: string, config: FastConfigFile): void {
+	try {
+		mkdirSync(dirname(filePath), { recursive: true });
+		writeFileSync(filePath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`[pi-openai-fast] Failed to write ${filePath}: ${message}`);
+	}
+}
+
+function ensureDefaultConfigFile(projectConfigPath: string, globalConfigPath: string): void {
+	if (existsSync(projectConfigPath) || existsSync(globalConfigPath)) {
+		return;
+	}
+	writeConfigFile(globalConfigPath, DEFAULT_CONFIG_FILE);
+}
+
+function resolveFastConfig(cwd: string, homeDir: string = homedir()): ResolvedFastConfig {
+	const { projectConfigPath, globalConfigPath } = getConfigPaths(cwd, homeDir);
+	ensureDefaultConfigFile(projectConfigPath, globalConfigPath);
+
+	const globalConfig = readConfigFile(globalConfigPath) ?? {};
+	const projectConfig = readConfigFile(projectConfigPath) ?? {};
+	const selectedConfigPath = existsSync(projectConfigPath) ? projectConfigPath : globalConfigPath;
+	const merged = { ...globalConfig, ...projectConfig };
+	const supportedModels =
+		parseSupportedModels(merged.supportedModels) ?? parseSupportedModels(DEFAULT_SUPPORTED_MODEL_KEYS);
+
+	return {
+		configPath: selectedConfigPath,
+		persistState: merged.persistState ?? DEFAULT_CONFIG_FILE.persistState ?? true,
+		active: typeof merged.active === "boolean" ? merged.active : undefined,
+		supportedModels,
+	};
 }
 
 function getCurrentModelKey(model: ExtensionContext["model"]): string | undefined {
@@ -48,29 +204,32 @@ function getCurrentModelKey(model: ExtensionContext["model"]): string | undefine
 	return `${model.provider}/${model.id}`;
 }
 
-function isFastSupportedModel(model: ExtensionContext["model"]): boolean {
+function isFastSupportedModel(model: ExtensionContext["model"], supportedModels: FastSupportedModel[]): boolean {
 	if (!model) {
 		return false;
 	}
-	return FAST_SUPPORTED_MODELS.some((supported) => supported.provider === model.provider && supported.id === model.id);
+	return supportedModels.some((supported) => supported.provider === model.provider && supported.id === model.id);
 }
 
-function describeSupportedModels(): string {
-	return FAST_SUPPORTED_MODELS.map((supported) => `${supported.provider}/${supported.id}`).join(", ");
+function describeSupportedModels(supportedModels: FastSupportedModel[]): string {
+	if (supportedModels.length === 0) {
+		return "none configured";
+	}
+	return supportedModels.map((supported) => `${supported.provider}/${supported.id}`).join(", ");
 }
 
-function describeCurrentState(ctx: ExtensionContext, active: boolean): string {
+function describeCurrentState(ctx: ExtensionContext, active: boolean, supportedModels: FastSupportedModel[]): string {
 	const model = getCurrentModelKey(ctx.model) ?? "none";
 	if (!active) {
 		return `Fast mode is off. Current model: ${model}.`;
 	}
 	if (!ctx.model) {
-		return `Fast mode is on. No model is selected. Supported models: ${describeSupportedModels()}.`;
+		return `Fast mode is on. No model is selected. Supported models: ${describeSupportedModels(supportedModels)}.`;
 	}
-	if (isFastSupportedModel(ctx.model)) {
+	if (isFastSupportedModel(ctx.model, supportedModels)) {
 		return `Fast mode is on for ${model}.`;
 	}
-	return `Fast mode is on, but ${model} does not support it. Supported models: ${describeSupportedModels()}.`;
+	return `Fast mode is on, but ${model} does not support it. Supported models: ${describeSupportedModels(supportedModels)}.`;
 }
 
 function applyFastServiceTier(payload: unknown): unknown {
@@ -85,12 +244,28 @@ function applyFastServiceTier(payload: unknown): unknown {
 
 export default function piOpenAIFast(pi: ExtensionAPI): void {
 	let state: FastModeState = { active: false };
+	let cachedConfig: ResolvedFastConfig | undefined;
+
+	function refreshConfig(ctx: ExtensionContext): ResolvedFastConfig {
+		cachedConfig = resolveFastConfig(getConfigCwd(ctx));
+		return cachedConfig;
+	}
+
+	function getConfig(ctx: ExtensionContext): ResolvedFastConfig {
+		return cachedConfig ?? refreshConfig(ctx);
+	}
 
-	function persistState(): void {
-		pi.appendEntry(FAST_STATE_ENTRY, state);
+	function persistState(config: ResolvedFastConfig): void {
+		cachedConfig = { ...config, active: state.active };
+		if (!config.persistState) {
+			return;
+		}
+		const nextConfig = { ...(readConfigFile(config.configPath) ?? {}), active: state.active };
+		writeConfigFile(config.configPath, nextConfig);
 	}
 
 	async function enableFastMode(ctx: ExtensionContext, options?: { notify?: boolean }): Promise<void> {
+		const config = refreshConfig(ctx);
 		if (state.active) {
 			if (options?.notify !== false) {
 				ctx.ui.notify("Fast mode is already on.", "info");
@@ -99,14 +274,15 @@ export default function piOpenAIFast(pi: ExtensionAPI): void {
 		}
 
 		state = { active: true };
-		persistState();
+		persistState(config);
 
 		if (options?.notify !== false) {
-			ctx.ui.notify(describeCurrentState(ctx, state.active), "info");
+			ctx.ui.notify(describeCurrentState(ctx, state.active, config.supportedModels), "info");
 		}
 	}
 
 	async function disableFastMode(ctx: ExtensionContext, options?: { notify?: boolean }): Promise<void> {
+		const config = refreshConfig(ctx);
 		if (!state.active) {
 			if (options?.notify !== false) {
 				ctx.ui.notify("Fast mode is already off.", "info");
@@ -115,7 +291,7 @@ export default function piOpenAIFast(pi: ExtensionAPI): void {
 		}
 
 		state = { active: false };
-		persistState();
+		persistState(config);
 
 		if (options?.notify !== false) {
 			ctx.ui.notify("Fast mode disabled.", "info");
@@ -137,7 +313,7 @@ export default function piOpenAIFast(pi: ExtensionAPI): void {
 	});
 
 	pi.registerCommand(FAST_COMMAND, {
-		description: "Toggle fast mode (priority service tier for supported OpenAI GPT-5.4 models)",
+		description: "Toggle fast mode (priority service tier for configured models)",
 		getArgumentCompletions: (prefix) => {
 			const items = FAST_COMMAND_ARGS.filter((value) => value.startsWith(prefix)).map((value) => ({
 				value,
@@ -161,7 +337,7 @@ export default function piOpenAIFast(pi: ExtensionAPI): void {
 					await disableFastMode(ctx);
 					return;
 				case "status":
-					ctx.ui.notify(describeCurrentState(ctx, state.active), "info");
+					ctx.ui.notify(describeCurrentState(ctx, state.active, refreshConfig(ctx).supportedModels), "info");
 					return;
 				default:
 					ctx.ui.notify("Usage: /fast [on|off|status]", "error");
@@ -170,17 +346,28 @@ export default function piOpenAIFast(pi: ExtensionAPI): void {
 	});
 
 	pi.on("before_provider_request", (event, ctx) => {
-		if (!state.active || !isFastSupportedModel(ctx.model)) {
+		const config = getConfig(ctx);
+		if (!state.active || !isFastSupportedModel(ctx.model, config.supportedModels)) {
 			return;
 		}
 		return applyFastServiceTier(event.payload);
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
-		state = getSavedFastModeState(ctx) ?? { active: false };
+		const config = refreshConfig(ctx);
+		state = config.persistState && typeof config.active === "boolean" ? { active: config.active } : { active: false };
 
-		if (pi.getFlag(FAST_FLAG) === true && !state.active) {
-			await enableFastMode(ctx, { notify: true });
+		if (pi.getFlag(FAST_FLAG) === true) {
+			if (!state.active) {
+				state = { active: true };
+				persistState(config);
+			}
+			ctx.ui.notify(describeCurrentState(ctx, state.active, config.supportedModels), "info");
+			return;
+		}
+
+		if (state.active) {
+			ctx.ui.notify(describeCurrentState(ctx, state.active, config.supportedModels), "info");
 		}
 	});
 }
@@ -188,12 +375,18 @@ export default function piOpenAIFast(pi: ExtensionAPI): void {
 export const _test = {
 	FAST_COMMAND,
 	FAST_FLAG,
-	FAST_STATE_ENTRY,
+	FAST_CONFIG_BASENAME,
 	FAST_COMMAND_ARGS,
 	FAST_SERVICE_TIER,
-	FAST_SUPPORTED_MODELS,
-	parseFastModeState,
+	DEFAULT_SUPPORTED_MODEL_KEYS,
+	DEFAULT_CONFIG_FILE,
+	getConfigPaths,
+	parseSupportedModelKey,
+	parseSupportedModels,
+	readConfigFile,
+	resolveFastConfig,
 	isFastSupportedModel,
+	describeSupportedModels,
 	describeCurrentState,
 	applyFastServiceTier,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benvargas/pi-openai-fast",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "OpenAI fast mode toggle for pi - Enables priority service tier on supported GPT-5.4 models",
   "keywords": [
     "pi",