@aliou/pi-neuralwatt 0.13.0 → 0.14.0

package/extensions/provider/index.ts

@@ -18,7 +18,8 @@ import type { NeuralwattQuotas } from "../../src/types/quota-api";
 import { getNeuralwattApiKey } from "../_shared/auth";
 import { registerNeuralwattSettings } from "./commands/settings";
 import { normalizeNeuralwattContextOverflowError } from "./context-overflow";
-import { getNeuralwattModels, refreshNeuralwattModels } from "./models";
+import { getNeuralwattModels } from "./models";
+import { createNeuralwattProvider } from "./provider";
 import { buildQuotasFromHeaders, fetchRequestedQuotas } from "./quota-store";
 import {
   type NeuralwattRateLimitInfo,
@@ -42,24 +43,24 @@ function registerNeuralwattProvider(
 ): void {
   const { provider: providerConfig } = configLoader.getConfig();
 
-  const models = getNeuralwattModels({
+  const staticModels = getNeuralwattModels({
     includeLegacyModelIds: providerConfig.includeLegacyModelIds,
     includeAliasedModelIds: providerConfig.includeAliasedModelIds,
   });
 
-  const config: Parameters<ExtensionAPI["registerProvider"]>[1] = {
-    name: "Neuralwatt",
-    baseUrl: "https://api.neuralwatt.com/v1",
-    apiKey: "$NEURALWATT_API_KEY",
-    api: "openai-completions",
-    authHeader: true,
-    headers: {
-      Referer: "https://pi.dev",
-      "X-Title": "npm:@aliou/pi-neuralwatt",
-    },
-    models,
-    refreshModels: (context) =>
-      refreshNeuralwattModels(context, {
+  const apiProvider = getApiProvider("openai-completions");
+  const baseStreamSimple = apiProvider?.streamSimple;
+  const streamSimple = baseStreamSimple
+    ? (wrapNeuralwattStreamSimple(
+        baseStreamSimple as never,
+        onSseQuota,
+      ) as never)
+    : undefined;
+
+  pi.registerProvider(
+    createNeuralwattProvider(
+      staticModels,
+      () => ({
         includeLegacyModelIds:
           configLoader.getConfig().provider.includeLegacyModelIds,
         includeAliasedModelIds:
@@ -67,18 +68,9 @@ function registerNeuralwattProvider(
         includeEarlyAccessModels:
           configLoader.getConfig().provider.includeEarlyAccessModels,
       }),
-  };
-
-  const provider = getApiProvider("openai-completions");
-  const baseStreamSimple = provider?.streamSimple;
-  if (baseStreamSimple) {
-    config.streamSimple = wrapNeuralwattStreamSimple(
-      baseStreamSimple as never,
-      onSseQuota,
-    ) as never;
-  }
-
-  pi.registerProvider("neuralwatt", config);
+      streamSimple,
+    ),
+  );
 }
 
 export default async function (pi: ExtensionAPI) {

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

@@ -180,28 +180,37 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
       },
     ],
   ],
+  // The kimi-k3 endpoint rejects anything above 327,680 total tokens with
+  // `400: max_completion_tokens is too large … supports at most 327680
+  // completion tokens` (verified at runtime), even though the API advertises
+  // `max_model_len: 1048560` with a null output cap for the whole family.
+  // The -fast/-flex endpoints don't enforce any cap server-side yet (they
+  // accept max_completion_tokens beyond the advertised window), but they are
+  // the same K3 deployment and are expected to share the 327,680 limit, so
+  // all three variants are pinned to it. The drift check in models.test.ts
+  // whitelists this divergence via CONTEXT_WINDOW_OVERRIDES.
   [
     KIMI_K3,
     [
       {
         id: "kimi-k3",
         name: "Kimi K3",
-        contextWindow: 1048560,
-        maxOutputTokens: null,
+        contextWindow: 327680,
+        maxOutputTokens: 327680,
         reasoning: true,
       },
       {
         id: "kimi-k3-fast",
         name: "Kimi K3 Fast",
-        contextWindow: 1048560,
-        maxOutputTokens: null,
+        contextWindow: 327680,
+        maxOutputTokens: 327680,
         reasoning: false,
       },
       {
         id: "kimi-k3-flex",
         name: "Kimi K3 (flex)",
-        contextWindow: 1048560,
-        maxOutputTokens: null,
+        contextWindow: 327680,
+        maxOutputTokens: 327680,
         reasoning: true,
         costMultiplier: FLEX_COST_MULTIPLIER,
       },

package/extensions/provider/models/refresh.ts

@@ -5,10 +5,6 @@ import type {
   RefreshModelsContext,
 } from "@earendil-works/pi-ai";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import {
-  persistModels,
-  readStoredModels,
-} from "../../../src/refresh-store-compat";
 import {
   ALIAS_NEURALWATT_MODEL_IDS,
   buildAliasNeuralwattModels,
@@ -24,6 +20,8 @@ const PROVIDER_ID = "neuralwatt";
 const BASE_URL = "https://api.neuralwatt.com/v1";
 const API = "openai-completions" as const;
 
+export type StoredProviderModels = readonly Model<Api>[];
+
 export interface RefreshNeuralwattModelsOptions {
   includeLegacyModelIds: boolean;
   includeAliasedModelIds: boolean;
@@ -129,25 +127,27 @@ function persistCatalog(
   context: RefreshModelsContext,
   models: ProviderModelConfig[],
 ): Promise<boolean> {
-  return persistModels(context, {
-    models: models.map(toStoredModel),
-    checkedAt: Date.now(),
+  return context.publish({
+    persist: {
+      models: models.map(toStoredModel),
+      checkedAt: Date.now(),
+    },
   });
 }
 
-/** Refresh the complete Neuralwatt catalog with Pi-managed persistence. */
+/** Refresh the complete Neuralwatt catalog; undefined = failed (stale store kept). */
 export async function refreshNeuralwattModels(
   context: RefreshModelsContext,
   options: RefreshNeuralwattModelsOptions,
-): Promise<ProviderModelConfig[]> {
+): Promise<ProviderModelConfig[] | undefined> {
   const baseline = configuredModels(
     options.includeLegacyModelIds,
     options.includeAliasedModelIds,
   );
-  const stored = await readStoredModels(context);
+  const stored = context.stored;
 
   if (!options.includeEarlyAccessModels) {
-    await persistCatalog(context, baseline);
+    await persistCatalog(context, baseline).catch(() => false);
     return baseline;
   }
 
@@ -161,29 +161,31 @@ export async function refreshNeuralwattModels(
     cachedEarlyAccess,
   );
 
-  if (!context.allowNetwork || context.signal?.aborted) {
+  if (!context.allowNetwork || context.signal.aborted) {
     return cachedCatalog;
   }
 
+  // Anonymous credential (empty or missing key): keep the public catalog and
+  // skip discovery, which requires a real key.
   const apiKey =
-    context.credential?.type === "api_key" ? context.credential.key : undefined;
+    context.credential?.type === "api_key" && context.credential.key
+      ? context.credential.key
+      : undefined;
   if (!apiKey) return cachedCatalog;
 
   const earlyAccess = await (options.loadEarlyAccess ?? loadEarlyAccessModels)(
     apiKey,
     context.signal,
   );
-  if (context.signal?.aborted) return cachedCatalog;
-  if (!earlyAccess) {
-    throw new Error("Neuralwatt model catalog refresh failed");
-  }
+  if (context.signal.aborted) return cachedCatalog;
+  if (!earlyAccess) return undefined;
 
   const catalog = configuredModels(
     options.includeLegacyModelIds,
     options.includeAliasedModelIds,
     configuredEarlyAccessModels(earlyAccess, baseline),
   );
-  context.signal?.throwIfAborted();
-  await persistCatalog(context, catalog);
+  context.signal.throwIfAborted();
+  await persistCatalog(context, catalog).catch(() => false);
   return catalog;
 }

package/extensions/provider/provider.ts

@@ -0,0 +1,113 @@
+import type {
+  Api,
+  Model,
+  Provider,
+  ProviderStreamOptions,
+} from "@earendil-works/pi-ai";
+import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import type {
+  RefreshNeuralwattModelsOptions,
+  StoredProviderModels,
+} from "./models/refresh";
+import { refreshNeuralwattModels } from "./models/refresh";
+import type { AnyStreamSimple } from "./stream-simple";
+
+export const NEURALWATT_PROVIDER_ID = "neuralwatt";
+export const NEURALWATT_BASE_URL = "https://api.neuralwatt.com/v1";
+export const NEURALWATT_API_KEY_ENV = "NEURALWATT_API_KEY";
+
+const NEURALWATT_REQUEST_HEADERS = {
+  Referer: "https://pi.dev",
+  "X-Title": "npm:@aliou/pi-neuralwatt",
+};
+
+const API = "openai-completions" as const;
+
+function toProviderModels(
+  models: readonly ProviderModelConfig[],
+): Model<Api>[] {
+  return models.map((model) => ({
+    ...model,
+    api: model.api ?? API,
+    provider: NEURALWATT_PROVIDER_ID,
+    baseUrl: model.baseUrl ?? NEURALWATT_BASE_URL,
+    headers: NEURALWATT_REQUEST_HEADERS,
+  }));
+}
+
+export function createNeuralwattProvider(
+  staticModels: ProviderModelConfig[],
+  refreshOptions: () => RefreshNeuralwattModelsOptions,
+  streamSimpleOverride?: AnyStreamSimple,
+): Provider {
+  let liveModels = toProviderModels(staticModels);
+
+  return {
+    id: NEURALWATT_PROVIDER_ID,
+    name: "Neuralwatt",
+    baseUrl: NEURALWATT_BASE_URL,
+    headers: NEURALWATT_REQUEST_HEADERS,
+    auth: {
+      apiKey: {
+        name: "Neuralwatt API key",
+        login: async (interaction) => ({
+          type: "api_key",
+          key: await interaction.prompt({
+            type: "secret",
+            message: "Enter Neuralwatt API key",
+          }),
+        }),
+        check: async ({ ctx, credential }) => {
+          if (credential?.type === "api_key" && credential.key) {
+            return { type: "api_key", source: "stored credential" };
+          }
+          if (await ctx.env(NEURALWATT_API_KEY_ENV)) {
+            return { type: "api_key", source: NEURALWATT_API_KEY_ENV };
+          }
+          return undefined;
+        },
+        resolve: async ({ ctx, credential, signal }) => {
+          signal.throwIfAborted();
+          if (credential?.type === "api_key" && credential.key) {
+            return {
+              auth: { apiKey: credential.key },
+              env: credential.env,
+              source: "stored credential",
+            };
+          }
+          const envKey = await ctx.env(NEURALWATT_API_KEY_ENV);
+          signal.throwIfAborted();
+          if (envKey) {
+            return { auth: { apiKey: envKey }, source: NEURALWATT_API_KEY_ENV };
+          }
+          // Resolve never fails: without a key the catalog is the hardcoded
+          // one and early-access discovery is skipped (anonymous playground
+          // traffic authenticates at stream time).
+          return { auth: { apiKey: "" }, source: "anonymous" };
+        },
+      },
+    },
+    getModels: () => liveModels,
+    refreshModels: async (context) => {
+      const refreshed = await refreshNeuralwattModels(
+        context,
+        refreshOptions(),
+      );
+      // Fresh or offline store: the refresh intentionally skipped the
+      // network; adopt the persisted catalog anyway so getModels reflects it
+      // (statics otherwise).
+      const next = refreshed ?? context.stored?.models;
+      if (!next || next.length === 0) return;
+      const adopted = toProviderModels(next as StoredProviderModels);
+      await context.publish({
+        update: () => {
+          liveModels = adopted;
+        },
+      });
+    },
+    stream: (model, context, options) =>
+      stream(model, context, options as ProviderStreamOptions | undefined),
+    streamSimple: streamSimpleOverride ?? streamSimple,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -38,8 +38,8 @@
     "@aliou/pi-utils-ui": "^0.5.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.80.8",
-    "@earendil-works/pi-coding-agent": ">=0.80.8",
+    "@earendil-works/pi-ai": ">=0.84.0",
+    "@earendil-works/pi-coding-agent": ">=0.84.0",
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {

package/src/refresh-store-compat.ts

@@ -1,69 +0,0 @@
-// ---------------------------------------------------------------------------
-// Backward-compat shim for the Pi coding-agent provider refresh context.
-//
-// Pi 0.84 replaced dynamic `context.store` read/write access with the
-// read-only `context.stored` snapshot and the generation-checked
-// `context.publish({ persist })` transaction. This module detects the
-// available API shape at runtime so the extension works on both <0.84 (store)
-// and >=0.84 (publish) hosts.
-//
-// Once the minimum supported @earendil-works/pi-coding-agent version is
-// >=0.84, delete this file and:
-//   - replace `readStoredModels(context)` with `context.stored`
-//   - replace `persistModels(context, entry)` with
-//     `await context.publish({ persist: entry })` (skip when aborted)
-// ---------------------------------------------------------------------------
-
-import type {
-  ModelsStoreEntry,
-  RefreshModelsContext,
-} from "@earendil-works/pi-ai";
-
-type LegacyRefreshModelsContext = RefreshModelsContext & {
-  store?: {
-    read(): Promise<ModelsStoreEntry | undefined>;
-    write(entry: ModelsStoreEntry): Promise<unknown>;
-  };
-};
-
-/**
- * Returns the persisted catalog entry for the current provider, reading from
- * the 0.84+ `context.stored` snapshot when available and falling back to the
- * legacy `context.store.read()` on older hosts.
- */
-export async function readStoredModels(
-  context: RefreshModelsContext,
-): Promise<ModelsStoreEntry | undefined> {
-  if (context.stored !== undefined) return context.stored;
-  return readLegacyStore(context);
-}
-
-function readLegacyStore(
-  context: RefreshModelsContext,
-): Promise<ModelsStoreEntry | undefined> {
-  const legacy = context as LegacyRefreshModelsContext;
-  return legacy.store ? legacy.store.read() : Promise.resolve(undefined);
-}
-
-/**
- * Persists the catalog entry, publishing through
- * `context.publish({ persist: entry })` on 0.84+ hosts and writing through
- * the legacy `context.store.write(entry)` on older hosts.
- *
- * Returns true when the entry was persisted. On 0.84+ hosts a return value of
- * false means a newer refresh superseded this publication (generation check).
- */
-export async function persistModels(
-  context: RefreshModelsContext,
-  entry: ModelsStoreEntry,
-): Promise<boolean> {
-  if (typeof context.publish === "function") {
-    return context.publish({ persist: entry });
-  }
-  const legacy = context as LegacyRefreshModelsContext;
-  if (legacy.store) {
-    await legacy.store.write(entry);
-    return true;
-  }
-  return false;
-}