pi-baseten-provider 1.0.1

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,177 @@
+<div align="center">
+
+# 🅱️ pi-baseten-provider
+
+**DeepSeek, Kimi, GLM & more through [Baseten](https://baseten.co/)**
+
+_A [pi](https://github.com/earendil-works/pi-coding-agent) provider extension for Baseten's OpenAI-compatible Model API._
+
+[![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
+
+- **8+ AI Models** including DeepSeek V3.1, Kimi K2.5/K2.6, GLM 4.7/5, MiniMax M2.5, Nemotron Super, and GPT OSS 120B
+- **OpenAI-Compatible API** — Just change the base URL and API key
+- **Cost Tracking** — Per-model pricing for budget management
+- **Reasoning Models** — Extended thinking via `reasoning_content` field
+- **Vision Support** — Image input on Kimi K2.5 and Kimi K2.6
+- **Reasoning Effort** — Control reasoning depth on GPT OSS 120B
+
+## Installation
+
+### Option 1: Using `pi install` (Recommended)
+
+Install directly from GitHub:
+
+```bash
+pi install https://github.com/monotykamary/pi-baseten-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 BASETEN_API_KEY=your-api-key-here
+
+pi
+```
+
+### Option 2: Manual Clone
+
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/monotykamary/pi-baseten-provider.git
+   cd pi-baseten-provider
+   ```
+
+2. Set your Baseten API key:
+   ```bash
+   # Recommended: add to auth.json
+   # See Authentication section below
+
+   # Or set as environment variable
+   export BASETEN_API_KEY=your-api-key-here
+   ```
+
+3. Run pi with the extension:
+   ```bash
+   pi -e /path/to/pi-baseten-provider
+   ```
+
+## Available Models
+
+| Model | Context | Vision | Reasoning | Input $/M | Output $/M |
+|-------|---------|--------|-----------|-----------|------------|
+| DeepSeek V4 Pro | 131K | ❌ | ✅ | $1.74 | $3.48 |
+| GLM 4.7 | 200K | ❌ | ✅ | $0.60 | $2.20 |
+| GLM 5 | 203K | ❌ | ✅ | $0.95 | $3.15 |
+| GLM 5.1 | 203K | ❌ | ❌ | $1.30 | $4.30 |
+| GLM 5.2 | 262K | ❌ | ✅ | $1.40 | $4.40 |
+| Kimi K2.5 | 262K | ✅ | ✅ | $0.60 | $3.00 |
+| Kimi K2.6 | 262K | ✅ | ✅ | $0.60 | $3.00 |
+| Kimi K2.7 Code | 262K | ❌ | ✅ | $0.95 | $4.00 |
+| Nemotron Super | 203K | ❌ | ✅ | $0.30 | $0.75 |
+| Nemotron Ultra | 203K | ❌ | ✅ | $0.60 | $2.40 |
+| OpenAI GPT 120B | 128K | ❌ | ✅ | $0.10 | $0.50 |
+
+*Costs are per million tokens. Prices subject to change — check [baseten.co/pricing](https://www.baseten.co/pricing/) for current pricing.*
+
+## Usage
+
+After loading the extension, use the `/model` command in pi to select your preferred model:
+
+```
+/model baseten deepseek-ai/DeepSeek-V3.1
+```
+
+Or start pi directly with a Baseten model:
+
+```bash
+pi --provider baseten --model deepseek-ai/DeepSeek-V3.1
+```
+
+## Authentication
+
+The Baseten API key can be configured in multiple ways (resolved in this order):
+
+1. **`auth.json`** (recommended) — Add to `~/.pi/agent/auth.json`:
+   ```json
+   { "baseten": { "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 `BASETEN_API_KEY`
+
+Get your API key at [app.baseten.co/settings/api_keys](https://app.baseten.co/settings/api_keys).
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `BASETEN_API_KEY` | No | Your Baseten API key (fallback if not in auth.json) |
+
+## Configuration
+
+Add to your pi configuration for automatic loading:
+
+```json
+{
+  "extensions": [
+    "/path/to/pi-baseten-provider"
+  ]
+}
+```
+
+### Compat Settings
+
+Baseten's API follows the OpenAI Chat Completions API:
+
+- **`supportsDeveloperRole: true`** — All models. Baseten supports the `developer` role.
+- **`maxTokensField: "max_completion_tokens"`** — All models. Baseten uses `max_completion_tokens`.
+- **`thinkingFormat: "qwen-chat-template"`** — Kimi K2.5/K2.6 and GLM 4.7/5. Reasoning is opt-in on Baseten via `chat_template_kwargs.enable_thinking`. Pi enables this automatically when you set a thinking level (Shift+Tab).
+- **`thinkingFormat: "openai"`** — DeepSeek V3.1, MiniMax M2.5, Nemotron Super. Returns thinking in `reasoning_content` field by default.
+- **`supportsReasoningEffort: true`** — GPT OSS 120B. Supports `reasoning_effort` parameter.
+- **`supportsStore: false`** — All models. Baseten doesn't support the `store` parameter.
+
+### Patch Overrides
+
+The `patch.json` file contains overrides that are applied on top of `models.json` data. This is useful for:
+- Marking models as reasoning-capable when the API features list doesn't include it
+- Filling in pricing for models where the API returns empty values (e.g. new/unlisted models)
+- Adding compat settings that the API doesn't provide
+- Setting `thinkingFormat: "qwen-chat-template"` for models that require `chat_template_kwargs` to enable reasoning (Kimi K2.5/K2.6, GLM 4.7/5)
+
+### Custom Models
+
+The `custom-models.json` file contains full model definitions for models that need manual curation beyond what the API provides, or models not yet available from the API. These are merged in after patch application, taking precedence for matching IDs.
+
+Merge order: `[live|cache|embedded] → patch.json → custom-models.json`
+
+## Updating Models
+
+Run the update script to fetch the latest models from Baseten's API:
+
+```bash
+export BASETEN_API_KEY=your-api-key
+node scripts/update-models.js
+```
+
+This will:
+1. Fetch models from `https://inference.baseten.co/v1/models`
+2. Convert per-token pricing to per-million-tokens
+3. Preserve existing model data (pricing, compat) for known models
+4. Apply overrides from `patch.json`
+5. 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,24 @@
+[
+  {
+    "id": "deepseek-ai/DeepSeek-V4-Pro",
+    "name": "DeepSeek V4 Pro",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.74,
+      "output": 3.48,
+      "cacheRead": 0.15,
+      "cacheWrite": 0
+    },
+    "contextWindow": 131000,
+    "maxTokens": 131000,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  }
+]

package/index.ts

@@ -0,0 +1,319 @@
+/**
+ * Baseten Provider Extension
+ *
+ * Registers Baseten as a custom provider using the openai-completions API.
+ * Base URL: https://inference.baseten.co/v1
+ *
+ * Model resolution strategy: Stale-While-Revalidate
+ *   1. Serve stale immediately: disk cache → embedded models.json (zero-latency)
+ *   2. Revalidate in background: live API /models → merge with embedded → cache → hot-swap
+ *   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:
+ *   #   "baseten": { "type": "api_key", "key": "your-api-key" }
+ *
+ *   # Option 2: Set as environment variable
+ *   export BASETEN_API_KEY=your-api-key
+ *
+ *   # Run pi with the extension
+ *   pi -e /path/to/pi-baseten-provider
+ *
+ * Then use /model to select from available models
+ */
+
+import type { ExtensionAPI, 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 os from "os";
+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;
+  thinkingLevelMap?: {
+    minimal?: string | null;
+    low?: string | null;
+    medium?: string | null;
+    high?: string | null;
+    xhigh?: string | null;
+  };
+  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;
+  thinkingLevelMap?: Record<string, string | null>;
+  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.thinkingLevelMap !== undefined) result.thinkingLevelMap = patch.thinkingLevelMap as JsonModel["thinkingLevelMap"];
+
+  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.reasoning && result.thinkingLevelMap) {
+    delete result.thinkingLevelMap;
+  }
+  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 = "baseten";
+const BASE_URL = "https://inference.baseten.co/v1";
+const MODELS_URL = `${BASE_URL}/models`;
+const CACHE_DIR = path.join(os.homedir(), ".pi", "agent", "cache");
+const CACHE_PATH = path.join(CACHE_DIR, `${PROVIDER_ID}-models.json`);
+const LIVE_FETCH_TIMEOUT_MS = 8000;
+
+/** Transform a model from the Baseten /v1/models API. Baseten returns rich metadata. */
+function transformApiModel(apiModel: any): JsonModel | null {
+  const features: string[] = apiModel.supported_features || [];
+  const hasVision = (apiModel.input_modalities || []).includes("image");
+  const pricing = apiModel.pricing || {};
+  const toPerM = (v: any) => (typeof v === "string" ? parseFloat(v) : (v || 0)) * 1_000_000;
+  const model: JsonModel = {
+    id: apiModel.id,
+    name: apiModel.name || apiModel.id,
+    reasoning: features.includes("reasoning"),
+    input: hasVision ? ["text", "image"] : ["text"],
+    cost: {
+      input: toPerM(pricing.prompt),
+      output: toPerM(pricing.completion),
+      cacheRead: toPerM(pricing.cache_prompt),
+      cacheWrite: 0,
+    },
+    contextWindow: apiModel.context_length || 131072,
+    maxTokens: apiModel.max_completion_tokens || 131072,
+  };
+  if (features.includes("reasoning_effort")) {
+    model.compat = { ...model.compat, supportsReasoningEffort: true };
+  }
+  return model;
+}
+
+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) {
+      result.push({
+        ...liveModel,
+        ...embedded,
+        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> {
+  if (!apiKey) return null;
+  const liveModels = await fetchLiveModels(apiKey, signal);
+  if (!liveModels || liveModels.length === 0) return null;
+  const merged = mergeWithEmbedded(liveModels, embeddedModels);
+  cacheModels(merged);
+  return merged;
+}
+
+// ─── 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("baseten") ?? undefined;
+}
+
+// ─── Extension Entry Point ────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+  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("baseten", {
+    baseUrl: BASE_URL,
+    apiKey: "$BASETEN_API_KEY",
+    api: "openai-completions",
+    models: staleModels,
+  });
+
+  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("baseten", {
+            baseUrl: BASE_URL,
+            apiKey: "$BASETEN_API_KEY",
+            api: "openai-completions",
+            models: buildModels(freshBase, customModels, patches),
+          });
+        }
+      });
+    });
+  });
+
+  pi.on("session_shutdown", () => {
+    revalidateAbort?.abort();
+  });
+}

