pi-wafer-provider 1.1.7 → 1.1.8

package/.github/FUNDING.yml

@@ -0,0 +1,4 @@
+github: monotykamary
+ko_fi: monotykamary
+buy_me_a_coffee: monotykamary
+polar: monotykamary

package/.pi/autoresearch/session-id

@@ -0,0 +1 @@
+019da9d5-6cb9-764d-a39e-ce1dbd18a3b2

package/.pi/messenger/channels/memory.jsonl

@@ -0,0 +1 @@
+{"_meta":true,"v":1,"id":"memory","type":"named","createdAt":"2026-05-22T02:22:08.562Z","description":"Cross-session knowledge and insights"}

package/.pi/messenger/session-id

@@ -0,0 +1 @@
+019e9c1b-cad3-7bd6-a910-c015d0788505

package/AGENTS.md

@@ -0,0 +1,57 @@
+# AGENTS.md
+
+## DO NOT EDIT — Auto-generated Files
+
+The following files are **idempotent** and regenerated by `scripts/update-models.js`. Never edit them directly — your changes will be overwritten on the next model sync.
+
+| File | Why it's auto-generated |
+|------|------------------------|
+| `models.json` | Built from the provider API. `update-models.js` fetches models, preserves curated data for known IDs, and writes this file. |
+| `deprecated-models.json` | Graveyard for models the API delisted. update-models.js stamps them with deprecatedAt and pi keeps serving them for a 2-week grace period, then evicts them. Never edit by hand. |
+| `README.md` (model table) | The table under `## Available Models` is replaced in-place by `update-models.js` after merging base models → patch → custom models. |
+
+## Correct Files to Edit
+
+When a model needs overrides, new properties, or corrections, edit the appropriate source file below. These are the **source of truth** that the update script reads but never writes.
+
+| File | Purpose |
+|------|---------|
+| `patch.json` | Per-model overrides keyed by model ID. Add reasoning flags, compat settings, pricing corrections, thinking level maps, etc. Applied on top of `models.json` at runtime and for README generation. |
+| `custom-models.json` | Models that don't exist in the provider API (hidden models, router endpoints, cross-provider aliases). Merged after patch. Format: array of full model objects (same schema as `models.json` entries). |
+| `index.ts` | Provider extension code. |
+| `scripts/update-models.js` | The sync script itself (edit only if changing how models are fetched/transformed). |
+
+## Data Flow
+
+```
+Provider API  ──fetch──►  models.json  ──apply──►  patch.json  ──merge──►  custom-models.json
+                                    │                            │                      │
+                                    └────────────────────────────┴──────────────────────┘
+                                                      │
+                                              README model table
+```
+
+1. `models.json` — base data from the provider API (auto-generated, DO NOT EDIT)
+2. `patch.json` — overrides applied on top (EDIT THIS for corrections/enrichments)
+3. `custom-models.json` — additional models not in the API (EDIT THIS for new models)
+4. README table — rendered from the merged result of all three (auto-generated, DO NOT EDIT)
+
+## Common Tasks
+
+### Add a compat setting or override pricing for an existing model
+→ Edit `patch.json`. Add an entry keyed by the model's `id`.
+
+### Add a model not available in the provider API
+→ Edit `custom-models.json`. Add a full model object to the array.
+
+### Update models from the provider API
+→ Run `node scripts/update-models.js` (may require an API key env var).
+
+### Regenerate the README model table
+→ Run `node scripts/update-models.js` — it updates both `models.json` and the README table.
+
+## TL;DR
+
+- **Never edit `models.json`** — edit `patch.json` instead.
+- **Never edit the README model table** — run the update script instead.
+- `patch.json` and `custom-models.json` are the source files you should modify.

package/custom-models.json

@@ -0,0 +1 @@
+[]

package/deprecated-models.json

