pi-hypercharm-provider 1.1.4 → 1.1.5

package/README.md

@@ -15,40 +15,41 @@ _Hyperoptimized coding models — DeepSeek, GLM, Kimi, Qwen, MiniMax, Gemma, GPT
 
 ## Features
 
-- **23+ AI Models** including DeepSeek V4 Flash/Pro, GLM 5/5.1, Kimi K2.5/K2.6, Qwen3.6/3.7, MiniMax M2.7, Gemma 4, GPT-OSS, and Llama
-- **DeepSeek Native Thinking** — Uses the `deepseek` thinking format with `reasoning_effort` and 384K max output for DeepSeek V4 models
+- **24+ AI Models** including DeepSeek V4 Flash/Pro, GLM 5/5.1, Kimi K2.5/K2.6, Qwen3.6/3.7, MiniMax M2.7, Gemma 4, GPT-OSS, and Llama
+- **DeepSeek Native Thinking** — Uses the `deepseek` thinking format for Charm Hyper requests, with native `reasoning_effort` on models that publish levels
 - **OpenAI-compatible API** via Charm Hyper's `/v1/chat/completions` endpoint
-- **Cost Tracking** with per-model pricing from the API
-- **Reasoning Models** with `reasoning_effort` parameter support on select models
-- **Vision Support** for image-capable models (Kimi K2.5/K2.6, GLM 5.1, Qwen3.6/3.7, Gemma 4)
+- **Official Catalog Sync** from Charm's typed `/v1/provider` endpoint, matching `@charmland/pi-hyper-provider`
+- **Reasoning Models** with provider-published on/off states and exact effort levels
+- **Attachment Support** for models the official catalog marks as attachment-capable
 
 ## Available Models
 
 | Model | Type | Context | Max Tokens | Input Cost | Output Cost |
 |-------|------|---------|------------|------------|-------------|
 | DeepSeek V4 Flash | Text | 1.0M | 384K | $0.20 | $0.40 |
+| DeepSeek V4 Flash 0731 | Text | 1.0M | 384K | $0.15 | $0.30 |
 | DeepSeek V4 Pro | Text | 1.0M | 384K | $2.40 | $4.80 |
-| Gemma 4 26B A4B | Text + Image | 256K | 26K | $0.12 | $0.41 |
-| GLM 5.1 | Text + Image | 203K | 131K | $1.40 | $4.40 |
-| GLM-5 | Text | 203K | 20K | $0.81 | $2.59 |
+| Gemma 4 26B A4B | Text | 256K | 26K | $0.13 | $0.43 |
+| GLM-5 | Text | 203K | 20K | $0.85 | $2.62 |
+| GLM-5.1 | Text | 203K | 131K | $1.52 | $4.79 |
 | GLM-5.2 | Text | 1.0M | 128K | $1.40 | $4.40 |
-| GPT-OSS 120B | Text | 131K | 13K | $0.17 | $0.56 |
-| Kimi K2.5 | Text + Image | 262K | 26K | $0.52 | $2.72 |
+| gpt-oss-120b | Text | 131K | 13K | $0.19 | $0.70 |
+| Kimi K2.5 | Text | 262K | 26K | $0.56 | $2.82 |
 | Kimi K2.6 | Text + Image | 262K | 262K | $0.95 | $4.00 |
-| Kimi K2.7 Code | Text | 256K | 16K | $0.95 | $4.00 |
-| Kimi K3 | Text | 1.0M | 131K | Free | Free |
-| Llama 3.3 70B Instruct | Text | 128K | 13K | $0.61 | $1.04 |
-| Llama 4 Maverick 17B 128E FP8 | Text | 430K | 43K | $0.28 | $0.93 |
-| MiniMax M2.7 | Text | 205K | 20K | $0.42 | $1.56 |
-| MiniMax M3 | Text | 512K | 512K | Free | Free |
-| Qwen3 Coder 480B A35B INT4 | Text | 106K | 11K | $0.60 | $2.08 |
-| Qwen3 Next 80B A3B | Text | 262K | 26K | $0.12 | $1.14 |
+| Kimi K2.7 Code | Text + Image | 256K | 16K | $0.95 | $4.00 |
+| Kimi K3 | Text + Image | 1.0M | 131K | $3.27 | $16.33 |
+| Llama 3.3 70B Instruct | Text | 128K | 13K | $0.51 | $1.04 |
+| Llama 4 Maverick 17B 128E Instruct FP8 | Text | 430K | 43K | $0.28 | $0.93 |
+| MiniMax M2.7 | Text | 205K | 20K | $0.44 | $1.72 |
+| MiniMax M3 | Text + Image | 512K | 512K | $0.33 | $1.31 |
+| Qwen3 Coder 480B A35B Instruct INT4 Mixed AR | Text | 106K | 11K | $0.57 | $2.13 |
+| Qwen3 Next 80B A3B Instruct | Text | 262K | 26K | $0.12 | $1.14 |
 | Qwen3.6-Flash | Text + Image | 1.0M | 64K | $1.00 | $4.00 |
