pi-requesty-discover 3.0.2 → 3.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-requesty-discover",
-  "version": "3.0.2",
+  "version": "3.1.2",
   "description": "Discover available Requesty models for the Pi Coding Agent",
   "repository": {
     "type": "git",
@@ -50,8 +50,8 @@
     ]
   },
   "devDependencies": {
-    "@earendil-works/pi-tui": "^0.85.0",
     "@earendil-works/pi-coding-agent": "^0.85.0",
+    "@earendil-works/pi-tui": "^0.85.0",
     "@eslint/js": "^10.0.1",
     "@types/node": "^26.1.0",
     "@vitest/coverage-v8": "^4.1.9",
@@ -67,6 +67,7 @@
     "vitest": "^4.1.9"
   },
   "dependencies": {
+    "openai": "^7.10.0",
     "json5": "^2.2.3",
     "zod": "^4.4.3"
   }

package/src/health-check.ts

@@ -1,8 +1,11 @@
 import type { ProviderModelConfig } from '@earendil-works/pi-coding-agent'
 import fs from 'node:fs'
 import path from 'node:path'
+import OpenAI from 'openai'
+import type { Stream } from 'openai/streaming'
 import { type Env, getEnv } from './env'
 import { formatModelsDiffSummary, type ModelsDiff } from './models-json'
+import { formatErrorMessage } from './utils'
 
 const HEALTH_CHECK_CONCURRENCY = 10
 const HEALTH_CHECK_TIMEOUT_MS = 15_000
@@ -16,8 +19,6 @@ const defaultHealthCheckOptions = {
   retryDelayMs: HEALTH_CHECK_RETRY_DELAY_MS,
 }
 
