pi-openmodel-provider 0.2.15 → 0.2.16

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

@@ -26,12 +26,25 @@ Models are fetched live from OpenModel's API at startup:
 
 If the API key is not configured yet, models still load — protocols are inferred automatically from the provider name.
 
+### Caching
+
+Models are cached locally at `~/.pi/agent/cache/openmodel-models.json` with a **5-minute TTL**. On subsequent startups or `/reload`, the cached list is used instead of hitting the API again. The `/openmodel` command shows `(cached)` when the cache is active.
+
 ## Thinking levels
 
 Reasoning models support thinking levels:
 - **Messages protocol:** minimal → low, low → medium, medium → high
 - **Responses protocol:** `reasoning_effort` levels (low, medium, high)
 
+## Compat flags
+
+Compat flags are automatically set per provider for optimal protocol compatibility:
+- **OpenAI:** `supportsReasoningEffort: true`
+- **Anthropic:** `sendSessionAffinityHeaders`, `supportsCacheControlOnTools`, `supportsEagerToolInputStreaming`
+- **DeepSeek (reasoning):** `thinkingFormat: "deepseek"`
+- **Qwen (reasoning):** `thinkingFormat: "qwen-chat-template"`
+- **ZAI / GLM (reasoning):** `thinkingFormat: "zai"`
+
 ## Available commands
 
 - `/openmodel` — Show provider status

package/AGENTS.md

@@ -3,6 +3,8 @@
 - This package is **pi-openmodel-provider** for OpenModel.ai, **NOT** OpenRouter.
 - OpenModel is a multi-model AI gateway, similar to OpenRouter but a different service.
 - Models are fetched dynamically from OpenModel's API at startup — no hardcoded model list.
+- Models are cached locally at `~/.pi/agent/cache/openmodel-models.json` with a 5-minute TTL to avoid hitting the API on every startup.
+- Compat flags are set per provider (openai, anthropic, deepseek, qwen, zai) for optimal protocol compatibility.
 - If the `/v1/models` endpoint fails (no API key), protocols are inferred from the provider.
 - See `.agents/skills/pi-openmodel-info/SKILL.md` for full documentation.
 - Follow [CONTRIBUTING.md](CONTRIBUTING.md) before changing code.

package/CHANGELOG.md

@@ -5,6 +5,21 @@ 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.16] - 2026-06-23
+
+### Added
+- Local model cache at `~/.pi/agent/cache/openmodel-models.json` with 5-minute TTL
+- `src/cache.ts` module for cache read/write operations
+- Compat flags per provider (openai, anthropic, deepseek, qwen, zai) for optimal protocol compatibility
+- AbortSignal support in stability fetch functions
+- CI workflow (`.github/workflows/ci.yml`) for typecheck + tests on push and PR
+- Typecheck and test steps before publish in `.github/workflows/publish.yml`
+- `(cached)` indicator in `/openmodel` status output
+
+### Changed
+- Models now load from cache first, falling back to API fetch
+- Updated `actions/checkout` and `actions/setup-node` to v5 (Node 24 native)
+
 ## [0.2.14] - 2026-06-22
 
 ### Changed

package/README.md

@@ -3,6 +3,7 @@
 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://img.shields.io/npm/v/pi-openmodel-provider)](https://www.npmjs.com/package/pi-openmodel-provider)