-| Qwen3.6-Max | Text + Image | 256K | 64K | $2.00 | $12.00 |
+| Qwen3.6-Max | Text | 256K | 64K | $2.00 | $12.00 |
 | Qwen3.6-Plus | Text + Image | 1.0M | 64K | $2.00 | $6.00 |
-| Qwen3.7-Flash | Text | 1.0M | 64K | Free | Free |
-| Qwen3.7-Max | Text + Image | 1.0M | 64K | $2.50 | $7.50 |
-| Qwen3.7-Plus | Text | 1.0M | 64K | $1.20 | $4.80 |
+| Qwen3.7-Flash | Text + Image | 1.0M | 64K | $0.20 | $0.80 |
+| Qwen3.7-Max | Text | 1.0M | 64K | $2.50 | $7.50 |
+| Qwen3.7-Plus | Text + Image | 1.0M | 64K | $1.20 | $4.80 |
 *Costs are per million tokens. Prices subject to change — check [hyper.charm.land](https://hyper.charm.land) for current pricing.*
 
 ## Installation
@@ -118,7 +119,7 @@ For reasoning models that support `reasoning_effort`, control thinking depth:
 pi --provider hypercharm --model deepseek-v4-pro --reasoning-effort max
 ```
 
-Values: `none`, `low`, `medium`, `high`, `max`
+Supported levels are model-specific and come from Charm's `/v1/provider` catalog (for example `low`/`medium`/`high` on Kimi K2.6). Models with no published levels support the Hyper thinking on state through Pi's `max` level.
 
 ### Thinking Mode
 
@@ -156,37 +157,21 @@ Add to your pi configuration for automatic loading:
 }
 ```
 
-### Compat Settings
+### Catalog and Compat Settings
 
-Charm Hyper uses an OpenAI-compatible API. Compatibility settings are managed via `patch.json`:
+Model metadata matches Charm's official [`@charmland/pi-hyper-provider`](https://github.com/charmbracelet/pi-hyper-provider) transform:
 
-**DeepSeek models** use the `deepseek` thinking format (identical to the native DeepSeek API):
+- canonical `/v1/provider` names, prices, context windows, output caps, attachment flags, and `can_reason`
+- `thinkingFormat: "deepseek"`, which maps Pi thinking levels onto Hyper's `thinking` envelope
+- `reasoning_effort` only when the catalog publishes concrete level names
+- `maxTokensField: "max_tokens"` and `supportsStore: false`
+- zero `cacheWrite`, because Hyper reports discounted cached-output pricing, not cache-write cost
 
-- **`thinkingFormat: "deepseek"`** — Sends `thinking: {type: "enabled/disabled"}` to toggle thinking mode
-- **`supportsReasoningEffort: true`** — Supports `reasoning_effort: "high" | "max"` via `thinkingLevelMap`
-- **`requiresReasoningContentOnAssistantMessages: true`** — Replayed assistant messages include empty `reasoning_content` when reasoning is enabled
-- **`maxTokensField: "max_tokens"`** — Uses `max_tokens` (not `max_completion_tokens`)
-
-**Other reasoning models** (GLM, Kimi, Qwen, MiniMax, Gemma, GPT-OSS) use the `openai` thinking format:
-
-- **`thinkingFormat: "openai"`** — Returns `reasoning_content` in OpenAI format
-- **`supportsReasoningEffort: true`** — Accepts `reasoning_effort` parameter on supported models
-- **`maxTokensField: "max_tokens"`** — Uses `max_tokens` (not `max_completion_tokens`)
-- **`supportsDeveloperRole: true`** — Developer role messages are accepted
-- **`supportsStore: false`** — The `store` parameter is not supported
-
-> **Note:** The HyperCharm `/v1/models` endpoint reports `supports_reasoning: true` for all models,
-> including those that don't natively support extended thinking (e.g., Llama 3.3 70B). `models.json`
-> curates reasoning flags based on known model capabilities; `patch.json` adds compat overrides.
+`patch.json` is reserved only for a verified provider regression and is currently empty.
 
 ### Patch Overrides
 
-The `patch.json` file contains overrides applied on top of `models.json` data:
-
-- Correcting API-derived values (e.g., DeepSeek `maxTokens` from 8000 to 384000)
-- Adding compat settings that the API doesn't provide
-- Setting `thinkingFormat: "deepseek"` + `thinkingLevelMap` for DeepSeek V4 models
-- Overriding pricing when official rates change
+`patch.json` is applied on top of `models.json` only for verified endpoint corrections. It is currently empty because every live field comes from Charm's canonical provider catalog.
 
 ## Updating Models
 
@@ -199,10 +184,11 @@ node scripts/update-models.js
 
 This will:
 1. Fetch models from `https://hyper.charm.land/v1/models`
-2. Preserve curated data (reasoning, vision, DeepSeek compat) from existing `models.json`
-3. Apply overrides from `patch.json`
+2. Regenerate `models.json` as pure metadata from Charm's typed `/v1/provider` catalog
+3. Apply overrides from `patch.json` only when building the README
 4. Remove custom models now available upstream from `custom-models.json`
-5. Update `models.json` and the README model table
+5. Reconcile delisted models through the 14-day `deprecated-models.json` grace layer
+6. Update `models.json` and the README model table
 
 A GitHub Actions workflow runs this daily and creates a PR if models have changed.
 

package/index.ts

@@ -4,13 +4,11 @@
  * Registers HyperCharm (hyper.charm.land) as a custom provider using the
  * openai-completions API. Base URL: https://hyper.charm.land/v1
  *
- * HyperCharm provides hyperoptimized coding models via an OpenAI-compatible API.
- * The /v1/models endpoint returns structured metadata including reasoning flags,
- * pricing, context windows, and max output tokens.
- *
- * Note: The API's `supports_reasoning` flag is unreliable for some models (e.g.,
- * it reports true for Llama 3.3 70B which doesn't support extended thinking).
- * The models.json embeds curated reasoning flags; patch.json corrects compat.
+ * Model metadata comes from Charm's typed official-catalog endpoint,
+ * /v1/provider, matching @charmland/pi-hyper-provider. It provides canonical
+ * names, pricing, context and output limits, reasoning levels, and attachment
+ * support. patch.json remains available for verified endpoint regressions, but
+ * currently contains no overrides.
  *
  * Model resolution strategy: Stale-While-Revalidate
  *   1. Serve stale immediately: disk cache → embedded models.json (zero-latency)
@@ -114,6 +112,9 @@ function applyPatch(model: JsonModel, patch: PatchEntry): JsonModel {
   if (!result.reasoning && result.compat?.thinkingFormat) {
     delete result.compat.thinkingFormat;
   }
+  if (!result.reasoning && result.thinkingLevelMap) {
+    delete result.thinkingLevelMap;
+  }
   if (result.compat && Object.keys(result.compat).length === 0) {
     delete result.compat;
   }
@@ -153,81 +154,76 @@ function buildModels(base: JsonModel[], custom: JsonModel[], patch: PatchData):
     }
   }
 
