pi-openmodel-provider 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-06-20
+
+### Added
+- Async factory pattern (same as pi-commandcode-provider)
+- API key auto-detection from pi's auth.json
+- Debug logs for model loading process
+- Windows path support for auth.json
+
+### Changed
+- Rewrote extension to match Command Code provider architecture
+- Removed all event hooks (session_start, before_agent_start)
+- Simplified to pure async factory function
+- Improved auth.json reading with error handling
+- Updated auth.json path for Windows compatibility
+
+### Fixed
+- All TypeScript errors (no `any`, proper types, `@types/node`)
+- `node:fs` import instead of bare `fs`
+- `allowImportingTsExtensions` in tsconfig
+- `.ts` extension imports working correctly
+- auth.json path resolution
+
+## [0.1.0] - 2026-06-20
+
+### Added
+- Initial release
+- Dynamic model discovery from OpenModel API (42 models)
+- OAuth login via `/login openmodel`
+- Model stability metrics via `/openmodel-stability`
+- Health status indicators on model names
+- Support for 3 protocols: Messages (Anthropic), Responses (OpenAI), Gemini (Google)
+- Provider-based inference for context window, maxTokens, and pricing
+- Commands: `/openmodel`, `/openmodel-stability`
+
+### Changed
+- Models fetched dynamically instead of hardcoded list
+- Context windows inferred from provider (DeepSeek = 1M, Anthropic = 200K, etc.)
+- Pricing as provider defaults with per-model overrides
+
+### Fixed
+- TypeScript type errors
+- `onSelect` optional callback handling
+- Import path extensions (.ts → .js)
+- Process import in models.ts
+
+[0.2.0]: https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/releases/tag/v0.2.0
+[0.1.0]: https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/releases/tag/v0.1.0

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,131 @@
+# pi-openmodel-provider
+
+A [pi](https://github.com/earendil-works/pi-mono) custom provider that connects pi to [OpenModel.ai](https://www.openmodel.ai) — a unified AI API gateway.
+
+> **Disclaimer:** This is an unofficial, community-maintained package. I am not affiliated with, endorsed by, or connected to OpenModel in any way. This provider simply forwards requests to the public OpenModel API using your own API key.
+
+> **Note:** This package only provides a model _provider_. It does **not** include an API key. You must bring your own OpenModel API key.
+
+## Install + Quick start
+
+```sh
+pi install git:github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider
+```
+
+| Step | What to do |
+|------|------------|
+| 1️⃣ | `/login` → "Use a subscription" → **OpenModel** → "Paste API key manually" → paste your key |
+| 2️⃣ | `/reload` (so models appear) |
+| 3️⃣ | `Ctrl + L` or `/model openmodel/deepseek-v4-flash` to select your model |
+
+Done! You can now use OpenModel in pi.
+
+## Usage
+
+After setup, select any OpenModel model:
+
+```txt
+/model openmodel/deepseek-v4-flash
+```
+
+Press **Ctrl + L** to open the model selector and browse available models.
+
+## Models
+
+Models are fetched live from OpenModel's API at startup, so new models show up without a package release.
+
+### Supported Providers
+
+| Provider | Models |
+|----------|--------|
+| OpenAI | GPT-5.x family |
+| Anthropic | Claude Opus/Sonnet/Haiku |
+| Google Gemini | Gemini Flash/Pro |
+| DeepSeek | DeepSeek V4 (1M context) |
+| Alibaba Qwen | Qwen3.x family |
+| Xiaomi (MiMo) | Mimo v2.x |
+| Moonshot (Kimi) | Kimi K2.x |
+| MiniMax | MiniMax M2.x/M3 |
+| ZAI (GLM) | GLM-4.x/5.x |
+
+## Model discovery
+
+On startup, the provider fetches:
+
+```txt
+https://api.openmodel.ai/v1/models
+```
+
+## Pricing
+
+OpenModel does not yet expose model pricing through its Provider API. The provider ships a static cost table (`PROVIDER_DEFAULTS` and `PRICING_OVERRIDES` in `src/models.ts`) for known models so that pi can display per-model pricing.
+
+- Models present in the provider defaults show their estimated per-million-token rates.
+- Models **not** in the table fall back to zero cost.
+
+## Features
+
+- **41 models** from 9+ providers (dynamically fetched)
+- **3 protocols**: Messages (Anthropic), Responses (OpenAI), Gemini (Google)
+- **Model stability metrics** via `/openmodel-stability`
+- **1M context window** for DeepSeek V4 models
+- **No hardcoding** — new models appear automatically
+
+## Commands
+
+```txt
+/openmodel                Show provider status
+/openmodel-stability      Show health metrics for all models
+/openmodel-stability <model>  Show detailed metrics for a specific model
+```
+
+## Stability explained
+
+The `/openmodel-stability` command shows how healthy each model is:
+
+| Symbol | Meaning | Condition |
+|--------|---------|-----------|
+| ✅ Operational | Healthy | ≥99.9% success + enough data |
+| 🟢 Healthy | Good | ≥99% success |
+| 🟡 Degraded | Some issues | ≥95% success |
+| 🔴 Unstable | Problems | <95% success |
+| ⚪ No Data | Not enough info | <10 requests (low confidence) |
+
+```
+✅ deepseek-v4-flash  100.0%   8541ms   136.4 t/s
+   ↑         ↑          ↑        ↑          ↑
+   |         |          |        |          └── Tokens per second
+   |         |          |        └── Average latency (ms)
+   |         |          └── Success rate
+   |         └── Model name
+   └── Health status
+```
+
+## Development
+
+```sh
+# Clone the repo
+git clone https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider
+cd pi-openmodel-provider
+
+# Install dependencies
+npm install
+
+# Type check
+npm run typecheck
+
+# Test model fetching
+npm run test:models
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, PR expectations, and commit message rules.
+
+## Release
+
+See [RELEASE.md](RELEASE.md) for prerelease, npm smoke-test, stable publish, git tag, and GitHub follow-up checklist.
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,128 @@
+/**
+ * OpenModel provider for pi.
+ *
+ * Models are fetched from OpenModel's API at startup.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import { fetchOpenModelModels } from "./src/models.ts"
+import { login, refreshToken, getApiKey } from "./src/auth.ts"
+import {
+  fetchModelStabilitySummary,
+  fetchModelStabilityDetail,
+  formatHealthStatus,
+} from "./src/stability.ts"
+import { readFileSync } from "node:fs"
+
+function getApiKeyFromAuth(): string | null {
+  try {
+    const authPath = "C:/Users/Admin/.pi/agent/auth.json"
+    const content = readFileSync(authPath, "utf-8")
+    const data = JSON.parse(content)
+    return data.openmodel?.access || data.openmodel?.refresh || null
+  } catch {
+    return null
+  }
+}
+
+export default async function (pi: ExtensionAPI) {
+  let models: Awaited<ReturnType<typeof fetchOpenModelModels>> = []
+  const apiKey = getApiKeyFromAuth()
+
+  if (apiKey) {
+    try {
+      models = await fetchOpenModelModels({ apiKey })
+    } catch {
+      // Models will load after API key is configured
+    }
+  }
+
+  pi.registerProvider("openmodel", {
+    name: "OpenModel",
+    baseUrl: "https://api.openmodel.ai",
+    apiKey: "$OPENMODEL_API_KEY",
+    api: "anthropic-messages",
+    oauth: {
+      name: "OpenModel",
+      login,
+      refreshToken,
+      getApiKey,
+    },
+    models: models.map((model) => ({
+      id: model.id,
+      name: model.name,
+      api: model.api,
+      reasoning: model.reasoning,
+      input: model.input,
+      cost: model.cost,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens,
+    })),
+  })
+
+  // /openmodel - Show provider status
+  pi.registerCommand("openmodel", {
+    description: "Show OpenModel provider status",
+    handler: async (_args: string, ctx: any) => {
+      const key = getApiKeyFromAuth()
+      const status = key ? "✅ Configured" : "❌ Not configured"
+      const count = models.length
+
+      const lines = [
+        "╔════════════════════════════════╗",
+        "║        OpenModel.ai            ║",
+        "╠════════════════════════════════╣",
+        `║  Status: ${status.padEnd(20)}║`,
+        `║  Models: ${String(count).padStart(3)} available           ║`,
+        "╠════════════════════════════════╣",
+        "║  Commands:                     ║",
+        "║  /model openmodel/...          ║",
+        "║  /openmodel-stability          ║",
+        "╚════════════════════════════════╝",
+      ]
+      ctx.ui.notify(lines.join("\n"), "info")
+    },
+  })
+
+  // /openmodel-stability - Show model health metrics
+  pi.registerCommand("openmodel-stability", {
+    description: "Show model stability metrics (24h)",
+    handler: async (args: string | undefined, ctx: any) => {
+      try {
+        if (args?.trim()) {
+          const name = args.trim()
+          const detail = await fetchModelStabilityDetail(name)
+          const lines = [
+            `📊 ${detail.model_name}`,
+            `━━━━━━━━━━━━━━━━━━━━━━`,
+            `Health:     ${formatHealthStatus(detail.health_status)}`,
+            `Success:    ${detail.summary.success_rate.toFixed(2)}%`,
+            `Latency:    ${detail.summary.avg_latency_ms.toFixed(0)}ms`,
+            `TTFT:       ${detail.summary.avg_ttft_ms.toFixed(0)}ms`,
+            `Throughput: ${detail.summary.avg_tps.toFixed(1)} t/s`,
+            `Confidence: ${detail.confidence}`,
+          ]
+          ctx.ui.notify(lines.join("\n"), "info")
+        } else {
+          const summary = await fetchModelStabilitySummary()
+          if (summary.length === 0) {
+            ctx.ui.notify("No stability data available.", "warning")
+            return
+          }
+          const lines = ["📊 OpenModel Stability (24h)", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"]
+          const sorted = [...summary].sort((a, b) => {
+            const order = { operational: 0, healthy: 1, degraded: 2, unstable: 3, no_data: 4 }
+            return (order[a.health_status] ?? 5) - (order[b.health_status] ?? 5)
+          })
+          for (const s of sorted) {
+            const emoji = formatHealthStatus(s.health_status).split(" ")[0]
+            lines.push(`${emoji} ${s.model_name.padEnd(28)} ${s.success_rate.toFixed(1).padStart(5)}%  ${s.avg_latency_ms.toFixed(0).padStart(5)}ms  ${s.avg_tps.toFixed(1).padStart(6)} t/s`)
+          }
+          ctx.ui.notify(lines.join("\n"), "info")
+        }
+      } catch {
+        ctx.ui.notify("Failed to fetch stability data.", "error")
+      }
+    },
+  })
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "pi-openmodel-provider",
+  "version": "0.2.0",
+  "description": "pi custom provider for OpenModel.ai - Multi-model AI gateway",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "openmodel",
+    "provider",
+    "ai-gateway"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider.git"
+  },
+  "homepage": "https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider#readme",
+  "files": [
+    "index.ts",
+    "src/",
+    "src/stub.d.ts",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "prettier": "^3.5.0",
+    "tsx": "4.22.4",
+    "typescript": "6.0.3"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test:models": "tsx src/models.ts"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.75.5"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    }
+  }
+}

package/src/auth.ts

@@ -0,0 +1,179 @@
+/**
+ * OpenModel authentication for pi's /login flow.
+ *
+ * Provides OAuth integration so users can authenticate via:
+ *   /login openmodel
+ *
+ * Flow:
+ * 1. Opens the OpenModel Console in the browser
+ * 2. Prompts the user to paste their API key
+ * 3. Validates the key format (must start with "om-")
+ * 4. Stores credentials in pi's auth.json
+ *
+ * Since OpenModel API keys don't expire, "refresh" is a no-op.
+ */
+
+export interface OAuthLoginCallbacks {
+  onAuth(params: { url: string }): void;
+  onPrompt(params: { message: string }): Promise<string>;
+  onSelect?(params: {
+    message: string;
+    options: { id: string; label: string }[];
+  }): Promise<string | undefined>;
+}
+
+export interface OAuthCredentials {
+  refresh: string;
+  access: string;
+  expires: number;
+}
+
+const CONSOLE_URL = "https://console.openmodel.ai";
+const FIVE_YEARS_MS = 5 * 365 * 24 * 60 * 60 * 1000; // API keys don't expire
+
+/**
+ * Sanitize API key input, removing terminal paste wrappers and control chars.
+ */
+export function sanitizeApiKey(input: string): string {
+  const esc = String.fromCharCode(27);
+  return Array.from(
+    input
+      .replaceAll(`${esc}[200~`, "")
+      .replaceAll(`${esc}[201~`, "")
+      .replaceAll("[200~", "")
+      .replaceAll("[201~", ""),
+  )
+    .filter((char) => {
+      const code = char.charCodeAt(0);
+      return code > 31 && code !== 127;
+    })
+    .join("")
+    .trim();
+}
+
+/**
+ * Validate that an API key looks like a valid OpenModel key.
+ */
+export function isValidApiKey(key: string): boolean {
+  return /^om-[A-Za-z0-9_-]+$/.test(key);
+}
+
+function credentialsFromApiKey(apiKey: string): OAuthCredentials {
+  return {
+    refresh: apiKey,
+    access: apiKey,
+    expires: Date.now() + FIVE_YEARS_MS,
+  };
+}
+
+/**
+ * /login openmodel handler.
+ *
+ * Offers two options:
+ * 1. Browser: opens the OpenModel Console so the user can create/copy a key
+ * 2. Manual: prompts the user to paste their API key
+ */
+export async function login(
+  callbacks: OAuthLoginCallbacks,
+): Promise<OAuthCredentials> {
+  // Offer login method choice (onSelect is optional)
+  let method: string | undefined;
+  if (callbacks.onSelect) {
+    method = await callbacks.onSelect({
+      message: "How would you like to authenticate with OpenModel?",
+      options: [
+        { id: "browser", label: "🌐 Open console in browser" },
+        { id: "paste", label: "📋 Paste API key manually" },
+      ],
+    });
+  }
+
+  if (!method) {
+    throw new Error("Login cancelled");
+  }
+
+  if (method === "browser") {
+    // Open the OpenModel Console in the browser
+    callbacks.onAuth({ url: CONSOLE_URL });
+
+    // Then prompt for the API key
+    const apiKey = sanitizeApiKey(
+      await callbacks.onPrompt({
+        message: `1. Open ${CONSOLE_URL}\n2. In the sidebar, click on API Keys\n3. Click Create API Key, give it a name, and copy the generated key\n4. Paste the key here (starts with "om-"):`,
+      }),
+    );
+
+    if (!apiKey) {
+      throw new Error("No OpenModel API key provided");
+    }
+
+    if (!isValidApiKey(apiKey)) {
+      let retry: string | undefined;
+      if (callbacks.onSelect) {
+        retry = await callbacks.onSelect({
+          message: `Invalid API key format. Key should start with "om-". Try again?`,
+          options: [
+            { id: "retry", label: "🔄 Try again" },
+            { id: "cancel", label: "❌ Cancel" },
+          ],
+        });
+      }
+
+      if (retry !== "retry") {
+        throw new Error("Login cancelled - invalid API key");
+      }
+
+      // Recursive retry
+      return login(callbacks);
+    }
+
+    return credentialsFromApiKey(apiKey);
+  }
+
+  // Manual paste
+  const apiKey = sanitizeApiKey(
+    await callbacks.onPrompt({
+      message: 'Paste your OpenModel API key (starts with "om-"):',
+    }),
+  );
+
+  if (!apiKey) {
+    throw new Error("No OpenModel API key provided");
+  }
+
+  if (!isValidApiKey(apiKey)) {
+    const retry = callbacks.onSelect
+      ? await callbacks.onSelect({
+          message: `Invalid API key format. Key should start with "om-". Try again?`,
+          options: [
+            { id: "retry", label: "🔄 Try again" },
+            { id: "cancel", label: "❌ Cancel" },
+          ],
+        })
+      : undefined;
+
+    if (retry !== "retry") {
+      throw new Error("Login cancelled - invalid API key");
+    }
+
+    return login(callbacks);
+  }
+
+  return credentialsFromApiKey(apiKey);
+}
+
+/**
+ * OpenModel API keys don't expire, so "refresh" is a no-op.
+ */
+export async function refreshToken(
+  credentials: OAuthCredentials,
+): Promise<OAuthCredentials> {
+  return credentialsFromApiKey(credentials.refresh);
+}
+
+/**
+ * Extract the API key from stored credentials.
+ */
+export function getApiKey(credentials: OAuthCredentials): string {
+  return credentials.access;
+}

package/src/models.ts

@@ -0,0 +1,309 @@
+/**
+ * OpenModel.ai model fetching and parsing.
+ *
+ * Fetches available models from OpenModel's API endpoint
+ * and maps them to pi provider model definitions.
+ *
+ * Rather than hardcoding per-model metadata, we infer capabilities
+ * from the provider (owned_by) and model name patterns. This way
+ * new models added by OpenModel are automatically supported.
+ */
+
+export const DEFAULT_MODELS_URL = "https://api.openmodel.ai/v1/models";
+export const DEFAULT_API_BASE = "https://api.openmodel.ai";
+
+/** Supported protocols from OpenModel API */
+type SupportedProtocol = "messages" | "responses" | "gemini" | "images";
+
+/** Raw model from OpenModel API response */
+interface OpenModelApiModel {
+  id: string;
+  object: string;
+  created: number;
+  owned_by: string;
+  supported_protocols: SupportedProtocol[];
+  supported_apis?: SupportedProtocol[]; // alt name from docs
+}
+
+/** OpenModel API response shape */
+interface OpenModelModelsResponse {
+  data: OpenModelApiModel[];
+  object: string;
+}
+
+/** Mapped provider model for pi */
+export interface OpenModelProviderModel {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: readonly ("text" | "image")[];
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+  maxTokens: number;
+  api: "anthropic-messages" | "openai-responses" | "google-generative-ai";
+}
+
+// ---------------------------------------------------------------------------
+// Provider-level defaults based on owned_by
+// ---------------------------------------------------------------------------
+
+interface ProviderDefaults {
+  contextWindow: number;
+  maxTokens: number;
+  reasoning: boolean;
+  supportsImages: boolean;
+  costPerMInput: number; // $ per million input tokens
+  costPerMOutput: number; // $ per million output tokens
+}
+
+const PROVIDER_DEFAULTS: Record<string, ProviderDefaults> = {
+  anthropic: {
+    contextWindow: 200_000,
+    maxTokens: 8_192,
+    reasoning: true,
+    supportsImages: true,
+    costPerMInput: 3,
+    costPerMOutput: 15,
+  },
+  deepseek: {
+    contextWindow: 1_000_000,
+    maxTokens: 65_536,
+    reasoning: true,
+    supportsImages: false,
+    costPerMInput: 0.14,
+    costPerMOutput: 0.28,
+  },
+  openai: {
+    contextWindow: 128_000,
+    maxTokens: 16_384,
+    reasoning: true,
+    supportsImages: true,
+    costPerMInput: 2.5,
+    costPerMOutput: 10,
+  },
+  gemini: {
+    contextWindow: 1_000_000,
+    maxTokens: 8_192,
+    reasoning: true,
+    supportsImages: true,
+    costPerMInput: 0.3,
+    costPerMOutput: 1.2,
+  },
+  moonshot: {
+    contextWindow: 128_000,
+    maxTokens: 65_536,
+    reasoning: true,
+    supportsImages: true,
+    costPerMInput: 0.6,
+    costPerMOutput: 3,
+  },
+  zai: {
+    contextWindow: 128_000,
+    maxTokens: 16_384,
+    reasoning: true,
+    supportsImages: false,
+    costPerMInput: 1,
+    costPerMOutput: 3.2,
+  },
+  dashscope: {
+    contextWindow: 131_072,
+    maxTokens: 16_384,
+    reasoning: true,
+    supportsImages: true,
+    costPerMInput: 0.5,
+    costPerMOutput: 3,
+  },
+  minimax: {
+    contextWindow: 128_000,
+    maxTokens: 16_384,
+    reasoning: true,
+    supportsImages: false,
+    costPerMInput: 0.27,
+    costPerMOutput: 0.95,
+  },
+  mimo: {
+    contextWindow: 128_000,
+    maxTokens: 16_384,
+    reasoning: true,
+    supportsImages: false,
+    costPerMInput: 0,
+    costPerMOutput: 0,
+  },
+};
+
+const DEFAULT_FALLBACK: ProviderDefaults = {
+  contextWindow: 128_000,
+  maxTokens: 16_384,
+  reasoning: true,
+  supportsImages: false,
+  costPerMInput: 0,
+  costPerMOutput: 0,
+};
+
+function getDefaults(ownedBy: string): ProviderDefaults {
+  return PROVIDER_DEFAULTS[ownedBy.toLowerCase()] ?? DEFAULT_FALLBACK;
+}
+
+// ---------------------------------------------------------------------------
+// Model-specific overrides for well-known exceptions
+// ---------------------------------------------------------------------------
+
+/** Fine-tune contextWindow for specific model IDs that differ from their provider default */
+const CONTEXT_OVERRIDES: Record<string, number> = {
+  // Some older/smaller models have less context
+};
+
+/** Fine-tune maxTokens for specific model IDs */
+const MAX_TOKENS_OVERRIDES: Record<string, number> = {
+  // e.g., "some-small-model": 4096,
+};
+
+/** Fine-tune reasoning for specific model IDs */
+const REASONING_OVERRIDES: Record<string, boolean> = {
+  "gpt-5.4-mini": false,
+  "gemini-3.1-flash-lite-preview": false,
+  "gemini-3-flash-preview": false,
+};
+
+/** Known pricing exceptions (model-specific overrides to provider defaults) */
+const PRICING_OVERRIDES: Record<string, { input: number; output: number }> = {
+  "claude-opus-4-7": { input: 15, output: 75 },
+  "claude-opus-4-6": { input: 15, output: 75 },
+  "claude-opus-4-8": { input: 15, output: 75 },
+  "claude-sonnet-4-5": { input: 3, output: 15 },
+  "claude-sonnet-4-6": { input: 3, output: 15 },
+  "claude-haiku-4-5-20251001": { input: 0.25, output: 1.25 },
+  "deepseek-v4-pro": { input: 0.435, output: 0.87 },
+  "deepseek-v4-flash": { input: 0.14, output: 0.28 },
+  "gpt-5.5-pro": { input: 10, output: 40 },
+  "gpt-5.5": { input: 5, output: 20 },
+  "gpt-5.4-pro": { input: 5, output: 20 },
+  "gpt-5.4": { input: 2.5, output: 10 },
+  "gpt-5.4-mini": { input: 0.4, output: 1.6 },
+  "gpt-5.3-codex": { input: 2, output: 8 },
+  "gpt-5.2-pro": { input: 5, output: 20 },
+  "gpt-5.2": { input: 2, output: 8 },
+  "gemini-3.5-flash": { input: 0.3, output: 1.2 },
+  "gemini-3.1-pro-preview": { input: 1.5, output: 6.0 },
+  "gemini-3-flash-preview": { input: 0.15, output: 0.6 },
+  "kimi-k2.6": { input: 0.95, output: 4 },
+  "kimi-k2.5": { input: 0.6, output: 3 },
+  "kimi-k2.7-code": { input: 0.95, output: 4 },
+  "glm-5.2": { input: 1.4, output: 5.6 },
+  "glm-5.1": { input: 1.4, output: 4.4 },
+  "glm-5": { input: 1, output: 3.2 },
+  "glm-4.7": { input: 0.5, output: 2 },
+  "qwen3.7-max": { input: 2, output: 6 },
+  "qwen3.6-max-preview": { input: 1.3, output: 7.8 },
+  "qwen3.6-plus": { input: 0.5, output: 3 },
+  "qwen3.6-flash": { input: 0.2, output: 1 },
+  "qwen3.5-plus": { input: 0.5, output: 3 },
+  "qwen3-max": { input: 2.5, output: 6 },
+  "MiniMax-M3": { input: 0.5, output: 2 },
+  "MiniMax-M2.7": { input: 0.3, output: 1.2 },
+  "MiniMax-M2.5": { input: 0.27, output: 0.95 },
+};
+
+// ---------------------------------------------------------------------------
+// Mapping
+// ---------------------------------------------------------------------------
+
+/** Map OpenModel protocol to pi API type */
+function protocolToApi(
+  protocols: SupportedProtocol[],
+): "anthropic-messages" | "openai-responses" | "google-generative-ai" | null {
+  if (protocols.includes("messages")) return "anthropic-messages";
+  if (protocols.includes("responses")) return "openai-responses";
+  if (protocols.includes("gemini")) return "google-generative-ai";
+  return null; // images-only, skip
+}
+
+/** Parse raw API model into pi provider model */
+function parseApiModel(raw: OpenModelApiModel): OpenModelProviderModel | null {
+  // Accept both supported_protocols (API) and supported_apis (doc) field names
+  const protocols = raw.supported_protocols ?? raw.supported_apis ?? [];
+  const api = protocolToApi(protocols);
+  if (!api) return null; // skip image-only models
+
+  const defaults = getDefaults(raw.owned_by);
+  const pricing = PRICING_OVERRIDES[raw.id] ?? {
+    input: defaults.costPerMInput,
+    output: defaults.costPerMOutput,
+  };
+
+  return {
+    id: raw.id,
+    name: raw.id,
+    reasoning: REASONING_OVERRIDES[raw.id] ?? defaults.reasoning,
+    input: defaults.supportsImages
+      ? (["text", "image"] as const)
+      : (["text"] as const),
+    cost: {
+      input: pricing.input,
+      output: pricing.output,
+      cacheRead: pricing.input * 0.1,
+      cacheWrite: pricing.input * 0.25,
+    },
+    contextWindow: CONTEXT_OVERRIDES[raw.id] ?? defaults.contextWindow,
+    maxTokens: MAX_TOKENS_OVERRIDES[raw.id] ?? defaults.maxTokens,
+    api,
+  };
+}
+
+/** Fetch models from OpenModel API */
+export async function fetchOpenModelModels(options?: {
+  url?: string;
+  fetchImpl?: typeof fetch;
+  apiKey?: string;
+}): Promise<readonly OpenModelProviderModel[]> {
+  const url = options?.url ?? DEFAULT_MODELS_URL;
+  const fetchImpl = options?.fetchImpl ?? fetch;
+
+  const headers: Record<string, string> = { accept: "application/json" };
+  if (options?.apiKey) {
+    headers["authorization"] = `Bearer ${options.apiKey}`;
+  }
+
+  const response = await fetchImpl(url, { headers });
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch OpenModel models: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const body = (await response.json()) as OpenModelModelsResponse;
+  const models: OpenModelProviderModel[] = [];
+
+  for (const raw of body.data) {
+    if (raw.object !== "model") continue;
+    const parsed = parseApiModel(raw);
+    if (parsed) models.push(parsed);
+  }
+
+  return models;
+}
+
+// Allow direct execution: `tsx src/models.ts`
+// if (import.meta.url === `file://${process.argv[1]}`) {
+//   const { env } = await import('node:process');
+//   const key = env.OPENMODEL_API_KEY
+//   const models = await fetchOpenModelModels({
+//     apiKey: key ?? undefined,
+//   })
+//   for (const m of models) {
+//     console.log(
+//       `${m.id.padEnd(30)} ` +
+//       `${m.api.padEnd(22)} ` +
+//       `${m.input.join("+").padEnd(8)} ` +
+//       `ctx=${String(m.contextWindow).padStart(7)} ` +
+//       `max=${String(m.maxTokens).padStart(5)} ` +
+//       `\$${m.cost.input.toFixed(3)}/\$${m.cost.output.toFixed(3)}`,
+//     )
+//   }
+// }

package/src/stability.ts

@@ -0,0 +1,182 @@
+/**
+ * OpenModel.ai Model Stability API.
+ *
+ * Fetches real-time stability metrics (success rate, latency, throughput)
+ * for all models. Publicly accessible without authentication.
+ *
+ * Reference:
+ *   GET https://api.openmodel.ai/web/v1/model-stability/summary
+ *   GET https://api.openmodel.ai/web/v1/model-stability/:modelKey
+ */
+
+export const STABILITY_SUMMARY_URL =
+  "https://api.openmodel.ai/web/v1/model-stability/summary";
+
+/** Health status derived from success rate */
+export type HealthStatus =
+  | "operational"
+  | "healthy"
+  | "degraded"
+  | "unstable"
+  | "no_data";
+
+/** Confidence level based on sample size */
+export type ConfidenceLevel = "high" | "medium" | "low";
+
+/** Stability summary for a single model */
+export interface ModelStability {
+  model_name: string;
+  success_rate: number;
+  avg_latency_ms: number;
+  avg_tps: number;
+  confidence: ConfidenceLevel;
+  health_status: HealthStatus;
+}
+
+/** Stability summary for a single model with time series */
+export interface ModelStabilityDetail {
+  model_name: string;
+  confidence: ConfidenceLevel;
+  summary: {
+    success_rate: number;
+    avg_latency_ms: number;
+    avg_ttft_ms: number;
+    avg_tps: number;
+  };
+  series: Array<{
+    ts: number;
+    success_rate: number;
+    avg_latency_ms: number;
+    avg_ttft_ms: number;
+    avg_tps: number;
+    confidence: ConfidenceLevel;
+  }>;
+  updated_at: number;
+  health_status: HealthStatus;
+}
+
+/** Determine health status from success rate */
+function determineHealth(
+  successRate: number,
+  confidence: ConfidenceLevel,
+): HealthStatus {
+  if (confidence === "low") return "no_data";
+  if (successRate >= 99.9) return "operational";
+  if (successRate >= 99) return "healthy";
+  if (successRate >= 95) return "degraded";
+  return "unstable";
+}
+
+/** Fetch stability summary for all models */
+export async function fetchModelStabilitySummary(options?: {
+  url?: string;
+  fetchImpl?: typeof fetch;
+  hours?: number;
+}): Promise<ModelStability[]> {
+  const url = options?.url ?? STABILITY_SUMMARY_URL;
+  const fetchImpl = options?.fetchImpl ?? fetch;
+  const hours = options?.hours ?? 24;
+
+  const params = new URLSearchParams({ hours: String(hours) });
+  const response = await fetchImpl(`${url}?${params}`, {
+    headers: { accept: "application/json" },
+  });
+
+  const body = (await response.json()) as {
+    success: boolean;
+    data: Array<{
+      model_name: string;
+      success_rate: number;
+      avg_latency_ms: number;
+      avg_tps: number;
+      confidence: ConfidenceLevel;
+    }>;
+  };
+
+  if (!body.success) throw new Error("Model stability summary request failed");
+
+  return body.data.map((item) => ({
+    ...item,
+    health_status: determineHealth(item.success_rate, item.confidence),
+  }));
+}
+
+/** Fetch stability detail for a specific model */
+export async function fetchModelStabilityDetail(
+  modelKey: string,
+  options?: {
+    fetchImpl?: typeof fetch;
+    hours?: number;
+  },
+): Promise<ModelStabilityDetail> {
+  const fetchImpl = options?.fetchImpl ?? fetch;
+  const hours = options?.hours ?? 24;
+
+  const params = new URLSearchParams({ hours: String(hours) });
+  const response = await fetchImpl(
+    `https://api.openmodel.ai/web/v1/model-stability/${encodeURIComponent(modelKey)}?${params}`,
+    { headers: { accept: "application/json" } },
+  );
+
+  const body = (await response.json()) as {
+    success: boolean;
+    data: {
+      model_name: string;
+      confidence: ConfidenceLevel;
+      summary: {
+        success_rate: number;
+        avg_latency_ms: number;
+        avg_ttft_ms: number;
+        avg_tps: number;
+      };
+      series: Array<{
+        ts: number;
+        success_rate: number;
+        avg_latency_ms: number;
+        avg_ttft_ms: number;
+        avg_tps: number;
+        confidence: ConfidenceLevel;
+      }>;
+      updated_at: number;
+    };
+  };
+
+  if (!body.success)
+    throw new Error(`Model stability detail request failed for ${modelKey}`);
+
+  return {
+    ...body.data,
+    health_status: determineHealth(
+      body.data.summary.success_rate,
+      body.data.confidence,
+    ),
+  };
+}
+
+/** Format health status with emoji */
+export function formatHealthStatus(status: HealthStatus): string {
+  switch (status) {
+    case "operational":
+      return "✅ Operational";
+    case "healthy":
+      return "🟢 Healthy";
+    case "degraded":
+      return "🟡 Degraded";
+    case "unstable":
+      return "🔴 Unstable";
+    case "no_data":
+      return "⚪ No Data";
+  }
+}
+
+/** Format confidence level */
+export function formatConfidence(level: ConfidenceLevel): string {
+  switch (level) {
+    case "high":
+      return "🟢 High";
+    case "medium":
+      return "🟡 Medium";
+    case "low":
+      return "⚪ Low";
+  }
+}

package/src/stub.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Stub type declarations for peer dependencies that may not be installed.
+ * These are provided by pi-coding-agent when the extension runs.
+ */
+
+declare module "@earendil-works/pi-coding-agent" {
+  export interface ExtensionAPI {
+    registerProvider(name: string, config: any): void;
+    registerCommand(name: string, options: any): void;
+  }
+
+  export interface ProviderModelConfig {
+    id: string;
+    name: string;
+    reasoning: boolean;
+    input: readonly ["text" | "image"];
+    cost: {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+    };
+    contextWindow: number;
+    maxTokens: number;
+    api?: string;
+    headers?: Record<string, string>;
+  }
+}