@aliou/pi-neuralwatt 0.14.2 → 0.15.0

package/extensions/provider/commands/settings/index.ts

@@ -104,82 +104,9 @@ export function registerNeuralwattSettings(
             ),
           ],
         },
-        {
-          label: "Other settings",
-          items: [
-            {
-              id: "includeLegacyModelIds",
-              label: "Legacy model IDs",
-              description:
-                "Include deprecated Neuralwatt model IDs as aliases in the model picker",
-              currentValue:
-                (tabConfig?.provider?.includeLegacyModelIds ??
-                resolved.provider.includeLegacyModelIds)
-                  ? "include"
-                  : "ignore",
-              values: ["include", "ignore"],
-            },
-            {
-              id: "includeAliasedModelIds",
-              label: "Alias model IDs",
-              description:
-                "Include active creator-scoped model IDs as aliases in the model picker",
-              currentValue:
-                (tabConfig?.provider?.includeAliasedModelIds ??
-                resolved.provider.includeAliasedModelIds)
-                  ? "include"
-                  : "ignore",
-              values: ["include", "ignore"],
-            },
-            {
-              id: "includeEarlyAccessModels",
-              label: "Early access models",
-              description:
-                "Include pre-release Neuralwatt models that your API key can reach but that are not yet in the public model list",
-              currentValue:
-                (tabConfig?.provider?.includeEarlyAccessModels ??
-                resolved.provider.includeEarlyAccessModels)
-                  ? "include"
-                  : "ignore",
-              values: ["include", "ignore"],
-            },
-          ],
-        },
       ];
     },
     onSettingChange: (id, newValue, config) => {
-      // Non-feature toggles are handled first so they are not blocked by the
-      // loaded-features guard (they are managed directly by the provider).
-      if (id === "includeLegacyModelIds") {
-        return {
-          ...config,
-          provider: {
-            ...config.provider,
-            includeLegacyModelIds: newValue === "include",
-          },
-        };
-      }
-
-      if (id === "includeAliasedModelIds") {
-        return {
-          ...config,
-          provider: {
-            ...config.provider,
-            includeAliasedModelIds: newValue === "include",
-          },
-        };
-      }
-
-      if (id === "includeEarlyAccessModels") {
-        return {
-          ...config,
-          provider: {
-            ...config.provider,
-            includeEarlyAccessModels: newValue === "include",
-          },
-        };
-      }
-
       if (!getLoadedFeatures().has(id as NeuralwattFeatureId)) {
         return null;
       }

package/extensions/provider/index.ts

@@ -13,12 +13,15 @@ import {
   type NeuralwattFeatureId,
   type NeuralwattQuotasUpdatedPayload,
 } from "../../src/events";
-import { fetchQuotas } from "../../src/lib/neuralwatt-api";
+import {
+  fetchNeuralwattModels,
+  fetchQuotas,
+} from "../../src/lib/neuralwatt-api";
 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 } from "./models";