-  const result = Array.from(modelMap.values());
-
-  // Ensure DeepSeek reasoning models have required compat settings.
-  // Live-fetched models from the SWR pipeline may not have these set.
-  for (const model of result) {
-    if (!model.reasoning) continue;
-    if (isDeepSeekModel(model.id)) {
-      if (!model.compat) {
-        model.compat = {
-          thinkingFormat: "deepseek",
-          maxTokensField: "max_tokens",
-          supportsDeveloperRole: true,
-          supportsStore: false,
-          supportsReasoningEffort: true,
-          requiresReasoningContentOnAssistantMessages: true,
-        };
-      } else {
-        if (model.compat.thinkingFormat === undefined) {
-          model.compat.thinkingFormat = "deepseek";
-        }
-        if (model.compat.supportsReasoningEffort === undefined) {
-          model.compat.supportsReasoningEffort = true;
-        }
-        if ((model.compat as any).requiresReasoningContentOnAssistantMessages === undefined) {
-          (model.compat as any).requiresReasoningContentOnAssistantMessages = true;
-        }
-      }
-      if (!model.thinkingLevelMap) {
-        model.thinkingLevelMap = {
-          minimal: null, low: null, medium: null, high: "high", max: "max",
-        };
-      }
-    }
-  }
-
-  return result;
-}
-
-function isDeepSeekModel(id: string): boolean {
-  return /^deepseek-v/.test(id);
+  return Array.from(modelMap.values());
 }
 
 // ─── Stale-While-Revalidate Model Sync ────────────────────────────────────────
 
 const PROVIDER_ID = "hypercharm";
 const BASE_URL = "https://hyper.charm.land/v1";
-const MODELS_URL = `${BASE_URL}/models`;
+const MODELS_URL = `${BASE_URL}/provider`;
 const CACHE_DIR = path.join(getAgentDir(), "cache");
 const CACHE_PATH = path.join(CACHE_DIR, `${PROVIDER_ID}-models.json`);
 const LIVE_FETCH_TIMEOUT_MS = 8000;
 
