pi-openmodel-provider 0.2.18 → 0.2.20

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/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.20] - 2026-06-28
+
+### Changed
+- `src/errors.ts` — replaced all `as any` casts with proper `isRecord()` type guard for type-safe body parsing
+
+### Fixed
+- Added missing `isRecord()` utility type guard to eliminate `any` usage in error parsing (adheres to project type safety policy)
+
+## [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

package/index.ts

@@ -6,15 +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 {
+  formatStabilityDetail,
+  formatStabilitySummaryLine,
+} from "./src/formatters/stability.ts"
+import { formatProviderStatus } from "./src/formatters/status.ts"
 import { readModelCache, writeModelCache } from "./src/cache.ts"
-import { readFile } from "node:fs/promises"
-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>> = []
@@ -75,70 +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
-
-      // Detect if user has configured an API key in auth.json
-      let hasApiKey = false
-      try {
-        const authPath = `${homedir()}/.pi/agent/auth.json`
-        const content = await readFile(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
@@ -149,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.18",
+  "version": "0.2.20",
   "description": "pi custom provider for OpenModel.ai - Multi-model AI gateway",
   "type": "module",
   "keywords": [

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/errors.ts

@@ -7,39 +7,49 @@
  * Proxy endpoints return errors in provider-specific formats (Anthropic, OpenAI, Gemini).
  */
 
+/** Check if a value is a non-null object (Record) */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null
+}
+
 /** 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 (isRecord(body) && isRecord(body.error)) {
+    const err = body.error
+    if (typeof err.code === "string" && typeof err.msg === "string") {
+      const result: { code: string; message: string; detail?: string } = {
+        code: err.code,
+        message: err.msg,
+      }
+      if (typeof err.detail === "string") {
+        result.detail = err.detail
+      }
+      return result
     }
-    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
+  if (isRecord(body) && isRecord(body.error)) {
+    const err = body.error
 
-  // Anthropic format: { type: "error", error: { type, message } }
-  if (b?.type === "error" && b?.error?.message) {
-    return { code: b.error.type ?? "UNKNOWN", message: b.error.message }
-  }
+    // Anthropic format: { type: "error", error: { type, message } }
+    if (body.type === "error" && typeof err.message === "string") {
+      return { code: typeof err.type === "string" ? err.type : "UNKNOWN", message: err.message }
+    }
 
-  // OpenAI format: { error: { message, type, code } }
-  if (b?.error?.message) {
-    return { code: b.error.code ?? b.error.type ?? "UNKNOWN", message: b.error.message }
-  }
+    // OpenAI format: { error: { message, type, code } }
+    if (typeof err.message === "string") {
+      const code = typeof err.code === "string" ? err.code : typeof err.type === "string" ? err.type : "UNKNOWN"
+      return { code, message: err.message }
+    }
 
-  // Gemini format: { error: { code, message, status } }
-  if (b?.error?.status) {
-    return { code: b.error.status, message: b.error.message }
+    // Gemini format: { error: { code, message, status } }
+    if (typeof err.status === "string") {
+      return { code: err.status, message: typeof err.message === "string" ? err.message : "Unknown error" }
+    }
   }
 
   return { code: "UNKNOWN", message: "An unknown error occurred" }

package/src/formatters/stability.ts

@@ -6,7 +6,12 @@
  */
 
 import type { HealthStatus } from "../health.ts"
-import type { ConfidenceLevel } from "../api/stability.ts"
+import type {
+  ConfidenceLevel,
+  ModelStability,
+  ModelStabilityDetail,
+} from "../api/stability.ts"
+
 /** Format health status with emoji */
 export function formatHealthStatus(status: HealthStatus): string {
   switch (status) {
@@ -34,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")
+}