+[![CI](https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/actions/workflows/ci.yml/badge.svg)](https://github.com/IvanGabrielYarupaitanRivera/pi-openmodel-provider/actions/workflows/ci.yml)
 
 > **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.
 
@@ -64,6 +65,12 @@ On startup, the provider fetches models from two endpoints:
 
 Pricing, context window, reasoning support, and vision capabilities are all provided by the API — no hardcoded data.
 
+### Caching
+
+Models are cached locally at `~/.pi/agent/cache/openmodel-models.json` with a **5-minute TTL**. On subsequent startups or `/reload`, the cached list is used instead of hitting the API again. The `/openmodel` command shows `(cached)` when the cache is active.
+
+To force a fresh fetch, wait 5 minutes or delete the cache file manually.
+
 ## 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.
@@ -75,13 +82,17 @@ Model pricing is fetched live from OpenModel's public API (`/web/v1/models`). Ea
 
 ## Features
 
-- **41 models** from 9+ providers (dynamically fetched)
+- **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
 - **Thinking levels** for reasoning models (DeepSeek, Claude, GPT, Gemini, etc.)
+- **Compat flags** per provider for optimal protocol compatibility
+- **Local caching** with 5-minute TTL to reduce API calls
+- **AbortSignal support** in stability commands for cancellation
 - **Friendly error messages** with emojis and actionable guidance
 - **No hardcoding** — new models, pricing, and capabilities appear automatically
+- **CI workflow** — typecheck and tests run on every push and PR
 
 ## Error handling
 

package/index.ts

@@ -13,19 +13,30 @@ import {
   formatHealthStatus,
 } from "./src/stability.ts"
 import { friendlyMessage } from "./src/errors.ts"
+import { readModelCache, writeModelCache } from "./src/cache.ts"
 import { homedir } from "node:os"
 
 export default async function (pi: ExtensionAPI) {
   let models: Awaited<ReturnType<typeof fetchOpenModelModels>> = []
   let modelError: string | null = null
+  let fromCache = false
 
-  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"}`
+  // Try local cache first to avoid hitting the API on every startup
+  const cached = await readModelCache()
+  if (cached) {
+    models = cached
+    fromCache = true
+  } else {
+    try {
+      models = await fetchOpenModelModels()
+      // Fire-and-forget cache write (failures are silently ignored)
+      writeModelCache(models)
+    } 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"}`
+      }
     }
   }
 
@@ -54,6 +65,9 @@ export default async function (pi: ExtensionAPI) {
       if (model.thinkingLevelMap) {
         config.thinkingLevelMap = model.thinkingLevelMap
       }
+      if (model.compat) {
+        config.compat = model.compat
+      }
       return config
     }),
   })
