pi-openmodel-provider 0.2.17 → 0.2.19

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

@@ -32,9 +32,31 @@ Models are cached locally at `~/.pi/agent/cache/openmodel-models.json` with a **
 
 ## Thinking levels
 
-Reasoning models support thinking levels:
-- **Messages protocol:** minimal → low, low → medium, medium → high
-- **Responses protocol:** `reasoning_effort` levels (low, medium, high)
+Reasoning models support thinking levels mapped per protocol:
+
+**Messages protocol (`anthropic-messages`):**
+
+| Level | Mapped value |
+|---|---|
+| `off` | `null` |
+| `minimal` | `low` |
+| `low` | `medium` |
+| `medium` | `high` |
+| `high` | `high` |
+| `xhigh` | `max` |
+
+**Responses protocol (`openai-responses`):** uses `reasoning_effort`
+
+| Level | Mapped value |
+|---|---|
+| `off` | `null` |
+| `minimal` | `low` |
+| `low` | `low` |
+| `medium` | `medium` |
+| `high` | `high` |
+| `xhigh` | `high` |
+
+**Gemini protocol (`google-generative-ai`):** no thinking level mapping (returns empty).
 
 ## Compat flags
 

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,39 @@ 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.19] - 2026-06-27
+
+### Added
+- `src/auth/login.ts` — `hasApiKey()` function to check for configured credentials (was inline in `index.ts`)
+- `src/formatters/status.ts` — new module with pure `formatProviderStatus()` for the `/openmodel` command display
+- `formatStabilityDetail()` and `formatStabilitySummaryLine()` in `src/formatters/stability.ts` — extract stability formatting from `index.ts`
+- `CommandContext` interface in `index.ts` — types the command handler context instead of using `any`
+
+### Changed
+- `index.ts` — refactored to pure orchestration: `/openmodel` and `/openmodel-stability` handlers delegate I/O, formatting, and display logic to extracted functions
+- `.agents/skills/pi-openmodel-info/SKILL.md` — completed thinking levels section with full mappings (`minimal` through `xhigh`) for both protocols
+
+### Removed
+- `import { readFile } from "node:fs/promises"` and `import { homedir } from "node:os"` from `index.ts` (moved into `hasApiKey()`)
+
+## [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

@@ -6,16 +6,25 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
 import { fetchOpenModelModels } from "./src/api/models.ts"
-import { login, refreshToken, getApiKey } from "./src/auth/login.ts"
+import { login, refreshToken, getApiKey, hasApiKey } from "./src/auth/login.ts"
 import {
   fetchModelStabilitySummary,
   fetchModelStabilityDetail,
 } from "./src/api/stability.ts"
-import { formatHealthStatus } from "./src/formatters/stability.ts"
-import { friendlyMessage } from "./src/errors.ts"
+import {
+  formatStabilityDetail,
+  formatStabilitySummaryLine,
+} from "./src/formatters/stability.ts"
+import { formatProviderStatus } from "./src/formatters/status.ts"
 import { readModelCache, writeModelCache } from "./src/cache.ts"