@@ -0,0 +1,75 @@
+{
+  "MiniMax-M3": {
+    "id": "MiniMax-M3",
+    "name": "MiniMax-M3",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.33,
+      "output": 1.32,
+      "cacheRead": 0.07,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1048576,
+    "maxTokens": 16384,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsStore": false,
+      "supportsZdr": false,
+      "supportsReasoningEffort": true
+    },
+    "deprecatedAt": "2026-08-10T02:00:21.380Z"
+  },
+  "GLM-5.1": {
+    "id": "GLM-5.1",
+    "name": "GLM-5.1",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1,
+      "output": 3.2,
+      "cacheRead": 0.1,
+      "cacheWrite": 0
+    },
+    "contextWindow": 202752,
+    "maxTokens": 32768,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsZdr": true,
+      "supportsStore": false,
+      "supportsReasoningEffort": true
+    },
+    "deprecatedAt": "2026-08-18T02:00:24.936Z"
+  },
+  "glm5.2-fast": {
+    "id": "glm5.2-fast",
+    "name": "GLM5.2-Fast",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 2.1,
+      "output": 6.6,
+      "cacheRead": 0.21,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1048576,
+    "maxTokens": 16384,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsStore": false,
+      "supportsZdr": true,
+      "supportsReasoningEffort": true
+    },
+    "deprecatedAt": "2026-08-18T02:00:24.936Z"
+  }
+}

package/models.json

@@ -0,0 +1,142 @@
+[
+  {
+    "id": "DeepSeek-V4-Flash-0731-Fast",
+    "name": "DeepSeek-V4-Flash-0731-Fast",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.28,
+      "output": 0.56,
+      "cacheRead": 0.07,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1048576,
+    "maxTokens": 1048576,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsStore": false,
+      "supportsZdr": true,
+      "supportsReasoningEffort": true
+    }
+  },
+  {
+    "id": "GLM-5.2",
+    "name": "GLM-5.2",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.26,
+      "output": 3.96,
+      "cacheRead": 0.23,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1048576,
+    "maxTokens": 16384,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsStore": false,
+      "supportsZdr": true,
+      "supportsReasoningEffort": true
+    }
+  },
+  {
+    "id": "Kimi-K2.6",
+    "name": "Kimi-K2.6",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 1.14,
+      "output": 4.8,
+      "cacheRead": 0.19,
+      "cacheWrite": 0
+    },
+    "contextWindow": 262144,
+    "maxTokens": 32768,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsZdr": false,
+      "supportsStore": false,
+      "supportsReasoningEffort": true
+    }
+  },
+  {
+    "id": "Kimi-K3",
+    "name": "Kimi-K3",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 3,
+      "output": 15,
+      "cacheRead": 0.3,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1048576,
+    "maxTokens": 16384,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsStore": false,
+      "supportsZdr": true,
+      "supportsReasoningEffort": true
+    }
+  },
+  {
+    "id": "kimi-k3-fast",
+    "name": "Kimi-K3-Fast",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 4.5,
+      "output": 22.5,
+      "cacheRead": 0.45,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1048576,
+    "maxTokens": 16384,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsStore": false,
+      "supportsZdr": true,
+      "supportsReasoningEffort": true
+    }
+  },
+  {
+    "id": "Qwen3.5-397B-A17B",
+    "name": "Qwen 3.5 397B (A17B)",
+    "reasoning": false,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0,
+      "output": 0,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 262144,
+    "maxTokens": 32768,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsZdr": false,
+      "supportsStore": false
+    }
+  }
+]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-wafer-provider",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Wafer Serverless provider extension for pi - Access Qwen3.5-397B-A17B, GLM-5.1, Kimi K2.6, and DeepSeek-V4 through the Wafer Serverless API",
   "type": "module",
   "main": "index.ts",
@@ -22,10 +22,6 @@
       "./index.ts"
     ]
   },
