@monotykamary/pi-better-grok 0.3.4 → 0.3.5

package/README.md

@@ -1,6 +1,6 @@
 # pi-better-grok
 
-Better Grok/xAI for [pi](https://pi.dev) — mirrors the [pi-better-openai](https://github.com/monotykamary/pi-better-openai) UX for SuperGrok subscribers: fast mode, subscription usage in the footer, footer polish, and a settings picker. Until pi-core ships it, Grok 4.7 is layered onto the existing `xai` (and sibling Grok) providers as a custom model.
+Better Grok/xAI for [pi](https://pi.dev) — mirrors the [pi-better-openai](https://github.com/monotykamary/pi-better-openai) UX for SuperGrok subscribers: fast mode, subscription usage in the footer, footer polish, and a settings picker. Until pi-core ships it, Grok 4.7 is layered onto the builtin `xai` provider via `~/.pi/agent/models.json` so session restore and scoped-model matching can see it at startup.
 
 ## Install
 

package/index.ts

@@ -73,7 +73,14 @@ import {
 } from "./src/grok-auth.ts";
 import { currentModelKey, FastController, modelList, supportsFast } from "./src/fast-controller.ts";
 import { isGrokSubscriptionModel, UsageController } from "./src/usage-controller.ts";
-import { registerGrok47OnProviders } from "./src/xai-models.ts";
+import { piAgentDir } from "./src/paths.ts";
+import {
+  GROK_47_ID,
+  ensureGrok47InModelsJsonFile,
+  lastSessionModel,
+  registerGrok47OnProviders,
+  shouldRestoreGrok47,
+} from "./src/xai-models.ts";
 import { sep } from "node:path";
 
 // pi-core's getSettingsListTheme pulls the host module graph into this
@@ -176,6 +183,17 @@ export function abbreviateHomePath(
 }
 
 export default function betterGrok(pi: ExtensionAPI): void {
+  // models.json is the only catalog layer that exists when pi restores the
+  // last model, before session_start. registerProvider is too late and replaces
+  // the xAI list, which drops grok-4.7 back out of scoped-model matching.
+  if (!process.env.VITEST) {
+    try {
+      ensureGrok47InModelsJsonFile(piAgentDir());
+    } catch {
+      // Missing home dir / unreadable models.json must not block the extension.
+    }
+  }
+
   const fetchUsageSnapshot = async (ctx: ExtensionContext): Promise<UsageSnapshot> => {
     const credential = await resolveGrokCredential(ctx);
     if (!credential) {
@@ -732,22 +750,47 @@ export default function betterGrok(pi: ExtensionAPI): void {
     setStatusWidget(ctx, statusWidgetParts(fast, usage));
   }
 
-  const ensureGrok47 = (ctx: ExtensionContext): void => {
-    if (typeof pi.registerProvider !== "function") return;
-    const getAll = ctx.modelRegistry?.getAll;
-    if (typeof getAll !== "function") return;
+  const ensureGrok47 = async (ctx: ExtensionContext): Promise<void> => {
+    if (!process.env.VITEST) {
+      try {
+        ensureGrok47InModelsJsonFile(piAgentDir());
+      } catch {
+        // Keep going; in-memory fallback below may still register the model.
+      }
+    }
     try {
-      registerGrok47OnProviders(
-        (name, config) => pi.registerProvider(name, config),
-        getAll.call(ctx.modelRegistry),
-      );
+      await ctx.modelRegistry?.refresh?.({ allowNetwork: false });
     } catch {
-      // Catalog registration must not break session startup.
+      // Offline refresh failures should not block session startup.
+    }
+    const registry = ctx.modelRegistry;
+    if (typeof registry?.find === "function" && !registry.find("xai", GROK_47_ID)) {
+      const getAll = registry.getAll;
+      if (typeof pi.registerProvider === "function" && typeof getAll === "function") {
+        try {
+          registerGrok47OnProviders(
+            (name, config) => pi.registerProvider(name, config),
+            getAll.call(registry),
+          );
+        } catch {
+          // Catalog registration must not break session startup.
+        }
+      }
     }
+    const branch =
+      typeof ctx.sessionManager.getBranch === "function"
+        ? ctx.sessionManager.getBranch()
+        : typeof ctx.sessionManager.getEntries === "function"
+          ? ctx.sessionManager.getEntries()
+          : [];
+    const saved = lastSessionModel(branch);
+    if (!shouldRestoreGrok47(ctx.model, saved) || !saved) return;
+    const restored = registry?.find?.(saved.provider, saved.modelId);
+    if (restored) await pi.setModel(restored);
   };
 
   pi.on("session_start", (_event, ctx) => {
-    ensureGrok47(ctx);
+    void ensureGrok47(ctx);
     invalidateContextUsage();
     invalidateSessionName();
     multiproviderRefreshCtx = ctx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-grok",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Improve Grok/xAI in pi with fast mode, subscription usage stats, banked reset redemption, multiprovider pools, footer polish, and settings — mirroring pi-better-openai.",
   "keywords": [
     "footer",

package/src/xai-models.ts

@@ -1,3 +1,5 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 
 export const GROK_47_ID = "grok-4.7";
@@ -14,10 +16,27 @@ const GROK_47_LONG_CONTEXT_TIER = {
   cacheWrite: 0,
 } as const;
 
+const GROK_47_COST = {
+  input: 2,
+  output: 6,
+  cacheRead: 0.5,
+  cacheWrite: 0,
+  tiers: [{ ...GROK_47_LONG_CONTEXT_TIER }],
+};
+
+const GROK_47_THINKING_LEVEL_MAP = {
+  off: null,
+  minimal: null,
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh",
+  max: null,
+} as const;
+
 /**
  * Native xAI Grok 4.7, cloned from pi-core's grok-4.6 catalog plus the public
- * 4.7 card: 500k context, $2/$6 per 1M, cache read $0.50, 2x rates above 200k,
- * reasoning efforts low/medium/high/xhigh. Used only when a sibling template exists.
+ * 4.7 card. Used as an in-memory fallback when models.json cannot be updated.
  */
 export const GROK_47_FALLBACK: ProviderModelConfig = {
   id: GROK_47_ID,
@@ -25,23 +44,25 @@ export const GROK_47_FALLBACK: ProviderModelConfig = {
   api: "openai-responses",
   baseUrl: "https://api.x.ai/v1",
   reasoning: true,
-  thinkingLevelMap: {
-    off: null,
-    minimal: null,
-    low: "low",
-    medium: "medium",
-    high: "high",
-    xhigh: "xhigh",
-    max: null,
-  },
+  thinkingLevelMap: { ...GROK_47_THINKING_LEVEL_MAP },
   input: ["text", "image"],
-  cost: {
-    input: 2,
-    output: 6,
-    cacheRead: 0.5,
-    cacheWrite: 0,
-    tiers: [{ ...GROK_47_LONG_CONTEXT_TIER }],
-  },
+  cost: { ...GROK_47_COST, tiers: [{ ...GROK_47_LONG_CONTEXT_TIER }] },
+  contextWindow: 500_000,
+  maxTokens: 500_000,
+  compat: { supportsLongCacheRetention: false },
+};
+
+/**
+ * models.json custom model layered onto builtin `xai`. api/baseUrl are omitted so
+ * pi inherits them from grok-4.6 instead of replacing the provider catalog.
+ */
+export const GROK_47_MODELS_JSON_DEFINITION = {
+  id: GROK_47_ID,
+  name: GROK_47_NAME,
+  reasoning: true,
+  thinkingLevelMap: { ...GROK_47_THINKING_LEVEL_MAP },
+  input: ["text", "image"] as Array<"text" | "image">,
+  cost: { ...GROK_47_COST, tiers: [{ ...GROK_47_LONG_CONTEXT_TIER }] },
   contextWindow: 500_000,
   maxTokens: 500_000,
   compat: { supportsLongCacheRetention: false },
@@ -160,3 +181,81 @@ export function registerGrok47OnProviders(
   }
   return registered;
 }
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+export function upsertGrok47InModelsJson(raw: unknown): {
+  next: Record<string, unknown>;
+  changed: boolean;
+} {
+  const root = { ...asObject(raw) };
+  const providers = { ...asObject(root.providers) };
+  const xai = { ...asObject(providers.xai) };
+  const models = Array.isArray(xai.models) ? [...xai.models] : [];
+  const alreadyPresent = models.some((entry) => asObject(entry)?.id === GROK_47_ID);
+  if (alreadyPresent) {
+    return { next: asObject(raw) ?? root, changed: false };
+  }
+  models.push({
+    ...GROK_47_MODELS_JSON_DEFINITION,
+    thinkingLevelMap: { ...GROK_47_THINKING_LEVEL_MAP },
+    input: [...GROK_47_MODELS_JSON_DEFINITION.input],
+    cost: { ...GROK_47_COST, tiers: [{ ...GROK_47_LONG_CONTEXT_TIER }] },
+    compat: { ...GROK_47_MODELS_JSON_DEFINITION.compat },
+  });
+  xai.models = models;
+  providers.xai = xai;
+  root.providers = providers;
+  return { next: root, changed: true };
+}
+
+export function grok47ModelsJsonPath(agentDir: string): string {
+  return join(agentDir, "models.json");
+}
+
+export function ensureGrok47InModelsJsonFile(agentDir: string): boolean {
+  const path = grok47ModelsJsonPath(agentDir);
+  let parsed: unknown = {};
+  if (existsSync(path)) {
+    try {
+      parsed = JSON.parse(readFileSync(path, "utf8"));
+    } catch {
+      return false;
+    }
+  }
+  const { next, changed } = upsertGrok47InModelsJson(parsed);
+  if (!changed) return false;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
+  return true;
+}
+
+export type SessionModelRef = { provider: string; modelId: string };
+
+export function lastSessionModel(
+  entries: ReadonlyArray<{ type: string; provider?: string; modelId?: string }>,
+): SessionModelRef | undefined {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (
+      entry?.type === "model_change" &&
+      typeof entry.provider === "string" &&
+      typeof entry.modelId === "string"
+    ) {
+      return { provider: entry.provider, modelId: entry.modelId };
+    }
+  }
+  return undefined;
+}
+
+export function shouldRestoreGrok47(
+  current: { provider?: string; id?: string } | undefined,
+  saved: SessionModelRef | undefined,
+): boolean {
+  if (!saved || saved.modelId !== GROK_47_ID) return false;
+  return current?.id !== saved.modelId || current?.provider !== saved.provider;
+}