pi-openmodel-provider 0.2.17 → 0.2.18

package/AGENTS.md

@@ -1,13 +1,14 @@
 # Agent Instructions
 
-- 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.
-- Use [RELEASE.md](RELEASE.md) for release process.
+This package is **pi-openmodel-provider** for [OpenModel.ai](https://www.openmodel.ai) — **NOT** OpenRouter.
+
+## Key facts for LLMs
+
+- Models are fetched dynamically from OpenModel's API at startup. No hardcoded model list.
+- Cached at `~/.pi/agent/cache/openmodel-models.json` with 5-min TTL.
+- Compat flags per provider (openai, anthropic, deepseek, qwen, zai) for optimal protocol compatibility.
+- If `/v1/models` fails (no API key), protocols are inferred from the provider.
+- Full docs at `.agents/skills/pi-openmodel-info/SKILL.md`.
+- General project docs: [README.md](README.md), [CONTRIBUTING.md](CONTRIBUTING.md), [RELEASE.md](RELEASE.md).
 
 **Maintained by** [Ivan Gabriel Yarupaitan Rivera](https://www.vanchi.pro/)

package/CHANGELOG.md

@@ -5,7 +5,24 @@ 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.17] - 2026-06-23
+## [0.2.18] - 2026-06-26
+
+### Added
+- `src/health.ts` — shared `HealthStatus` type and `determineHealth()` function, extracted from `src/api/stability.ts` and `src/formatters/stability.ts` to eliminate code duplication
+- `tests/test-cache.ts` — 12 tests covering cache read (valid, expired, corrupted, missing) and write (success, directory creation, error suppression)
+- `CacheFs` interface in `src/cache.ts` for dependency injection (matching `fetchImpl` pattern)
+- `test:cache` npm script
+
+### Changed
+- `src/api/stability.ts` — removed local `determineHealthFallback()` copy, imports from `src/health.ts` instead
+- `src/formatters/stability.ts` — removed local `determineHealth()` copy, imports from `src/health.ts` instead
+- `src/api/models.ts` — eliminated unsafe `as unknown as OpenModelProviderModel` cast and 4 `as number` price casts via type annotation and `getNumberPrice()` helper; removed `as const` on model base object
+- `src/providers/compat.ts` — removed unused `api` parameter from `compatForProvider()`
+- `index.ts` — replaced blocking `readFileSync` with `await readFile` from `fs/promises`
+- `LICENSE` — added copyright holder name
+- `tsconfig.json` — enabled `noUnusedLocals`, `noUnusedParameters`, `noImplicitReturns`, `noFallthroughCasesInSwitch`
+- `AGENTS.md` — reduced to LLM-focused bullet points with references to README and SKILL.md
+- `README.md` — added `health.ts` to architecture tree, added `test:cache` to development section
 
 ### Changed
 - **Major refactor (SRP):** Reorganized `src/` into single-responsibility modules

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026
+Copyright (c) 2026 Ivan Gabriel Yarupaitan Rivera
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -161,6 +161,7 @@ npm run test:auth
 npm run test:pricing
 npm run test:stability
 npm run test:edge
+npm run test:cache
 ```
 
 ### Codebase Architecture
@@ -181,6 +182,7 @@ src/
 │   └── validate.ts         #   sanitizeApiKey() + isValidApiKey()
 ├── formatters/             # Pure display formatting
 │   └── stability.ts        #   formatHealthStatus() + formatConfidence()
+├── health.ts               # Shared health status determination
 ├── cache.ts                # Local model cache (read/write)
 ├── errors.ts               # API error parsing + friendly messages
 └── stub.d.ts               # Type stubs for pi peer dependency

package/index.ts

@@ -12,9 +12,8 @@ import {
   fetchModelStabilityDetail,
 } from "./src/api/stability.ts"
 import { formatHealthStatus } from "./src/formatters/stability.ts"
-import { friendlyMessage } from "./src/errors.ts"
 import { readModelCache, writeModelCache } from "./src/cache.ts"
-import { readFileSync } from "node:fs"
+import { readFile } from "node:fs/promises"
 import { homedir } from "node:os"
 
 export default async function (pi: ExtensionAPI) {
@@ -78,15 +77,12 @@ export default async function (pi: ExtensionAPI) {
     description: "Show OpenModel provider status",
     handler: async (_args: string, ctx: any) => {
       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 authPath = `${homedir()}/.pi/agent/auth.json`
-        const content = readFileSync(authPath, "utf-8")
+        const content = await readFile(authPath, "utf-8")
         const data = JSON.parse(content)
         hasApiKey = !!(data.openmodel?.access || data.openmodel?.refresh)
       } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openmodel-provider",
-  "version": "0.2.17",
+  "version": "0.2.18",
   "description": "pi custom provider for OpenModel.ai - Multi-model AI gateway",
   "type": "module",
   "keywords": [
@@ -40,7 +40,8 @@
     "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"
+    "test:cache": "tsx tests/test-cache.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 && tsx tests/test-cache.ts"
   },
   "pi": {
     "extensions": [

package/src/api/models.ts

@@ -161,6 +161,15 @@ async function fetchLegacyModels(options?: {
 // Orchestration
 // ──────────────────────────────────────────────
 
+/** Safely extract a numeric price from the prices record */
+function getNumberPrice(
+  prices: Record<string, number | Record<string, number>>,
+  key: string,
+): number | undefined {
+  const val = prices[key]
+  return typeof val === "number" ? val : undefined
+}
+
 /**
  * Fetch all models from OpenModel API (public, no auth required for web endpoint).
  *
@@ -200,17 +209,17 @@ export async function fetchOpenModelModels(options?: {
       api = inferApiFromProvider(web.provider_key)
     }
 
-    // Parse pricing
-    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)
+    // Parse pricing (safely — some price fields may be Record<string, number>)
+    const inputPrice = pricePerMillion(getNumberPrice(web.prices, "input_cost_per_token"))
+    const outputPrice = pricePerMillion(getNumberPrice(web.prices, "output_cost_per_token"))
+    const cacheRead = pricePerMillion(getNumberPrice(web.prices, "cache_read_input_token_cost"))
+    const cacheWrite = pricePerMillion(getNumberPrice(web.prices, "cache_creation_input_token_cost"))
 
     // Build model config
     const reasoning = web.supports.supports_reasoning ?? false
-    const compat = compatForProvider(web.provider_key, api, reasoning)
+    const compat = compatForProvider(web.provider_key, reasoning)
 
-    const base = {
+    const model: OpenModelProviderModel = {
       id,
       name: id,
       reasoning,
@@ -224,13 +233,9 @@ export async function fetchOpenModelModels(options?: {
       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) } : {}),
       ...(compat ? { compat } : {}),
-    } as unknown as OpenModelProviderModel
+    }
 
     models.push(model)
   }

package/src/api/stability.ts

@@ -12,18 +12,12 @@
  */
 
 import { parseWebError, friendlyMessage } from "../errors.ts"
+import { determineHealth } from "../health.ts"
+import type { HealthStatus } from "../health.ts"
 
 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"
 
@@ -100,7 +94,7 @@ export async function fetchModelStabilitySummary(options?: {
 
   return body.data.map((item) => ({
     ...item,
-    health_status: determineHealthFallback(item.success_rate, item.confidence),
+    health_status: determineHealth(item.success_rate, item.confidence),
   }))
 }
 
@@ -161,24 +155,9 @@ export async function fetchModelStabilityDetail(
 
   return {
     ...body.data,
-    health_status: determineHealthFallback(
+    health_status: determineHealth(
       body.data.summary.success_rate,
       body.data.confidence,
     ),
   }
 }
-
-/**
- * Inline fallback to avoid circular dependency with formatters.
- * determineHealth() in formatters/stability.ts is the canonical version.
- */
-function determineHealthFallback(
-  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"
-}

package/src/cache.ts

@@ -22,13 +22,27 @@ interface ModelCache {
   models: readonly OpenModelProviderModel[]
 }
 
+/** Minimal fs interface matching what cache.ts actually uses */
+export interface CacheFs {
+  readFile(path: string, encoding: string): Promise<string>
+  writeFile(path: string, data: string, encoding?: string): Promise<void>
+  mkdir(path: string, options?: { recursive?: boolean }): Promise<void>
+}
+
+const DEFAULT_FS: CacheFs = {
+  readFile: readFile as CacheFs["readFile"],
+  writeFile: writeFile as CacheFs["writeFile"],
+  mkdir: mkdir as CacheFs["mkdir"],
+}
+
 /**
  * Read models from cache.
  * Returns null if cache is missing, expired, or corrupted.
  */
-export async function readModelCache(): Promise<readonly OpenModelProviderModel[] | null> {
+export async function readModelCache(fsImpl?: CacheFs): Promise<readonly OpenModelProviderModel[] | null> {
+  const { readFile: rf } = fsImpl ?? DEFAULT_FS
   try {
-    const raw = await readFile(CACHE_FILE, "utf-8")
+    const raw = await rf(CACHE_FILE, "utf-8")
     const cache: ModelCache = JSON.parse(raw)
 
     if (typeof cache.timestamp !== "number" || !Array.isArray(cache.models)) {
@@ -50,11 +64,12 @@ export async function readModelCache(): Promise<readonly OpenModelProviderModel[
  * Write models to the local cache.
  * Failures are silently ignored — cache is optional.
  */
-export async function writeModelCache(models: readonly OpenModelProviderModel[]): Promise<void> {
+export async function writeModelCache(models: readonly OpenModelProviderModel[], fsImpl?: CacheFs): Promise<void> {
+  const { mkdir: mkd, writeFile: wf } = fsImpl ?? DEFAULT_FS
   try {
-    await mkdir(CACHE_DIR, { recursive: true })
+    await mkd(CACHE_DIR, { recursive: true })
     const cache: ModelCache = { timestamp: Date.now(), models }
-    await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8")
+    await wf(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8")
   } catch {
     // Cache writes are best-effort
   }

package/src/formatters/stability.ts

@@ -5,20 +5,8 @@
  * Transforms health/confidence data into display-ready strings.
  */
 
-import type { HealthStatus, ConfidenceLevel } from "../api/stability.ts"
-
-/** Determine health status from success rate and confidence */
-export 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"
-}
-
+import type { HealthStatus } from "../health.ts"
+import type { ConfidenceLevel } from "../api/stability.ts"
 /** Format health status with emoji */
 export function formatHealthStatus(status: HealthStatus): string {
   switch (status) {

package/src/health.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared health status determination for model stability.
+ *
+ * Extracted from stability.ts and formatters/stability.ts to avoid
+ * code duplication — both modules need the same logic.
+ */
+
+import type { ConfidenceLevel } from "./api/stability.ts"
+
+export type HealthStatus =
+  | "operational"
+  | "healthy"
+  | "degraded"
+  | "unstable"
+  | "no_data"
+
+/**
+ * Determine health status from success rate and confidence.
+ * Low confidence → no_data regardless of success rate.
+ */
+export 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"
+}

package/src/providers/compat.ts

@@ -6,15 +6,12 @@
  * affinity, cache control, etc.).
  */
 
-import type { ApiProtocol } from "./protocols.ts"
-
 /**
- * Determine compat flags based on provider and API.
+ * Determine compat flags based on provider.
  * Returns undefined when no special flags are needed.
  */
 export function compatForProvider(
   providerKey: string,
-  api: ApiProtocol,
   reasoning: boolean,
 ): Record<string, unknown> | undefined {
   switch (providerKey) {