@benvargas/pi-openai-fast 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ben Vargas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# @benvargas/pi-openai-fast
+
+Session-scoped `/fast` toggle for pi that enables OpenAI priority service tier on supported GPT-5.4 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.
+
+Requires pi `0.57.0` or newer.
+
+## Install
+
+```bash
+pi install npm:@benvargas/pi-openai-fast
+```
+
+Or try without installing:
+
+```bash
+pi -e npm:@benvargas/pi-openai-fast
+```
+
+## Usage
+
+- `/fast` toggles fast mode on or off.
+- `/fast on` explicitly enables fast mode.
+- `/fast off` explicitly disables fast mode.
+- `/fast status` reports the current fast-mode state.
+- `--fast` starts the session with fast mode enabled.
+
+Example:
+
+```bash
+pi -e npm:@benvargas/pi-openai-fast --fast
+```
+
+## Supported Models
+
+- `openai/gpt-5.4`
+- `openai-codex/gpt-5.4`
+
+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.
+
+## 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`.
+
+## Uninstall
+
+```bash
+pi remove npm:@benvargas/pi-openai-fast
+```
+
+## License
+
+MIT

package/extensions/index.ts

@@ -0,0 +1,199 @@
+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_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;
+
+interface FastModeState {
+	active: boolean;
+}
+
+type FastPayload = {
+	service_tier?: string;
+	[key: string]: unknown;
+};
+
+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") {
+		return undefined;
+	}
+	return { active: value.active };
+}
+
+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);
+		}
+	}
+	return undefined;
+}
+
+function getCurrentModelKey(model: ExtensionContext["model"]): string | undefined {
+	if (!model) {
+		return undefined;
+	}
+	return `${model.provider}/${model.id}`;
+}
+
+function isFastSupportedModel(model: ExtensionContext["model"]): boolean {
+	if (!model) {
+		return false;
+	}
+	return FAST_SUPPORTED_MODELS.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 describeCurrentState(ctx: ExtensionContext, active: boolean): 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()}.`;
+	}
+	if (isFastSupportedModel(ctx.model)) {
+		return `Fast mode is on for ${model}.`;
+	}
+	return `Fast mode is on, but ${model} does not support it. Supported models: ${describeSupportedModels()}.`;
+}
+
+function applyFastServiceTier(payload: unknown): unknown {
+	if (!isRecord(payload)) {
+		return payload;
+	}
+
+	const nextPayload: FastPayload = { ...payload };
+	nextPayload.service_tier = FAST_SERVICE_TIER;
+	return nextPayload;
+}
+
+export default function piOpenAIFast(pi: ExtensionAPI): void {
+	let state: FastModeState = { active: false };
+
+	function persistState(): void {
+		pi.appendEntry(FAST_STATE_ENTRY, state);
+	}
+
+	async function enableFastMode(ctx: ExtensionContext, options?: { notify?: boolean }): Promise<void> {
+		if (state.active) {
+			if (options?.notify !== false) {
+				ctx.ui.notify("Fast mode is already on.", "info");
+			}
+			return;
+		}
+
+		state = { active: true };
+		persistState();
+
+		if (options?.notify !== false) {
+			ctx.ui.notify(describeCurrentState(ctx, state.active), "info");
+		}
+	}
+
+	async function disableFastMode(ctx: ExtensionContext, options?: { notify?: boolean }): Promise<void> {
+		if (!state.active) {
+			if (options?.notify !== false) {
+				ctx.ui.notify("Fast mode is already off.", "info");
+			}
+			return;
+		}
+
+		state = { active: false };
+		persistState();
+
+		if (options?.notify !== false) {
+			ctx.ui.notify("Fast mode disabled.", "info");
+		}
+	}
+
+	async function toggleFastMode(ctx: ExtensionContext): Promise<void> {
+		if (state.active) {
+			await disableFastMode(ctx);
+			return;
+		}
+		await enableFastMode(ctx);
+	}
+
+	pi.registerFlag(FAST_FLAG, {
+		description: "Start with OpenAI fast mode enabled",
+		type: "boolean",
+		default: false,
+	});
+
+	pi.registerCommand(FAST_COMMAND, {
+		description: "Toggle fast mode (priority service tier for supported OpenAI GPT-5.4 models)",
+		getArgumentCompletions: (prefix) => {
+			const items = FAST_COMMAND_ARGS.filter((value) => value.startsWith(prefix)).map((value) => ({
+				value,
+				label: value,
+			}));
+			return items.length > 0 ? items : null;
+		},
+		handler: async (args, ctx) => {
+			const command = args.trim().toLowerCase();
+
+			if (command.length === 0) {
+				await toggleFastMode(ctx);
+				return;
+			}
+
+			switch (command) {
+				case "on":
+					await enableFastMode(ctx);
+					return;
+				case "off":
+					await disableFastMode(ctx);
+					return;
+				case "status":
+					ctx.ui.notify(describeCurrentState(ctx, state.active), "info");
+					return;
+				default:
+					ctx.ui.notify("Usage: /fast [on|off|status]", "error");
+			}
+		},
+	});
+
+	pi.on("before_provider_request", (event, ctx) => {
+		if (!state.active || !isFastSupportedModel(ctx.model)) {
+			return;
+		}
+		return applyFastServiceTier(event.payload);
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		state = getSavedFastModeState(ctx) ?? { active: false };
+
+		if (pi.getFlag(FAST_FLAG) === true && !state.active) {
+			await enableFastMode(ctx, { notify: true });
+		}
+	});
+}
+
+export const _test = {
+	FAST_COMMAND,
+	FAST_FLAG,
+	FAST_STATE_ENTRY,
+	FAST_COMMAND_ARGS,
+	FAST_SERVICE_TIER,
+	FAST_SUPPORTED_MODELS,
+	parseFastModeState,
+	isFastSupportedModel,
+	describeCurrentState,
+	applyFastServiceTier,
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@benvargas/pi-openai-fast",
+  "version": "1.0.0",
+  "description": "OpenAI fast mode toggle for pi - Enables priority service tier on supported GPT-5.4 models",
+  "keywords": [
+    "pi",
+    "pi-package",
+    "pi-extension",
+    "pi-coding-agent",
+    "openai",
+    "codex",
+    "gpt-5.4",
+    "fast",
+    "priority",
+    "service-tier"
+  ],
+  "type": "module",
+  "files": [
+    "extensions/",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": ">=0.57.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ben-vargas/pi-packages.git",
+    "directory": "packages/pi-openai-fast"
+  },
+  "author": "Ben Vargas",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ben-vargas/pi-packages/issues"
+  },
+  "homepage": "https://github.com/ben-vargas/pi-packages/tree/main/packages/pi-openai-fast#readme"
+}