@aliou/pi-neuralwatt 0.7.1 → 0.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "license": "MIT",
   "type": "module",
   "private": false,

package/src/extensions/provider/index.ts

@@ -21,7 +21,12 @@ import {
   type NeuralwattQuotasUpdatedPayload,
 } from "../../types/quota-events";
 import { normalizeNeuralwattContextOverflowError } from "./context-overflow";
-import { getNeuralwattModels, loadHiddenModels } from "./models";
+import {
+  getNeuralwattModels,
+  loadCachedHiddenModels,
+  loadHiddenModels,
+  writeHiddenModelsCache,
+} from "./models";
 import { buildQuotasFromHeaders, fetchRequestedQuotas } from "./quota-store";
 import {
   type NeuralwattRateLimitInfo,
@@ -72,8 +77,24 @@ export default async function (pi: ExtensionAPI) {
   await configLoader.load();
 
   let latestQuotas: NeuralwattQuotas | undefined;
+
+  // Stale-while-revalidate seed for hidden models.
+  //
+  // Hidden models are only discoverable by hitting the authenticated
+  // `/v1/models` endpoint, which we can do inside `session_start` (Pi does not
+  // expose `authStorage` to extension factories). However, Pi validates scoped
+  // models (e.g. `neuralwatt/glm-5.2-short`) during startup, *before*
+  // `session_start` fires. To avoid "No models match pattern" warnings on saved
+  // scoped models, we synchronously restore the previous session's fetch from
+  // the on-disk cache so the provider is registered with hidden models at
+  // load time. `session_start` then revalidates from the live API and writes
+  // the cache back. First run with no cache still warns once.
   let hiddenModels: ProviderModelConfig[] = [];
+  if (configLoader.getConfig().includeHiddenModels) {
+    hiddenModels = loadCachedHiddenModels();
+  }
   let hiddenModelsLoaded = false;
+  let hiddenModelsAbort: AbortController | undefined;
 
   const handleSseQuota = (line: string) => {
     const quotas = updateQuotasFromSseComment(latestQuotas, line);
@@ -85,7 +106,7 @@ export default async function (pi: ExtensionAPI) {
     });
   };
 
-  registerNeuralwattProvider(pi, handleSseQuota);
+  registerNeuralwattProvider(pi, handleSseQuota, hiddenModels);
 
   const loadedFeatures = new Set<NeuralwattFeatureId>();
 
@@ -95,9 +116,24 @@ export default async function (pi: ExtensionAPI) {
   });
 
   pi.events.on(NEURALWATT_CONFIG_UPDATED_EVENT, () => {
+    // Toggle may have enabled hidden models since startup. Seed from the disk
+    // cache so previously discovered models are available immediately without
+    // waiting for the next session_start revalidation.
+    if (
+      configLoader.getConfig().includeHiddenModels &&
+      !hiddenModelsLoaded &&
+      hiddenModels.length === 0
+    ) {
+      hiddenModels = loadCachedHiddenModels();
+    }
     registerNeuralwattProvider(pi, handleSseQuota, hiddenModels);
   });
 
+  pi.on("session_shutdown", () => {
+    hiddenModelsAbort?.abort();
+    hiddenModelsAbort = undefined;
+  });
+
   let lastHeaderEmitAt = 0;
   let quotaRequestInFlight = false;
 
@@ -135,12 +171,21 @@ export default async function (pi: ExtensionAPI) {
       return { message };
     }
 
