pi-opencode-go-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/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) 2025
+
+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,128 @@
+<div align="center">
+
+# 🟢 pi-opencode-go-provider
+
+**Fast GLM, Kimi & MiniMax via [opencode-go](https://opencode.ai/)**
+
+_Go-optimized endpoints for lower latency — 14+ models 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
+
+- **14+ Optimized AI Models** - DeepSeek, GLM, Kimi, MiMo, MiniMax, and Qwen
+- **Multi-API Support** — uses the correct API protocol per model (Anthropic, OpenAI Completions)
+- **Fast & Efficient** - Go-optimized endpoints for lower latency
+- **Cost Tracking** with per-model pricing for budget management
+- **Reasoning Models** with thinking level maps for proper effort control
+
+## Installation
+
+### Option 1: Using `pi install` (Recommended)
+
+Install directly from GitHub:
+
+```bash
+pi install https://github.com/monotykamary/pi-opencode-go-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 OPENCODE_API_KEY=your-api-key-here
+
+pi
+```
+
+### Option 2: Manual Clone
+
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/monotykamary/pi-opencode-go-provider.git
+   cd pi-opencode-go-provider
+   ```
+
+2. Set your opencode API key:
+   ```bash
+   # Recommended: add to auth.json
+   # See Authentication section below
+
+   # Or set as environment variable
+   export OPENCODE_API_KEY=your-api-key-here
+   ```
+
+3. Run pi with the extension:
+   ```bash
+   pi -e /path/to/pi-opencode-go-provider
+   ```
+
+## Available Models
+
+| Model | API | Type | Context | Max Tokens | Input Cost | Output Cost |
+|-------|-----|------|---------|------------|------------|-------------|
+| DeepSeek V4 Flash | Completions | Text | 1.0M | 384K | $0.14 | $0.28 |
+| DeepSeek V4 Pro | Completions | Text | 1.0M | 384K | $1.74 | $3.48 |
+| GLM-5.1 | Completions | Text | 203K | 33K | $1.40 | $4.40 |
+| GLM-5.2 | Completions | Text | 1.0M | 131K | $1.40 | $4.40 |
+| Kimi K2.6 | Completions | Text + Image | 262K | 66K | $0.95 | $4.00 |
+| Kimi K2.7 Code | Completions | Text + Image | 262K | 262K | $0.95 | $4.00 |
+| MiMo V2.5 | Completions | Text + Image | 1.0M | 128K | $0.14 | $0.28 |
+| MiMo V2.5 Pro | Completions | Text | 1.0M | 128K | $1.74 | $3.48 |
+| MiniMax-M2.7 | Anthropic | Text | 205K | 131K | $0.30 | $1.20 |
+| MiniMax-M3 | Anthropic | Text + Image | 1.0M | 131K | $0.30 | $1.20 |
+| Qwen3.6 Plus | Anthropic | Text + Image | 1.0M | 66K | $0.50 | $3.00 |
+| Qwen3.7 Max | Anthropic | Text | 1.0M | 66K | $2.50 | $7.50 |
+| Qwen3.7 Plus | Anthropic | Text + Image | 1.0M | 66K | $0.40 | $1.60 |
+*Costs are per million tokens. Prices subject to change - check [opencode.ai](https://opencode.ai) for current pricing.*
+
+## Usage
+
+After loading the extension, use the `/model` command in pi to select your preferred model:
+
+```
+/model
+```
+
+Then select "opencode-go" as the provider and choose from the available models.
+
+## Authentication
+
+The opencode-go API key can be configured in multiple ways (resolved in this order):
+
+1. **`auth.json`** (recommended) — Add to `~/.pi/agent/auth.json`:
+   ```json
+   { "opencode-go": { "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 `OPENCODE_API_KEY`
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `OPENCODE_API_KEY` | No | Your opencode.ai API key (fallback if not in auth.json) |
+
+## Configuration
+
+Add to your pi configuration for automatic loading:
+
+```json
+{
+  "extensions": [
+    "/path/to/pi-opencode-go-provider"
+  ]
+}
+```
+
+## License
+
+MIT

package/custom-models.json

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

package/index.ts

@@ -0,0 +1,354 @@
+/**
+ * opencode-go Provider Extension
+ *
+ * Registers opencode-go as a custom provider with multi-API support.
+ * Models use anthropic-messages or openai-completions as appropriate,
+ * with per-model baseUrl/api.
+ *
+ * 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:
+ *   # Set your API key
+ *   export OPENCODE_API_KEY=your-api-key
+ *
+ *   # Run pi with the extension
+ *   pi -e /path/to/pi-opencode-go-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 ────────────────────────────────────────────────────────────────────
+
+type Api = "openai-completions" | "openai-responses" | "anthropic-messages" | "google-generative-ai";
+
+interface ThinkingLevelMapValue {
+  [level: string]: string | null;
+}
+
+interface JsonModel {
+  id: string;
+  name: string;
+  api?: Api;
+  baseUrl?: string;
+  reasoning: boolean;
+  thinkingLevelMap?: ThinkingLevelMapValue;
+  input: ("text" | "image")[];
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+  maxTokens: number;
+  compat?: Record<string, unknown>;
+}
+
+interface PatchEntry {
+  name?: string;
+  api?: Api;
+  baseUrl?: string;
+  reasoning?: boolean;
+  thinkingLevelMap?: ThinkingLevelMapValue;
+  input?: ("text" | "image")[];
+  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.api !== undefined) result.api = patch.api;
+  if (patch.baseUrl !== undefined) result.baseUrl = patch.baseUrl;
+  if (patch.reasoning !== undefined) result.reasoning = patch.reasoning;
+  if (patch.thinkingLevelMap !== undefined) result.thinkingLevelMap = patch.thinkingLevelMap;
+  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 = "opencode-go";
+const BASE_URL = "https://opencode.ai/zen/go/v1";
+const MODELS_URL = `${BASE_URL}/models`;
+const CACHE_DIR = path.join(getAgentDir(), "cache");
+const CACHE_PATH = path.join(CACHE_DIR, `${PROVIDER_ID}-models.json`);
+const LIVE_FETCH_TIMEOUT_MS = 8000;
+
+/** Map models.dev provider.npm to pi API type and base URL. */
+const NPM_TO_API: Record<string, { api: Api; baseUrl: string }> = {
+  "@ai-sdk/anthropic": { api: "anthropic-messages", baseUrl: "https://opencode.ai/zen/go" },
+};
+const DEFAULT_API: { api: Api; baseUrl: string } = { api: "openai-completions", baseUrl: "https://opencode.ai/zen/go/v1" };
+
+/** Transform a model from the opencode-go /v1/models API. Returns minimal data. */
+function transformApiModel(apiModel: any): JsonModel {
+  const npm = apiModel.provider?.npm;
+  const { api, baseUrl } = (npm && NPM_TO_API[npm]) || DEFAULT_API;
+  const rawInput = apiModel.modalities?.input || ["text"];
+  // Pi Model type only supports "text" and "image"
+  const input: ("text" | "image")[] = rawInput.filter((m: string) => m === "text" || m === "image") as ("text" | "image")[];
+  if (!input.includes("text")) input.unshift("text");
+
+  return {
+    id: apiModel.id,
+    name: apiModel.name || apiModel.id,
+    api,
+    baseUrl,
+    reasoning: apiModel.reasoning || false,
+    input,
+    cost: {
+      input: apiModel.cost?.input || 0,
+      output: apiModel.cost?.output || 0,
+      cacheRead: apiModel.cost?.cache_read || 0,
+      cacheWrite: apiModel.cost?.cache_write || 0,
+    },
+    contextWindow: apiModel.limit?.context || apiModel.context_length || 131072,
+    maxTokens: apiModel.limit?.output || 0,
+  };
+}
+
+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);
+  } 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> {
+  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("opencode-go") ?? 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("opencode-go", {
+    baseUrl: BASE_URL,
+    apiKey: "$OPENCODE_API_KEY",
+    api: "openai-completions",
+    models: staleModels.map(m => ({
+      id: m.id,
+      name: m.name,
+      api: m.api || "openai-completions",
+      baseUrl: m.baseUrl,
+      reasoning: m.reasoning,
+      thinkingLevelMap: m.thinkingLevelMap,
+      input: m.input,
+      cost: m.cost,
+      contextWindow: m.contextWindow,
+      maxTokens: m.maxTokens,
+      compat: m.compat,
+    })),
+  });
+
+  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("opencode-go", {
+            baseUrl: BASE_URL,
+            apiKey: "$OPENCODE_API_KEY",
+            api: "openai-completions",
+            models: buildModels(freshBase, customModels, patches).map(m => ({
+              id: m.id,
+              name: m.name,
+              api: m.api || "openai-completions",
+              baseUrl: m.baseUrl,
+              reasoning: m.reasoning,
+              thinkingLevelMap: m.thinkingLevelMap,
+              input: m.input,
+              cost: m.cost,
+              contextWindow: m.contextWindow,
+              maxTokens: m.maxTokens,
+              compat: m.compat,
+            })),
+          });
+        }
+      });
+    });
+  });
+
+  pi.on("session_shutdown", () => {
+    revalidateAbort?.abort();
+  });
+}