package/models.json

@@ -0,0 +1,246 @@
+[
+  {
+    "id": "deepseek-ai/DeepSeek-V4-Pro",
+    "name": "Deepseek V4 Pro",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.74,
+      "output": 3.48,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 131000,
+    "maxTokens": 131000,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  },
+  {
+    "id": "zai-org/GLM-4.7",
+    "name": "GLM 4.7",
+    "reasoning": false,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.6,
+      "output": 2.2,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 200000,
+    "maxTokens": 200000,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  },
+  {
+    "id": "zai-org/GLM-5",
+    "name": "GLM 5",
+    "reasoning": false,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.95,
+      "output": 3.15,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 202800,
+    "maxTokens": 202800,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  },
+  {
+    "id": "zai-org/GLM-5.1",
+    "name": "GLM 5.1",
+    "reasoning": false,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.3,
+      "output": 4.3,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 202800,
+    "maxTokens": 202800,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens"
+    }
+  },
+  {
+    "id": "zai-org/GLM-5.2",
+    "name": "GLM 5.2",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.4,
+      "output": 4.4,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 262144,
+    "maxTokens": 262144,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  },
+  {
+    "id": "moonshotai/Kimi-K2.5",
+    "name": "Kimi K2.5",
+    "reasoning": false,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.6,
+      "output": 3,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 262000,
+    "maxTokens": 262000,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  },
+  {
+    "id": "moonshotai/Kimi-K2.6",
+    "name": "Kimi K2.6",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.95,
+      "output": 4,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 262000,
+    "maxTokens": 262000,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "qwen-chat-template"
+    }
+  },
+  {
+    "id": "moonshotai/Kimi-K2.7-Code",
+    "name": "Kimi K2.7 Code",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.95,
+      "output": 4,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 262000,
+    "maxTokens": 262000,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  },
+  {
+    "id": "nvidia/Nemotron-120B-A12B",
+    "name": "Nemotron Super",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.3,
+      "output": 0.75,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 202800,
+    "maxTokens": 202800,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  },
+  {
+    "id": "nvidia/NVIDIA-Nemotron-3-Ultra-550B-A55B",
+    "name": "Nemotron Ultra",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.6,
+      "output": 2.4,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 202800,
+    "maxTokens": 202800,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai"
+    }
+  },
+  {
+    "id": "openai/gpt-oss-120b",
+    "name": "OpenAI GPT 120B",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.1,
+      "output": 0.5,
+      "cacheRead": 0,
+      "cacheWrite": 0
+    },
+    "contextWindow": 128072,
+    "maxTokens": 128072,
+    "compat": {
+      "supportsDeveloperRole": true,
+      "supportsStore": false,
+      "maxTokensField": "max_completion_tokens",
+      "thinkingFormat": "openai",
+      "supportsReasoningEffort": true
+    }
+  }
+]

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "pi-baseten-provider",
+  "version": "1.0.1",
+  "description": "Baseten provider extension for pi - Access DeepSeek, Kimi, GLM, MiniMax, Nemotron, and GPT-OSS models through the Baseten Model API",
+  "author": "monotykamary",
+  "homepage": "https://github.com/monotykamary/pi-baseten-provider#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monotykamary/pi-baseten-provider.git"
+  },
+  "bugs": {
+    "url": "https://github.com/monotykamary/pi-baseten-provider/issues"
+  },
+  "type": "module",
+  "main": "index.ts",
+  "keywords": [
+    "pi",
+    "extension",
+    "provider",
+    "baseten",
+    "ai",
+    "llm",
+    "deepseek",
+    "kimi",
+    "glm",
+    "minimax",
+    "nemotron"
+  ],
+  "license": "MIT",
+  "files": [
+    "index.ts",
+    "models.json",
+    "custom-models.json",
+    "patch.json",
+    "scripts/update-models.js"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'",
+    "update-models": "node scripts/update-models.js"
+  }
+}

