pi-openmodel-provider 0.2.16 → 0.2.18

package/src/auth/login.ts

@@ -0,0 +1,132 @@
+/**
+ * OpenModel authentication for pi's /login flow.
+ *
+ * Flow:
+ * 1. Opens the OpenModel Console in the browser
+ * 2. Prompts the user to paste their API key
+ * 3. Validates the key format (must start with "om-")
+ * 4. Stores credentials in pi's auth.json
+ *
+ * Since OpenModel API keys don't expire, "refresh" is a no-op.
+ */
+
+import { sanitizeApiKey, isValidApiKey } from "./validate.ts"
+
+export interface OAuthLoginCallbacks {
+  onAuth(params: { url: string }): void;
+  onPrompt(params: { message: string }): Promise<string>;
+  onSelect?(params: {
+    message: string;
+    options: { id: string; label: string }[];
+  }): Promise<string | undefined>;
+}
+
+export interface OAuthCredentials {
+  refresh: string;
+  access: string;
+  expires: number;
+}
+
+export const CONSOLE_URL = "https://console.openmodel.ai"
+const FIVE_YEARS_MS = 5 * 365 * 24 * 60 * 60 * 1000 // API keys don't expire
+
+function credentialsFromApiKey(apiKey: string): OAuthCredentials {
+  return {
+    refresh: apiKey,
+    access: apiKey,
+    expires: Date.now() + FIVE_YEARS_MS,
+  }
+}
+
+async function promptForKey(
+  callbacks: OAuthLoginCallbacks,
+  message: string,
+): Promise<string> {
+  return sanitizeApiKey(await callbacks.onPrompt({ message }))
+}
+
+async function handleKey(
+  apiKey: string,
+  callbacks: OAuthLoginCallbacks,
+): Promise<OAuthCredentials> {
+  if (!apiKey) {
+    throw new Error("No OpenModel API key provided")
+  }
+
+  if (!isValidApiKey(apiKey)) {
+    // Offer retry when onSelect is available
+    if (callbacks.onSelect) {
+      const retry = await callbacks.onSelect({
+        message: `Invalid API key format. Key should start with "om-". Try again?`,
+        options: [
+          { id: "retry", label: "🔄 Try again" },
+          { id: "cancel", label: "❌ Cancel" },
+        ],
+      })
+      if (retry === "retry") {
+        return login(callbacks)
+      }
+    }
+    throw new Error("Login cancelled - invalid API key")
+  }
+
+  return credentialsFromApiKey(apiKey)
+}
+
+/**
+ * /login openmodel handler.
+ *
+ * Offers two options:
+ * 1. Browser: opens the OpenModel Console so the user can create/copy a key
+ * 2. Manual: prompts the user to paste their API key
+ */
+export async function login(
+  callbacks: OAuthLoginCallbacks,
+): Promise<OAuthCredentials> {
+  // Determine login method (onSelect is optional)
+  let method: string | undefined
+  if (callbacks.onSelect) {
+    method = await callbacks.onSelect({
+      message: "How would you like to authenticate with OpenModel?",
+      options: [
+        { id: "browser", label: "🌐 Open console in browser" },
+        { id: "paste", label: "📋 Paste API key manually" },
+      ],
+    })
+  }
+
+  if (!method) {
+    throw new Error("Login cancelled")
+  }
+
+  if (method === "browser") {
+    callbacks.onAuth({ url: CONSOLE_URL })
+
+    const apiKey = await promptForKey(
+      callbacks,
+      `1. Open ${CONSOLE_URL}\n2. In the sidebar, click on API Keys\n3. Click Create API Key, give it a name, and copy the generated key\n4. Paste the key here (starts with "om-"):`,
+    )
+
+    return handleKey(apiKey, callbacks)
+  }
+
+  // Manual paste
+  const apiKey = await promptForKey(callbacks, 'Paste your OpenModel API key (starts with "om-"):')
+  return handleKey(apiKey, callbacks)
+}
+
+/**
+ * OpenModel API keys don't expire, so "refresh" is a no-op.
+ */
+export async function refreshToken(
+  credentials: OAuthCredentials,
+): Promise<OAuthCredentials> {
+  return credentialsFromApiKey(credentials.refresh)
+}
+
+/**
+ * Extract the API key from stored credentials.
+ */
+export function getApiKey(credentials: OAuthCredentials): string {
+  return credentials.access
+}

package/src/auth/validate.ts

