pi-requesty-discover 1.0.5 → 1.1.0

package/CONTRIBUTING.adoc

@@ -0,0 +1,35 @@
+= Contributing
+
+Thanks for your interest in contributing.
+
+== Useful scripts
+
+These will also be run in the CI/CD pipeline.
+Make sure to run them beforehand to get faster feedback
+about the overall quality.
+
+[source,bash]
+----
+# install all dependencies
+npm install
+
+# linting and format checking all-in-one
+npm run check
+
+# run all the tests
+npm test
+----
+
+Use `npm run format` to fix formatting.
+
+Refer to additional scripts in link:package.json[].
+
+Please keep changes focused and include tests or docs when behavior changes.
+
+Notes:
+
+* The package is loaded directly from TypeScript; do not add a build step casually.
+* Keep implementation in `src/`; root `index.ts` is just the package entrypoint.
+* Edit `README.adoc` if necessary.
+* See `AGENTS.md` for detailed repository conventions.
+* I am pretty good at identifying AI slop 😁.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-requesty-discover",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Discover available Requesty models for the Pi Coding Agent",
   "repository": {
     "type": "git",
@@ -22,12 +22,13 @@
     "models"
   ],
   "scripts": {
-    "agent-lint": "agnix . -v",
-    "format:check": "prettier --check src test",
-    "format": "prettier --write src test",
+    "check": "npm run agent-lint && npm run format:check && npm run typecheck && npm run lint",
+    "agent-lint": "agnix . -v --strict",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
     "typecheck": "tsc --noEmit",
     "lint": "eslint .",
-    "release": "npm version patch && git push --follow-tags",
+    "release": "read -p 'Release a new version? [y/N] ' ok && [ \"$ok\" = \"y\" ] && npm version patch && git push --follow-tags",
     "test": "vitest run",
     "test:unit": "vitest run src",
     "test:unit:coverage": "vitest run src --coverage",

package/src/env.ts

@@ -1,7 +1,7 @@
-import os from 'node:os'
 import path from 'node:path'
 import process from 'node:process'
 import { prettifyError, z } from 'zod'
+import { getAgentDir } from '@earendil-works/pi-coding-agent'
 
 const HealthCheckModeSchema = z.enum(['off', 'basic', 'full']).default('full')
 
@@ -15,10 +15,6 @@ export type Env = {
 
 export function getEnv(): Env {
   const envVars = process.env
-  const configuredAgentPath = envVars.PI_CODING_AGENT_DIR
-  const defaultAgentPath = path.join(os.homedir(), '.pi', 'agent')
-  const agentPath = configuredAgentPath || defaultAgentPath
-
   const result = HealthCheckModeSchema.safeParse(envVars.REQUESTY_HEALTH_CHECK_MODE)
   if (!result.success) {
     throw new Error(prettifyError(result.error))
@@ -28,7 +24,7 @@ export function getEnv(): Env {
   if (!apiKey) {
     throw new Error(`apiKey must be set via REQUESTY_API_KEY env var`)
   }
-
+  const agentPath = getAgentDir()
   return {
     models_json_path: path.join(agentPath, 'models.json'),
     health_check_log_path: path.join(agentPath, 'requesty-health-check.log'),
@@ -37,5 +33,3 @@ export function getEnv(): Env {
     health_check_mode: result.data,
   }
 }
-
-export default getEnv

package/src/health-check.ts

@@ -1,7 +1,6 @@
 import type { ProviderModelConfig } from '@earendil-works/pi-coding-agent'
 import fs from 'node:fs'
 import path from 'node:path'
-import { z } from 'zod'
 import { getEnv, type Env } from './env'
 
 const HEALTH_CHECK_CONCURRENCY = 10
@@ -16,9 +15,7 @@ const defaultHealthCheckOptions = {
   retryDelayMs: HEALTH_CHECK_RETRY_DELAY_MS,
 }
 
-const ChatCompletionResponseSchema = z.object({
-  choices: z.array(z.unknown()).min(1),
-})
+const DATA_PREFIX = 'data:'
 
 export type Provider = {
   baseUrl: string
@@ -138,48 +135,92 @@ export function writeHealthCheckLog(provider: Provider, results: HealthCheckResu
 
 export async function postChatCompletion(
   provider: Provider,
-  body: unknown,
+  body: Record<string, unknown>,
   options: HealthCheckOptions = {},
 ): Promise<ModelCheckResult> {
   const healthCheckOptions = resolveHealthCheckOptions(options)
   const start = Date.now()
-  try {
-    const response = await fetchWithTimeoutRetries(
-      `${provider.baseUrl}/chat/completions`,
-      {
+
+  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),
-      },
-      healthCheckOptions,
-    )
+        body: JSON.stringify({ ...body, stream: true }),
+        signal: AbortSignal.timeout(healthCheckOptions.timeoutMs),
+      })
 
-    const latencyMs = Date.now() - start
+      const latencyMs = Date.now() - start
 
-    if (!response.ok) {
-      const text = await response.text().catch(() => '')
-      return { ok: false, latencyMs, error: `HTTP ${response.status} ${response.statusText}${text ? `: ${text}` : ''}` }
-    }
+      if (!response.ok) {
+        const text = await response.text().catch(() => '')
+        return {
+          ok: false,
+          latencyMs,
+          error: `HTTP ${response.status} ${response.statusText}${text ? `: ${text}` : ''}`,
+        }
+      }
 
-    const result = ChatCompletionResponseSchema.safeParse(await response.json())
-    if (!result.success) {
-      return { ok: false, latencyMs, error: 'Empty choices in response' }
+      return await verifyFirstStreamChunk(response.body!, start)
+    } catch (err) {
+      if (isTimeoutError(err) && attempt < healthCheckOptions.retries) {
+        if (healthCheckOptions.retryDelayMs > 0) {
+          await new Promise(resolve => setTimeout(resolve, healthCheckOptions.retryDelayMs))
+        }
+        continue
+      }
+      const attempts = attempt + 1
+      return {
+        ok: false,
+        latencyMs: Date.now() - start,
+        error: isTimeoutError(err)
+          ? `Timed out after ${attempts} attempt(s); per-attempt timeout is ${healthCheckOptions.timeoutMs / 1000}s`
+          : String(err),
+      }
     }
+  }
 
-    return { ok: true, latencyMs }
-  } catch (err) {
-    const latencyMs = Date.now() - start
-    const attempts = healthCheckOptions.retries + 1
-    return {
-      ok: false,
-      latencyMs,
-      error: isTimeoutError(err)
-        ? `Timed out after ${attempts} attempt(s); per-attempt timeout is ${healthCheckOptions.timeoutMs / 1000}s`
-        : String(err),
+  return { ok: false, 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 { ok: true, latencyMs: Date.now() - start }
+          }
+        } catch {
+          // partial JSON or non-choices chunk — keep reading
+        }
+      }
     }
+    return { ok: false, latencyMs: Date.now() - start, error: 'Stream ended without content' }
+  } finally {
+    await reader.cancel()
   }
 }
 
@@ -248,34 +289,6 @@ function resolveHealthCheckOptions(options: HealthCheckOptions): ResolvedHealthC
   }
 }
 
-async function fetchWithTimeoutRetries(
-  url: string,
-  options: RequestInit,
-  { timeoutMs, retries, retryDelayMs }: ResolvedHealthCheckOptions,
-) {
-  function sleep(ms: number) {
-    if (ms <= 0) {
-      return
-    }
-    return new Promise(resolve => setTimeout(resolve, ms))
-  }
-
-  for (let attempt = 0; ; attempt++) {
-    try {
-      return await fetch(url, {
-        ...options,
-        signal: AbortSignal.timeout(timeoutMs),
-      })
-    } catch (error) {
-      if (!isTimeoutError(error) || attempt >= retries) {
-        throw error
-      }
-
-      await sleep(retryDelayMs)
-    }
-  }
-}
-
 function isTimeoutError(error: unknown): boolean {
   return error instanceof Error && (error.name === 'AbortError' || error.name === 'TimeoutError')
 }