pi-parasail-provider 1.0.2

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 @@
+019dea0e-d06e-72dc-b8b1-e2c14288bed8

package/AGENTS.md

@@ -0,0 +1,56 @@
+# 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. |
+| `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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,196 @@
+<div align="center">
+
+# 🪂 pi-parasail-provider
+
+**30+ models via [Parasail](https://parasail.io/)**
+
+_DeepSeek, Qwen, GLM, Kimi, Llama, Gemma, Mistral — serverless with live pricing for [pi](https://github.com/earendil-works/pi-coding-agent)._
+
+[![pi extension](https://img.shields.io/badge/pi-extension-blueviolet)](https://github.com/earendil-works/pi-coding-agent)
+[![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+
+</div>
+
+---
+
+## Features
+
+- **Wide Model Selection** — 30+ models from DeepSeek, Qwen, GLM, Kimi, Llama, Gemma, Mistral, MiniMax, and more
+- **Reasoning Models** — DeepSeek V4, Qwen3, GLM 5, Kimi K2.5/K2.6, Trinity, MiniMax with thinking mode
+- **Vision Support** — Qwen3-VL, Gemma 4, Qwen2.5-VL accept image + text input
+- **Unified API** — OpenAI-compatible completions endpoint
+- **Long Context** — DeepSeek V4 (1M), Llama 4 Maverick (1M), MiniMax M2.5 (1M)
+
+## Installation
+
+### Option 1: Using `pi install` (Recommended)
+
+Install directly from GitHub:
+
+```bash
+pi install https://github.com/monotykamary/pi-parasail-provider
+```
+
+Then set your API key and run pi:
+```bash
+# Recommended: add to auth.json
+# See Authentication section below
+
+# Or set as environment variable
+export PARASAIL_API_KEY=your-api-key-here
+
+pi
+```
+
+Get your API key at [parasail.io](https://parasail.io/).
+
+### Option 2: Manual Clone
+
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/monotykamary/pi-parasail-provider.git
+   cd pi-parasail-provider
+   ```
+
+2. Set your Parasail API key:
+   ```bash
+   # Recommended: add to auth.json
+   # See Authentication section below
+
+   # Or set as environment variable
+   export PARASAIL_API_KEY=your-api-key-here
+   ```
+
+3. Run pi with the extension:
+   ```bash
+   pi -e /path/to/pi-parasail-provider
+   ```
+
+## Available Models
+
+| Model | Context | Reasoning | Input | Max Output | Input $/M | Output $/M | Cache $/M |
+|-------|---------|-----------|-------|------------|-----------|------------|-----------|
+| Cydonia 24B v4.1 | 131K | ❌ | Text | 16K | $0.30 | $0.50 | $0.15 |
+| DeepSeek V4 Flash | 1M | ✅ | Text | 384K | $0.14 | $0.28 | $0.07 |
+| DeepSeek V4 Pro | 1M | ✅ | Text | 384K | $1.74 | $3.48 | $0.10 |
+| Gemma 3 27B | 131K | ❌ | Text + Image | 16K | $0.08 | $0.45 | $0.04 |
+| Gemma 4 26B (A4B) | 262K | ❌ | Text + Image | 16K | $0.13 | $0.40 | $0.05 |
+| Gemma 4 31B | 262K | ❌ | Text + Image | 16K | $0.15 | $0.40 | $0.06 |
+| GLM 5 | 203K | ✅ | Text | 16K | $1.00 | $3.20 | $0.20 |
+| GLM 5.1 | 203K | ✅ | Text | 16K | $1.40 | $4.40 | $0.26 |
+| Glm 52 | 262K | ❌ | Text | 16K | $1.40 | $4.40 | $0.26 |
+| Gpt Oss 120b Fast | 131K | ❌ | Text | 16K | $0.15 | $0.60 | Free |
+| GPT-OSS 120B | 131K | ❌ | Text | 16K | $0.10 | $0.75 | $0.06 |
+| GPT-OSS 20B | 131K | ❌ | Text | 16K | $0.04 | $0.20 | $0.02 |
+| Kimi K2.6 | 262K | ✅ | Text + Image | 16K | $0.75 | $3.50 | $0.16 |
+| Kimi K27 Code | 262K | ❌ | Text | 16K | $0.75 | $3.50 | $0.16 |
+| Llama 3.3 70B | 131K | ❌ | Text | 16K | $0.22 | $0.50 | $0.11 |
+| Llama 4 Maverick 17B-128E | 524K | ❌ | Text + Image | 16K | $0.35 | $1.00 | $0.17 |
+| Mimo V25 | 1M | ❌ | Text | 16K | $0.14 | $0.28 | $0.05 |
+| MiniMax M2.5 | 197K | ✅ | Text | 16K | $0.30 | $1.20 | $0.03 |
+| Minimax M3 | 1M | ❌ | Text | 16K | $0.30 | $1.20 | $0.06 |
+| Mistral Small 3.2 24B | 131K | ❌ | Text + Image | 16K | $0.09 | $0.30 | $0.05 |
+| Qwen 3.5 35B (A3B) | 262K | ✅ | Text + Image | 33K | $0.15 | $1.00 | $0.05 |
+| Qwen 3.5 397B (A17B) | 262K | ✅ | Text + Image | 33K | $0.50 | $3.60 | $0.30 |
+| Qwen 3.6 35B (A3B) | 262K | ✅ | Text + Image | 33K | $0.15 | $1.00 | $0.05 |
+| Qwen2.5-VL 72B | 128K | ❌ | Text + Image | 8K | $0.80 | $1.00 | $0.40 |
+| Qwen3 235B (A22B) | 131K | ✅ | Text | 33K | $0.14 | $0.80 | $0.05 |
+| Qwen3 Coder Next | 262K | ✅ | Text | 33K | $0.12 | $0.80 | $0.07 |
+| Qwen3 Next 80B (A3B) | 262K | ✅ | Text | 33K | $0.10 | $1.10 | $0.07 |
+| Qwen3-VL 235B (A22B) | 131K | ✅ | Text + Image | 33K | $0.21 | $1.90 | $0.10 |
+| Qwen3-VL 8B | 262K | ✅ | Text + Image | 8K | $0.25 | $0.75 | $0.12 |
+| Skyfall 36b V2 Fp8 | 33K | ❌ | Text | 16K | $0.55 | $0.80 | $0.25 |
+| Trinity Large Thinking | 262K | ❌ | Text | 16K | $0.22 | $0.85 | $0.06 |
+
+*Pricing fetched live from [Parasail's pricing API](https://www.saas.parasail.io/api/v1/prices/serverlessEndpoints). Prices are per million tokens and subject to change.*
+
+## Usage
+
+After loading the extension, use the `/model` command in pi to select your preferred model:
+
+```
+/model parasail parasail-deepseek-v4-pro
+```
+
+Or start pi directly with a Parasail model:
+
+```bash
+pi --provider parasail --model parasail-deepseek-v4-pro
+```
+
+### Thinking Mode
+
+Reasoning models (DeepSeek V4, Qwen3, GLM, Kimi) support both thinking and non-thinking modes. In pi, reasoning models automatically use the appropriate thinking format:
+
+- **DeepSeek V4** — `openai` thinking format (`thinking: {type: "enabled"}`)
+- **Qwen3/Qwen3.5** — `qwen` thinking format
+- **GLM** — `zai` thinking format
+
+## Authentication
+
+The Parasail API key can be configured in multiple ways (resolved in this order):
+
+1. **`auth.json`** (recommended) — Add to `~/.pi/agent/auth.json`:
+   ```json
+   { "parasail": { "type": "api_key", "key": "your-api-key" } }
+   ```
+   The `key` field supports literal values, env var names, and shell commands (prefix with `!`). See [pi's auth file docs](https://github.com/badlogic/pi-mono) for details.
+2. **Runtime override** — Use the `--api-key` CLI flag
+3. **Environment variable** — Set `PARASAIL_API_KEY`
+
+Get your API key at [parasail.io](https://parasail.io/).
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `PARASAIL_API_KEY` | No | Your Parasail API key (fallback if not in auth.json) |
+
+## Configuration
+
+Add to your pi configuration for automatic loading:
+
+```json
+{
+  "extensions": [
+    "/path/to/pi-parasail-provider"
+  ]
+}
+```
+
+### Compat Settings
+
+Parasail's API uses OpenAI-compatible settings:
+
+- **`thinkingFormat`** — Set per-model family: `"openai"` (DeepSeek V4), `"qwen"` (Qwen3), `"zai"` (GLM)
+- **`maxTokensField: "max_completion_tokens"`** — All models use `max_completion_tokens`
+- **`supportsDeveloperRole: false`** — All models use `system` role, not `developer`
+- **`supportsStore: false`** — All models don't support the `store` parameter
+
+### Patch Overrides
+
+The `patch.json` file contains overrides that are applied on top of `models.json` data at runtime. This is useful for:
+- Correcting API-derived values (e.g., marking a model as reasoning-capable)
+- Adding compat settings that the API doesn't provide
+- Overriding pricing/context window when specs change
+
+## Updating Models
+
+Run the update script to fetch the latest models from Parasail's API:
+
+```bash
+export PARASAIL_API_KEY=your-api-key
+node scripts/update-models.js
+```
+
+This will:
+1. Fetch models from `https://api.parasail.io/v1/models`
+2. Preserve pricing, compat, and metadata from existing `models.json`
+3. Apply overrides from `patch.json` at runtime
+4. Update `models.json` and the README model table
+
+A GitHub Actions workflow runs this daily and creates a PR if models have changed.
+
+## License
+
+MIT

package/custom-models.json

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

package/index.ts

@@ -0,0 +1,405 @@
+/**
+ * Parasail Provider Extension
+ *
+ * Registers Parasail (api.parasail.io) as a custom provider.
+ * Base URL: https://api.parasail.io/v1 (OpenAI-compatible)
+ *
+ * Parasail's API is fully OpenAI-compatible and hosts a wide range of
+ * open-source models including DeepSeek, Qwen, GLM, Kimi, Llama, Gemma,
+ * Mistral, and more.
+ *
+ * Model resolution strategy: Stale-While-Revalidate
+ *   1. Serve stale immediately: disk cache → embedded models.json (zero-latency)
+ *   2. Revalidate in background:
+ *      a. Live API /v1/models → merge with embedded → enrich with pricing
+ *      b. Public pricing endpoint → apply input/output/cache costs + context windows
+ *   3. patch.json + custom-models.json applied on top of whichever source won
+ *
+ * Merge order: [live|cache|embedded] → apply patch.json → merge custom-models.json
+ *
+ * Usage:
+ *   # Option 1: Store in auth.json (recommended)
+ *   # Add to ~/.pi/agent/auth.json:
+ *   #   "parasail": { "type": "api_key", "key": "your-api-key" }
+ *
+ *   # Option 2: Set as environment variable
+ *   export PARASAIL_API_KEY=your-api-key
+ *
+ *   # Run pi with the extension
+ *   pi -e /path/to/pi-parasail-provider
+ *
+ * Then use /model to select from available models
+ */
+
+import { getAgentDir, type ExtensionAPI, type ModelRegistry } from "@earendil-works/pi-coding-agent";
+import modelsData from "./models.json" with { type: "json" };
+import customModelsData from "./custom-models.json" with { type: "json" };
+import patchData from "./patch.json" with { type: "json" };
+import fs from "fs";
+import path from "path";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface JsonModel {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: string[];
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+  maxTokens: number;
+  compat?: {
+    supportsDeveloperRole?: boolean;
+    supportsStore?: boolean;
+    maxTokensField?: "max_completion_tokens" | "max_tokens";
+    thinkingFormat?: "openai" | "zai" | "qwen" | "qwen-chat-template";
+    supportsReasoningEffort?: boolean;
+  };
+}
+
+interface PatchEntry {
+  name?: string;
+  reasoning?: boolean;
+  input?: string[];
+  cost?: {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+  };
+  contextWindow?: number;
+  maxTokens?: number;
+  compat?: Record<string, unknown>;
+}
+
+type PatchData = Record<string, PatchEntry>;
+
+// ─── Patch Application ────────────────────────────────────────────────────────
+
+function applyPatch(model: JsonModel, patch: PatchEntry): JsonModel {
+  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 (!result.reasoning && result.compat?.thinkingFormat) {
+    delete result.compat.thinkingFormat;
+  }
+  if (result.compat && Object.keys(result.compat).length === 0) {
+    delete result.compat;
+  }
+
+  return result;
+}
+
+/** Full pipeline: base models → patch → custom → result */
+function buildModels(base: JsonModel[], custom: JsonModel[], patch: PatchData): JsonModel[] {
+  const modelMap = new Map<string, JsonModel>();
+
+  for (const model of base) {
+    modelMap.set(model.id, model);
+  }
+
+  for (const [id, patchEntry] of Object.entries(patch)) {
+    const existing = modelMap.get(id);
+    if (existing) {
+      modelMap.set(id, applyPatch(existing, patchEntry));
+    }
+  }
+
+  for (const model of custom) {
+    const existing = modelMap.get(model.id);
+    const patchEntry = patch[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());
+}
+
+// ─── Stale-While-Revalidate Model Sync ────────────────────────────────────────
+
+const PROVIDER_ID = "parasail";
+const BASE_URL = "https://api.parasail.io/v1";
+const MODELS_URL = `${BASE_URL}/models`;
+const PRICING_URL = "https://www.saas.parasail.io/api/v1/prices/serverlessEndpoints";
+const CACHE_DIR = path.join(getAgentDir(), "cache");
+const CACHE_PATH = path.join(CACHE_DIR, `${PROVIDER_ID}-models.json`);
+const LIVE_FETCH_TIMEOUT_MS = 8000;
+
+// Non-LLM model prefixes to skip (embedding, TTS, UI agent models)
+const SKIP_PREFIXES = ["parasail-bge-", "parasail-resemble-", "parasail-ui-tars-"];
+
+/** Transform a model from the Parasail /v1/models API. API returns minimal data (id only). */
+function transformApiModel(apiModel: any): JsonModel | null {
+  const id = apiModel.id;
+
+  // Skip non-LLM models
+  if (SKIP_PREFIXES.some(prefix => id.startsWith(prefix))) return null;
+
+  // Prefer parasail- prefixed IDs (cleaner aliases)
+  // Skip original IDs that have parasail- equivalents
+  if (!id.startsWith("parasail-")) return null;
+
+  return {
+    id,
+    name: generateDisplayName(id),
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 131072,
+    maxTokens: 16384,
+  };
+}
+
+function generateDisplayName(id: string): string {
+  // Strip parasail- prefix and prettify
+  const raw = id.replace(/^parasail-/, "");
+  return raw
+    .replace(/[-_]/g, " ")
+    .replace(/\b\w/g, c => c.toUpperCase());
+}
+
+interface PricingEntry {
+  externalAlias: string;
+  contextLength: number;
+  inputCost: number | null;
+  outputCost: number | null;
+  cachedCost: number | null;
+  tags: string[];
+}
+
+/** Fetch pricing data from the public Parasail SaaS pricing endpoint (no auth required). */
+async function fetchPricingData(signal?: AbortSignal): Promise<Map<string, PricingEntry> | null> {
+  try {
+    const response = await fetch(PRICING_URL, {
+      signal: signal ? AbortSignal.any([AbortSignal.timeout(LIVE_FETCH_TIMEOUT_MS), signal]) : AbortSignal.timeout(LIVE_FETCH_TIMEOUT_MS),
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (!Array.isArray(data)) return null;
+    const map = new Map<string, PricingEntry>();
+    for (const entry of data) {
+      const alias = entry.externalAlias;
+      if (!alias || !alias.startsWith("parasail-")) continue;
+      map.set(alias, {
+        externalAlias: alias,
+        contextLength: entry.contextLength || 0,
+        inputCost: entry.inputCost ?? 0,
+        outputCost: entry.outputCost ?? 0,
+        cachedCost: entry.cachedCost ?? 0,
+        tags: entry.tags || [],
+      });
+    }
+    return map;
+  } catch {
+    return null;
+  }
+}
+
+/** Enrich models with live pricing data from the public endpoint. */
+function applyPricing(models: JsonModel[], pricing: Map<string, PricingEntry>): JsonModel[] {
+  return models.map((model) => {
+    const entry = pricing.get(model.id);
+    if (!entry) return model;
+    const updated = { ...model };
+    updated.cost = {
+      ...updated.cost,
+      input: entry.inputCost ?? updated.cost.input,
+      output: entry.outputCost ?? updated.cost.output,
+      cacheRead: entry.cachedCost ?? updated.cost.cacheRead,
+    };
+    // Update context window from pricing data (authoritative)
+    if (entry.contextLength) {
+      updated.contextWindow = entry.contextLength;
+    }
+    // Update vision from tags
+    if (entry.tags.includes("multimodal") && !updated.input.includes("image")) {
+      updated.input = [...updated.input, "image"];
+    }
+    return updated;
+  });
+}
+
+async function fetchLiveModels(apiKey: string, signal?: AbortSignal): Promise<JsonModel[] | null> {
+  try {
+    const response = await fetch(MODELS_URL, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: signal ? AbortSignal.any([AbortSignal.timeout(LIVE_FETCH_TIMEOUT_MS), signal]) : AbortSignal.timeout(LIVE_FETCH_TIMEOUT_MS),
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    const apiModels = Array.isArray(data) ? data : (data.data || []);
+    if (!Array.isArray(apiModels) || apiModels.length === 0) return null;
+    return apiModels.map(transformApiModel).filter((m): m is JsonModel => m !== null);
+  } catch {
+    return null;
+  }
+}
+
+function loadCachedModels(): JsonModel[] | null {
+  try {
+    const data = JSON.parse(fs.readFileSync(CACHE_PATH, "utf8"));
+    return Array.isArray(data) ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+function cacheModels(models: JsonModel[]): void {
+  try {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(models, null, 2) + "\n");
+  } catch {
+    // Cache write failure is non-fatal
+  }
+}
+
+function mergeWithEmbedded(liveModels: JsonModel[], embeddedModels: JsonModel[]): JsonModel[] {
+  const embeddedMap = new Map(embeddedModels.map(m => [m.id, m]));
+  const seen = new Set<string>();
+  const result: JsonModel[] = [];
+  for (const liveModel of liveModels) {
+    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.
+      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,
+        },
+        contextWindow: liveModel.contextWindow || embedded.contextWindow,
+      });
+    } else {
+      result.push(liveModel);
+    }
+  }
+  // Append any embedded models that the live API didn't return
+  for (const em of embeddedModels) {
+    if (!seen.has(em.id)) {
+      result.push(em);
+    }
+  }
+  return result;
+}
+
+function loadStaleModels(embeddedModels: JsonModel[]): JsonModel[] {
+  const cached = loadCachedModels();
+  if (!cached || cached.length === 0) return embeddedModels;
+
+  // Merge embedded models that are missing from cache (newly added models)
+  const cachedMap = new Map(cached.map(m => [m.id, m]));
+  for (const em of embeddedModels) {
+    if (!cachedMap.has(em.id)) {
+      cached.push(em);
+    }
+  }
+  return cached;
+}
+
+async function revalidateModels(apiKey: string | undefined, embeddedModels: JsonModel[], signal?: AbortSignal): Promise<JsonModel[] | null> {
+  // Fetch both models list and pricing in parallel
+  const [liveModels, pricing] = await Promise.all([
+    apiKey ? fetchLiveModels(apiKey, signal) : Promise.resolve(null),
+    fetchPricingData(signal),
+  ]);
+
+  // Use embedded as base if live fetch failed
+  const base = liveModels && liveModels.length > 0
+    ? mergeWithEmbedded(liveModels, embeddedModels)
+    : embeddedModels;
+
+  // Always apply live pricing if available (public endpoint, no auth needed)
+  const enriched = pricing ? applyPricing(base, pricing) : base;
+
+  cacheModels(enriched);
+  return enriched;
+}
+
+// ─── API Key Resolution (via ModelRegistry) ────────────────────────────────────
+
+let cachedApiKey: string | undefined;
+let revalidateAbort: AbortController | null = null;
+
+async function resolveApiKey(modelRegistry: ModelRegistry): Promise<void> {
+  cachedApiKey = await modelRegistry.getApiKeyForProvider("parasail") ?? undefined;
+}
+
+// ─── Extension Entry Point ────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+  // SWR: Serve stale immediately (cache → embedded) — zero-latency registration
+  const embeddedModels = modelsData as JsonModel[];
+  const customModels = customModelsData as JsonModel[];
+  const patches = patchData as PatchData;
+
+  const staleBase = loadStaleModels(embeddedModels);
+  const staleModels = buildModels(staleBase, customModels, patches);
+
+  pi.registerProvider("parasail", {
+    baseUrl: BASE_URL,
+    apiKey: "$PARASAIL_API_KEY",
+    api: "openai-completions",
+    models: staleModels,
+  });
+
+  // Revalidate in background: fetch live models + pricing → merge → cache → hot-swap
+  // Pricing endpoint is public (no auth needed), models endpoint requires API key
+  pi.on("session_start", async (_event, ctx) => {
+    revalidateAbort?.abort();
+    revalidateAbort = new AbortController();
+    const signal = revalidateAbort.signal;
+    resolveApiKey(ctx.modelRegistry).then(() => {
+      revalidateModels(cachedApiKey, embeddedModels, signal).then((freshBase) => {
+        if (freshBase && !signal.aborted) {
+          pi.registerProvider("parasail", {
+            baseUrl: BASE_URL,
+            apiKey: "$PARASAIL_API_KEY",
+            api: "openai-completions",
+            models: buildModels(freshBase, customModels, patches),
+          });
+        }
+      });
+    });
+  });
+
+  pi.on("session_shutdown", () => {
+    revalidateAbort?.abort();
+  });
+}