-  "files": [
-    "README.md",
-    "LICENSE"
-  ],
   "scripts": {
     "clean": "echo 'nothing to clean'",
     "build": "echo 'nothing to build'",

package/patch.json

@@ -0,0 +1,48 @@
+{
+  "kimi-k3-fast": {
+    "thinkingLevelMap": {
+      "off": null,
+      "minimal": null,
+      "low": "low",
+      "medium": null,
+      "high": "high",
+      "xhigh": null,
+      "max": "max"
+    }
+  },
+  "Qwen3.5-397B-A17B": {
+    "providers": [
+      "wafer-serverless"
+    ],
+    "reasoning": true,
+    "compat": {
+      "thinkingFormat": "qwen",
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsReasoningEffort": true
+    }
+  },
+  "GLM-5.1": {
+    "providers": [
+      "wafer-serverless"
+    ],
+    "reasoning": true,
+    "compat": {
+      "thinkingFormat": "zai",
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsReasoningEffort": true
+    }
+  },
+  "Kimi-K2.6": {
+    "providers": [
+      "wafer-serverless"
+    ],
+    "reasoning": true,
+    "compat": {
+      "maxTokensField": "max_completion_tokens",
+      "supportsDeveloperRole": false,
+      "supportsReasoningEffort": true
+    }
+  }
+}

package/scripts/e2e-kimi-k2.6.mjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+/**
+ * E2E test for Kimi K2.6 on Wafer (pass.wafer.ai).
+ *
+ * Tests:
+ * 1. Basic streaming with reasoning prompt (delta.reasoning / reasoning_content)
+ * 2. Non-streaming (reasoning_content structure)
+ * 3. Preserved Thinking via thinking.keep="all"
+ * 4. Preserved Thinking via chat_template_kwargs
+ */
+
+const API_KEY = process.env.WAFER_SERVERLESS_API_KEY || process.env.WAFER_API_KEY;
+const MODEL = process.env.MODEL || "Kimi-K2.6";
+const BASE_URL = "https://pass.wafer.ai/v1/chat/completions";
+
+if (!API_KEY) {
+  console.error("❌ WAFER_SERVERLESS_API_KEY (or WAFER_API_KEY) is not set.");
+  process.exit(1);
+}
+
+async function streamRequest(label, body) {
+  console.log(`\n═══════════════════════════════════════════════════`);
+  console.log(`  TEST: ${label}`);
+  console.log(`  Model: ${MODEL}`);
+  console.log(`  Base URL: ${BASE_URL}`);
+  console.log(`═══════════════════════════════════════════════════`);
+
+  const res = await fetch(BASE_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${API_KEY}`,
+      "Wafer-ZDR": "required",
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const text = await res.text();
+    console.error(`❌ HTTP ${res.status}: ${text}`);
+    return { ok: false, error: text };
+  }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  let reasoningChunks = [];
+  let contentChunks = [];
+  let hasDone = false;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("data: ")) {
+          const payload = trimmed.slice(6);
+          if (payload === "[DONE]") {
+            hasDone = true;
+            continue;
+          }
+          try {
+            const obj = JSON.parse(payload);
+            const delta = obj.choices?.[0]?.delta || {};
+            if (delta.reasoning) reasoningChunks.push(delta.reasoning);
+            if (delta.content) contentChunks.push(delta.content);
+          } catch {}
+        }
+      }
+    }
+  } catch (e) {
+    console.error(`💥 Stream error: ${e.message}`);
+  } finally {
+    reader.releaseLock();
+  }
+
+  console.log(`  Reasoning chunks:  ${reasoningChunks.length}`);
+  console.log(`  Content chunks:      ${contentChunks.length}`);
+  console.log(`  [DONE] seen:       ${hasDone}`);
+
+  if (reasoningChunks.length > 0) {
+    console.log(`\n  --- First reasoning chunk ---`);
+    console.log(`  ${reasoningChunks[0].substring(0, 200)}`);
+  }
+  if (contentChunks.length > 0) {
+    const fullContent = contentChunks.join("");
+    console.log(`\n  --- Final content (first 300 chars) ---`);
+    console.log(`  ${fullContent.substring(0, 300)}`);
+  }
+
+  return { ok: true, reasoning: reasoningChunks, content: contentChunks };
+}
+
+async function nonStreamRequest(label, body) {
+  console.log(`\n═══════════════════════════════════════════════════`);
+  console.log(`  TEST: ${label}`);
+  console.log(`  Model: ${MODEL}`);
+  console.log(`  Base URL: ${BASE_URL}`);
+  console.log(`═══════════════════════════════════════════════════`);
+
+  const res = await fetch(BASE_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${API_KEY}`,
+      "Wafer-ZDR": "required",
+    },
+    body: JSON.stringify(body),
+  });
+
+  const data = await res.json();
+
+  if (!res.ok) {
+    console.error(`❌ HTTP ${res.status}: ${JSON.stringify(data)}`);
+    return { ok: false, error: data };
+  }
+
+  const choice = data.choices?.[0];
+  const msg = choice?.message || {};
+
+  console.log(`  keys:                ${JSON.stringify(Object.keys(msg))}`);
+  console.log(`  has reasoning_content: ${"reasoning_content" in msg}`);
+  console.log(`  has reasoning:         ${"reasoning" in msg}`);
+  if (msg.reasoning_content) {
+    console.log(`  reasoning_content len: ${msg.reasoning_content.length}`);
+    console.log(`  --- reasoning_content (first 300) ---`);
+    console.log(`  ${msg.reasoning_content.substring(0, 300)}`);
+  }
+  if (msg.reasoning) {
+    console.log(`  reasoning: ${msg.reasoning.substring(0, 300)}`);
+  }
+  console.log(`  content: ${(msg.content || "").substring(0, 300)}`);
+  console.log(`  usage: ${JSON.stringify(data.usage)}`);
+
+  return { ok: true, message: msg, usage: data.usage };
+}
+
+async function main() {
+  console.log(`E2E Testing Kimi K2.6 on Wafer`);
+  console.log(`Base URL: ${BASE_URL}`);
+
+  // Test 1: Basic streaming
+  await streamRequest("Basic stream (reasoning prompt)", {
+    model: MODEL,
+    messages: [{ role: "user", content: "What is 13 × 17? Show your reasoning." }],
+    max_tokens: 500,
+    stream: true,
+  });
+
+  // Test 2: Non-streaming
+  await nonStreamRequest("Non-stream (inspect structure)", {
+    model: MODEL,
+    messages: [{ role: "user", content: "What is 13 × 17? Show your reasoning." }],
+    max_tokens: 500,
+    stream: false,
+  });
+
+  // Test 3: Preserved Thinking via extra_body thinking.keep
+  const r3 = await streamRequest("Stream with thinking.keep='all' (extra_body)", {
+    model: MODEL,
+    messages: [
+      { role: "user", content: "Tell me three random numbers." },
+      {
+        role: "assistant",
+        reasoning_content: "I generated five numbers and told the first three: 473, 921, 235, and the other two were 215, 222.",
+        content: "473, 921, 235",
+      },
+      { role: "user", content: "What are the other two numbers you have in mind?" },
+    ],
+    max_tokens: 500,
+    stream: true,
+    extra_body: { thinking: { type: "enabled", keep: "all" } },
+  });
+
+  if (r3.ok && r3.content.length > 0) {
+    const fullContent = r3.content.join("");
+    const got215 = fullContent.includes("215");
+    const got222 = fullContent.includes("222");
+    console.log(`\n  🧪 Preserved Thinking (extra_body) check: mentions 215=${got215}, mentions 222=${got222}`);
+  }
+
+  // Test 4: Preserved Thinking via chat_template_kwargs
+  const r4 = await streamRequest("Stream with chat_template_kwargs preserve_thinking", {
+    model: MODEL,
+    messages: [
+      { role: "user", content: "Tell me three random numbers." },
+      {
+        role: "assistant",
+        reasoning_content: "I generated five numbers and told the first three: 473, 921, 235, and kept 215 and 222 hidden.",
+        content: "473, 921, 235",
+      },
+      { role: "user", content: "What are the other two numbers you have in mind?" },
+    ],
+    max_tokens: 500,
+    stream: true,
+    extra_body: { chat_template_kwargs: { thinking: true, preserve_thinking: true } },
+  });
+
+  if (r4.ok && r4.content.length > 0) {
+    const fullContent = r4.content.join("");
+    const got215 = fullContent.includes("215");
+    const got222 = fullContent.includes("222");
+    console.log(`\n  🧪 Preserved Thinking (chat_template_kwargs) check: mentions 215=${got215}, mentions 222=${got222}`);
+  }
+
+  console.log(`\n═══════════════════════════════════════════════════`);
+  console.log(`  E2E Test Complete`);
+  console.log(`═══════════════════════════════════════════════════`);
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });

