@aliou/pi-neuralwatt 0.15.2 → 0.15.3

package/README.md

@@ -144,5 +144,5 @@ This repository uses [Changesets](https://github.com/changesets/changesets) for
 ## Links
 
 - [Neuralwatt](https://portal.neuralwatt.com/auth/register?ref=NW-ALIOU-Q7MF)
-- [Neuralwatt API Docs](https://neuralwatt.com/docs)
+- [Neuralwatt API Docs](https://docs.neuralwatt.com/quickstart.md)
 - [Pi Documentation](https://buildwithpi.ai/)

package/extensions/provider/models/build.ts

@@ -13,7 +13,7 @@ export type ThinkingLevelMap = NonNullable<
  * streams. A non-streaming request to a `-flex` model silently falls back to
  * the standard tier and the standard price.
  *
- * https://portal.neuralwatt.com/docs/guides/flex-tier
+ * https://docs.neuralwatt.com/guides/flex-tier.md
  */
 export const FLEX_COST_MULTIPLIER = 0.65;
 
@@ -107,12 +107,14 @@ export function buildThinkingLevelMap(
 
 /**
  * Neuralwatt reports `max_output_tokens: null` for models whose output is only
- * bounded by the context window. Mirror the API instead of inventing a cap.
+ * bounded by the context window. Some models incorrectly report 0; treat 0
+ * like null so we never emit maxTokens: 0.
  */
 export function resolveMaxTokens(
   maxOutputTokens: number | null | undefined,
   contextWindow: number,
 ): number {
+  if (maxOutputTokens === 0) return contextWindow;
   return maxOutputTokens ?? contextWindow;
 }
 

package/extensions/provider/models/catalog.ts

@@ -10,12 +10,6 @@ import { NEURALWATT_MODELS } from "./public-models";
 
 export type NeuralwattModel = ProviderModelConfig;
 
-const CONTEXT_WINDOW_OVERRIDES: ReadonlyMap<string, number> = new Map([
-  ["kimi-k3", 327_680],
-  ["kimi-k3-fast", 327_680],
-  ["kimi-k3-flex", 327_680],
-]);
-
 // Chat-template thinking: the API exposes a `reasoning` block, but the
 // underlying mechanism is chat_template_kwargs, so Pi needs the mapping.
 const COMPAT_OVERRIDES: Partial<
@@ -62,8 +56,7 @@ function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
   if (reasoning) compat.requiresReasoningContentOnAssistantMessages = true;
   Object.assign(compat, COMPAT_OVERRIDES[model.id]);
 
-  const contextWindow =
-    CONTEXT_WINDOW_OVERRIDES.get(model.id) ?? model.max_model_len;
+  const contextWindow = model.max_model_len;
 
   const result: NeuralwattModel = {
     id: model.id,
@@ -135,7 +128,14 @@ export function buildNeuralwattProviderModelsFromApi(
   const models = apiModels
     .filter(
       (m) =>
-        m.metadata && !m.metadata.deprecated && !m.metadata.pricing.pricing_tbd,
+        m.metadata &&
+        !m.metadata.deprecated &&
+        !m.metadata.pricing.pricing_tbd &&
+        // Exclude non-chat models (e.g. embeddings) by task
+        !(
+          m.metadata.capabilities.task &&
+          !["chat", "completions"].includes(m.metadata.capabilities.task)
+        ),
     )
     .map(apiModelToProviderModel);
   return [...models, ...buildAliases(models, apiModels)];

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

@@ -31,7 +31,7 @@ const DEEPSEEK_V4_FLASH: NeuralwattModelFamily = {
 // `max` and `none`; every non-`none` request resolves to `max` upstream.
 // It does not reason by default (`default_enabled: false`), but the model
 // can produce reasoning traces when asked. See
-// https://portal.neuralwatt.com/docs/api/chat-completions#reasoning-effort
+// https://docs.neuralwatt.com/api/chat-completions.md
 const GEMMA_4: NeuralwattModelFamily = {
   cost: { input: 0.144, output: 0.42, cacheRead: 0.0144 },
   vision: true,
@@ -208,37 +208,28 @@ 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: 327680,
-        maxOutputTokens: 327680,
+        contextWindow: 1048560,
+        maxOutputTokens: null,
         reasoning: true,
       },
       {
         id: "kimi-k3-fast",
         name: "Kimi K3 Fast",
-        contextWindow: 327680,
-        maxOutputTokens: 327680,
+        contextWindow: 1048560,
+        maxOutputTokens: null,
         reasoning: false,
       },
       {
         id: "kimi-k3-flex",
         name: "Kimi K3 (flex)",
-        contextWindow: 327680,
-        maxOutputTokens: 327680,
+        contextWindow: 1048560,
+        maxOutputTokens: null,
         reasoning: true,
         costMultiplier: FLEX_COST_MULTIPLIER,
       },
@@ -299,7 +290,7 @@ const FAMILIES: [NeuralwattModelFamily, NeuralwattVariantSpec[]][] = [
 // The API now advertises flex variants but lists them at standard pricing;
 // the 35% Flex discount is a billing-time concept applied here via
 // `costMultiplier` rather than reflected in the catalog metadata.
-// https://portal.neuralwatt.com/docs/guides/flex-tier
+// https://docs.neuralwatt.com/guides/flex-tier.md
 
 export const NEURALWATT_MODELS: ProviderModelConfig[] = FAMILIES.flatMap(
   ([family, variants]) => buildNeuralwattFamily(family, variants),

package/extensions/provider/models/refresh.ts

@@ -12,6 +12,38 @@ import type {
 
 export const MODEL_STORE_TTL_MS = 4 * 60 * 60 * 1000;
 
+/**
+ * Scope a store entry applies to. The public catalog is a subset of any
+ * key-scoped catalog (preview, grant-gated, private models), so an entry
+ * stamped "public" must not shadow a keyed refresh — and a key-scoped entry
+ * must not be replayed for an anonymous user. Matches the anonymous-key
+ * convention in src/lib/neuralwatt-api.ts (authHeaders).
+ */
+const CATALOG_SCOPE_VERSION = "v1";
+type CatalogScope = "public" | "key";
+
+type ScopedModelsStoreEntry = ModelsStoreEntry & { catalogKey?: string };
+
+function catalogScope(apiKey: string | undefined): CatalogScope {
+  return apiKey !== undefined && apiKey !== "" && apiKey !== "-"
+    ? "key"
+    : "public";
+}
+
+function storedCatalogKey(entry: ScopedModelsStoreEntry): string | undefined {
+  return entry.catalogKey;
+}
+
+function catalogKeyMatches(
+  entry: ScopedModelsStoreEntry | undefined,
+  scope: CatalogScope,
+): boolean {
+  return (
+    entry !== undefined &&
+    storedCatalogKey(entry) === `${scope} ${CATALOG_SCOPE_VERSION}`
+  );
+}
+
 export type FetchNeuralwattApiModels = (
   apiKey: string | undefined,
   signal?: AbortSignal,
@@ -25,6 +57,13 @@ function isFreshStoreEntry(
   return Date.now() - checkedAt < MODEL_STORE_TTL_MS;
 }
 
+function isUsableStoreEntry(
+  entry: Readonly<ModelsStoreEntry> | undefined,
+  scope: CatalogScope,
+): entry is ModelsStoreEntry {
+  return isFreshStoreEntry(entry) && catalogKeyMatches(entry, scope);
+}
+
 export function createNeuralwattRefreshModels(
   staticModels: ReturnType<typeof buildNeuralwattProviderModels>,
   fetchApiModels: FetchNeuralwattApiModels,
@@ -35,29 +74,29 @@ export function createNeuralwattRefreshModels(
     context.signal.throwIfAborted();
     const fallback = buildFromStore(staticModels);
     try {
-      if (!context.allowNetwork) {
-        return context.stored
-          ? buildFromStore(context.stored.models)
-          : fallback;
-      }
-      if (!context.force && isFreshStoreEntry(context.stored)) {
-        return buildFromStore(context.stored.models);
-      }
       const apiKey =
         context.credential?.type === "api_key"
           ? context.credential.key
           : undefined;
+      const scope = catalogScope(apiKey);
+      const stored = context.stored as ScopedModelsStoreEntry | undefined;
+      if (!context.allowNetwork) {
+        return stored !== undefined && catalogKeyMatches(stored, scope)
+          ? buildFromStore(stored.models)
+          : fallback;
+      }
+      if (!context.force && isUsableStoreEntry(stored, scope)) {
+        return buildFromStore(stored.models);
+      }
       const apiModels = await fetchApiModels(apiKey, context.signal);
       context.signal.throwIfAborted();
       const models = buildFromApi(apiModels);
-      await context
-        .publish({
-          persist: {
-            models: models as unknown as ModelsStoreEntry["models"],
-            checkedAt: Date.now(),
-          },
-        })
-        .catch(() => undefined);
+      const entry: ScopedModelsStoreEntry = {
+        models: models as unknown as ModelsStoreEntry["models"],
+        checkedAt: Date.now(),
+        catalogKey: `${scope} ${CATALOG_SCOPE_VERSION}`,
+      };
+      await context.publish({ persist: entry }).catch(() => undefined);
       context.signal.throwIfAborted();
       return models;
     } catch (error) {

package/extensions/provider/rate-limit-error.ts

@@ -12,7 +12,7 @@ interface AssistantErrorLike {
  * layer. Each sets unique headers so the client can tell which layer
  * triggered the rejection.
  *
- * @see https://portal.neuralwatt.com/docs/guides/rate-limits
+ * @see https://docs.neuralwatt.com/guides/rate-limits.md
  */
 export interface NeuralwattRateLimitInfo {
   /** Which rate-limit layer triggered the 429 */

package/package.json

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

package/src/types/models-api.ts

@@ -16,6 +16,8 @@ export interface NeuralwattApiModelCapabilities {
   streaming: boolean;
   system_role: boolean;
   developer_role: boolean;
+  task?: string;
+  embedding_dimensions?: number;
 }
 
 /**