@@ -0,0 +1,33 @@
+/**
+ * API key validation and sanitization.
+ *
+ * Sanitizes user-pasted input (handling terminal paste wrappers, control chars)
+ * and validates that the key matches OpenModel's "om-..." format.
+ */
+
+/**
+ * Sanitize API key input, removing terminal paste wrappers and control chars.
+ */
+export function sanitizeApiKey(input: string): string {
+  const esc = String.fromCharCode(27)
+  return Array.from(
+    input
+      .replaceAll(`${esc}[200~`, "")
+      .replaceAll(`${esc}[201~`, "")
+      .replaceAll("[200~", "")
+      .replaceAll("[201~", ""),
+  )
+    .filter((char) => {
+      const code = char.charCodeAt(0)
+      return code > 31 && code !== 127
+    })
+    .join("")
+    .trim()
+}
+
+/**
+ * Validate that an API key looks like a valid OpenModel key.
+ */
+export function isValidApiKey(key: string): boolean {
+  return /^om-[A-Za-z0-9_-]+$/.test(key)
+}

package/src/cache.ts

@@ -8,7 +8,7 @@
 import { readFile, writeFile, mkdir } from "node:fs/promises"
 import { join } from "node:path"
 import { homedir } from "node:os"
-import type { OpenModelProviderModel } from "./models.ts"
+import type { OpenModelProviderModel } from "./api/models.ts"
 
 export const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
 
@@ -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

@@ -0,0 +1,36 @@
+/**
+ * Formatters for model stability presentation.
+ *
+ * Pure functions — no side effects, no network calls.
+ * Transforms health/confidence data into display-ready strings.
+ */
+
+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) {
+    case "operational":
+      return "✅ Operational"
+    case "healthy":
+      return "🟢 Healthy"
+    case "degraded":
+      return "🟡 Degraded"
+    case "unstable":
+      return "🔴 Unstable"
+    case "no_data":
+      return "⚪ No Data"
+  }
+}
+
+/** Format confidence level */
+export function formatConfidence(level: ConfidenceLevel): string {
+  switch (level) {
+    case "high":
+      return "🟢 High"
+    case "medium":
+      return "🟡 Medium"
+    case "low":
+      return "⚪ Low"
+  }
+}

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

@@ -0,0 +1,47 @@
+/**
+ * Provider-specific compatibility flags for pi.
+ *
+ * These flags tell pi about each provider's quirks and capabilities,
+ * enabling optimal protocol compatibility (thinking formats, session
+ * affinity, cache control, etc.).
+ */
+
+/**
+ * Determine compat flags based on provider.
+ * Returns undefined when no special flags are needed.
+ */
+export function compatForProvider(
+  providerKey: string,
+  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
+  }
+}

package/src/providers/pricing.ts

@@ -0,0 +1,12 @@
+/**
+ * Pricing utilities for converting cost-per-token to $/M tokens.
+ *
+ * OpenModel API returns prices in cost-per-token (microdollars).
+ * We convert to dollars per million tokens for pi's display.
+ */
+
+/** Convert cost-per-token to dollars per million tokens */
+export function pricePerMillion(costPerToken: number | undefined): number {
+  if (costPerToken === undefined || costPerToken === null) return 0
+  return Math.round(costPerToken * 1_000_000 * 1000) / 1000
+}

package/src/providers/protocols.ts

@@ -0,0 +1,53 @@
+/**
+ * Protocol detection and thinking level mapping per provider.
+ *
+ * Determines the correct pi protocol (anthropic-messages, openai-responses,
+ * google-generative-ai) based on provider protocol lists and fallback inference.
+ */
+
+export type ApiProtocol = "anthropic-messages" | "openai-responses" | "google-generative-ai"
+
+/** Infer protocol from a list of supported protocol strings */
+export function determineApi(
+  protocols: string[],
+  _provider: string,
+): ApiProtocol | 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
+}
+
+/** Fallback: infer API protocol from provider name when legacy endpoint fails */
+export function inferApiFromProvider(providerKey: string): ApiProtocol {
+  if (["openai"].includes(providerKey)) return "openai-responses"
+  if (["gemini"].includes(providerKey)) return "google-generative-ai"
+  return "anthropic-messages"
+}
+
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh"
+
+/** Build a thinking-level map appropriate for the protocol */
+export function thinkingLevelMapForApi(
+  api: ApiProtocol,
+): Partial<Record<ThinkingLevel, 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 {}
+}

package/src/auth.ts