package/patch.json

@@ -0,0 +1,54 @@
+{
+  "moonshotai/Kimi-K2.6": {
+    "reasoning": true,
+    "cost": {
+      "input": 0.6,
+      "output": 3.0
+    },
+    "compat": {
+      "thinkingFormat": "qwen-chat-template"
+    }
+  },
+  "moonshotai/Kimi-K2.5": {
+    "reasoning": true,
+    "compat": {
+      "thinkingFormat": "qwen-chat-template"
+    }
+  },
+  "zai-org/GLM-4.7": {
+    "reasoning": true,
+    "compat": {
+      "thinkingFormat": "qwen-chat-template"
+    }
+  },
+  "zai-org/GLM-5": {
+    "reasoning": true,
+    "compat": {
+      "thinkingFormat": "qwen-chat-template"
+    }
+  },
+  "zai-org/GLM-5.2": {
+    "compat": {
+      "thinkingFormat": "qwen-chat-template"
+    },
+    "thinkingLevelMap": {
+      "minimal": "minimal",
+      "low": "low",
+      "medium": "medium",
+      "high": "high",
+      "xhigh": "max"
+    }
+  },
+  "moonshotai/Kimi-K2.7-Code": {
+    "thinkingLevelMap": {
+      "minimal": null,
+      "low": "low",
+      "medium": "medium",
+      "high": "high",
+      "xhigh": null
+    }
+  },
+  "nvidia/Nemotron-120B-A12B": {
+    "reasoning": true
+  }
+}