@@ -83,7 +97,7 @@ export default async function (pi: ExtensionAPI) {
         "╔══════════════════════════════════╗",
         "║        OpenModel.ai              ║",
         "╠══════════════════════════════════╣",
-        `║  Models: ${String(count).padStart(3)} loaded                    ║`,
+        `║  Models: ${String(count).padStart(3)} loaded${fromCache ? " (cached)" : ""}         ║`,
         hasApiKey ? "║  API Key: ✅ Configured              ║" : "║  API Key: ❌ Not configured          ║",
         "╠══════════════════════════════════╣",
         "║  Commands:                       ║",
@@ -115,7 +129,7 @@ export default async function (pi: ExtensionAPI) {
       try {
         if (args?.trim()) {
           const name = args.trim()
-          const detail = await fetchModelStabilityDetail(name)
+          const detail = await fetchModelStabilityDetail(name, { signal: ctx.signal })
           const lines = [
             `📊 ${detail.model_name}`,
             `━━━━━━━━━━━━━━━━━━━━━━`,
@@ -128,7 +142,7 @@ export default async function (pi: ExtensionAPI) {
           ]
           ctx.ui.notify(lines.join("\n"), "info")
         } else {
-          const summary = await fetchModelStabilitySummary()
+          const summary = await fetchModelStabilitySummary({ signal: ctx.signal })
           if (summary.length === 0) {
             ctx.ui.notify("📊 No stability data available for any model yet.", "warning")
             return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openmodel-provider",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "pi custom provider for OpenModel.ai - Multi-model AI gateway",
   "type": "module",
   "keywords": [

package/src/cache.ts

@@ -0,0 +1,61 @@
+/**
+ * Local cache for fetched OpenModel models.
+ *
+ * Avoids hitting the OpenModel API on every startup or /reload.
+ * Cache is stored at ~/.pi/agent/cache/openmodel-models.json with a 5-minute TTL.
+ */
+
+import { readFile, writeFile, mkdir } from "node:fs/promises"
+import { join } from "node:path"
+import { homedir } from "node:os"
+import type { OpenModelProviderModel } from "./models.ts"
+
+export const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+
+const CACHE_DIR = join(homedir(), ".pi", "agent", "cache")
+const CACHE_FILE = join(CACHE_DIR, "openmodel-models.json")
+
+interface ModelCache {
+  /** Unix timestamp (ms) when the cache was written */
+  timestamp: number
+  /** Cached model list */
+  models: readonly OpenModelProviderModel[]
+}
+
+/**
+ * Read models from cache.
+ * Returns null if cache is missing, expired, or corrupted.
+ */
+export async function readModelCache(): Promise<readonly OpenModelProviderModel[] | null> {
+  try {
+    const raw = await readFile(CACHE_FILE, "utf-8")
+    const cache: ModelCache = JSON.parse(raw)
+
+    if (typeof cache.timestamp !== "number" || !Array.isArray(cache.models)) {
+      return null
+    }
+
+    const age = Date.now() - cache.timestamp
+    if (age >= CACHE_TTL_MS) {
+      return null // expired
+    }
+
+    return cache.models
+  } catch {
+    return null // no cache or invalid JSON
+  }
+}
+
+/**
+ * Write models to the local cache.
+ * Failures are silently ignored — cache is optional.
+ */
+export async function writeModelCache(models: readonly OpenModelProviderModel[]): Promise<void> {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true })
+    const cache: ModelCache = { timestamp: Date.now(), models }
+    await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8")
+  } catch {
+    // Cache writes are best-effort
+  }
+}

package/src/models.ts

@@ -20,6 +20,7 @@ export interface OpenModelProviderModel {
   contextWindow: number
   maxTokens: number
   api: "anthropic-messages" | "openai-responses" | "google-generative-ai"
+  compat?: Record<string, unknown>
 }
 
 interface WebApiModel {
@@ -70,6 +71,47 @@ function determineApi(protocols: string[], provider: string): "anthropic-message
   return null
 }
 
+/**
+ * Determine compat flags based on provider and API.
+ * These tell pi about provider-specific quirks and capabilities.
+ */
+function compatForProvider(
+  providerKey: string,
+  api: "anthropic-messages" | "openai-responses" | "google-generative-ai",
+  reasoning: boolean,
+): Record<string, unknown> | undefined {
+  switch (providerKey) {
+    case "openai":
+      return { supportsReasoningEffort: true }
+    case "deepseek":
+      if (reasoning) {
+        return { thinkingFormat: "deepseek" }
+      }
+      return undefined
+    case "anthropic":
+      return {
+        sendSessionAffinityHeaders: true,
+        supportsCacheControlOnTools: true,
+        supportsEagerToolInputStreaming: true,
+      }
+    case "google":
+    case "gemini":
+      return undefined
+    case "qwen":
+      if (reasoning) {
+        return { thinkingFormat: "qwen-chat-template" }
+      }
+      return undefined
+    case "zai":
+      if (reasoning) {
+        return { thinkingFormat: "zai" }
+      }
+      return undefined
+    default:
+      return undefined
+  }
+}
+
 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 {
@@ -199,6 +241,7 @@ export async function fetchOpenModelModels(options?: {
     const cacheWrite = pricePerMillion(web.prices.cache_creation_input_token_cost as number)
 
     const reasoning = web.supports.supports_reasoning ?? false
+    const compat = compatForProvider(web.provider_key, api, reasoning)
 
     const base = {
       id,
@@ -219,6 +262,7 @@ export async function fetchOpenModelModels(options?: {
     const model = {
       ...base,
       ...(reasoning ? { thinkingLevelMap: thinkingLevelMapForApi(api) } : {}),
+      ...(compat ? { compat } : {}),
     } as unknown as OpenModelProviderModel
 
     models.push(model)

package/src/stability.ts

@@ -74,6 +74,7 @@ export async function fetchModelStabilitySummary(options?: {
   url?: string;
   fetchImpl?: typeof fetch;
   hours?: number;
+  signal?: AbortSignal;
 }): Promise<ModelStability[]> {
   const url = options?.url ?? STABILITY_SUMMARY_URL;
   const fetchImpl = options?.fetchImpl ?? fetch;
@@ -82,6 +83,7 @@ export async function fetchModelStabilitySummary(options?: {
   const params = new URLSearchParams({ hours: String(hours) });
   const response = await fetchImpl(`${url}?${params}`, {
     headers: { accept: "application/json" },
+    signal: options?.signal ?? null,
   });
 
   if (!response.ok) {
@@ -118,6 +120,7 @@ export async function fetchModelStabilityDetail(
   options?: {
     fetchImpl?: typeof fetch;
     hours?: number;
+    signal?: AbortSignal;
   },
 ): Promise<ModelStabilityDetail> {
   const fetchImpl = options?.fetchImpl ?? fetch;
@@ -126,7 +129,7 @@ export async function fetchModelStabilityDetail(
   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" } },
+    { headers: { accept: "application/json" }, signal: options?.signal ?? null },
   );
 
   if (!response.ok) {