@@ -1,179 +0,0 @@
-/**
- * OpenModel authentication for pi's /login flow.
- *
- * Provides OAuth integration so users can authenticate via:
- *   /login openmodel
- *
- * Flow:
- * 1. Opens the OpenModel Console in the browser
- * 2. Prompts the user to paste their API key
- * 3. Validates the key format (must start with "om-")
- * 4. Stores credentials in pi's auth.json
- *
- * Since OpenModel API keys don't expire, "refresh" is a no-op.
- */
-
-export interface OAuthLoginCallbacks {
-  onAuth(params: { url: string }): void;
-  onPrompt(params: { message: string }): Promise<string>;
-  onSelect?(params: {
-    message: string;
-    options: { id: string; label: string }[];
-  }): Promise<string | undefined>;
-}
-
-export interface OAuthCredentials {
-  refresh: string;
-  access: string;
-  expires: number;
-}
-
-const CONSOLE_URL = "https://console.openmodel.ai";
-const FIVE_YEARS_MS = 5 * 365 * 24 * 60 * 60 * 1000; // API keys don't expire
-
-/**
- * Sanitize API key input, removing terminal paste wrappers and control chars.
- */
-export function sanitizeApiKey(input: string): string {
-  const esc = String.fromCharCode(27);
-  return Array.from(
-    input
-      .replaceAll(`${esc}[200~`, "")
-      .replaceAll(`${esc}[201~`, "")
-      .replaceAll("[200~", "")
-      .replaceAll("[201~", ""),
-  )
-    .filter((char) => {
-      const code = char.charCodeAt(0);
-      return code > 31 && code !== 127;
-    })
-    .join("")
-    .trim();
-}
-
-/**
- * Validate that an API key looks like a valid OpenModel key.
- */
-export function isValidApiKey(key: string): boolean {
-  return /^om-[A-Za-z0-9_-]+$/.test(key);
-}
-
-function credentialsFromApiKey(apiKey: string): OAuthCredentials {
-  return {
-    refresh: apiKey,
-    access: apiKey,
-    expires: Date.now() + FIVE_YEARS_MS,
-  };
-}
-
-/**
- * /login openmodel handler.
- *
- * Offers two options:
- * 1. Browser: opens the OpenModel Console so the user can create/copy a key
- * 2. Manual: prompts the user to paste their API key
- */
-export async function login(
-  callbacks: OAuthLoginCallbacks,
-): Promise<OAuthCredentials> {
-  // Offer login method choice (onSelect is optional)
-  let method: string | undefined;
-  if (callbacks.onSelect) {
-    method = await callbacks.onSelect({
-      message: "How would you like to authenticate with OpenModel?",
-      options: [
-        { id: "browser", label: "🌐 Open console in browser" },
-        { id: "paste", label: "📋 Paste API key manually" },
-      ],
-    });
-  }
-
-  if (!method) {
-    throw new Error("Login cancelled");
-  }
-
-  if (method === "browser") {
-    // Open the OpenModel Console in the browser
-    callbacks.onAuth({ url: CONSOLE_URL });
-
-    // Then prompt for the API key
-    const apiKey = sanitizeApiKey(
-      await callbacks.onPrompt({
-        message: `1. Open ${CONSOLE_URL}\n2. In the sidebar, click on API Keys\n3. Click Create API Key, give it a name, and copy the generated key\n4. Paste the key here (starts with "om-"):`,
-      }),
-    );
-
-    if (!apiKey) {
-      throw new Error("No OpenModel API key provided");
-    }
-
-    if (!isValidApiKey(apiKey)) {
-      let retry: string | undefined;
-      if (callbacks.onSelect) {
-        retry = await callbacks.onSelect({
-          message: `Invalid API key format. Key should start with "om-". Try again?`,
-          options: [
-            { id: "retry", label: "🔄 Try again" },
-            { id: "cancel", label: "❌ Cancel" },
-          ],
-        });
-      }
-
-      if (retry !== "retry") {
-        throw new Error("Login cancelled - invalid API key");
-      }
-
-      // Recursive retry
-      return login(callbacks);
-    }
-
-    return credentialsFromApiKey(apiKey);
-  }
-
-  // Manual paste
-  const apiKey = sanitizeApiKey(
-    await callbacks.onPrompt({
-      message: 'Paste your OpenModel API key (starts with "om-"):',
-    }),
-  );
-
-  if (!apiKey) {
-    throw new Error("No OpenModel API key provided");
-  }
-
-  if (!isValidApiKey(apiKey)) {
-    const retry = callbacks.onSelect
-      ? await callbacks.onSelect({
-          message: `Invalid API key format. Key should start with "om-". Try again?`,
-          options: [
-            { id: "retry", label: "🔄 Try again" },
-            { id: "cancel", label: "❌ Cancel" },
-          ],
-        })
-      : undefined;
-
-    if (retry !== "retry") {
-      throw new Error("Login cancelled - invalid API key");
-    }
-
-    return login(callbacks);
-  }
-
-  return credentialsFromApiKey(apiKey);
-}
-
-/**
- * OpenModel API keys don't expire, so "refresh" is a no-op.
- */
-export async function refreshToken(
-  credentials: OAuthCredentials,
-): Promise<OAuthCredentials> {
-  return credentialsFromApiKey(credentials.refresh);
-}
-
-/**
- * Extract the API key from stored credentials.
- */
-export function getApiKey(credentials: OAuthCredentials): string {
-  return credentials.access;
-}