-/** Transform a model from the HyperCharm /v1/models API to JsonModel format. */
-function transformApiModel(apiModel: any): JsonModel | null {
-  if (!apiModel.id) return null;
-
-  const cost = apiModel.cost?.usd || {};
-  const toPerM = (v: any) => {
-    const n = typeof v === "string" ? parseFloat(v) : (v || 0);
-    // API returns $/M directly; round to 6 decimals to preserve sub-cent cache prices.
-    return Math.round(n * 1e6) / 1e6;
+const PI_THINKING_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+const ON_OFF_THINKING_LEVEL_MAP: Record<string, string | null> = {
+  off: "off",
+  minimal: null,
+  low: null,
+  medium: null,
+  high: null,
+  xhigh: null,
+  max: "max",
+};
+
+function buildThinkingLevelMap(levels: string[]): Record<string, string | null> | undefined {
+  if (levels.length === 0) return undefined;
+  const available = new Set(levels);
+  const result: Record<string, string | null> = {
+    off: available.has("off") ? "off" : available.has("none") ? "none" : null,
   };
+  for (const level of PI_THINKING_LEVELS) {
+    result[level] = available.has(level) ? level : null;
+  }
+  return result;
+}
+
+/** Transform a model from Charm's official typed Hyper /v1/provider catalog. */
+function transformApiModel(apiModel: any): JsonModel | null {
+  if (typeof apiModel.id !== "string" || apiModel.id.length === 0) return null;
+
+  const reasoningLevels = Array.isArray(apiModel.reasoning_levels)
+    ? apiModel.reasoning_levels.filter((level: any) => typeof level === "string")
+    : [];
+  const supportsReasoningEffort = reasoningLevels.length > 0;
+  const thinkingLevelMap = supportsReasoningEffort
+    ? buildThinkingLevelMap(reasoningLevels)
+    : apiModel.can_reason === true
+      ? ON_OFF_THINKING_LEVEL_MAP
+      : undefined;
 
   return {
     id: apiModel.id,
-    name: apiModel.display_name || apiModel.id,
-    reasoning: false, // API supports_reasoning is unreliable; patch.json corrects
-    input: ["text"],
+    name: apiModel.name || apiModel.id,
+    reasoning: apiModel.can_reason === true,
+    thinkingLevelMap,
+    input: apiModel.supports_attachments === true ? ["text", "image"] : ["text"],
     cost: {
-      input: toPerM(cost["1m_in"]),
-      output: toPerM(cost["1m_out"]),
-      cacheRead: toPerM(cost["1m_in_cache"]),
-      cacheWrite: toPerM(cost["1m_out_cache"]),
+      input: apiModel.cost_per_1m_in || 0,
+      output: apiModel.cost_per_1m_out || 0,
+      cacheRead: apiModel.cost_per_1m_in_cached || 0,
+      cacheWrite: 0,
     },
     contextWindow: apiModel.context_window || 0,
-    maxTokens: apiModel.max_output_tokens || 0,
+    maxTokens: apiModel.default_max_tokens || apiModel.context_window || 0,
+    compat: {
+      supportsStore: false,
+      supportsReasoningEffort,
+      thinkingFormat: "deepseek",
+      maxTokensField: "max_tokens",
+    },
   };
 }
 
@@ -239,7 +235,7 @@ async function fetchLiveModels(apiKey: string, signal?: AbortSignal): Promise<Js
     });
     if (!response.ok) return null;
     const data = await response.json();
-    const apiModels = Array.isArray(data) ? data : (data.data || []);
+    const apiModels = Array.isArray(data) ? data : (data.models || data.data || []);
     if (!Array.isArray(apiModels) || apiModels.length === 0) return null;
     return apiModels.map(transformApiModel).filter((m): m is JsonModel => m !== null);
   } catch {
@@ -273,20 +269,13 @@ function mergeWithEmbedded(liveModels: JsonModel[], embeddedModels: JsonModel[])
     const embedded = embeddedMap.get(liveModel.id);
     seen.add(liveModel.id);
     if (embedded) {
-      // Self-heal: live API pricing is authoritative field-by-field. Prefer the
-      // live cost when the API reports it (non-zero); fall back to embedded when
-      // the API is silent (0) so curated cacheRead/cacheWrite isn't clobbered and
-      // providers whose /models endpoint exposes no pricing keep their curated
-      // cost. Curation (reasoning/input/compat/name) still wins via ...embedded.
+      // The official /v1/provider catalog is authoritative for pricing, including
+      // legitimately zero-priced preview models. Curation (reasoning/input/compat/name)
+      // still wins via ...embedded.
       result.push({
         ...liveModel,
         ...embedded,
-        cost: {
-          input: liveModel.cost.input || embedded.cost.input,
-          output: liveModel.cost.output || embedded.cost.output,
-          cacheRead: liveModel.cost.cacheRead || embedded.cost.cacheRead,
-          cacheWrite: liveModel.cost.cacheWrite || embedded.cost.cacheWrite,
-        },
+        cost: liveModel.cost,
         contextWindow: liveModel.contextWindow || embedded.contextWindow,
       });
     } else {