-const DATA_PREFIX = 'data:'
-
 export type Provider = {
   baseUrl: string
   apiKey: string
@@ -170,53 +171,35 @@ export function writeHealthCheckLog(
 
 export async function postChatCompletion(
   provider: Provider,
-  body: Record<string, unknown>,
+  body: Omit<OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming, 'stream'>,
   options: HealthCheckOptions = {},
 ): Promise<ModelCheckResult> {
   const healthCheckOptions = resolveHealthCheckOptions(options)
   const start = Date.now()
+  const client = createClient(provider, healthCheckOptions)
 
   for (let attempt = 0; attempt <= healthCheckOptions.retries; attempt++) {
     try {
-      const response = await fetch(`${provider.baseUrl}/chat/completions`, {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${provider.apiKey}`,
-          'Content-Type': 'application/json',
-          Accept: 'text/event-stream',
-        },
-        body: JSON.stringify({ ...body, stream: true }),
-        signal: AbortSignal.timeout(healthCheckOptions.timeoutMs),
+      const stream = await client.chat.completions.create({
+        ...body,
+        stream: true,
       })
-
-      const latencyMs = Date.now() - start
-
-      if (!response.ok) {
-        const text = await response.text().catch(() => '')
-        // rate limits are transient - a warning, not an error
-        const status: HealthCheckStatus = response.status === 429 ? 'warning' : 'error'
-        return {
-          status,
-          latencyMs,
-          error: `HTTP ${response.status} ${response.statusText}${text ? `: ${text}` : ''}`,
-        }
-      }
-
-      return await verifyFirstStreamChunk(response.body!, start)
+      return await verifyFirstStreamChunk(stream, start)
     } catch (err) {
-      if (isTimeoutError(err) && attempt < healthCheckOptions.retries) {
+      if (isTimeout(err) && attempt < healthCheckOptions.retries) {
         if (healthCheckOptions.retryDelayMs > 0) {
           await new Promise(resolve => setTimeout(resolve, healthCheckOptions.retryDelayMs))
         }
         continue
       }
       const attempts = attempt + 1
+      const status: HealthCheckStatus = isTransient(err) ? 'warning' : 'error'
       return {
-        status: 'error',
+        status,
         latencyMs: Date.now() - start,
-        error: isTimeoutError(err)
+        error: isTimeout(err)
           ? `Timed out after ${attempts} attempt(s); per-attempt timeout is ${healthCheckOptions.timeoutMs / 1000}s`
-          : String(err),
+          : formatRequestError(err),
       }
     }
   }
@@ -224,41 +207,43 @@ export async function postChatCompletion(
   return { status: 'error', latencyMs: Date.now() - start, error: 'Unknown error' }
 }
 
-async function verifyFirstStreamChunk(body: ReadableStream<Uint8Array>, start: number): Promise<ModelCheckResult> {
-  const reader = body.getReader()
-  const decoder = new TextDecoder()
-  let tail = ''
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) {
-        break
-      }
-      tail += decoder.decode(value, { stream: true })
-      const lines = tail.split('\n')
-      tail = lines.pop()!
-      for (const line of lines) {
-        if (!line.startsWith(DATA_PREFIX)) {
-          continue
-        }
-        const payload = line.slice(DATA_PREFIX.length).trim()
-        if (payload === '[DONE]') {
-          continue
-        }
-        try {
-          const parsed = JSON.parse(payload) as { choices?: unknown }
-          if (Array.isArray(parsed.choices) && parsed.choices.length > 0) {
-            return { status: 'ok', latencyMs: Date.now() - start }
-          }
-        } catch {
-          // partial JSON or non-choices chunk — keep reading
-        }
-      }
+function isTimeout(err: unknown) {
+  return err instanceof OpenAI.APIConnectionTimeoutError
+}
+
+function isTransient(err: unknown) {
+  return err instanceof OpenAI.RateLimitError
+}
+
+function formatRequestError(err: unknown) {
+  if (err instanceof OpenAI.APIError && err.status !== undefined) {
+    // for JSON bodies err.error holds the (unwrapped) parsed payload; for text bodies err.message
+    // already includes the status and the raw response text
+    const body = err.error ? `: ${JSON.stringify(err.error)}` : `: ${err.message}`
+    return `HTTP ${err.status}${body}`
+  }
+  return formatErrorMessage(err)
+}
+
+function createClient(provider: Provider, options: ResolvedHealthCheckOptions): OpenAI {
+  return new OpenAI({
+    apiKey: provider.apiKey,
+    baseURL: provider.baseUrl,
+    timeout: options.timeoutMs,
+    maxRetries: 0,
+  })
+}
+
+async function verifyFirstStreamChunk(
+  stream: Stream<OpenAI.Chat.Completions.ChatCompletionChunk>,
+  start: number,
+): Promise<ModelCheckResult> {
+  for await (const chunk of stream) {
+    if (chunk.choices instanceof Array && chunk.choices.length > 0) {
+      return { status: 'ok', latencyMs: Date.now() - start }
     }
-    return { status: 'error', latencyMs: Date.now() - start, error: 'Stream ended without content' }
-  } finally {
-    await reader.cancel()
   }
+  return { status: 'error', latencyMs: Date.now() - start, error: 'Stream ended without content' }
 }
 
 async function checkModel(
@@ -325,7 +310,3 @@ function resolveHealthCheckOptions(options: HealthCheckOptions): ResolvedHealthC
     ...options,
   }
 }
-
-function isTimeoutError(error: unknown): boolean {
-  return error instanceof Error && (error.name === 'AbortError' || error.name === 'TimeoutError')
-}

package/src/models-json.ts

@@ -23,9 +23,15 @@ const ProviderSchema = z
 
 const ModelsJsonSchema = z
   .object({
+    $schema: z.string().optional(),
     providers: z.record(z.string(), ProviderSchema),
   })
   .catchall(z.unknown())
+  .transform(({ $schema, providers, ...rest }) => ({
+    ...($schema !== undefined ? { $schema } : {}),
+    ...rest,
+    providers,
+  }))
 
 export type ModelsJson = z.infer<typeof ModelsJsonSchema>
 type ModelsJsonProvider = z.infer<typeof ProviderSchema>

package/docs/DECISIONS.adoc

@@ -1,46 +0,0 @@
-= Decision records
-
-Short notes for non-obvious decisions: context, decision, why not the obvious alternative.
-
-== Usage status stays on `setStatus` (shared, truncated footer line)
-
-Pi's `FooterComponent` joins all extensions' `setStatus` entries on one line and ellipsis-truncates the joined line to terminal width.
-No per-key layout, no wrap.
-
-`ctx.ui.setFooter(factory)` is replacement-only — it swaps the whole footer (pwd, tokens, context %, model, statuses), and the factory gets `footerData` but not token/model state.
-No "extra footer" API exists.
-
-Decision: keep `setStatus`.
-Revisit when the line overflows visibly with other extensions' statuses, or if the usage string grows past a typical width.
-
-== Hand-rolled `Try<T>` instead of an effects library
-
-Context: env loading and discovery evaluation both need a caught-error result value (`{ ok: true, value } | { ok: false, error }`).
-Libraries like Effect ship an industrial `Either`/`Effect.try` for exactly this.
-
-Why not: Effect is a runtime, a generator DSL, and a worldview — not a utility.
-Two call sites in a Pi extension don't justify the dependency weight or the learning curve for contributors.
-The hand-rolled version is ~10 lines (`Try<T>`, `runCatching`, `runCatchingAsync`, named after Kotlin's `Result`), lives in `utils.ts`, and documents intent just as well.
-
-Decision: keep the hand-rolled `Try<T>`.
-Revisit if the extension ever needs typed errors, retries, or resource scoping; that's the day Effect earns its place.
-
-== Not a provider — a models.json-writing extension
-
-Context: Requesty already works as a Pi provider via `models.json`.
-The temptation is to make this extension *be* the provider: read the model list from the Requesty API, hold it in memory, surface usage stats, let Pi manage the API key.
-
-Why not:
-
-- Health-checking is the core value and has no home in a provider.
-A provider serves models; it doesn't vet them.
-The health check plus the diff/confirm/write flow is a discovery-and-selection step, not serving.
-- A provider keeps its model list in-memory and refreshes occasionally.
-Here the list is a persistent on-disk snapshot (`models.json`) — constant until you re-run
-`/requesty-discover`.
-That matches the intent: an explicit, reviewed, user-confirmed write, after which Pi's normal provider machinery serves the models.
-
-The provider-like parts (API model fetch, usage footer, wanting Pi-managed auth) are real, but the health check and the snapshot model break the provider fit.
-
-Decision: stay a `/requesty-discover` command that writes `models.json`.
-

package/docs/requesty-discovery-settings.schema.json

@@ -1,36 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "type": "object",
-  "properties": {
-    "bannedModels": {
-      "default": [],
-      "type": "array",
-      "items": {
-        "type": "string",
-        "minLength": 1
-      }
-    },
-    "healthCheckMode": {
-      "default": "full",
-      "type": "string",
-      "enum": [
-        "off",
-        "basic",
-        "full"
-      ]
-    },
-    "providerId": {
-      "default": "requesty-export",
-      "type": "string"
-    }
-  },
-  "required": [
-    "bannedModels",
-    "healthCheckMode",
-    "providerId"
-  ],
-  "additionalProperties": false,
-  "$id": "https://raw.githubusercontent.com/enolive/pi-requesty/main/docs/requesty-discovery-settings.schema.json",
-  "title": "Requesty discovery settings",
-  "description": "Settings for the pi-requesty discovery extension. The file uses JSON5, so comments are allowed."
-}

package/scripts/generate-settings-schema.ts

@@ -1,17 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { z } from 'zod'
-import { DiscoverySettingsSchema } from '../src/settings'
-
-const OUT_PATH = path.resolve('docs/requesty-discovery-settings.schema.json')
-const SCHEMA_URL =
-  'https://raw.githubusercontent.com/enolive/pi-requesty/main/docs/requesty-discovery-settings.schema.json'
-
-const schema = z.toJSONSchema(DiscoverySettingsSchema, { target: 'draft-2020-12', io: 'output' })
-schema.$id = SCHEMA_URL
-schema.title = 'Requesty discovery settings'
-schema.description = 'Settings for the pi-requesty discovery extension. The file uses JSON5, so comments are allowed.'
-
-fs.mkdirSync(path.dirname(OUT_PATH), { recursive: true })
-fs.writeFileSync(OUT_PATH, `${JSON.stringify(schema, null, 2)}\n`, 'utf8')
-console.log(`wrote ${OUT_PATH}`)