package/models.json

@@ -0,0 +1,242 @@
+[
+  {
+    "id": "deepseek-v4-flash",
+    "name": "DeepSeek V4 Flash",
+    "api": "openai-completions",
+    "baseUrl": "https://opencode.ai/zen/go/v1",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.14,
+      "output": 0.28,
+      "cacheRead": 0.0028,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1000000,
+    "maxTokens": 384000
+  },
+  {
+    "id": "qwen3.7-plus",
+    "name": "Qwen3.7 Plus",
+    "api": "anthropic-messages",
+    "baseUrl": "https://opencode.ai/zen/go",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.4,
+      "output": 1.6,
+      "cacheRead": 0.04,
+      "cacheWrite": 0.5
+    },
+    "contextWindow": 1000000,
+    "maxTokens": 65536
+  },
+  {
+    "id": "qwen3.7-max",
+    "name": "Qwen3.7 Max",
+    "api": "anthropic-messages",
+    "baseUrl": "https://opencode.ai/zen/go",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 2.5,
+      "output": 7.5,
+      "cacheRead": 0.5,
+      "cacheWrite": 3.125
+    },
+    "contextWindow": 1000000,
+    "maxTokens": 65536
+  },
+  {
+    "id": "kimi-k2.7-code",
+    "name": "Kimi K2.7 Code",
+    "api": "openai-completions",
+    "baseUrl": "https://opencode.ai/zen/go/v1",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.95,
+      "output": 4,
+      "cacheRead": 0.19,
+      "cacheWrite": 0
+    },
+    "contextWindow": 262144,
+    "maxTokens": 262144
+  },
+  {
+    "id": "glm-5.1",
+    "name": "GLM-5.1",
+    "api": "openai-completions",
+    "baseUrl": "https://opencode.ai/zen/go/v1",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.4,
+      "output": 4.4,
+      "cacheRead": 0.26,
+      "cacheWrite": 0
+    },
+    "contextWindow": 202752,
+    "maxTokens": 32768
+  },
+  {
+    "id": "deepseek-v4-pro",
+    "name": "DeepSeek V4 Pro",
+    "api": "openai-completions",
+    "baseUrl": "https://opencode.ai/zen/go/v1",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.74,
+      "output": 3.48,
+      "cacheRead": 0.0145,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1000000,
+    "maxTokens": 384000
+  },
+  {
+    "id": "glm-5.2",
+    "name": "GLM-5.2",
+    "api": "openai-completions",
+    "baseUrl": "https://opencode.ai/zen/go/v1",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.4,
+      "output": 4.4,
+      "cacheRead": 0.26,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1000000,
+    "maxTokens": 131072
+  },
+  {
+    "id": "minimax-m3",
+    "name": "MiniMax-M3",
+    "api": "anthropic-messages",
+    "baseUrl": "https://opencode.ai/zen/go",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.3,
+      "output": 1.2,
+      "cacheRead": 0.06,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1000000,
+    "maxTokens": 131072
+  },
+  {
+    "id": "minimax-m2.7",
+    "name": "MiniMax-M2.7",
+    "api": "anthropic-messages",
+    "baseUrl": "https://opencode.ai/zen/go",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 0.3,
+      "output": 1.2,
+      "cacheRead": 0.06,
+      "cacheWrite": 0
+    },
+    "contextWindow": 204800,
+    "maxTokens": 131072
+  },
+  {
+    "id": "mimo-v2.5",
+    "name": "MiMo V2.5",
+    "api": "openai-completions",
+    "baseUrl": "https://opencode.ai/zen/go/v1",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.14,
+      "output": 0.28,
+      "cacheRead": 0.0028,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1000000,
+    "maxTokens": 128000
+  },
+  {
+    "id": "kimi-k2.6",
+    "name": "Kimi K2.6",
+    "api": "openai-completions",
+    "baseUrl": "https://opencode.ai/zen/go/v1",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.95,
+      "output": 4,
+      "cacheRead": 0.16,
+      "cacheWrite": 0
+    },
+    "contextWindow": 262144,
+    "maxTokens": 65536
+  },
+  {
+    "id": "mimo-v2.5-pro",
+    "name": "MiMo V2.5 Pro",
+    "api": "openai-completions",
+    "baseUrl": "https://opencode.ai/zen/go/v1",
+    "reasoning": true,
+    "input": [
+      "text"
+    ],
+    "cost": {
+      "input": 1.74,
+      "output": 3.48,
+      "cacheRead": 0.0145,
+      "cacheWrite": 0
+    },
+    "contextWindow": 1048576,
+    "maxTokens": 128000
+  },
+  {
+    "id": "qwen3.6-plus",
+    "name": "Qwen3.6 Plus",
+    "api": "anthropic-messages",
+    "baseUrl": "https://opencode.ai/zen/go",
+    "reasoning": true,
+    "input": [
+      "text",
+      "image"
+    ],
+    "cost": {
+      "input": 0.5,
+      "output": 3,
+      "cacheRead": 0.05,
+      "cacheWrite": 0.625
+    },
+    "contextWindow": 1000000,
+    "maxTokens": 65536
+  }
+]