package/scripts/update-models.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+/**
+ * Update Baseten models from API
+ *
+ * Fetches models from https://inference.baseten.co/v1/models and updates:
+ * - models.json: Provider model definitions (enriched with pricing & compat)
+ * - README.md: Model table in the Available Models section
+ *
+ * The Baseten /v1/models API returns model info including pricing per token,
+ * context lengths, and supported features. Pricing is converted from per-token
+ * to per-million-tokens for pi.
+ *
+ * models.json is the source of truth for curated specs — the script preserves
+ * existing data and only adds new models with API-derived defaults.
+ * Curate models.json manually after new model discovery.
+ *
+ * patch.json and custom-models.json are applied at runtime by the provider.
+ * They are NOT baked into models.json, but ARE used to generate the README table.
+ *
+ * Requires BASETEN_API_KEY environment variable.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const MODELS_API_URL = 'https://inference.baseten.co/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)}`);
+}
+
+// Convert per-token pricing from API to per-million-tokens
+function toPerMillion(val) {
+  if (val === '' || val === null || val === undefined) return null;
+  return Math.round(parseFloat(val) * 1_000_000 * 100) / 100;
+}
+
+// ─── API fetch ───────────────────────────────────────────────────────────────
+
+async function fetchModels() {
+  const apiKey = process.env.BASETEN_API_KEY;
+  if (!apiKey) {
+    throw new Error('BASETEN_API_KEY environment variable is required');
+  }
+
+  console.log(`Fetching models from ${MODELS_API_URL}...`);
+  const response = await fetch(MODELS_API_URL, {
+    headers: { 'Authorization': `Api-Key ${apiKey}` },
+  });
+
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status} ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  const models = 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;
+
+  // Preserve existing curated data (pricing, reasoning, compat, etc.)
+  if (existingModelsMap[id]) {
+    const existing = { ...existingModelsMap[id] };
+    // Update context window from API if changed
+    if (apiModel.context_length) {
+      existing.contextWindow = apiModel.context_length;
+    }
+    // Update max output tokens from API
+    if (apiModel.max_completion_tokens) {
+      existing.maxTokens = apiModel.max_completion_tokens;
+    }
+    // Update features from API
+    const features = apiModel.supported_features || [];
+    existing.reasoning = features.includes('reasoning') ?? existing.reasoning;
+    if (features.includes('vision') && !existing.input.includes('image')) {
+      existing.input = ['text', 'image'];
+    }
+    // Update pricing from API
+    const pricing = apiModel.pricing || {};
+    const inputCost = toPerMillion(pricing.prompt);
+    const outputCost = toPerMillion(pricing.completion);
+    if (inputCost !== null && inputCost > 0) existing.cost.input = inputCost;
+    if (outputCost !== null && outputCost > 0) existing.cost.output = outputCost;
+    return existing;
+  }
+
+  // New model — build from API data + sensible defaults
+  const features = apiModel.supported_features || [];
+  const pricing = apiModel.pricing || {};
+  const hasReasoning = features.includes('reasoning');
+  const hasVision = features.includes('vision');
+
+  const inputTypes = ['text'];
+  if (hasVision) inputTypes.push('image');
+
+  // Convert pricing from per-token to per-million
+  let inputCost = toPerMillion(pricing.prompt) || 0;
+  let outputCost = toPerMillion(pricing.completion) || 0;
+
+  const model = {
+    id,
+    name: apiModel.name || generateDisplayName(id),
+    reasoning: hasReasoning,
+    input: inputTypes,
+    cost: {
+      input: inputCost,
+      output: outputCost,
+      cacheRead: 0,
+      cacheWrite: 0,
+    },
+    contextWindow: apiModel.context_length || 131072,
+    maxTokens: apiModel.max_completion_tokens || apiModel.context_length || 131072,
+  };
+
+  // Add compat
+  const compat = {
+    supportsDeveloperRole: true,
+    supportsStore: false,
+    maxTokensField: 'max_completion_tokens',
+  };
+
+  if (hasReasoning) {
+    compat.thinkingFormat = 'openai';
+  }
+  if (features.includes('reasoning_effort')) {
+    compat.supportsReasoningEffort = true;
+  }
+
+  model.compat = compat;
+
+  return model;
+}
+
+function generateDisplayName(id) {
+  // Fallback: prettify the ID
+  return id
+    .split('/')
+    .pop()
+    .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.thinkingLevelMap !== undefined) result.thinkingLevelMap = patch.thinkingLevelMap;
+  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.reasoning && result.thinkingLevelMap) {
+    delete result.thinkingLevelMap;
+  }
+  if (result.compat && Object.keys(result.compat).length === 0) {
+    delete result.compat;
+  }
+  return result;
+}
+
+/** Full pipeline: base models → patch → custom → 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 >= 1000000) return `${(n / 1000000).toFixed(1)}M`;
+  if (n >= 1000) return `${Math.round(n / 1000)}K`;
+  return n.toString();
+}
+
+function formatCost(cost) {
+  if (cost === 0) return 'Free';
+  if (cost === null || cost === undefined) return '-';
+  return `$${cost.toFixed(2)}`;
+}
+
+function generateReadmeTable(models) {
+  const lines = [
+    '| Model | Context | Vision | Reasoning | Input $/M | Output $/M |',
+    '|-------|---------|--------|-----------|-----------|------------|',
+  ];
+
+  for (const model of models) {
+    const context = formatContext(model.contextWindow);
+    const vision = model.input.includes('image') ? '✅' : '❌';
+    const reasoning = model.reasoning ? '✅' : '❌';
+    const inputCost = formatCost(model.cost.input);
+    const outputCost = formatCost(model.cost.output);
+
+    lines.push(`| ${model.name} | ${context} | ${vision} | ${reasoning} | ${inputCost} | ${outputCost} |`);
+  }
+
+  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 \|[^\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 ────────────────────────────────────────────────────────────────────
+
+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)
+    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(`Reasoning models: ${models.filter(m => m.reasoning).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();