-import { readFileSync } from "node:fs"
-import { homedir } from "node:os"
+
+/** Minimal command context type for pi extension command handlers. */
+interface CommandContext {
+  signal?: AbortSignal
+  ui: {
+    notify(message: string, type: string): void
+  }
+}
 
 export default async function (pi: ExtensionAPI) {
   let models: Awaited<ReturnType<typeof fetchOpenModelModels>> = []
@@ -76,73 +85,31 @@ export default async function (pi: ExtensionAPI) {
   // /openmodel - Show provider status
   pi.registerCommand("openmodel", {
     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 data = JSON.parse(content)
-        hasApiKey = !!(data.openmodel?.access || data.openmodel?.refresh)
-      } catch {
-        // Auth file not found
-      }
-
-      const lines = [
-        "╔══════════════════════════════════╗",
-        "║        OpenModel.ai              ║",
-        "╠══════════════════════════════════╣",
-        `║  Models: ${String(count).padStart(3)} loaded${fromCache ? " (cached)" : ""}         ║`,
-        hasApiKey ? "║  API Key: ✅ Configured              ║" : "║  API Key: ❌ Not configured          ║",
-        "╠══════════════════════════════════╣",
-        "║  Commands:                       ║",
-        "║  /model openmodel/...            ║",
-        "║  /openmodel-stability            ║",
-        "╚══════════════════════════════════╝",
-      ]
-
-      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")
+    handler: async (_args: string, ctx: CommandContext) => {
+      ctx.ui.notify(
+        formatProviderStatus({
+          count: models.length,
+          fromCache,
+          hasApiKey: await hasApiKey(),
+          modelError,
+        }),
+        "info",
+      )
     },
   })
 
   // /openmodel-stability - Show model health metrics
   pi.registerCommand("openmodel-stability", {
     description: "Show model stability metrics (24h)",
-    handler: async (args: string | undefined, ctx: any) => {
+    handler: async (args: string | undefined, ctx: CommandContext) => {
       try {
+        const fetchOptions = ctx.signal ? { signal: ctx.signal } : {}
         if (args?.trim()) {
           const name = args.trim()
-          const detail = await fetchModelStabilityDetail(name, { signal: ctx.signal })
-          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")
+          const detail = await fetchModelStabilityDetail(name, fetchOptions)
+          ctx.ui.notify(formatStabilityDetail(detail), "info")
         } else {
-          const summary = await fetchModelStabilitySummary({ signal: ctx.signal })
+          const summary = await fetchModelStabilitySummary(fetchOptions)
           if (summary.length === 0) {
             ctx.ui.notify("📊 No stability data available for any model yet.", "warning")
             return
@@ -153,8 +120,7 @@ export default async function (pi: ExtensionAPI) {
             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`)
+            lines.push(formatStabilitySummaryLine(s))
           }
           ctx.ui.notify(lines.join("\n"), "info")
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openmodel-provider",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "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/auth/login.ts

@@ -10,6 +10,9 @@
  * Since OpenModel API keys don't expire, "refresh" is a no-op.
  */
 
+import { readFile } from "node:fs/promises"
+import { join } from "node:path"
+import { homedir } from "node:os"
 import { sanitizeApiKey, isValidApiKey } from "./validate.ts"
 
 export interface OAuthLoginCallbacks {
@@ -130,3 +133,17 @@ export async function refreshToken(
 export function getApiKey(credentials: OAuthCredentials): string {
   return credentials.access
 }
+
+/**
+ * Check if the user has configured an OpenModel API key in pi's auth file.
+ */
+export async function hasApiKey(): Promise<boolean> {
+  const authPath = join(homedir(), ".pi", "agent", "auth.json")
+  try {
+    const content = await readFile(authPath, "utf-8")
+    const data = JSON.parse(content)
+    return !!(data.openmodel?.access || data.openmodel?.refresh)
+  } catch {
+    return false
+  }
+}

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,19 +5,12 @@
  * 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,
+  ModelStability,
+  ModelStabilityDetail,
+} from "../api/stability.ts"
 
 /** Format health status with emoji */
 export function formatHealthStatus(status: HealthStatus): string {
@@ -46,3 +39,23 @@ export function formatConfidence(level: ConfidenceLevel): string {
       return "⚪ Low"
   }
 }
+
+/** Format detailed stability view for a single model */
+export function formatStabilityDetail(detail: ModelStabilityDetail): string {
+  return [
+    `📊 ${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: ${formatConfidence(detail.confidence)}`,
+  ].join("\n")
+}
+
+/** Format a single summary line for the stability list */
+export function formatStabilitySummaryLine(s: ModelStability): string {
+  const emoji = formatHealthStatus(s.health_status).split(" ")[0]
+  return `${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`
+}

package/src/formatters/status.ts

@@ -0,0 +1,46 @@
+/**
+ * Formatters for the /openmodel provider status display.
+ *
+ * Pure functions — no side effects, no network calls.
+ */
+
+export interface ProviderStatusOptions {
+  count: number
+  fromCache: boolean
+  hasApiKey: boolean
+  modelError: string | null
+}
+
+/**
+ * Format the full /openmodel status display including hints.
+ */
+export function formatProviderStatus(options: ProviderStatusOptions): string {
+  const { count, fromCache, hasApiKey, modelError } = options
+
+  const lines = [
+    "╔══════════════════════════════════╗",
+    "║        OpenModel.ai              ║",
+    "╠══════════════════════════════════╣",
+    `║  Models: ${String(count).padStart(3)} loaded${fromCache ? " (cached)" : ""}         ║`,
+    hasApiKey ? "║  API Key: ✅ Configured              ║" : "║  API Key: ❌ Not configured          ║",
+    "╠══════════════════════════════════╣",
+    "║  Commands:                       ║",
+    "║  /model openmodel/...            ║",
+    "║  /openmodel-stability            ║",
+    "╚══════════════════════════════════╝",
+  ]
+
+  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")
+
+  return [...lines, ...hints].join("\n")
+}

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) {