package/scripts/update-models.js

@@ -0,0 +1,483 @@
+#!/usr/bin/env node
+/**
+ * Update Wafer models from API
+ *
+ * Fetches models from https://pass.wafer.ai/v1/models and updates:
+ * - models.json: Provider model definitions (enriched with pricing & compat)
+ * - README.md: Model table in the Available Models section
+ *
+ * The Wafer /v1/models API returns model limits plus nested capability, pricing,
+ * modality, and ZDR metadata. models.json mirrors those API-owned fields while
+ * patch.json remains the source of truth for thinking controls and corrections.
+ *
+ * patch.json is applied at runtime by the provider — not baked into models.json.
+ *
+ * API key: the stored `wafer-serverless` credential in ~/.pi/agent/auth.json wins, then
+ * the WAFER_SERVERLESS_API_KEY (or WAFER_API_KEY) environment variable. The script refuses to run without one.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// pi's agent directory: PI_CODING_AGENT_DIR (with ~ expansion) or ~/.pi/agent.
+function piAgentDir() {
+  const envDir = process.env.PI_CODING_AGENT_DIR;
+  if (envDir) {
+    return envDir.startsWith('~/') || envDir === '~'
+      ? path.join(os.homedir(), envDir.slice(1))
+      : envDir;
+  }
+  return path.join(os.homedir(), '.pi', 'agent');
+}
+
+const AUTH_JSON_PATH = path.join(piAgentDir(), 'auth.json');
+
+/**
+ * Resolve a configured value using pi's semantics (resolve-config-value.ts in
+ * pi-mono): "!command" runs via the shell (10s timeout) and uses trimmed
+ * stdout; "$VAR" / "${VAR}" interpolate environment variables ("$$" escapes a
+ * literal "$", "$!" a literal "!"); anything else is a literal. Returns
+ * undefined when a referenced env var is unset or a command fails.
+ */
+function resolveConfigValue(config, env) {
+  if (typeof config !== 'string' || config.length === 0) return undefined;
+  if (config.startsWith('!')) {
+    try {
+      const out = execSync(config.slice(1), {
+        encoding: 'utf8',
+        timeout: 10000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+      return out.trim() || undefined;
+    } catch {
+      return undefined;
+    }
+  }
+  const ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+  let resolved = '';
+  let index = 0;
+  while (index < config.length) {
+    const dollar = config.indexOf('$', index);
+    if (dollar < 0) {
+      resolved += config.slice(index);
+      break;
+    }
+    resolved += config.slice(index, dollar);
+    const next = config[dollar + 1];
+    let name;
+    if (next === '$' || next === '!') {
+      resolved += next;
+      index = dollar + 2;
+      continue;
+    } else if (next === '{') {
+      const end = config.indexOf('}', dollar + 2);
+      if (end < 0) {
+        resolved += '$';
+        index = dollar + 1;
+        continue;
+      }
+      const inner = config.slice(dollar + 2, end);
+      if (!ENV_NAME_RE.test(inner)) {
+        resolved += config.slice(dollar, end + 1);
+        index = end + 1;
+        continue;
+      }
+      name = inner;
+      index = end + 1;
+    } else {
+      const match = config.slice(dollar + 1).match(/^[A-Za-z_][A-Za-z0-9_]*/);
+      if (!match) {
+        resolved += '$';
+        index = dollar + 1;
+        continue;
+      }
+      name = match[0];
+      index = dollar + 1 + name.length;
+    }
+    const value = (env && env[name]) || process.env[name] || undefined;
+    if (value === undefined) return undefined;
+    resolved += value;
+  }
+  return resolved;
+}
+
+/**
+ * The API key, resolved the way pi itself resolves it for this provider: the
+ * stored `wafer-serverless` credential in ~/.pi/agent/auth.json wins, then
+ * the WAFER_SERVERLESS_API_KEY (or WAFER_API_KEY) environment variable.
+ */
+function resolveApiKey() {
+  try {
+    const auth = JSON.parse(fs.readFileSync(AUTH_JSON_PATH, 'utf8'));
+    const credential = auth?.['wafer-serverless'];
+    if (credential && credential.type === 'api_key' && typeof credential.key === 'string') {
+      const key = resolveConfigValue(credential.key, credential.env);
+      if (key) return key;
+    }
+  } catch {
+    // Missing or unparseable auth.json: fall through to the env var.
+  }
+  return process.env.WAFER_SERVERLESS_API_KEY || process.env.WAFER_API_KEY || undefined;
+}
+
+const MODELS_API_URL = 'https://pass.wafer.ai/v1/models';
+const MODELS_JSON_PATH = path.join(__dirname, '..', 'models.json');
+const PATCH_JSON_PATH = path.join(__dirname, '..', 'patch.json');
+const CUSTOM_MODELS_JSON_PATH = path.join(__dirname, '..', 'custom-models.json');
+const README_PATH = path.join(__dirname, '..', 'README.md');
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function loadJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveJson(filePath, data) {
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+  console.log(`✓ Saved ${path.basename(filePath)}`);
+}
+
+// ─── API fetch ───────────────────────────────────────────────────────────────
+
+async function fetchModels() {
+  const apiKey = resolveApiKey();
+  if (!apiKey) {
+    throw new Error('No API key found: no `wafer-serverless` credential resolved from ' + AUTH_JSON_PATH + ' and WAFER_SERVERLESS_API_KEY (or WAFER_API_KEY) is not set');
+  }
+
+  console.log(`Fetching models from ${MODELS_API_URL}...`);
+  const response = await fetch(MODELS_API_URL, {
+    headers: { 'Authorization': `Bearer ${apiKey}` },
+  });
+
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status} ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  const models = Array.isArray(data) ? data : (data.data || []);
+  console.log(`✓ Fetched ${models.length} models from API`);
+  return models;
+}
+
+// ─── Transform API model → models.json entry ────────────────────────────────
+
+function transformApiModel(apiModel, existingModelsMap) {
+  const id = apiModel.id;
+
+  const details = apiModel.wafer || {};
+  const capabilities = details.capabilities || {};
+  const pricing = details.pricing || {};
+  const reasoning = capabilities.reasoning === true;
+  const input = capabilities.vision === true ? ['text', 'image'] : ['text'];
+  const cost = {
+    input: (pricing.input_cents_per_million || 0) / 100,
+    output: (pricing.output_cents_per_million || 0) / 100,
+    cacheRead: (pricing.cache_read_cents_per_million || 0) / 100,
+    cacheWrite: 0,
+  };
+
+  if (existingModelsMap[id]) {
+    const existing = { ...existingModelsMap[id] };
+    existing.name = details.display_name || existing.name;
+    existing.reasoning = reasoning;
+    existing.input = input;
+    existing.cost = cost;
+    existing.contextWindow = details.context_length || apiModel.max_model_len || existing.contextWindow;
+    existing.compat = {
+      ...(existing.compat || {}),
+      supportsStore: false,
+      supportsDeveloperRole: false,
+      maxTokensField: 'max_completion_tokens',
+      supportsZdr: apiModel.zdr_supported,
+      ...(reasoning ? { supportsReasoningEffort: true } : {}),
+    };
+    return existing;
+  }
+
+  const contextWindow = details.context_length || apiModel.max_model_len || 131072;
+  const model = {
+    id,
+    name: details.display_name || generateDisplayName(id),
+    reasoning,
+    input,
+    cost,
+    contextWindow,
+    maxTokens: contextWindow,
+    compat: {
+      maxTokensField: 'max_completion_tokens',
+      supportsDeveloperRole: false,
+      supportsStore: false,
+      supportsZdr: apiModel.zdr_supported,
+      ...(reasoning ? { supportsReasoningEffort: true } : {}),
+    },
+  };
+
+  return model;
+}
+
+function generateDisplayName(id) {
+  // Fallback: prettify the ID
+  return id
+    .replace(/[-_]/g, ' ')
+    .replace(/\b\w/g, c => c.toUpperCase());
+}
+
+// ─── Patch & Custom Models ──────────────────────────────────────────────────
+
+function applyPatch(model, patch) {
+  const result = { ...model };
+  if (patch.name !== undefined) result.name = patch.name;
+  if (patch.reasoning !== undefined) result.reasoning = patch.reasoning;
+  if (patch.input !== undefined) result.input = patch.input;
+  if (patch.contextWindow !== undefined) result.contextWindow = patch.contextWindow;
+  if (patch.maxTokens !== undefined) result.maxTokens = patch.maxTokens;
+  if (patch.cost) {
+    result.cost = {
+      input: patch.cost.input ?? result.cost.input,
+      output: patch.cost.output ?? result.cost.output,
+      cacheRead: patch.cost.cacheRead ?? result.cost.cacheRead,
+      cacheWrite: patch.cost.cacheWrite ?? result.cost.cacheWrite,
+    };
+  }
+  if (patch.compat) {
+    result.compat = { ...(result.compat || {}), ...patch.compat };
+  }
+  if (patch.thinkingLevelMap !== undefined) result.thinkingLevelMap = patch.thinkingLevelMap;
+  if (!result.reasoning && result.compat?.thinkingFormat) {
+    delete result.compat.thinkingFormat;
+  }
+  if (result.compat && Object.keys(result.compat).length === 0) {
+    delete result.compat;
+  }
+  return result;
+}
+
+function buildModels(baseModels, customModels, patchData) {
+  const modelMap = new Map();
+  for (const model of baseModels) {
+    modelMap.set(model.id, model);
+  }
+  for (const [id, patchEntry] of Object.entries(patchData)) {
+    const existing = modelMap.get(id);
+    if (existing) {
+      modelMap.set(id, applyPatch(existing, patchEntry));
+    }
+  }
+  for (const model of customModels) {
+    const existing = modelMap.get(model.id);
+    const patchEntry = patchData[model.id];
+    if (existing && patchEntry) {
+      modelMap.set(model.id, applyPatch(model, patchEntry));
+    } else if (existing) {
+      modelMap.set(model.id, model);
+    } else if (patchEntry) {
+      modelMap.set(model.id, applyPatch(model, patchEntry));
+    } else {
+      modelMap.set(model.id, model);
+    }
+  }
+  return Array.from(modelMap.values());
+}
+
+// ─── README generation ──────────────────────────────────────────────────────
+
+function formatContext(n) {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(0)}M`;
+  if (n >= 1000) return `${Math.round(n / 1000)}K`;
+  return n.toString();
+}
+
+function formatCost(cost) {
+  if (cost === 0) return '—';
+  if (cost === null || cost === undefined) return '—';
+  return '$' + cost.toFixed(2);
+}
+
+function generateReadmeTable(models) {
+  const lines = [
+    '| Model | Type | Context | Max Output | Input Cost | Output Cost | Cached Input |',
+    '|-------|------|---------|------------|------------|-------------|--------------|',
+  ];
+
+  for (const model of models) {
+    const type = model.input.includes('image') ? 'Text + Image' : 'Text';
+    const context = formatContext(model.contextWindow);
+    const maxOutput = formatContext(model.maxTokens);
+    const inputCost = formatCost(model.cost.input);
+    const outputCost = formatCost(model.cost.output);
+    const cacheCost = formatCost(model.cost.cacheRead);
+
+    lines.push(`| ${model.name} | ${type} | ${context} | ${maxOutput} | ${inputCost} | ${outputCost} | ${cacheCost} |`);
+  }
+
+  return lines.join('\n');
+}
+
+function updateReadme(models) {
+  let readme = fs.readFileSync(README_PATH, 'utf8');
+  const newTable = generateReadmeTable(models);
+
+  const tableRegex = /(## Available Models\n\n)\| Model \| Type \| Context[^\n]+\|\n\|[-| ]+\|(\n\|[^\n]+\|)*\n*/;
+
+  if (tableRegex.test(readme)) {
+    readme = readme.replace(tableRegex, (match, header) => `${header}${newTable}\n\n`);
+    fs.writeFileSync(README_PATH, readme);
+    console.log('✓ Updated README.md');
+  } else {
+    console.warn('⚠ Could not find model table in "## Available Models" section');
+  }
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+// Grace period for delisted models: update-models.js moves models the API no
+// longer lists into deprecated-models.json (stamped with deprecatedAt) instead
+// of dropping them; the runtime appends them back so sessions and saved model
+// settings keep working, and after 14 days they are evicted permanently.
+const DEPRECATED_MODEL_TTL_MS = 14 * 24 * 60 * 60 * 1000;
+
+/**
+ * Reconcile deprecated-models.json against the freshly fetched model list.
+ * - in old models.json but not the API: moved into the deprecated file
+ *   (deprecatedAt = now; preserved on repeat runs so the grace clock is not reset)
+ * - back in the API: resurrected (dropped from the deprecated file)
+ * - deprecatedAt older than 14 days: evicted permanently
+ * Must run BEFORE the new models.json is written; it reads the old file itself.
+ */
+function updateDeprecatedModels(modelsJsonPath, newModels) {
+  const deprecatedPath = path.join(path.dirname(modelsJsonPath), 'deprecated-models.json');
+
+  let oldModels = [];
+  try {
+    const parsed = JSON.parse(fs.readFileSync(modelsJsonPath, 'utf8'));
+    if (Array.isArray(parsed)) oldModels = parsed;
+  } catch { /* first run: no previous models.json */ }
+
+  let deprecated = {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(deprecatedPath, 'utf8'));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) deprecated = parsed;
+  } catch { /* no graveyard yet */ }
+
+  const currentIds = new Set(newModels.map(m => m.id));
+  const now = new Date().toISOString();
+  const added = [];
+  const resurrected = [];
+  const evicted = [];
+
+  for (const old of oldModels) {
+    if (old && old.id && !currentIds.has(old.id) && !deprecated[old.id]) {
+      deprecated[old.id] = { ...old, deprecatedAt: now };
+      added.push(old.id);
+    }
+  }
+
+  for (const [id, entry] of Object.entries(deprecated)) {
+    if (currentIds.has(id)) {
+      delete deprecated[id];
+      resurrected.push(id);
+      continue;
+    }
+    const removedAt = Date.parse(entry && entry.deprecatedAt ? entry.deprecatedAt : '');
+    if (Number.isNaN(removedAt) || Date.now() - removedAt > DEPRECATED_MODEL_TTL_MS) {
+      delete deprecated[id];
+      evicted.push(id);
+    }
+  }
+
+  if (added.length > 0 || resurrected.length > 0 || evicted.length > 0) {
+    fs.writeFileSync(deprecatedPath, JSON.stringify(deprecated, null, 2) + '\n');
+    console.log('Updated deprecated-models.json ' + JSON.stringify({ added, resurrected, evicted }));
+  }
+}
+
+/**
+ * Grace-period deprecated models (deprecatedAt within TTL) with metadata stripped.
+ * Keeps the README table serving models that are delisted but still within their
+ * 14-day grace window.
+ */
+function withDeprecatedForReadme(models) {
+  const deprecatedPath = path.join(path.dirname(MODELS_JSON_PATH), 'deprecated-models.json');
+  let deprecated = {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(deprecatedPath, 'utf8'));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) deprecated = parsed;
+  } catch { /* no graveyard yet */ }
+  const now = Date.now();
+  const seen = new Set(models.map(m => m.id));
+  const extras = [];
+  for (const entry of Object.values(deprecated)) {
+    if (!entry || !entry.id || seen.has(entry.id)) continue;
+    const removedAt = Date.parse(entry.deprecatedAt || '');
+    if (Number.isNaN(removedAt) || now - removedAt > DEPRECATED_MODEL_TTL_MS) continue;
+    const m = { ...entry };
+    delete m.deprecatedAt;
+    extras.push(m);
+  }
+  return extras.length > 0 ? [...models, ...extras] : models;
+}
+async function main() {
+  try {
+    const apiModels = await fetchModels();
+
+    // Load existing models.json — source of truth for curated specs
+    const existingModels = loadJson(MODELS_JSON_PATH);
+    const existingModelsMap = {};
+    for (const m of (Array.isArray(existingModels) ? existingModels : [])) {
+      existingModelsMap[m.id] = m;
+    }
+
+    // Transform API models, preserving existing data where available
+    let models = apiModels.map(m =>
+      transformApiModel(m, existingModelsMap)
+    );
+
+    // Live API is authoritative — models absent from API are removed
+    // (embedded data is already used for enrichment in transformApiModel)
+
+    // Sort by model name
+    models.sort((a, b) => a.name.localeCompare(b.name));
+
+    // Save models.json (pure API output, no patch/custom baked in)
+    // Move delisted models to deprecated-models.json BEFORE models.json is overwritten
+    updateDeprecatedModels(MODELS_JSON_PATH, models);
+    saveJson(MODELS_JSON_PATH, models);
+
+    // Build full model list for README: base → patch → custom
+    const patchData = loadJson(PATCH_JSON_PATH);
+    const customModels = loadJson(CUSTOM_MODELS_JSON_PATH);
+    const readmeModels = buildModels(models, Array.isArray(customModels) ? customModels : [], patchData);
+    readmeModels.sort((a, b) => a.name.localeCompare(b.name));
+
+    // Update README
+    updateReadme(readmeModels);
+
+    // Summary
+    const newIds = new Set(models.map(m => m.id));
+    const oldIds = new Set(Object.keys(existingModelsMap));
+    const added = [...newIds].filter(id => !oldIds.has(id));
+    const removed = [...oldIds].filter(id => !newIds.has(id));
+
+    console.log('\n--- Summary ---');
+    console.log(`Total models: ${models.length}`);
+    console.log(`Vision models: ${models.filter(m => m.input.includes('image')).length}`);
+    if (added.length > 0) console.log(`New models: ${added.join(', ')} — curate models.json manually`);
+    if (removed.length > 0) console.log(`Removed models: ${removed.join(', ')}`);
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();