pi-nvidia-nim 1.1.21 → 1.1.23

package/README.md

@@ -1,6 +1,6 @@
 # pi-nvidia-nim
 
-NVIDIA NIM API provider extension for [pi coding agent](https://github.com/earendil-works/pi-mono) - access 100+ models from [build.nvidia.com](https://build.nvidia.com) including DeepSeek V4 Flash/Pro, DeepSeek V3.2, Kimi K2.6, MiniMax M2.1, GLM-5, GLM-4.7, Qwen3, Llama 4, and many more.
+NVIDIA NIM API provider extension for [pi coding agent](https://github.com/earendil-works/pi-mono) - access 100+ models from [build.nvidia.com](https://build.nvidia.com) including Inkling, MiniMax M3, DeepSeek V4 Flash/Pro, DeepSeek V3.2, Kimi K2.6, GLM-5, GLM-4.7, Qwen3, Llama 4, and many more.
 
 https://github.com/user-attachments/assets/f44773e4-9bf8-4bb5-a9c0-d5938030701c
 
@@ -74,35 +74,40 @@ NVIDIA NIM models use a non-standard `chat_template_kwargs` parameter to enable
 
 When you change the thinking level in pi (`Shift+Tab` to cycle), the extension:
 
-1. **Maps thinking levels** to values each NIM model accepts. For DeepSeek V4, `xhigh` maps to `max`; lower enabled levels use `high`.
+1. **Maps thinking levels** to values each NIM model accepts. MiniMax M3 uses its native `disabled`/`adaptive`/`enabled` modes; Inkling and DeepSeek V4 map extended levels to `max`.
 2. **Injects `chat_template_kwargs`** per model to actually enable thinking:
+   - Inkling: `{ reasoning_effort: "none" | "minimal" | "low" | "medium" | "high" | "max" }`
+   - MiniMax M3: `{ thinking_mode: "disabled" | "adaptive" | "enabled" }`
    - DeepSeek V4: `{ thinking: true, reasoning_effort: "high" | "max" }`
    - DeepSeek V3.x, R1 distills: `{ thinking: true }`
    - GLM-5, GLM-4.7: `{ enable_thinking: true, clear_thinking: false }`
    - Kimi K2.6, K2-thinking: `{ thinking: true }`
    - Qwen3, QwQ: `{ enable_thinking: true }`
-3. **Explicitly disables thinking** when the level is "off" for models that think by default (e.g., GLM-5, GLM-4.7).
+3. **Explicitly selects the lowest/off setting** when thinking is "off" for configurable models. MiniMax M3 uses `disabled`; Inkling uses `none` as a conditioning hint rather than a guarantee of zero reasoning tokens.
 4. **Uses `system` role** instead of `developer` for all NIM models - the `developer` role combined with `chat_template_kwargs` causes 500 errors on NIM.
 
 ### Supported thinking levels
 
 | pi Level | NIM Mapping | Effect |
 |----------|-------------|--------|
-| off | No kwargs (or explicit disable) | No reasoning output |
-| minimal | low, or high for DeepSeek V4 | Thinking enabled |
-| low | low, or high for DeepSeek V4 | Thinking enabled |
-| medium | medium, or high for DeepSeek V4 | Thinking enabled |
-| high | high | Thinking enabled |
-| xhigh | high, or max for DeepSeek V4 | Maximum supported thinking |
+| off | MiniMax M3 `disabled`; Inkling `none`; explicit disable elsewhere | No/lowest reasoning effort |
+| minimal | MiniMax M3 `adaptive`; Inkling `minimal`; low/high where required | Thinking enabled when useful |
+| low | MiniMax M3 `adaptive`; low, or high for DeepSeek V4 | Thinking enabled when useful |
+| medium | MiniMax M3 `adaptive`; medium, or high for DeepSeek V4 | Thinking enabled when useful |
+| high | MiniMax M3 `enabled`; high elsewhere | Thinking enabled |
+| xhigh | MiniMax M3 `enabled`; max for Inkling/DeepSeek V4 | Extended thinking |
+| max | MiniMax M3 `enabled`; max for Inkling/DeepSeek V4 | Maximum supported thinking |
 
 ## Available Models
 
-The extension ships with curated metadata for 42 featured models. At startup, it also queries the NVIDIA NIM API to discover additional models automatically.
+The extension ships with curated metadata for 44 featured models. At startup, it also queries the NVIDIA NIM API to discover additional models automatically.
 
 ### Featured Models
 
 | Model | Reasoning | Vision | Context |
 |-------|-----------|--------|---------|
+| `thinkingmachines/inkling` | ✅ | ✅ | 1M |
+| `minimaxai/minimax-m3` | ✅ | ✅ | 1M |
 | `deepseek-ai/deepseek-v4-flash` | ✅ | | 1M |
 | `deepseek-ai/deepseek-v4-pro` | ✅ | | 1M |
 | `deepseek-ai/deepseek-v3.2` | ✅ | | 128K |
@@ -138,7 +143,7 @@ This extension uses `pi.registerProvider()` to register NVIDIA NIM as a custom p
 The custom streamer:
 1. Intercepts the request payload via `onPayload` callback
 2. Injects `chat_template_kwargs` for models that need it to enable thinking
-3. Maps unsupported thinking levels to NIM-compatible values (`minimal` → `low`; `xhigh` → `high` or DeepSeek V4 `max`)
+3. Maps unsupported thinking levels to NIM-compatible values while preserving MiniMax M3's native modes and Inkling's native effort presets
 4. Suppresses `reasoning_effort` for models that don't respond to it (e.g., DeepSeek without kwargs)
 5. Uses the standard OpenAI SSE streaming format - pi already parses `reasoning_content` and `reasoning` fields from streaming deltas
 
@@ -153,7 +158,7 @@ The only configuration needed is either the `NVIDIA_NIM_API_KEY` or `NVIDIA_API_
 - If a model isn't in the curated list, it gets a conservative 32K context window and 8K max output tokens
 - The extension filters out embedding, reward, safety, and other non-chat models automatically
 - Rate limits on free preview keys are relatively strict; you may encounter 429 errors during heavy usage
-- MiniMax models use `<think>` tags inline in content rather than the `reasoning_content` field
+- MiniMax M3 streams thinking through `reasoning_content`; older MiniMax models may use `<think>` tags inline in content
 
 ## License
 

package/index.ts

@@ -34,17 +34,16 @@
  * thinking settings.
  */
 
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 import type {
 	Api,
 	AssistantMessageEventStream,
 	Context,
 	Model,
 	SimpleStreamOptions,
+	ThinkingLevelMap,
 } from "@earendil-works/pi-ai";
-import { streamSimpleOpenAICompletions } from "@earendil-works/pi-ai";
-import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { streamSimpleOpenAICompletions } from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 // =============================================================================
 // Constants
@@ -55,6 +54,8 @@ const NVIDIA_NIM_API_KEY_ENV = "NVIDIA_NIM_API_KEY";
 const NVIDIA_API_KEY_ENV = "NVIDIA_API_KEY";
 const NVIDIA_API_KEY_ENV_NAMES = [NVIDIA_NIM_API_KEY_ENV, NVIDIA_API_KEY_ENV] as const;
 const PROVIDER_NAME = "nvidia-nim";
+const INKLING_MODEL_ID = "thinkingmachines/inkling";
+const MINIMAX_M3_MODEL_ID = "minimaxai/minimax-m3";
 
 // =============================================================================
 // Per-model thinking configuration
@@ -185,7 +186,11 @@ const THINKING_CONFIGS: Record<string, ThinkingConfig> = {
 // Reasoning models and their capabilities
 // =============================================================================
 
-const REASONING_MODELS = new Set(Object.keys(THINKING_CONFIGS));
+const REASONING_MODELS = new Set([
+	...Object.keys(THINKING_CONFIGS),
+	INKLING_MODEL_ID,
+	MINIMAX_M3_MODEL_ID,
+]);
 
 // Models known to support image/vision input
 const VISION_MODELS = new Set([
@@ -197,6 +202,8 @@ const VISION_MODELS = new Set([
 	"nvidia/llama-3.1-nemotron-nano-vl-8b-v1",
 	"nvidia/nemotron-nano-12b-v2-vl",
 	"nvidia/cosmos-reason2-8b",
+	INKLING_MODEL_ID,
+	MINIMAX_M3_MODEL_ID,
 ]);
 
 // Embedding / non-chat models to skip
@@ -269,6 +276,7 @@ const CONTEXT_WINDOWS: Record<string, number> = {
 	"minimaxai/minimax-m2": 1048576,
 	"minimaxai/minimax-m2.1": 1048576,
 	"minimaxai/minimax-m2.7": 204800,
+	[MINIMAX_M3_MODEL_ID]: 1_048_576,
 	// Meta Llama
 	"meta/llama-3.1-405b-instruct": 131072,
 	"meta/llama-3.1-70b-instruct": 131072,
@@ -339,6 +347,8 @@ const CONTEXT_WINDOWS: Record<string, number> = {
 	"nvidia/llama-3.3-nemotron-super-49b-v1.5": 131072,
 	"nvidia/nemotron-4-340b-instruct": 4096,
 	"nvidia/nvidia-nemotron-nano-9b-v2": 131072,
+	// Thinking Machines
+	[INKLING_MODEL_ID]: 1_048_576,
 	// OpenAI open-source
 	"openai/gpt-oss-120b": 131072,
 	"openai/gpt-oss-20b": 131072,
@@ -396,6 +406,7 @@ const MAX_TOKENS: Record<string, number> = {
 	"minimaxai/minimax-m2": 8192,
 	"minimaxai/minimax-m2.1": 8192,
 	"minimaxai/minimax-m2.7": 8192,
+	[MINIMAX_M3_MODEL_ID]: 16_384,
 	"meta/llama-4-maverick-17b-128e-instruct": 16384,
 	"meta/llama-4-scout-17b-16e-instruct": 16384,
 	"z-ai/glm4.7": 16384,
@@ -406,6 +417,7 @@ const MAX_TOKENS: Record<string, number> = {
 	"openai/gpt-oss-20b": 16384,
 	"mistralai/mistral-large-3-675b-instruct-2512": 16384,
 	"mistralai/devstral-2-123b-instruct-2512": 32768,
+	[INKLING_MODEL_ID]: 16_384,
 };
 
 // =============================================================================
@@ -423,6 +435,7 @@ const FEATURED_MODELS = [
 	"moonshotai/kimi-k2-thinking",
 	"moonshotai/kimi-k2-instruct",
 	"moonshotai/kimi-k2-instruct-0905",
+	MINIMAX_M3_MODEL_ID,
 	"minimaxai/minimax-m2.1",
 	"minimaxai/minimax-m2",
 	"minimaxai/minimax-m2.7",
@@ -432,6 +445,7 @@ const FEATURED_MODELS = [
 	"openai/gpt-oss-20b",
 	"stepfun-ai/step-3.5-flash",
 	"bytedance/seed-oss-36b-instruct",
+	INKLING_MODEL_ID,
 	// Qwen
 	"qwen/qwen3-coder-480b-a35b-instruct",
 	"qwen/qwen3-235b-a22b",
@@ -479,14 +493,6 @@ const FEATURED_MODELS = [
  * 4. Uses onPayload callback to mutate request params before they're sent
  */
 type NimApiKeyEnvName = (typeof NVIDIA_API_KEY_ENV_NAMES)[number];
-type AuthStorageLike = {
-	get?: (provider: string) => unknown;
-};
-
-interface NimApiKeyCredential {
-	type: "api_key";
-	key: string;
-}
 
 function getNimApiKeyEnv(): NimApiKeyEnvName | undefined {
 	return NVIDIA_API_KEY_ENV_NAMES.find((envName) => !!process.env[envName]);
@@ -498,59 +504,27 @@ function getNimApiKey(): string | undefined {
 	return apiKey?.trim() || undefined;
 }
 
-function isNimApiKeyEnvName(value: string): value is NimApiKeyEnvName {
-	return NVIDIA_API_KEY_ENV_NAMES.includes(value as NimApiKeyEnvName);
-}
-
-function isNimApiKeyEnvValue(value: string): boolean {
-	return NVIDIA_API_KEY_ENV_NAMES.some((envName) => process.env[envName]?.trim() === value);
+function getNimProviderApiKeyConfig(): string {
+	return `$${getNimApiKeyEnv() ?? NVIDIA_NIM_API_KEY_ENV}`;
 }
 
-function isNimApiKeyCredential(credential: unknown): credential is NimApiKeyCredential {
-	return (
-		typeof credential === "object" &&
-		credential !== null &&
-		(credential as { type?: unknown }).type === "api_key" &&
-		typeof (credential as { key?: unknown }).key === "string"
-	);
-}
-
-function readStoredNimApiKeyConfig(): string | undefined {
-	try {
-		const authPath = join(getAgentDir(), "auth.json");
-		if (!existsSync(authPath)) return undefined;
-
-		const data = JSON.parse(readFileSync(authPath, "utf-8")) as Record<string, unknown>;
-		const credential = data[PROVIDER_NAME];
-		return isNimApiKeyCredential(credential) ? credential.key : undefined;
-	} catch {
-		return undefined;
-	}
+function isNimApiKeyEnvName(value: string): value is NimApiKeyEnvName {
+	return NVIDIA_API_KEY_ENV_NAMES.includes(value as NimApiKeyEnvName);
 }
 
-function getStoredNimApiKeyConfig(authStorage?: AuthStorageLike): string | undefined {
-	if (authStorage) {
-		try {
-			const credential = authStorage.get?.(PROVIDER_NAME);
-			return isNimApiKeyCredential(credential) ? credential.key : undefined;
-		} catch {
-			return undefined;
-		}
-	}
-
-	return readStoredNimApiKeyConfig();
+function isNimApiKeyEnvReference(value: string): boolean {
+	return value.startsWith("$") && isNimApiKeyEnvName(value.slice(1));
 }
 
-function hasStoredNimCommandCredential(authStorage?: AuthStorageLike): boolean {
-	return getStoredNimApiKeyConfig(authStorage)?.startsWith("!") ?? false;
+function isNimApiKeyEnvPlaceholder(value: string): boolean {
+	return isNimApiKeyEnvName(value) || isNimApiKeyEnvReference(value);
 }
 
-function getStoredResolvedNimApiKey(authStorage?: AuthStorageLike): string | undefined {
-	const configuredApiKey = getStoredNimApiKeyConfig(authStorage)?.trim();
-	if (!configuredApiKey || configuredApiKey.startsWith("!")) return undefined;
+function resolveNimApiKeyEnvReference(value: string): string | undefined {
+	if (!isNimApiKeyEnvReference(value)) return undefined;
 
-	const envValue = process.env[configuredApiKey]?.trim();
-	return envValue || configuredApiKey;
+	const envValue = process.env[value.slice(1)]?.trim();
+	return envValue || undefined;
 }
 
 function normalizeResolvedNimApiKey(apiKey: string | undefined): string | undefined {
@@ -564,21 +538,19 @@ function normalizeResolvedNimApiKey(apiKey: string | undefined): string | undefi
 	return trimmed;
 }
 
-function resolveNimApiKey(apiKey: string | undefined, authStorage?: AuthStorageLike): string | undefined {
+function resolveNimApiKey(apiKey: string | undefined): string | undefined {
 	const resolvedApiKey = normalizeResolvedNimApiKey(apiKey);
-	const hasStoredCommandCredential = hasStoredNimCommandCredential(authStorage);
 
-	if (
-		hasStoredCommandCredential &&
-		(!resolvedApiKey || isNimApiKeyEnvName(resolvedApiKey) || isNimApiKeyEnvValue(resolvedApiKey))
-	) {
-		throw new Error("NVIDIA NIM API key command resolved to an empty value.");
-	}
+	if (resolvedApiKey) {
+		const envReferenceApiKey = resolveNimApiKeyEnvReference(resolvedApiKey);
+		if (envReferenceApiKey) return envReferenceApiKey;
 
-	const storedApiKey = getStoredResolvedNimApiKey(authStorage);
-	if (storedApiKey && (!resolvedApiKey || isNimApiKeyEnvName(resolvedApiKey))) return storedApiKey;
+		if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(resolvedApiKey) && Object.hasOwn(process.env, resolvedApiKey)) {
+			return normalizeResolvedNimApiKey(process.env[resolvedApiKey]);
+		}
 
-	if (resolvedApiKey && !isNimApiKeyEnvName(resolvedApiKey)) return resolvedApiKey;
+		if (!isNimApiKeyEnvPlaceholder(resolvedApiKey)) return resolvedApiKey;
+	}
 
 	return getNimApiKey();
 }
@@ -615,6 +587,20 @@ function buildThinkingKwargs(
 	return kwargs;
 }
 
+function buildNimRequestHeaders(headers: SimpleStreamOptions["headers"], apiKey: string): Record<string, string> {
+	const resolvedHeaders: Record<string, string> = {};
+
+	for (const [key, value] of Object.entries(headers ?? {})) {
+		if (key.toLowerCase() === "authorization" || value === null) continue;
+		resolvedHeaders[key] = value;
+	}
+
+	return {
+		...resolvedHeaders,
+		Authorization: `Bearer ${apiKey}`,
+	};
+}
+
 function nimStreamSimple(
 	model: Model<Api>,
 	context: Context,
@@ -632,9 +618,9 @@ function nimStreamSimple(
 	const reasoning = options?.reasoning;
 	const isThinkingEnabled = !!reasoning;
 
-	// Map provider-agnostic pi levels to NIM's accepted top-level values.
-	// Model-specific chat_template_kwargs may apply a different mapping below.
-	const mappedReasoning = mapNimTopLevelReasoning(reasoning);
+	// Custom NIM thinking configs use the provider-wide effort mapping. Models that
+	// declare native chat-template compatibility keep their own named levels.
+	const mappedReasoning = thinkingConfig ? mapNimTopLevelReasoning(reasoning) : reasoning;
 
 	// For models that have a thinking config: we handle thinking via chat_template_kwargs.
 	// Suppress reasoning_effort (set reasoning to undefined) unless the model explicitly
@@ -654,6 +640,7 @@ function nimStreamSimple(
 		...options,
 		reasoning: effectiveReasoning,
 		apiKey: nimApiKey,
+		headers: buildNimRequestHeaders(options?.headers, nimApiKey),
 		onPayload: (params: unknown) => {
 			const p = params as Record<string, unknown>;
 
@@ -705,6 +692,7 @@ interface NimModelEntry {
 	id: string;
 	name: string;
 	reasoning: boolean;
+	thinkingLevelMap?: ThinkingLevelMap;
 	input: ("text" | "image")[];
 	contextWindow: number;
 	maxTokens: number;
@@ -750,6 +738,35 @@ function buildModelEntry(modelId: string): NimModelEntry | null {
 		maxTokensField: "max_tokens",
 	};
 
+	// Inkling conditions reasoning through its chat template rather than a top-level
+	// reasoning_effort field. NVIDIA NIM accepts the same named effort presets as
+	// Inkling's tokenizer; map pi's extended levels to Inkling's 0.99 preset.
+	if (modelId === INKLING_MODEL_ID) {
+		entry.thinkingLevelMap = { off: "none", xhigh: "max", max: "max" };
+		entry.compat.thinkingFormat = "chat-template";
+		entry.compat.chatTemplateKwargs = {
+			reasoning_effort: { $var: "thinking.effort" },
+		};
+	}
+
+	// MiniMax M3 exposes discrete disabled/adaptive/enabled reasoning modes through
+	// chat_template_kwargs.thinking_mode. Map pi's effort scale to the closest mode.
+	if (modelId === MINIMAX_M3_MODEL_ID) {
+		entry.thinkingLevelMap = {
+			off: "disabled",
+			minimal: "adaptive",
+			low: "adaptive",
+			medium: "adaptive",
+			high: "enabled",
+			xhigh: "enabled",
+			max: "enabled",
+		};
+		entry.compat.thinkingFormat = "chat-template";
+		entry.compat.chatTemplateKwargs = {
+			thinking_mode: { $var: "thinking.effort" },
+		};
+	}
+
 	// Mistral models on NIM need extra compat flags
 	if (modelId.startsWith("mistralai/")) {
 		entry.compat.requiresToolResultName = true;
@@ -781,14 +798,17 @@ function sanitizeNimLogMessage(message: string): string {
 	return message.replace(/nvapi-[A-Za-z0-9._-]+/g, "nvapi-[REDACTED]");
 }
 
-function notifyNimDiscoveryCredentialWarning(ctx: any): void {
-	ctx?.ui?.notify?.(NIM_DISCOVERY_CREDENTIAL_WARNING, "warning");
+function notifyNimDiscoveryCredentialWarning(ctx: ExtensionContext): void {
+	ctx.ui.notify(NIM_DISCOVERY_CREDENTIAL_WARNING, "warning");
 }
 
-async function resolveNimDiscoveryApiKey(ctx: any): Promise<string | undefined> {
+async function resolveNimDiscoveryApiKey(ctx: ExtensionContext): Promise<string | undefined> {
 	try {
-		const apiKey = await ctx?.modelRegistry?.getApiKeyForProvider?.(PROVIDER_NAME);
-		return resolveNimApiKey(apiKey, ctx?.modelRegistry?.authStorage);
+		const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_NAME);
+		if (apiKey === undefined && ctx.modelRegistry.getProviderAuthStatus(PROVIDER_NAME).configured) {
+			throw new Error("NVIDIA NIM configured credential resolved to an empty value.");
+		}
+		return resolveNimApiKey(apiKey);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		console.warn(`pi-nvidia-nim: ${sanitizeNimLogMessage(message)}`);
@@ -834,7 +854,7 @@ async function fetchNimModels(apiKey: string): Promise<NimModelFetchResult> {
 // =============================================================================
 
 export default function (pi: ExtensionAPI) {
-	const providerApiKeyConfig = getNimApiKeyEnv() ?? NVIDIA_NIM_API_KEY_ENV;
+	const providerApiKeyConfig = getNimProviderApiKeyConfig();
 
 	// Always register the curated model list. The request path resolves credentials
 	// through pi first (CLI override, auth.json, shell command), then falls back to
@@ -863,7 +883,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// On session start, discover additional models from the API
-	pi.on("session_start", async (_event: any, ctx: any) => {
+	pi.on("session_start", async (_event, ctx) => {
 		const apiKey = await resolveNimDiscoveryApiKey(ctx);
 		if (!apiKey) return;
 
@@ -889,15 +909,12 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
-		// Re-register with full model list if we found new ones.
-		// NOTE: must use ctx.modelRegistry.registerProvider() here, not pi.registerProvider().
-		// pi.registerProvider() only queues registrations for the initial extension load.
-		// From event handlers/commands, we need to call the registry directly.
+		// Runtime provider registrations now apply immediately through the extension API.
 		if (newModelsAdded > 0) {
 			const allModels = Array.from(modelMap.values());
-			ctx.modelRegistry.registerProvider(PROVIDER_NAME, {
+			pi.registerProvider(PROVIDER_NAME, {
 				baseUrl: NVIDIA_NIM_BASE_URL,
-				apiKey: getNimApiKeyEnv() ?? NVIDIA_NIM_API_KEY_ENV,
+				apiKey: getNimProviderApiKeyConfig(),
 				api: "openai-completions",
 				authHeader: true,
 				models: allModels,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-nvidia-nim",
-  "version": "1.1.21",
+  "version": "1.1.23",
   "description": "NVIDIA NIM API provider extension for pi coding agent — access 100+ models from build.nvidia.com",
   "type": "module",
   "files": [
@@ -23,9 +23,14 @@
     "test": "node --test test/*.test.mjs"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.74.0",
-    "@earendil-works/pi-coding-agent": "^0.74.0",
-    "@types/node": "^22.0.0"
+    "@earendil-works/pi-ai": "^0.80.10",
+    "@earendil-works/pi-coding-agent": "^0.80.10",
+    "@types/node": "^24.0.0",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
   },
   "repository": {
     "type": "git",