+import { buildNeuralwattProviderModels } from "./models";
 import { createNeuralwattProvider } from "./provider";
 import { buildQuotasFromHeaders, fetchRequestedQuotas } from "./quota-store";
 import {
@@ -41,12 +44,7 @@ function registerNeuralwattProvider(
   pi: ExtensionAPI,
   onSseQuota: (line: string) => void,
 ): void {
-  const { provider: providerConfig } = configLoader.getConfig();
-
-  const staticModels = getNeuralwattModels({
-    includeLegacyModelIds: providerConfig.includeLegacyModelIds,
-    includeAliasedModelIds: providerConfig.includeAliasedModelIds,
-  });
+  const staticModels = buildNeuralwattProviderModels();
 
   const apiProvider = getApiProvider("openai-completions");
   const baseStreamSimple = apiProvider?.streamSimple;
@@ -60,14 +58,13 @@ function registerNeuralwattProvider(
   pi.registerProvider(
     createNeuralwattProvider(
       staticModels,
-      () => ({
-        includeLegacyModelIds:
-          configLoader.getConfig().provider.includeLegacyModelIds,
-        includeAliasedModelIds:
-          configLoader.getConfig().provider.includeAliasedModelIds,
-        includeEarlyAccessModels:
-          configLoader.getConfig().provider.includeEarlyAccessModels,
-      }),
+      async (apiKey, signal) => {
+        const result = await fetchNeuralwattModels(apiKey, signal);
+        if (!result.success) {
+          throw new Error("Neuralwatt models API request failed");
+        }
+        return result.data;
+      },
       streamSimple,
     ),
   );
@@ -92,9 +89,6 @@ export default async function (pi: ExtensionAPI) {
   };
 
   registerNeuralwattProvider(pi, handleSseQuota);
-  let registeredProviderSettings = {
-    ...configLoader.getConfig().provider,
-  };
 
   const loadedFeatures = new Set<NeuralwattFeatureId>();
 
@@ -103,22 +97,6 @@ export default async function (pi: ExtensionAPI) {
     getLoadedFeatures: () => loadedFeatures,
   });
 
-  pi.events.on(NEURALWATT_CONFIG_UPDATED_EVENT, () => {
-    const next = configLoader.getConfig().provider;
-    if (
-      next.includeLegacyModelIds ===
-        registeredProviderSettings.includeLegacyModelIds &&
-      next.includeAliasedModelIds ===
-        registeredProviderSettings.includeAliasedModelIds &&
-      next.includeEarlyAccessModels ===
-        registeredProviderSettings.includeEarlyAccessModels
-    ) {
-      return;
-    }
-    registeredProviderSettings = { ...next };
-    registerNeuralwattProvider(pi, handleSseQuota);
-  });
-
   let lastHeaderEmitAt = 0;
   let quotaRequestInFlight = false;
 

package/extensions/provider/models/catalog.ts

@@ -0,0 +1,148 @@
+import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
+import type { NeuralwattApiModel } from "../../../src/types/models-api";
+import {
+  buildThinkingLevelMap,
+  FLEX_COST_MULTIPLIER,
+  resolveMaxTokens,
+  type ThinkingLevelMap,
+} from "./build";
+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<
+  Record<string, Partial<NonNullable<ProviderModelConfig["compat"]>>>
+> = {
+  "Qwen/Qwen3.8-27B-FP8": {
+    thinkingFormat: "chat-template",
+    chatTemplateKwargs: {
+      enable_thinking: { $var: "thinking.enabled" },
+    },
+  },
+};
+
+const HARDCODED_ALIASES: Record<string, string> = {
+  "zai-org/GLM-5.2-FP8": "glm-5.2",
+  "moonshotai/Kimi-K2.7-Code": "kimi-k2.7-code",
+  "Qwen/Qwen3.6-35B-A3B": "qwen3.6-35b",
+  "deepseek-ai/DeepSeek-V4-Flash": "deepseek-v4-flash",
+};
+
+function isFlexModelId(id: string): boolean {
+  return id.endsWith("-flex");
+}
+
+function isVariantId(id: string): boolean {
+  return id.includes("-fast") || id.includes("-flex") || id.includes("-short");
+}
+
+function apiModelToProviderModel(model: NeuralwattApiModel): NeuralwattModel {
+  const meta = model.metadata;
+  if (!meta)
+    throw new Error(
+      `Neuralwatt API returned model "${model.id}" without metadata`,
+    );
+
+  const reasoning = meta.capabilities.reasoning;
+  // Flex variants are billed at 0.65x when streaming (35% off).
+  const multiplier = isFlexModelId(model.id) ? FLEX_COST_MULTIPLIER : 1;
+
+  const compat: NonNullable<ProviderModelConfig["compat"]> = {
+    supportsDeveloperRole: meta.capabilities.developer_role,
+    maxTokensField: "max_tokens",
+  };
+  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 result: NeuralwattModel = {
+    id: model.id,
+    name: meta.display_name ?? model.id,
+    reasoning,
+    input: meta.capabilities.vision
+      ? (["text", "image"] as const)
+      : (["text"] as const),
+    cost: {
+      input: meta.pricing.input_per_million * multiplier,
+      output: meta.pricing.output_per_million * multiplier,
+      cacheRead: (meta.pricing.cached_input_per_million ?? 0) * multiplier,
+      cacheWrite: (meta.pricing.cached_output_per_million ?? 0) * multiplier,
+    },
+    contextWindow,
+    maxTokens: resolveMaxTokens(meta.limits.max_output_tokens, contextWindow),
+    compat,
+  };
+
+  if (reasoning) {
+    result.thinkingLevelMap = buildThinkingLevelMap(
+      meta.reasoning,
+    ) as ThinkingLevelMap;
+  }
+
+  return result;
+}
+
+function buildAliases(
+  models: NeuralwattModel[],
+  apiModels: readonly NeuralwattApiModel[],
+): NeuralwattModel[] {
+  const existingIds = new Set(models.map((m) => m.id));
+  const aliases: NeuralwattModel[] = [];
+  const seen = new Set<string>();
+
+  const addAlias = (aliasId: string, canonicalId: string): void => {
+    if (seen.has(aliasId) || existingIds.has(aliasId)) return;
+    const canonical = models.find((m) => m.id === canonicalId);
+    if (!canonical) return;
+    seen.add(aliasId);
+    aliases.push({
+      ...canonical,
+      id: aliasId,
+      name: `${canonical.name} (alias ID)`,
+    });
+  };
+
+  for (const [aliasId, canonicalId] of Object.entries(HARDCODED_ALIASES)) {
+    addAlias(aliasId, canonicalId);
+  }
+
+  for (const apiModel of apiModels) {
+    const hfId = apiModel.metadata?.huggingface_id;
+    if (!hfId || hfId === apiModel.id || isVariantId(apiModel.id)) continue;
+    addAlias(hfId, apiModel.id);
+  }
+
+  return aliases;
+}
+
+export function buildNeuralwattProviderModels(): NeuralwattModel[] {
+  return NEURALWATT_MODELS.map((model) => ({ ...model }));
+}
+
+export function buildNeuralwattProviderModelsFromApi(
+  apiModels: readonly NeuralwattApiModel[],
+): NeuralwattModel[] {
+  const models = apiModels
+    .filter(
+      (m) =>
+        m.metadata && !m.metadata.deprecated && !m.metadata.pricing.pricing_tbd,
+    )
+    .map(apiModelToProviderModel);
+  return [...models, ...buildAliases(models, apiModels)];
+}
+
+export function buildNeuralwattProviderModelsFromStore(
+  storedModels: readonly NeuralwattModel[],
+): NeuralwattModel[] {
+  return storedModels.map((model) => ({ ...model }));
+}

package/extensions/provider/models/index.ts

@@ -1,39 +1,12 @@
-import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import { buildAliasNeuralwattModels } from "./aliases";
-import { buildLegacyNeuralwattModels } from "./legacy";
-import { NEURALWATT_MODELS } from "./public-models";
-
 export {
-  ALIAS_MODEL_MAP,
-  ALIAS_NEURALWATT_MODEL_IDS,
-  buildAliasNeuralwattModels,
-} from "./aliases";
-
-export {
-  EARLY_ACCESS_NEURALWATT_MODELS,
-  loadEarlyAccessModels,
-} from "./early-access";
-export {
-  buildLegacyNeuralwattModels,
-  LEGACY_MODEL_ALIAS_MAP,
-  LEGACY_NEURALWATT_MODEL_IDS,
-} from "./legacy";
+  buildNeuralwattProviderModels,
+  buildNeuralwattProviderModelsFromApi,
+  buildNeuralwattProviderModelsFromStore,
+  type NeuralwattModel,
+} from "./catalog";
 export { NEURALWATT_MODELS } from "./public-models";
-export { refreshNeuralwattModels } from "./refresh";
-
-export function getNeuralwattModels(options?: {
-  includeLegacyModelIds?: boolean;
-  includeAliasedModelIds?: boolean;
-}): ProviderModelConfig[] {
-  const models: ProviderModelConfig[] = [...NEURALWATT_MODELS];
-
-  if (options?.includeLegacyModelIds) {
-    models.push(...buildLegacyNeuralwattModels());
-  }
-
-  if (options?.includeAliasedModelIds) {
-    models.push(...buildAliasNeuralwattModels());
-  }
-
-  return models;
-}
+export {
+  createNeuralwattRefreshModels,
+  type FetchNeuralwattApiModels,
+  MODEL_STORE_TTL_MS,
+} from "./refresh";

package/extensions/provider/models/refresh.ts

@@ -1,191 +1,73 @@
 import type {
-  Api,
-  Model,
   ModelsStoreEntry,
   RefreshModelsContext,
 } from "@earendil-works/pi-ai";
-import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import {
-  ALIAS_NEURALWATT_MODEL_IDS,
-  buildAliasNeuralwattModels,
-} from "./aliases";
-import {
-  EARLY_ACCESS_NEURALWATT_MODELS,
-  loadEarlyAccessModels,
-} from "./early-access";
-import { buildLegacyNeuralwattModels } from "./legacy";
-import { NEURALWATT_MODELS } from "./public-models";
-
-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;
-  includeEarlyAccessModels: boolean;
-  loadEarlyAccess?: typeof loadEarlyAccessModels;
-}
-
-function configuredModels(
-  includeLegacyModelIds: boolean,
-  includeAliasedModelIds: boolean,
-  extraCanonicalModels: ProviderModelConfig[] = [],
-): ProviderModelConfig[] {
-  const canonicalModels = [...NEURALWATT_MODELS, ...extraCanonicalModels];
-  const models: ProviderModelConfig[] = [...canonicalModels];
-
-  if (includeLegacyModelIds) {
-    models.push(...buildLegacyNeuralwattModels());
-  }
-
-  if (includeAliasedModelIds) {
-    models.push(...buildAliasNeuralwattModels(canonicalModels));
-  }
-
-  return models;
-}
-
-function toStoredModel(model: ProviderModelConfig): Model<Api> {
-  return {
-    ...model,
-    provider: PROVIDER_ID,
-    api: model.api ?? API,
-    baseUrl: model.baseUrl ?? BASE_URL,
-  };
+import type { NeuralwattApiModel } from "../../../src/types/models-api";
+import type {
+  buildNeuralwattProviderModels,
+  buildNeuralwattProviderModelsFromApi,
+  buildNeuralwattProviderModelsFromStore,
+  NeuralwattModel,
+} from "./catalog";
+
+export const MODEL_STORE_TTL_MS = 4 * 60 * 60 * 1000;
+
+export type FetchNeuralwattApiModels = (
+  apiKey: string | undefined,
+  signal?: AbortSignal,
+) => Promise<readonly NeuralwattApiModel[]>;
+
+function isFreshStoreEntry(
+  entry: Readonly<ModelsStoreEntry> | undefined,
+): entry is ModelsStoreEntry {
+  if (!entry) return false;
+  const checkedAt = entry.checkedAt ?? Date.now();
+  return Date.now() - checkedAt < MODEL_STORE_TTL_MS;
 }
 
-function toProviderModel(model: Model<Api>): ProviderModelConfig {
-  return {
-    id: model.id,
-    name: model.name,
-    api: model.api,
-    baseUrl: model.baseUrl,
-    reasoning: model.reasoning,
-    thinkingLevelMap: model.thinkingLevelMap,
-    input: [...model.input],
-    cost: structuredClone(model.cost),
-    contextWindow: model.contextWindow,
-    maxTokens: model.maxTokens,
-    headers: model.headers
-      ? Object.fromEntries(
-          Object.entries(model.headers).filter(
-            (entry): entry is [string, string] => entry[1] !== null,
-          ),
-        )
-      : undefined,
-    compat: model.compat ? structuredClone(model.compat) : undefined,
+export function createNeuralwattRefreshModels(
+  staticModels: ReturnType<typeof buildNeuralwattProviderModels>,
+  fetchApiModels: FetchNeuralwattApiModels,
+  buildFromApi: typeof buildNeuralwattProviderModelsFromApi,
+  buildFromStore: typeof buildNeuralwattProviderModelsFromStore,
+) {
+  return async (context: RefreshModelsContext): Promise<NeuralwattModel[]> => {
+    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 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);
+      context.signal.throwIfAborted();
+      return models;
+    } catch (error) {
+      if (
+        context.signal.aborted ||
+        (error instanceof Error && error.name === "AbortError")
+      ) {
+        throw error;
+      }
+      return fallback;
+    }
   };
 }
-
-function dedupeEarlyAccessModels(
-  earlyAccessModels: ProviderModelConfig[],
-  baselineModels: ProviderModelConfig[],
-): ProviderModelConfig[] {
-  const baselineIds = new Set(baselineModels.map((model) => model.id));
-  return earlyAccessModels.filter((model) => !baselineIds.has(model.id));
-}
-
-function configuredEarlyAccessModels(
-  discoveredModels: ProviderModelConfig[],
-  baselineModels: ProviderModelConfig[],
-): ProviderModelConfig[] {
-  const hardcodedIds = new Set(
-    EARLY_ACCESS_NEURALWATT_MODELS.map((model) => model.id),
-  );
-  return dedupeEarlyAccessModels(
-    [
-      ...EARLY_ACCESS_NEURALWATT_MODELS,
-      ...discoveredModels.filter((model) => !hardcodedIds.has(model.id)),
-    ],
-    baselineModels,
-  );
-}
-
-function cachedEarlyAccessModels(
-  stored: ModelsStoreEntry | undefined,
-): ProviderModelConfig[] {
-  if (!stored) return [];
-
-  const allStaticIds = new Set(
-    configuredModels(true, true).map((model) => model.id),
-  );
-
-  return stored.models
-    .filter(
-      (model) =>
-        model.provider === PROVIDER_ID &&
-        !allStaticIds.has(model.id) &&
-        !ALIAS_NEURALWATT_MODEL_IDS.has(model.id),
-    )
-    .map(toProviderModel);
-}
-
-function persistCatalog(
-  context: RefreshModelsContext,
-  models: ProviderModelConfig[],
-): Promise<boolean> {
-  return context.publish({
-    persist: {
-      models: models.map(toStoredModel),
-      checkedAt: Date.now(),
-    },
-  });
-}
-
-/** Refresh the complete Neuralwatt catalog; undefined = failed (stale store kept). */
-export async function refreshNeuralwattModels(
-  context: RefreshModelsContext,
-  options: RefreshNeuralwattModelsOptions,
-): Promise<ProviderModelConfig[] | undefined> {
-  const baseline = configuredModels(
-    options.includeLegacyModelIds,
-    options.includeAliasedModelIds,
-  );
-  const stored = context.stored;
-
-  if (!options.includeEarlyAccessModels) {
-    await persistCatalog(context, baseline).catch(() => false);
-    return baseline;
-  }
-
-  const cachedEarlyAccess = configuredEarlyAccessModels(
-    cachedEarlyAccessModels(stored),
-    baseline,
-  );
-  const cachedCatalog = configuredModels(
-    options.includeLegacyModelIds,
-    options.includeAliasedModelIds,
-    cachedEarlyAccess,
-  );
-
-  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
-      ? 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) return undefined;
-
-  const catalog = configuredModels(
-    options.includeLegacyModelIds,
-    options.includeAliasedModelIds,
-    configuredEarlyAccessModels(earlyAccess, baseline),
-  );
-  context.signal.throwIfAborted();
-  await persistCatalog(context, catalog).catch(() => false);
-  return catalog;
-}