pi-openmodel-provider 0.2.8 → 0.2.9

package/.agents/skills/pi-openmodel-info/SKILL.md

@@ -39,3 +39,7 @@ The `/openmodel-stability` command shows real-time data from OpenModel's public
 - 🟡 Degraded (≥95%)
 - 🔴 Unstable (<95%)
 - ⚪ No Data (<10 requests)
+
+---
+
+**Maintained by** [Ivan Gabriel Yarupaitan Rivera](https://www.vanchi.pro/)

package/AGENTS.md

@@ -5,3 +5,5 @@
 - See `.agents/skills/pi-openmodel-info/SKILL.md` for full documentation.
 - Follow [CONTRIBUTING.md](CONTRIBUTING.md) before changing code.
 - Use [RELEASE.md](RELEASE.md) for release process.
+
+**Maintained by** [Ivan Gabriel Yarupaitan Rivera](https://www.vanchi.pro/)

package/CHANGELOG.md

@@ -5,6 +5,29 @@ 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.9] - 2026-06-20
+
+### Added
+- `src/errors.ts` with `parseWebError`, `parseProxyError`, `friendlyMessage` helpers
+- Friendly error messages for 401, 402, 404, 429, 5xx and more
+- `thinkingLevelMap` for reasoning models (Messages + Responses protocols)
+- Error handling in model discovery and stability endpoints
+- Comprehensive error handling section in README
+
+### Changed
+- Models now fetched from two public endpoints (no auth required)
+- Pricing, context window, reasoning, and vision capabilities from real API
+- Removed all hardcoded pricing tables (PROVIDER_DEFAULTS, PRICING_OVERRIDES)
+- Simplified index.ts: removed readFileSync and auth.json reading
+- Stability errors now show specific API error codes
+- Updated all tests to use mock fetch with real API response format
+
+### Removed
+- Hardcoded PROVIDER_DEFAULTS in src/models.ts
+- Hardcoded PRICING_OVERRIDES, CONTEXT_OVERRIDES, MAX_TOKENS_OVERRIDES
+- Hardcoded REASONING_OVERRIDES in src/models.ts
+- readFileSync import and getApiKeyFromAuth function from index.ts
+
 ## [0.2.6] - 2026-06-20
 
 ### Fixed
@@ -86,6 +109,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Import path extensions (.ts → .js)
 - Process import in models.ts
 
+[0.2.9]: https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/releases/tag/v0.2.9
 [0.2.6]: https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/releases/tag/v0.2.6
 [0.2.5]: https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/releases/tag/v0.2.5
 [0.2.4]: https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/releases/tag/v0.2.4

package/README.md

@@ -2,6 +2,8 @@
 
 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.
 
+[![npm version](https://badge.fury.io/js/pi-openmodel-provider.svg)](https://www.npmjs.com/package/pi-openmodel-provider)
+
 > **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.
@@ -16,8 +18,6 @@ pi install npm:pi-openmodel-provider
 
 ![pi-openmodel-provider thumbnail](https://raw.githubusercontent.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/master/media/thumbnail.jpeg)
 
-[▶️ Watch video tutorial](https://youtu.be/aUaXznGVuzg)
-
 | Step | What to do |
 |------|------------|
 | 1️⃣ | `/reload` (so OpenModel appears in /login) |
@@ -57,18 +57,21 @@ Models are fetched live from OpenModel's API at startup, so new models show up w
 
 ## Model discovery
 
-On startup, the provider fetches:
+On startup, the provider fetches models from two public endpoints (no authentication required):
 
-```txt
-https://api.openmodel.ai/v1/models
-```
+- **Model list & protocols:** `https://api.openmodel.ai/v1/models`
+- **Pricing & capabilities:** `https://api.openmodel.ai/web/v1/models`
+
+Pricing, context window, reasoning support, and vision capabilities are all provided by the API — no hardcoded data.
 
 ## 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.
+Model pricing is fetched live from OpenModel's public API (`/web/v1/models`). Each model returns its real per-token rates in microdollars, converted to dollars per million tokens for display.
 
-- Models present in the provider defaults show their estimated per-million-token rates.
-- Models **not** in the table fall back to zero cost.
+- Input and output tokens are billed at separate rates
+- Cache reads and writes are billed at reduced rates
+- A `price_multiplier` may apply (e.g., 0.95 = 5% discount)
+- Free models have zero cost
 
 ## Features
 
@@ -76,7 +79,23 @@ OpenModel does not yet expose model pricing through its Provider API. The provid
 - **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
+- **Thinking levels** for reasoning models (DeepSeek, Claude, GPT, Gemini, etc.)
+- **Friendly error messages** with emojis and actionable guidance
+- **No hardcoding** — new models, pricing, and capabilities appear automatically
+
+## Error handling
+
+Errors from OpenModel's API are shown with friendly messages:
+
+| HTTP Status | What you'll see |
+|-------------|-----------------|
+| 401 | 🔑 Invalid API key. Check your credentials or run /login again. |
+| 402 | 💳 Insufficient balance. Top up at console.openmodel.ai |
+| 429 | ⏳ Rate limited. Try again later. |
+| 404 | 🔍 Resource not found. Check the model name. |
+| 5xx | 🔧 OpenModel API error. Try again later. |
+
+For stability endpoints, errors include context about what went wrong.
 
 ## Commands
 
@@ -121,8 +140,14 @@ npm install
 # Type check
 npm run typecheck
 
-# Test model fetching
+# Run all tests
+npm test
+
+# Run specific tests
 npm run test:models
+npm run test:auth
+npm run test:pricing
+npm run test:stability
 ```
 
 ## Contributing
@@ -135,4 +160,8 @@ See [RELEASE.md](RELEASE.md) for prerelease, npm smoke-test, stable publish, git
 
 ## License
 
-MIT
+MIT
+
+---
+
+**Maintained by** [Ivan Gabriel Yarupaitan Rivera](https://www.vanchi.pro/)

package/index.ts

@@ -1,7 +1,7 @@
 /**
  * OpenModel provider for pi.
  *
- * Models are fetched from OpenModel's API at startup.
+ * Models are fetched from OpenModel's public API at startup.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
@@ -12,28 +12,19 @@ import {
   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
-  }
-}
+import { friendlyMessage } from "./src/errors.ts"
 
 export default async function (pi: ExtensionAPI) {
   let models: Awaited<ReturnType<typeof fetchOpenModelModels>> = []
-  const apiKey = getApiKeyFromAuth()
+  let modelError: string | null = null
 
-  if (apiKey) {
-    try {
-      models = await fetchOpenModelModels({ apiKey })
-    } catch {
-      // Models will load after API key is configured
+  try {
+    models = await fetchOpenModelModels()
+  } catch (error) {
+    if (error instanceof TypeError && error.message.includes("fetch")) {
+      modelError = "🌐 Network error: check your internet connection"
+    } else {
+      modelError = `⚠️ ${error instanceof Error ? error.message : "Could not load models"}`
     }
   }
 
@@ -48,39 +39,71 @@ export default async function (pi: ExtensionAPI) {
       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,
-    })),
+    models: models.map((model) => {
+      const config: Record<string, unknown> = {
+        id: model.id,
+        name: model.name,
+        api: model.api,
+        reasoning: model.reasoning,
+        input: model.input,
+        cost: model.cost,
+        contextWindow: model.contextWindow,
+        maxTokens: model.maxTokens,
+      }
+      if (model.thinkingLevelMap) {
+        config.thinkingLevelMap = model.thinkingLevelMap
+      }
+      return config
+    }),
   })
 
   // /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 status = count > 0
+        ? `✅ ${count} models loaded`
+        : modelError ?? "❌ No models loaded"
+
+      // Detect if user has configured an API key in auth.json
+      let hasApiKey = false
+      try {
+        const { readFileSync } = await import("node:fs")
+        const authPath = `${require("node:os").homedir()}/.pi/agent/auth.json`
+        const content = readFileSync(authPath, "utf-8")
+        const data = JSON.parse(content)
+        hasApiKey = !!(data.openmodel?.access || data.openmodel?.refresh)
+      } catch {
+        // Auth file not found
+      }
 
       const lines = [
-        "╔════════════════════════════════╗",
-        "║        OpenModel.ai            ║",
-        "╠════════════════════════════════╣",
-        `║  Status: ${status.padEnd(20)}║`,
-        `║  Models: ${String(count).padStart(3)} available           ║`,
-        "╠════════════════════════════════╣",
-        "║  Commands:                     ║",
-        "║  /model openmodel/...          ║",
-        "║  /openmodel-stability          ║",
-        "╚════════════════════════════════╝",
+        "╔══════════════════════════════════╗",
+        "║        OpenModel.ai              ║",
+        "╠══════════════════════════════════╣",
+        `║  Models: ${String(count).padStart(3)} loaded                    ║`,
+        hasApiKey ? "║  API Key: ✅ Configured              ║" : "║  API Key: ❌ Not configured          ║",
+        "╠══════════════════════════════════╣",
+        "║  Commands:                       ║",
+        "║  /model openmodel/...            ║",
+        "║  /openmodel-stability            ║",
+        "╚══════════════════════════════════╝",
       ]
-      ctx.ui.notify(lines.join("\n"), "info")
+
+      const hints: string[] = []
+      if (!hasApiKey) {
+        hints.push("ℹ️  Run /login → OpenModel → paste your API key")
+      }
+      if (count === 0 && hasApiKey) {
+        hints.push("ℹ️  Run /reload after setting your API key")
+      }
+      if (count === 0 && modelError) {
+        hints.push(`ℹ️  ${modelError}`)
+      }
+      hints.push("ℹ️  Press Ctrl+L to select a model")
+
+      ctx.ui.notify([...lines, ...hints].join("\n"), "info")
     },
   })
 
@@ -106,7 +129,7 @@ export default async function (pi: ExtensionAPI) {
         } else {
           const summary = await fetchModelStabilitySummary()
           if (summary.length === 0) {
-            ctx.ui.notify("No stability data available.", "warning")
+            ctx.ui.notify("📊 No stability data available for any model yet.", "warning")
             return
           }
           const lines = ["📊 OpenModel Stability (24h)", "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"]
@@ -120,8 +143,9 @@ export default async function (pi: ExtensionAPI) {
           }
           ctx.ui.notify(lines.join("\n"), "info")
         }
-      } catch {
-        ctx.ui.notify("Failed to fetch stability data.", "error")
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : "Unknown error"
+        ctx.ui.notify(`❌ ${msg}`, "error")
       }
     },
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openmodel-provider",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "pi custom provider for OpenModel.ai - Multi-model AI gateway",
   "type": "module",
   "keywords": [
@@ -35,7 +35,12 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "test:models": "tsx src/models.ts"
+    "test:models": "tsx tests/test-models.ts",
+    "test:auth": "tsx tests/test-auth.ts",
+    "test:pricing": "tsx tests/test-pricing.ts",
+    "test:stability": "tsx tests/test-stability.ts",
+    "test:edge": "tsx tests/test-edge-cases.ts",
+    "test": "tsx tests/test-models.ts && tsx tests/test-auth.ts && tsx tests/test-pricing.ts && tsx tests/test-stability.ts && tsx tests/test-edge-cases.ts"
   },
   "pi": {
     "extensions": [

package/src/errors.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared error handling for OpenModel API responses.
+ *
+ * OpenModel Web API returns errors in this format:
+ *   { success: false, error: { code: string, msg: string, detail?: string } }
+ *
+ * Proxy endpoints return errors in provider-specific formats (Anthropic, OpenAI, Gemini).
+ */
+
+/** Parse an OpenModel Web API error response body */
+export function parseWebError(body: unknown): { code: string; message: string; detail?: string } {
+  const err = (body as any)?.error
+  if (err?.code && err?.msg) {
+    const result: { code: string; message: string; detail?: string } = {
+      code: String(err.code),
+      message: String(err.msg),
+    }
+    if (err.detail) {
+      result.detail = String(err.detail)
+    }
+    return result
+  }
+  return { code: "UNKNOWN", message: "An unknown error occurred" }
+}
+
+/** Parse an OpenModel proxy API error body (any format) */
+export function parseProxyError(body: unknown): { code: string; message: string } {
+  const b = body as any
+
+  // Anthropic format: { type: "error", error: { type, message } }
+  if (b?.type === "error" && b?.error?.message) {
+    return { code: b.error.type ?? "UNKNOWN", message: b.error.message }
+  }
+
+  // OpenAI format: { error: { message, type, code } }
+  if (b?.error?.message) {
+    return { code: b.error.code ?? b.error.type ?? "UNKNOWN", message: b.error.message }
+  }
+
+  // Gemini format: { error: { code, message, status } }
+  if (b?.error?.status) {
+    return { code: b.error.status, message: b.error.message }
+  }
+
+  return { code: "UNKNOWN", message: "An unknown error occurred" }
+}
+
+/** Return a user-friendly message for known error codes */
+export function friendlyMessage(code: string, fallback: string): string {
+  const map: Record<string, string> = {
+    UNAUTHORIZED: "🔑 Invalid API key. Check your credentials or run /login again.",
+    INVALID_TOKEN: "🔑 Invalid or expired API key. Run /login again.",
+    TOKEN_EXPIRED: "🔑 API key expired. Run /login again.",
+    FORBIDDEN: "🚫 Permission denied. Check your account permissions.",
+    NOT_FOUND: "🔍 Resource not found. Check the model name or endpoint.",
+    RESOURCE_NOT_FOUND: "🔍 Model not found. Check the name and try again.",
+    TOO_MANY_REQUESTS: "⏳ Rate limited. Try again later.",
+    INSUFFICIENT_BALANCE: "💳 Insufficient balance. Top up at console.openmodel.ai",
+    PAYLOAD_TOO_LARGE: "📦 Request too large. Reduce the input size.",
+    VALIDATION_FAILED: "⚠️ Invalid request. Check your parameters.",
+    INTERNAL_ERROR: "🔧 OpenModel API error. Try again later.",
+    SERVICE_UNAVAIL: "🔧 Service temporarily unavailable. Try again later.",
+    BAD_REQUEST: "⚠️ Invalid request. Check the parameters.",
+    CONFIG_NOT_READY: "⏳ System not ready. Try again later.",
+  }
+  return map[code] ?? fallback
+}

package/src/models.ts

@@ -1,309 +1,223 @@
 /**
  * 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.
+ * Fetches available models from OpenModel's public API (no auth required).
+ * Pricing, context window, and capabilities are all provided by the API.
  */
 
-export const DEFAULT_MODELS_URL = "https://api.openmodel.ai/v1/models";
-export const DEFAULT_API_BASE = "https://api.openmodel.ai";
+import { parseWebError, parseProxyError, friendlyMessage } from "./errors.ts"
 
-/** Supported protocols from OpenModel API */
-type SupportedProtocol = "messages" | "responses" | "gemini" | "images";
+const DEFAULT_WEB_MODELS_URL = "https://api.openmodel.ai/web/v1/models"
+export const DEFAULT_LEGACY_MODELS_URL = "https://api.openmodel.ai/v1/models"
 
-/** 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
+export interface OpenModelProviderModel {
+  id: string
+  name: string
+  reasoning: boolean
+  thinkingLevelMap?: Partial<Record<"off" | "minimal" | "low" | "medium" | "high" | "xhigh", string | null>>
+  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"
 }
 
-/** OpenModel API response shape */
-interface OpenModelModelsResponse {
-  data: OpenModelApiModel[];
-  object: string;
+interface WebApiModel {
+  key: string
+  provider_key: string
+  provider_name: string
+  prices: Record<string, number | Record<string, number>>
+  max: {
+    max_input_tokens?: number
+    max_output_tokens?: number
+    max_tokens?: number
+  }
+  supports: {
+    supports_reasoning?: boolean
+    supports_vision?: boolean
+    supports_image_generation?: boolean
+  }
+  price_multiplier: number
 }
 
-/** 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";
+interface WebApiResponse {
+  success: boolean
+  data: WebApiModel[]
+  meta: { pagination: { page: number; pageSize: number; total: number; totalPages: number } }
 }
 
-// ---------------------------------------------------------------------------
-// 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
+interface LegacyApiModel {
+  id: string
+  object: string
+  owned_by: string
+  supported_protocols: string[]
 }
 
-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;
+interface LegacyApiResponse {
+  data: LegacyApiModel[]
+  object: string
 }
 
-// ---------------------------------------------------------------------------
-// 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
+function pricePerMillion(costPerToken: number | undefined): number {
+  if (costPerToken === undefined || costPerToken === null) return 0
+  return Math.round(costPerToken * 1_000_000 * 1000) / 1000
 }
 
-/** 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,
-  };
+function determineApi(protocols: string[], provider: string): "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
 }
 
-/** 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;
+function thinkingLevelMapForApi(api: "anthropic-messages" | "openai-responses" | "google-generative-ai"): Partial<Record<"off" | "minimal" | "low" | "medium" | "high" | "xhigh", string | null>> {
+  if (api === "anthropic-messages") {
+    return {
+      minimal: "low",
+      low: "medium",
+      medium: "high",
+      high: "high",
+      xhigh: "max",
+    }
+  }
+  if (api === "openai-responses") {
+    return {
+      minimal: "low",
+      low: "low",
+      medium: "medium",
+      high: "high",
+      xhigh: "high",
+    }
+  }
+  return {}
+}
 
-  const headers: Record<string, string> = { accept: "application/json" };
-  if (options?.apiKey) {
-    headers["authorization"] = `Bearer ${options.apiKey}`;
+/** Fetch all models from the web API (public, no auth required) */
+async function fetchWebModels(options?: {
+  url?: string
+  fetchImpl?: typeof fetch
+}): Promise<Map<string, WebApiModel>> {
+  const baseUrl = options?.url ?? DEFAULT_WEB_MODELS_URL
+  const fetchImpl = options?.fetchImpl ?? fetch
+
+  const modelMap = new Map<string, WebApiModel>()
+  let page = 1
+  let totalPages = 1
+
+  while (page <= totalPages) {
+    const response = await fetchImpl(`${baseUrl}?page=${page}`, {
+      headers: { accept: "application/json" },
+    })
+
+    if (!response.ok) {
+      let body: any
+      try { body = await response.json() } catch {}
+      const err = parseWebError(body)
+      throw new Error(`Failed to fetch models: ${response.status} ${err.code} — ${friendlyMessage(err.code, err.message)}`)
+    }
+
+    const body = (await response.json()) as WebApiResponse
+    if (!body.success) {
+      throw new Error(`Failed to fetch models — ${friendlyMessage("INTERNAL_ERROR", "Unknown error")}`)
+    }
+
+    totalPages = body.meta.pagination.totalPages
+    for (const model of body.data) {
+      modelMap.set(model.key, model)
+    }
+    page++
   }
 
-  const response = await fetchImpl(url, { headers });
+  return modelMap
+}
+
+/** Fetch protocol info from legacy models endpoint */
+async function fetchLegacyModels(options?: {
+  url?: string
+  fetchImpl?: typeof fetch
+}): Promise<Map<string, LegacyApiModel>> {
+  const url = options?.url ?? DEFAULT_LEGACY_MODELS_URL
+  const fetchImpl = options?.fetchImpl ?? fetch
+
+  const response = await fetchImpl(url, {
+    headers: { accept: "application/json" },
+  })
 
   if (!response.ok) {
-    throw new Error(
-      `Failed to fetch OpenModel models: ${response.status} ${response.statusText}`,
-    );
+    let body: any
+    try { body = await response.json() } catch {}
+    const err = parseProxyError(body)
+    throw new Error(`Failed to fetch models: ${response.status} — ${friendlyMessage(err.code, err.message)}`)
   }
 
-  const body = (await response.json()) as OpenModelModelsResponse;
-  const models: OpenModelProviderModel[] = [];
+  const body = (await response.json()) as LegacyApiResponse
+  const modelMap = new Map<string, LegacyApiModel>()
 
-  for (const raw of body.data) {
-    if (raw.object !== "model") continue;
-    const parsed = parseApiModel(raw);
-    if (parsed) models.push(parsed);
+  for (const model of body.data) {
+    if (model.object === "model") {
+      modelMap.set(model.id, model)
+    }
   }
 
-  return models;
+  return modelMap
 }
 
-// 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)}`,
-//     )
-//   }
-// }
+/** Fetch models from OpenModel API (public, no auth required) */
+export async function fetchOpenModelModels(options?: {
+  webUrl?: string
+  legacyUrl?: string
+  fetchImpl?: typeof fetch
+}): Promise<readonly OpenModelProviderModel[]> {
+  const fetchImpl = options?.fetchImpl ?? fetch
+
+  const [webModels, legacyModels] = await Promise.all([
+    fetchWebModels({ fetchImpl }),
+    fetchLegacyModels({ fetchImpl }),
+  ])
+
+  const models: OpenModelProviderModel[] = []
+
+  for (const [id, web] of webModels) {
+    // Skip image-only models
+    if (web.supports.supports_image_generation && !web.supports.supports_vision && !web.supports.supports_reasoning) {
+      continue
+    }
+
+    const legacy = legacyModels.get(id)
+    const protocols = legacy?.supported_protocols ?? []
+    const api = determineApi(protocols, web.provider_key)
+    if (!api) continue
+
+    const inputPrice = pricePerMillion(web.prices.input_cost_per_token as number)
+    const outputPrice = pricePerMillion(web.prices.output_cost_per_token as number)
+    const cacheRead = pricePerMillion(web.prices.cache_read_input_token_cost as number)
+    const cacheWrite = pricePerMillion(web.prices.cache_creation_input_token_cost as number)
+
+    const reasoning = web.supports.supports_reasoning ?? false
+
+    const base = {
+      id,
+      name: id,
+      reasoning,
+      input: web.supports.supports_vision ? ["text", "image"] as const : ["text"] as const,
+      cost: {
+        input: inputPrice * (web.price_multiplier ?? 1),
+        output: outputPrice * (web.price_multiplier ?? 1),
+        cacheRead,
+        cacheWrite,
+      },
+      contextWindow: web.max.max_input_tokens ?? 128_000,
+      maxTokens: web.max.max_output_tokens ?? web.max.max_tokens ?? 16_384,
+      api,
+    } as const
+
+    const model = {
+      ...base,
+      ...(reasoning ? { thinkingLevelMap: thinkingLevelMapForApi(api) } : {}),
+    } as unknown as OpenModelProviderModel
+
+    models.push(model)
+  }
+
+  return models
+}

package/src/stability.ts

@@ -9,6 +9,8 @@
  *   GET https://api.openmodel.ai/web/v1/model-stability/:modelKey
  */
 
+import { parseWebError, friendlyMessage } from "./errors.ts"
+
 export const STABILITY_SUMMARY_URL =
   "https://api.openmodel.ai/web/v1/model-stability/summary";
 
@@ -82,6 +84,13 @@ export async function fetchModelStabilitySummary(options?: {
     headers: { accept: "application/json" },
   });
 
+  if (!response.ok) {
+    let errBody: any
+    try { errBody = await response.json() } catch {}
+    const err = parseWebError(errBody)
+    throw new Error(`stability — ${friendlyMessage(err.code, err.message)}`)
+  }
+
   const body = (await response.json()) as {
     success: boolean;
     data: Array<{
@@ -93,7 +102,9 @@ export async function fetchModelStabilitySummary(options?: {
     }>;
   };
 
-  if (!body.success) throw new Error("Model stability summary request failed");
+  if (!body.success) {
+    throw new Error(`stability — ${friendlyMessage("INTERNAL_ERROR", "Summary request failed")}`)
+  }
 
   return body.data.map((item) => ({
     ...item,
@@ -118,6 +129,13 @@ export async function fetchModelStabilityDetail(
     { headers: { accept: "application/json" } },
   );
 
+  if (!response.ok) {
+    let errBody: any
+    try { errBody = await response.json() } catch {}
+    const err = parseWebError(errBody)
+    throw new Error(`stability — ${friendlyMessage(err.code, err.message)}`)
+  }
+
   const body = (await response.json()) as {
     success: boolean;
     data: {
@@ -141,8 +159,9 @@ export async function fetchModelStabilityDetail(
     };
   };
 
-  if (!body.success)
-    throw new Error(`Model stability detail request failed for ${modelKey}`);
+  if (!body.success) {
+    throw new Error(`stability — ${friendlyMessage("NOT_FOUND", `Model "${modelKey}" not found`)}`)
+  }
 
   return {
     ...body.data,