+    // Fallback for 429s where no layer-specific headers were captured. The
+    // streamSimple wrap (wrapNeuralwattStreamSimple) already formats a
+    // detailed message via formatRateLimitError when it captures headers;
+    // detect that case by the `"429 rate limit:"` prefix it emits and leave
+    // it untouched. This branch only fires for genuinely headerless 429s
+    // (e.g. anonymous playground limits, or a 429 from infra in front of
+    // Neuralwatt), since after_provider_response cannot observe 429s — the
+    // OpenAI SDK throws before Pi's onResponse hook runs.
     if (
       event.message.role === "assistant" &&
       event.message.stopReason === "error" &&
       (event.message.provider === "neuralwatt" ||
         ctx.model?.provider === "neuralwatt") &&
-      event.message.errorMessage?.includes("429")
+      event.message.errorMessage?.includes("429") &&
+      !event.message.errorMessage.startsWith("429 rate limit:")
     ) {
       return {
         message: normalizeNeuralwattRateLimitError(event.message, {
@@ -203,10 +248,20 @@ export default async function (pi: ExtensionAPI) {
 
     if (!hiddenModelsLoaded && configLoader.getConfig().includeHiddenModels) {
       hiddenModelsLoaded = true;
-      const fetched = await loadHiddenModels(ctx.modelRegistry.authStorage);
+      hiddenModelsAbort?.abort();
+      hiddenModelsAbort = new AbortController();
+      const fetched = await loadHiddenModels(
+        ctx.modelRegistry.authStorage,
+        hiddenModelsAbort.signal,
+      );
+      // Persist for the next startup so scoped models resolve without warnings
+      // on Pi's subsequent launches.
       if (fetched.length > 0) {
         hiddenModels = fetched;
-        registerNeuralwattProvider(pi, handleSseQuota, hiddenModels);
+        await writeHiddenModelsCache(hiddenModels);
+        if (!hiddenModelsAbort.signal.aborted) {
+          registerNeuralwattProvider(pi, handleSseQuota, hiddenModels);
+        }
       }
     }
 

package/src/extensions/provider/models/cache.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Stale-while-revalidate disk cache for hidden Neuralwatt models.
+ *
+ * Hidden models are discovered by hitting the authenticated `/v1/models`
+ * endpoint, which only happens inside `session_start` (Pi does not expose
+ * `authStorage` to the extension factory). Because Pi validates scoped models
+ * during startup — before `session_start` fires — we persist the last fetch to
+ * disk so the provider can be registered with cached models instantly on the
+ * next launch. The first run with no cache still warns once; subsequent runs
+ * resolve cleanly.
+ *
+ * File shape: `{ version: 1, models: ProviderModelConfig[] }`.
+ */
+
+const CACHE_VERSION = 1;
+const CACHE_FILENAME = "neuralwatt-hidden-models.json";
+
+function cachePath(): string {
+  return join(getAgentDir(), "cache", CACHE_FILENAME);
+}
+
+interface HiddenModelsCacheFile {
+  version?: unknown;
+  models?: unknown;
+}
+
+/**
+ * Read cached hidden models synchronously.
+ *
+ * Designed to be called from the provider extension factory body, where Pi
+ * has not entered the event loop yet. Returns an empty array if the cache is
+ * missing, unreadable, or malformed.
+ */
+export function loadCachedHiddenModels(): ProviderModelConfig[] {
+  try {
+    const path = cachePath();
+    if (!existsSync(path)) return [];
+
+    const parsed: HiddenModelsCacheFile = JSON.parse(
+      readFileSync(path, "utf8"),
+    );
+    if (!Array.isArray(parsed?.models)) return [];
+
+    return parsed.models as ProviderModelConfig[];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Persist hidden models to disk for the next startup.
+ *
+ * Called after a successful `/v1/models` fetch in `session_start`. Failures are
+ * swallowed since a missing cache only degrades to first-run behavior.
+ */
+export async function writeHiddenModelsCache(
+  models: ProviderModelConfig[],
+): Promise<void> {
+  try {
+    const path = cachePath();
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(
+      path,
+      `${JSON.stringify({ version: CACHE_VERSION, models }, null, 2)}\n`,
+      "utf8",
+    );
+  } catch {
+    // Cache writes are best-effort. A missing cache only falls back to the
+    // first-run path (next session revalidates and writes again).
+  }
+}

package/src/extensions/provider/models/hidden.ts

@@ -10,19 +10,10 @@ import { NEURALWATT_MODELS } from "./public-models";
 // Per-ID overrides for known hidden models. The authenticated /v1/models endpoint
 // exposes pricing and capabilities, but some Pi-specific behavior (thinking levels,
 // compat flags) has to be supplied by hand.
+// Previously hidden models that have since gone public now live in public-models.ts.
 const HIDDEN_MODEL_OVERRIDES: Partial<
   Record<string, Partial<ProviderModelConfig>>
-> = {
-  "glm-5.2-short": {
-    thinkingLevelMap: {
-      minimal: null,
-      low: null,
-      medium: null,
-      high: "high",
-      xhigh: "max",
-    },
-  },
-};
+> = {};
 
 function buildHiddenModel(apiModel: NeuralwattApiModel): ProviderModelConfig {
   const meta = apiModel.metadata;
@@ -108,11 +99,12 @@ function applyHiddenOverride(
  */
 export async function loadHiddenModels(
   authStorage: AuthStorage,
+  signal?: AbortSignal,
 ): Promise<ProviderModelConfig[]> {
   const apiKey = await getNeuralwattApiKey(authStorage);
   if (!apiKey) return [];
 
-  const result = await fetchNeuralwattModels(apiKey);
+  const result = await fetchNeuralwattModels(apiKey, signal);
   if (!result.success) return [];
 
   const publicIds = new Set(NEURALWATT_MODELS.map((model) => model.id));

package/src/extensions/provider/models/index.ts

@@ -2,6 +2,7 @@ import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 import { buildLegacyNeuralwattModels } from "./legacy";
 import { NEURALWATT_MODELS } from "./public-models";
 
+export { loadCachedHiddenModels, writeHiddenModelsCache } from "./cache";
 export { loadHiddenModels } from "./hidden";
 export {
   buildLegacyNeuralwattModels,

package/src/extensions/provider/models/public-models.ts

@@ -49,6 +49,52 @@ export const NEURALWATT_MODELS: ProviderModelConfig[] = [
       maxTokensField: "max_tokens",
     },
   },
+  // GLM-5.2 Short - ZhipuAI (200K context, bounded reasoning budget)
+  {
+    id: "glm-5.2-short",
+    name: "GLM-5.2 Short",
+    reasoning: true,
+    input: ["text"],
+    cost: {
+      input: 1.45,
+      output: 4.5,
+      cacheRead: 0.3625,
+      cacheWrite: 0,
+    },
+    contextWindow: 199984,
+    maxTokens: 65536,
+    thinkingLevelMap: {
+      minimal: null,
+      low: null,
+      medium: null,
+      high: "high",
+      xhigh: "max",
+    },
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+      requiresReasoningContentOnAssistantMessages: true,
+    },
+  },
+  // GLM-5.2 Short Fast - ZhipuAI (200K context, reasoning disabled)
+  {
+    id: "glm-5.2-short-fast",
+    name: "GLM-5.2 Short Fast",
+    reasoning: false,
+    input: ["text"],
+    cost: {
+      input: 1.45,
+      output: 4.5,
+      cacheRead: 0.3625,
+      cacheWrite: 0,
+    },
+    contextWindow: 199984,
+    maxTokens: 65536,
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+    },
+  },
   // Kimi K2.5 - MoonshotAI
   {
     id: "moonshotai/Kimi-K2.5",