@likelz/pi-gpt 0.1.0

package/README.md

@@ -0,0 +1,72 @@
+# pi-gpt
+
+GPT fast mode for [Pi](https://pi.dev), extracted from `gpt-fast-mode.ts`.
+
+Run `/fast` to toggle priority processing for an explicit list of models. The extension adds `service_tier: "priority"` to matching requests and displays `fast` in the status bar. Provider support and account eligibility determine the actual processing tier and charges.
+
+## Install
+
+Install from npm:
+
+```sh
+pi install npm:@likelz/pi-gpt
+```
+
+Or from GitHub:
+
+```sh
+pi install git:github.com/ekil1100/pi-gpt
+```
+
+Or from a local checkout:
+
+```sh
+bun install
+pi install /absolute/path/to/pi-gpt
+```
+
+The package exposes TypeScript source through its Pi manifest, so local and Git installations work without a build step. Disable or move the original `~/.pi/agent/extensions/gpt-fast-mode.ts` outside the extensions directory before loading this package to avoid registering `/fast` twice. Rename its JSON configuration to `pi-gpt.json`.
+
+## Configure
+
+Edit `~/.pi/agent/extensions/pi-gpt.json` (under `PI_CODING_AGENT_DIR` when overridden):
+
+```json
+{
+  "enabled": false,
+  "models": ["openai/gpt-6-astra"]
+}
+```
+
+Use the exact `provider/model` identifiers shown by Pi, including any additional slashes in a model ID. The list starts empty; add models whose endpoint supports priority processing. Restart Pi or reload extensions after editing the file.
+
+- `/fast` toggles and persists `enabled`.
+- Unlisted models and disabled mode leave requests unchanged.
+- Missing or invalid configuration starts with fast mode off and an empty list. Invalid configuration produces a warning.
+- A failed save leaves the in-memory state unchanged.
+- The status indicates the requested mode. It does not confirm the provider's actual processing tier.
+
+## Ultrafast
+
+This extension requests **priority**, preserving the original behavior. OpenAI also documents `service_tier: "ultrafast"` for GPT-6 Astra in the Responses API. That is a separate tier with separate eligibility and pricing.
+
+- **API key:** API billing and rate limits apply independently of ChatGPT subscriptions. The official guide says GPT-6 Astra Ultrafast is available to all API users at low limits; its published allowance table covers usage tiers 1–5.
+- **Codex subscription:** Pro $500/month and eligible Enterprise/Edu plans have Ultrafast access. Other self-serve plans do not gain access by purchasing credits.
+- A third-party proxy must support and forward the tier. This package does not verify account eligibility or enable Ultrafast.
+
+Sources: [Ultrafast API](https://developers.openai.com/api/docs/guides/ultrafast-mode), [Fast API](https://developers.openai.com/api/docs/guides/fast-mode), [Codex speed and eligibility](https://learn.chatgpt.com/docs/agent-configuration/speed), [Codex pricing](https://learn.chatgpt.com/docs/pricing).
+
+## Development
+
+Use Bun 1.4.2 and Vite+ 1.0.0. Development was verified on Node.js 24.
+
+```sh
+vp install
+vp check
+vp test run
+vp pack
+```
+
+`vp pack` builds the ESM library and declarations in `dist/`. `vp run build` runs the package's build script; `vp dev` starts Vite's application server and is not used for this extension. Pi supplies its host package at runtime; Effect is a runtime dependency.
+
+The implementation uses pure functions for state validation and request transformation, Effect for file I/O and failure handling, and a small Pi adapter for commands and events. Tests use temporary directories and make no model requests.

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+//#region src/index.d.ts
+export default function piGpt(pi: ExtensionAPI): void;
+//#endregion

package/dist/index.mjs

@@ -0,0 +1,80 @@
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { Effect, Either, Schema } from "effect";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+//#region src/state.ts
+const FastModeState = Schema.Struct({
+	enabled: Schema.Boolean,
+	models: Schema.Array(Schema.String.pipe(Schema.pattern(/^[^/\s]+\/[^\s]+$/)))
+});
+const emptyState = () => ({
+	enabled: false,
+	models: []
+});
+const decodeState = Schema.decodeUnknownSync(Schema.parseJson(FastModeState));
+const modelKey = (model) => model ? `${model.provider}/${model.id}` : void 0;
+const isActive = (state, model) => {
+	const key = modelKey(model);
+	return state.enabled && key !== void 0 && state.models.includes(key);
+};
+const transformRequest = (state, model, payload) => isActive(state, model) && typeof payload === "object" && payload !== null && !Array.isArray(payload) ? {
+	...payload,
+	service_tier: "priority"
+} : void 0;
+const describeState = (state, model) => {
+	const key = modelKey(model) ?? "no model";
+	if (!state.enabled) return `Fast mode is off. Current model: ${key}.`;
+	return isActive(state, model) ? `Fast mode is on for ${key}.` : `Fast mode is on, but ${key} is not listed in pi-gpt.json models.`;
+};
+//#endregion
+//#region src/storage.ts
+const isMissing = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+const loadState = (path) => Effect.try({
+	try: () => readFileSync(path, "utf8"),
+	catch: (error) => error
+}).pipe(Effect.flatMap((text) => Effect.try(() => decodeState(text))), Effect.catchAll((error) => Effect.sync(() => {
+	if (!isMissing(error)) console.warn(`[pi-gpt] Failed to read ${path}: ${String(error)}`);
+	return emptyState();
+})));
+const saveState = (path, state) => Effect.try(() => {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+});
+//#endregion
+//#region src/index.ts
+const updateStatus = (ctx, state) => {
+	ctx.ui.setStatus("gpt-fast-mode", isActive(state, ctx.model) ? ctx.ui.theme.fg("accent", "fast") : void 0);
+};
+function piGpt(pi) {
+	const path = join(getAgentDir(), "extensions", "pi-gpt.json");
+	let state = Effect.runSync(loadState(path));
+	pi.registerCommand("fast", {
+		description: "Toggle GPT Fast mode for configured models",
+		handler: async (args, ctx) => {
+			if (args.trim()) {
+				ctx.ui.notify("Usage: /fast", "error");
+				return;
+			}
+			const next = {
+				...state,
+				enabled: !state.enabled
+			};
+			const saved = Effect.runSync(Effect.either(saveState(path, next)));
+			if (Either.isLeft(saved)) {
+				ctx.ui.notify(`Failed to save Fast mode: ${String(saved.left)}`, "error");
+				return;
+			}
+			state = next;
+			updateStatus(ctx, state);
+			ctx.ui.notify(describeState(state, ctx.model), "info");
+		}
+	});
+	pi.on("session_start", (_event, ctx) => {
+		state = Effect.runSync(loadState(path));
+		updateStatus(ctx, state);
+	});
+	pi.on("model_select", (_event, ctx) => updateStatus(ctx, state));
+	pi.on("before_provider_request", (event, ctx) => transformRequest(state, ctx.model, event.payload));
+}
+//#endregion
+export { piGpt as default };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@likelz/pi-gpt",
+  "version": "0.1.0",
+  "description": "GPT fast mode for Pi with explicit model allowlists.",
+  "keywords": [
+    "gpt",
+    "pi",
+    "pi-package"
+  ],
+  "homepage": "https://github.com/ekil1100/pi-gpt#readme",
+  "bugs": {
+    "url": "https://github.com/ekil1100/pi-gpt/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ekil1100/pi-gpt.git"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test run",
+    "check": "vp check",
+    "prepublishOnly": "vp check && vp test run && vp pack"
+  },
+  "dependencies": {
+    "effect": "^3.0.0"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "1.0.2",
+    "@types/node": "^24.0.0",
+    "typescript": "^7.0.2",
+    "vite-plus": "1.0.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "packageManager": "bun@1.4.2",
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/src/index.ts

@@ -0,0 +1,49 @@
+import { join } from "node:path";
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Effect, Either } from "effect";
+import { describeState, isActive, transformRequest, type FastModeState } from "./state.ts";
+import { loadState, saveState } from "./storage.ts";
+
+const updateStatus = (ctx: ExtensionContext, state: FastModeState): void => {
+  ctx.ui.setStatus(
+    "gpt-fast-mode",
+    isActive(state, ctx.model) ? ctx.ui.theme.fg("accent", "fast") : undefined,
+  );
+};
+
+export default function piGpt(pi: ExtensionAPI): void {
+  const path = join(getAgentDir(), "extensions", "pi-gpt.json");
+  let state = Effect.runSync(loadState(path));
+
+  pi.registerCommand("fast", {
+    description: "Toggle GPT Fast mode for configured models",
+    handler: async (args, ctx) => {
+      if (args.trim()) {
+        ctx.ui.notify("Usage: /fast", "error");
+        return;
+      }
+      const next = { ...state, enabled: !state.enabled };
+      const saved = Effect.runSync(Effect.either(saveState(path, next)));
+      if (Either.isLeft(saved)) {
+        ctx.ui.notify(`Failed to save Fast mode: ${String(saved.left)}`, "error");
+        return;
+      }
+      state = next;
+      updateStatus(ctx, state);
+      ctx.ui.notify(describeState(state, ctx.model), "info");
+    },
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    state = Effect.runSync(loadState(path));
+    updateStatus(ctx, state);
+  });
+  pi.on("model_select", (_event, ctx) => updateStatus(ctx, state));
+  pi.on("before_provider_request", (event, ctx) =>
+    transformRequest(state, ctx.model, event.payload),
+  );
+}

package/src/state.ts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+
+export const FastModeState = Schema.Struct({
+  enabled: Schema.Boolean,
+  models: Schema.Array(Schema.String.pipe(Schema.pattern(/^[^/\s]+\/[^\s]+$/))),
+});
+export type FastModeState = typeof FastModeState.Type;
+export const emptyState = (): FastModeState => ({ enabled: false, models: [] });
+export const decodeState = Schema.decodeUnknownSync(Schema.parseJson(FastModeState));
+
+type Model = { readonly provider: string; readonly id: string } | undefined;
+export const modelKey = (model: Model): string | undefined =>
+  model ? `${model.provider}/${model.id}` : undefined;
+
+export const isActive = (state: FastModeState, model: Model): boolean => {
+  const key = modelKey(model);
+  return state.enabled && key !== undefined && state.models.includes(key);
+};
+
+export const transformRequest = (
+  state: FastModeState,
+  model: Model,
+  payload: unknown,
+): Record<string, unknown> | undefined =>
+  isActive(state, model) &&
+  typeof payload === "object" &&
+  payload !== null &&
+  !Array.isArray(payload)
+    ? { ...payload, service_tier: "priority" }
+    : undefined;
+
+export const describeState = (state: FastModeState, model: Model): string => {
+  const key = modelKey(model) ?? "no model";
+  if (!state.enabled) return `Fast mode is off. Current model: ${key}.`;
+  return isActive(state, model)
+    ? `Fast mode is on for ${key}.`
+    : `Fast mode is on, but ${key} is not listed in pi-gpt.json models.`;
+};

package/src/storage.ts

@@ -0,0 +1,27 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { Effect } from "effect";
+import { decodeState, emptyState, type FastModeState } from "./state.ts";
+
+const isMissing = (error: unknown): boolean =>
+  typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+
+export const loadState = (path: string) =>
+  Effect.try({
+    try: () => readFileSync(path, "utf8"),
+    catch: (error) => error,
+  }).pipe(
+    Effect.flatMap((text) => Effect.try(() => decodeState(text))),
+    Effect.catchAll((error) =>
+      Effect.sync(() => {
+        if (!isMissing(error)) console.warn(`[pi-gpt] Failed to read ${path}: ${String(error)}`);
+        return emptyState();
+      }),
+    ),
+  );
+
+export const saveState = (path: string, state: FastModeState) =>
+  Effect.try(() => {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+  });