@monotykamary/pi-better-openai 0.1.35 → 0.1.37

package/README.md

@@ -29,6 +29,7 @@ Usage display, image generation, and live voice require pi's `openai-codex` OAut
 
 ## Features
 
+- GPT-6 Astra and Daybreak Blue/Red model fallbacks for the built-in `openai-codex` provider.
 - Fast mode for supported OpenAI models, toggled with `/fast` or in `/openai-settings`.
 - OpenAI subscription usage display via `/openai-usage` and the footer.
 - Interactive settings picker via `/openai-settings`.
@@ -61,6 +62,7 @@ Default supported models:
 [
   "openai/gpt-5.4",
   "openai/gpt-5.5",
+  "openai-codex/gpt-6-astra",
   "openai-codex/gpt-5.6-sol",
   "openai-codex/gpt-5.6-terra",
   "openai-codex/gpt-5.6-luna",
@@ -111,6 +113,12 @@ Example config:
 }
 ```
 
+## Codex model fallbacks
+
+The extension adds `gpt-6-astra`, `gpt-daybreak-blue-latest`, and `gpt-daybreak-red-latest` to the built-in `openai-codex` provider without requiring local `models.json` entries. Existing built-in models remain available, and metadata from pi's live catalog takes precedence when pi publishes an official entry with the same ID.
+
+Daybreak models require separate OpenAI approval and provisioning. pi currently exposes reasoning levels through `max`; Codex's `ultra` automatic-delegation mode is not a pi thinking level.
+
 ## Live voice
 
 Run `/live` or press `Ctrl+Shift+L` to open the realtime voice panel. `Ctrl+L` remains pi's model selector, so the extension deliberately uses the shifted chord. While live mode has focus:

package/index.ts

@@ -12,6 +12,7 @@ import {
   SettingsList,
   type SettingsListTheme,
 } from "@earendil-works/pi-tui";
+import { registerOpenAICodexModels } from "./src/codex-models.ts";
 import { CONFIG_BASENAME, STATUS_KEY } from "./src/identity.ts";
 import {
   formatTokens,
@@ -209,6 +210,8 @@ function textPanel(title: string, lines: string[], done: () => void) {
 }
 
 export default function betterOpenAI(pi: ExtensionAPI): void {
+  registerOpenAICodexModels(pi);
+
   const fastController = new FastController(SERVICE_TIER);
   let cachedConfig: ResolvedConfig | undefined;
   let footerTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-openai",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",
@@ -62,6 +62,7 @@
     "ws": "8.21.2"
   },
   "devDependencies": {
+    "@earendil-works/pi-ai": "0.85.0",
     "@earendil-works/pi-coding-agent": "0.85.0",
     "@earendil-works/pi-tui": "0.85.0",
     "@types/node": "~22.19.0",
@@ -73,6 +74,7 @@
     "vitest": "^4.1.5"
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"
   },

package/src/codex-models.ts

@@ -0,0 +1,203 @@
+import {
+  createProvider,
+  type Model,
+  type Provider,
+  type RefreshModelsContext,
+} from "@earendil-works/pi-ai";
+import { openAICodexResponsesApi } from "@earendil-works/pi-ai/api/openai-codex-responses.lazy";
+import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const CODEX_API = "openai-codex-responses" as const;
+const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const CODEX_CATALOG_URL = "https://pi.dev/api/models/providers/openai-codex";
+const CODEX_PROVIDER_ID = "openai-codex";
+const CATALOG_REFRESH_INTERVAL_MS = 4 * 60 * 60 * 1000;
+
+type CodexModel = Model<typeof CODEX_API>;
+
+type CreateCodexProviderOptions = {
+  fetch?: typeof globalThis.fetch;
+  now?: () => number;
+};
+
+const CODEX_COMPAT = {
+  supportsOpenAIGrammarTools: true,
+  supportsAdditionalTools: true,
+  supportsToolSearch: true,
+} as const;
+
+export const CODEX_MODEL_FALLBACKS: CodexModel[] = [
+  {
+    id: "gpt-6-astra",
+    name: "GPT-6 Astra",
+    api: CODEX_API,
+    provider: CODEX_PROVIDER_ID,
+    baseUrl: CODEX_BASE_URL,
+    reasoning: true,
+    thinkingLevelMap: {
+      minimal: "low",
+      xhigh: "xhigh",
+      max: "max",
+    },
+    input: ["text", "image"],
+    contextWindow: 272000,
+    maxTokens: 128000,
+    cost: {
+      input: 10,
+      output: 50,
+      cacheRead: 1,
+      cacheWrite: 12.5,
+      tiers: [
+        {
+          inputTokensAbove: 272000,
+          input: 20,
+          output: 75,
+          cacheRead: 2,
+          cacheWrite: 25,
+        },
+      ],
+    },
+    compat: CODEX_COMPAT,
+  },
+  {
+    id: "gpt-daybreak-blue-latest",
+    name: "Daybreak Blue",
+    api: CODEX_API,
+    provider: CODEX_PROVIDER_ID,
+    baseUrl: CODEX_BASE_URL,
+    reasoning: true,
+    thinkingLevelMap: {
+      minimal: "low",
+      xhigh: "xhigh",
+      max: "max",
+    },
+    input: ["text", "image"],
+    contextWindow: 272000,
+    maxTokens: 128000,
+    cost: {
+      input: 4,
+      output: 20,
+      cacheRead: 0.4,
+      cacheWrite: 5,
+      tiers: [
+        {
+          inputTokensAbove: 272000,
+          input: 8,
+          output: 30,
+          cacheRead: 0.8,
+          cacheWrite: 10,
+        },
+      ],
+    },
+    compat: CODEX_COMPAT,
+  },
+  {
+    id: "gpt-daybreak-red-latest",
+    name: "Daybreak Red",
+    api: CODEX_API,
+    provider: CODEX_PROVIDER_ID,
+    baseUrl: CODEX_BASE_URL,
+    reasoning: true,
+    thinkingLevelMap: {
+      minimal: "low",
+      xhigh: "xhigh",
+      max: "max",
+    },
+    input: ["text", "image"],
+    contextWindow: 372000,
+    maxTokens: 128000,
+    cost: {
+      input: 12.5,
+      output: 75,
+      cacheRead: 1.25,
+      cacheWrite: 15.625,
+    },
+    compat: CODEX_COMPAT,
+  },
+];
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function catalogEntries(value: unknown): unknown[] | undefined {
+  if (Array.isArray(value)) return value;
+  if (!isRecord(value)) return undefined;
+  if (Array.isArray(value.models)) return value.models;
+  return Object.values(value);
+}
+
+export function parseCodexCatalog(value: unknown): CodexModel[] {
+  const entries = catalogEntries(value);
+  if (!entries) throw new Error("Invalid openai-codex model catalog");
+
+  return entries
+    .filter((entry): entry is Record<string, unknown> => {
+      return isRecord(entry) && typeof entry.id === "string" && entry.id.length > 0;
+    })
+    .map((entry) => ({ ...entry, provider: CODEX_PROVIDER_ID }) as CodexModel);
+}
+
+export function appendMissingCodexModels(
+  models: readonly CodexModel[],
+  fallbacks: readonly CodexModel[] = CODEX_MODEL_FALLBACKS,
+): CodexModel[] {
+  const merged = [...models];
+  const modelIds = new Set(merged.map((model) => model.id));
+  for (const model of fallbacks) {
+    if (modelIds.has(model.id)) continue;
+    merged.push(model);
+    modelIds.add(model.id);
+  }
+  return merged;
+}
+
+function storedCodexModels(context: RefreshModelsContext): CodexModel[] {
+  return (context.stored?.models ?? []).filter(
+    (model): model is CodexModel => model.provider === CODEX_PROVIDER_ID && model.api === CODEX_API,
+  );
+}
+
+async function fetchCodexModels(
+  context: RefreshModelsContext,
+  options: CreateCodexProviderOptions,
+): Promise<readonly CodexModel[]> {
+  const cached = storedCodexModels(context);
+  const checkedAt = context.stored?.checkedAt;
+  const now = options.now?.() ?? Date.now();
+  if (!context.force && checkedAt !== undefined && now - checkedAt < CATALOG_REFRESH_INTERVAL_MS) {
+    return cached;
+  }
+
+  const response = await (options.fetch ?? globalThis.fetch)(CODEX_CATALOG_URL, {
+    headers: { accept: "application/json" },
+    signal: context.signal,
+  });
+  if (response.status === 404 || response.status === 501) return cached;
+  if (!response.ok) {
+    throw new Error(`OpenAI Codex model catalog request failed: ${response.status}`);
+  }
+  return parseCodexCatalog(await response.json());
+}
+
+export function createOpenAICodexProvider(
+  options: CreateCodexProviderOptions = {},
+): Provider<typeof CODEX_API> {
+  const builtIn = openaiCodexProvider();
+  return createProvider({
+    id: builtIn.id,
+    name: builtIn.name,
+    baseUrl: builtIn.baseUrl,
+    headers: builtIn.headers,
+    auth: builtIn.auth,
+    models: appendMissingCodexModels(builtIn.getModels()),
+    fetchModels: (context) => fetchCodexModels(context, options),
+    filterModels: builtIn.filterModels,
+    api: openAICodexResponsesApi(),
+  });
+}
+
+export function registerOpenAICodexModels(pi: ExtensionAPI): void {
+  pi.registerProvider(createOpenAICodexProvider());
+}

package/src/config.ts

@@ -37,6 +37,7 @@ export const PET_STATES = [
 export const DEFAULT_SUPPORTED_MODELS = [
   "openai/gpt-5.4",
   "openai/gpt-5.5",
+  "openai-codex/gpt-6-astra",
   "openai-codex/gpt-5.6-sol",
   "openai-codex/gpt-5.6-terra",
   "openai-codex/gpt-5.6-luna",

package/src/usage.ts

@@ -4,6 +4,7 @@ export { AUTH_FILE, readCodexAuth } from "./codex-auth.ts";
 
 export type UsageWindow = {
   used_percent?: number | null;
+  limit_window_seconds?: number | null;
   reset_after_seconds?: number | null;
   reset_at?: number | null;
 };
@@ -112,14 +113,14 @@ function formatResetClock(
 }
 
 function formatCompactReset(
-  label: string,
+  label: string | undefined,
   seconds: number | null,
   options?: { includeDate?: boolean },
   now = Date.now(),
 ): string | null {
   const countdown = formatResetCountdown(seconds);
   const clock = formatResetClock(seconds, options, now);
-  return countdown && clock ? `${label} ↺ ${countdown} - ${clock}` : null;
+  return countdown && clock ? `${label ? `${label} ` : ""}↺ ${countdown} - ${clock}` : null;
 }
 
 function isAbortSignal(value: unknown): value is AbortSignal {
@@ -202,6 +203,16 @@ export function usageScopeForModel(modelId: string | undefined): UsageScope {
   return modelId === SPARK_MODEL_ID ? "spark" : "default";
 }
 
+function isWeeklyWindow(window: UsageWindow | null | undefined, now: number): boolean {
+  if (
+    typeof window?.limit_window_seconds === "number" &&
+    Number.isFinite(window.limit_window_seconds)
+  )
+    return window.limit_window_seconds >= 6 * 86_400;
+  const resetSeconds = getResetSeconds(window, now);
+  return resetSeconds !== null && resetSeconds > 5 * 3_600;
+}
+
 export function parseUsageSnapshot(
   data: CodexUsageResponse,
   modelId: string | undefined,
@@ -212,13 +223,18 @@ export function parseUsageSnapshot(
     scope === "spark"
       ? (findSparkRateLimitBucket(data) ?? normalizeRateLimitBucket(data.rate_limit))
       : normalizeRateLimitBucket(data.rate_limit);
+  const primaryWindow = bucket?.primary_window;
+  const secondaryWindow = bucket?.secondary_window;
+  const weeklyOnly = !secondaryWindow && isWeeklyWindow(primaryWindow, now);
   return {
     capturedAt: now,
     scope,
-    fiveHourLeftPercent: usedToLeftPercent(bucket?.primary_window?.used_percent),
-    sevenDayLeftPercent: usedToLeftPercent(bucket?.secondary_window?.used_percent),
-    fiveHourResetInSeconds: getResetSeconds(bucket?.primary_window, now),
-    sevenDayResetInSeconds: getResetSeconds(bucket?.secondary_window, now),
+    fiveHourLeftPercent: weeklyOnly ? null : usedToLeftPercent(primaryWindow?.used_percent),
+    sevenDayLeftPercent: usedToLeftPercent(
+      weeklyOnly ? primaryWindow?.used_percent : secondaryWindow?.used_percent,
+    ),
+    fiveHourResetInSeconds: weeklyOnly ? null : getResetSeconds(primaryWindow, now),
+    sevenDayResetInSeconds: getResetSeconds(weeklyOnly ? primaryWindow : secondaryWindow, now),
     isLimited: bucket?.limit_reached === true || bucket?.allowed === false,
   };
 }
@@ -234,25 +250,40 @@ export function formatUsageSnapshot(
   options: { showResetTimes: boolean },
   now = Date.now(),
 ): string {
-  const fiveHour = formatPercent(snapshot.fiveHourLeftPercent);
-  const sevenDay = formatPercent(snapshot.sevenDayLeftPercent);
+  const windows = [
+    {
+      label: "5h",
+      percent: snapshot.fiveHourLeftPercent,
+      resetSeconds: snapshot.fiveHourResetInSeconds,
+      includeDate: false,
+    },
+    {
+      label: "7d",
+      percent: snapshot.sevenDayLeftPercent,
+      resetSeconds: snapshot.sevenDayResetInSeconds,
+      includeDate: true,
+    },
+  ];
+  const availableWindows = windows.filter(
+    (window) => window.percent !== null || window.resetSeconds !== null,
+  );
+  const displayedWindows = availableWindows.length > 0 ? availableWindows : windows;
+  const usage = displayedWindows
+    .map((window) => `${window.label}: ${formatPercent(window.percent)}`)
+    .join(" · ");
   const resets = options.showResetTimes
-    ? [
-        formatCompactReset(
-          "5h",
-          remainingResetSeconds(snapshot.fiveHourResetInSeconds, snapshot.capturedAt, now),
-          undefined,
-          now,
-        ),
-        formatCompactReset(
-          "7d",
-          remainingResetSeconds(snapshot.sevenDayResetInSeconds, snapshot.capturedAt, now),
-          { includeDate: true },
-          now,
-        ),
-      ].filter((value): value is string => value !== null)
+    ? displayedWindows
+        .map((window) =>
+          formatCompactReset(
+            displayedWindows.length > 1 ? window.label : undefined,
+            remainingResetSeconds(window.resetSeconds, snapshot.capturedAt, now),
+            window.includeDate ? { includeDate: true } : undefined,
+            now,
+          ),
+        )
+        .filter((value): value is string => value !== null)
     : [];
-  return `Usage: 5h: ${fiveHour} · 7d: ${sevenDay}${resets.length ? ` · ${resets.join(" · ")}` : ""}`;
+  return `Usage: ${usage}${resets.length ? ` · ${resets.join(" · ")}` : ""}`;
 }
 
 function remainingResetSeconds(