package/npm-shrinkwrap.json

@@ -0,0 +1,13 @@
+{
+  "name": "pi-opencode-go-provider",
+  "version": "1.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "pi-opencode-go-provider",
+      "version": "1.0.1",
+      "license": "MIT"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "pi-opencode-go-provider",
+  "version": "1.0.2",
+  "description": "Opencode Go provider extension for pi - Fast, efficient GLM, Kimi, and MiniMax models through the opencode.ai API",
+  "type": "module",
+  "main": "index.ts",
+  "keywords": [
+    "pi",
+    "extension",
+    "provider",
+    "opencode",
+    "opencode-go",
+    "ai",
+    "llm",
+    "glm",
+    "kimi",
+    "minimax"
+  ],
+  "author": "",
+  "license": "MIT",
+  "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,17 @@
+{
+  "deepseek-v4-flash": {
+    "compat": { "requiresReasoningContentOnAssistantMessages": true, "thinkingFormat": "deepseek" },
+    "thinkingLevelMap": { "minimal": null, "low": null, "medium": null, "high": "high", "xhigh": "max" }
+  },
+  "deepseek-v4-pro": {
+    "compat": { "requiresReasoningContentOnAssistantMessages": true, "thinkingFormat": "deepseek" },
+    "thinkingLevelMap": { "minimal": null, "low": null, "medium": null, "high": "high", "xhigh": "max" }
+  },
+  "kimi-k2.6": {
+    "compat": { "thinkingFormat": "deepseek", "supportsReasoningEffort": false },
+    "thinkingLevelMap": { "minimal": null, "low": null, "medium": null }
+  },
+  "qwen3.6-plus": {
+    "compat": { "thinkingFormat": "qwen" }
+  }
+}

package/scripts/update-models.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+/**
+ * Script to update opencode-go models from models.dev API
+ * Writes to models.json (Pi-native format) and updates README.md.
+ *
+ * Pipeline: models.dev API → models.json (idempotent, re-runnable)
+ *           patch.json + custom-models.json for our layered overrides
+ */
+
+import https from 'https';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const API_URL = 'https://models.dev/api.json';
+const PROVIDER_ID = 'opencode-go';
+
+// Map models.dev provider.npm to pi API type and base URL
+const NPM_TO_API = {
+  '@ai-sdk/anthropic': { api: 'anthropic-messages', baseUrl: 'https://opencode.ai/zen/go' },
+};
+const DEFAULT_API = { api: 'openai-completions', baseUrl: 'https://opencode.ai/zen/go/v1' };
+
+// Fetch JSON from URL
+function fetchJSON(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse JSON: ${e.message}`));
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+// Format cost for display
+function formatCost(cost) {
+  if (cost === 0) return 'Free';
+  return `$${cost.toFixed(2)}`;
+}
+
+// Format number with K/M suffix
+function formatNumber(num) {
+  if (num === null || num === undefined) return '-';
+  if (num >= 1000000) return `${(num / 1000000).toFixed(1)}M`;
+  if (num >= 1000) return `${(num / 1000).toFixed(0)}K`;
+  return num.toString();
+}
+
+// Get input types from modalities (pi supports "text" and "image" only)
+function getInputTypes(modalities) {
+  const raw = modalities?.input || ['text'];
+  const filtered = raw.filter(m => m === 'text' || m === 'image');
+  if (!filtered.includes('text')) filtered.unshift('text');
+  return filtered;
+}
+
+// Get API label for display
+function getApiLabel(api) {
+  const labels = {
+    'anthropic-messages': 'Anthropic',
+    'openai-responses': 'Responses',
+    'openai-completions': 'Completions',
+    'google-generative-ai': 'Gemini',
+  };
+  return labels[api] || api;
+}
+
+// Convert API model to Pi-native format with per-model api/baseUrl
+function convertModel(model) {
+  const npm = model.provider?.npm;
+  const { api, baseUrl } = (npm && NPM_TO_API[npm]) || DEFAULT_API;
+  const inputTypes = getInputTypes(model.modalities);
+  const cost = model.cost || {};
+  const limit = model.limit || {};
+
+  return {
+    id: model.id,
+    name: model.name,
+    api,
+    baseUrl,
+    reasoning: model.reasoning || false,
+    input: inputTypes,
+    cost: {
+      input: cost.input || 0,
+      output: cost.output || 0,
+      cacheRead: cost.cache_read || 0,
+      cacheWrite: cost.cache_write || 0,
+    },
+    contextWindow: limit.context || 0,
+    maxTokens: limit.output || 0,
+  };
+}
+
+// Generate README model table row
+function generateReadmeRow(model) {
+  const cost = model.cost || {};
+  const hasImage = model.input.includes('image');
+  const typeLabel = hasImage ? 'Text + Image' : 'Text';
+  return `| ${model.name} | ${getApiLabel(model.api)} | ${typeLabel} | ${formatNumber(model.contextWindow)} | ${formatNumber(model.maxTokens)} | ${formatCost(cost.input)} | ${formatCost(cost.output)} |`;
+}
+
+// Update README model table
+function updateReadme(models) {
+  const readmePath = path.join(process.cwd(), 'README.md');
+  let readme;
+
+  try {
+    readme = fs.readFileSync(readmePath, 'utf8');
+  } catch {
+    console.log('  No README.md found, skipping README update');
+    return;
+  }
+
+  // Sort models by name
+  const sortedModels = [...models].sort((a, b) => a.name.localeCompare(b.name));
+
+  // Generate table rows
+  const tableRows = sortedModels.map(generateReadmeRow).join('\n');
+  const newTable = `| Model | API | Type | Context | Max Tokens | Input Cost | Output Cost |
+|-------|-----|------|---------|------------|------------|-------------|
+${tableRows}`;
+
+  // Replace table in README
+  const tableRegex = /\| Model \| API \| Type \| Context \| Max Tokens \| Input Cost \| Output Cost \|[\s\S]*?(?=\n\*Costs are per million)/;
+  if (readme.match(tableRegex)) {
+    readme = readme.replace(tableRegex, newTable);
+  } else {
+    // Fallback: replace old 6-column table format
+    const oldTableRegex = /\| Model \| Type \| Context \| Max Tokens \| Input Cost \| Output Cost \|[\s\S]*?(?=\n\*Costs are per million)/;
+    if (readme.match(oldTableRegex)) {
+      readme = readme.replace(oldTableRegex, newTable);
+    }
+  }
+
+  // Update model count in features
+  readme = readme.replace(/\*\*\d+ Optimized AI Models\*\*/, `**${models.length} Optimized AI Models**`);
+
+  fs.writeFileSync(readmePath, readme);
+  console.log(`  Updated README.md with ${models.length} models`);
+}
+
+async function main() {
+  console.log('Fetching models from API...');
+
+  try {
+    const data = await fetchJSON(API_URL);
+    const provider = data[PROVIDER_ID];
+
+    if (!provider) {
+      throw new Error(`Provider "${PROVIDER_ID}" not found in API`);
+    }
+
+    if (!provider.models) {
+      throw new Error(`No models found for provider "${PROVIDER_ID}"`);
+    }
+
+    // Convert models object to array and filter out deprecated
+    const apiModels = Object.values(provider.models).filter(m => m.status !== 'deprecated');
+
+    console.log(`Found ${apiModels.length} active models`);
+
+    // Convert to Pi-native format and save to models.json
+    const models = apiModels.map(convertModel);
+    const modelsPath = path.join(process.cwd(), 'models.json');
+    fs.writeFileSync(modelsPath, JSON.stringify(models, null, 2) + '\n');
+    console.log(`  Saved ${models.length} models to models.json`);
+
+    // Update README
+    updateReadme(models);
+
+    console.log('\nDone!');
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();