pi-requesty-discover 1.0.0

package/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 Christoph Welcz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+Copyright for portions of project pi-requesty-discover are held by [Requesty, 2026]
+as part of project pi-requesty. All other copyright are held by [Christoph Welcz, 2026].

package/README.adoc

@@ -0,0 +1,129 @@
+ifdef::env-github[]
+:tip-caption: :bulb:
+:note-caption: :information_source:
+:important-caption: :heavy_exclamation_mark:
+:caution-caption: :fire:
+:warning-caption: :warning:
+endif::[]
+
+= pi-requesty-discover
+
+This extension helps you discover currently available models in requesty.ai for your Pi Coding Agent.
+
+This is a fork of https://github.com/requestyai/pi-requesty[pi-requesty] with additional features:
+
+* Use `REQUESTY_API_KEY` from the environment
+* Health-check available models and write a log about them
+* Provide a dry-run mode that does not change anything
+
+== When and why use it
+
+Use this extension if
+
+- you are on Requesty.ai
+- you are limited to certain models by a company policy (for instance, for data residency/protection reasons)
+- you don't want to handcraft your own curated list of models constantly
+- you want to health check the list to complain about non-working models via a dry-run
+
+== Recommended Installation from GitHub repo
+
+[source,bash]
+----
+pi install git:github.com/enolive/pi-requesty-discover
+----
+
+== Install locally
+
+Check out the code from the official code repository `https://github.com/enolive/pi-requesty-discover`, and then:
+
+[source,bash]
+----
+pi install ./pi-requesty-discover
+----
+
+To run once without installing:
+
+[source,bash]
+----
+pi -e ./pi-requesty-discover
+----
+
+== Configuration
+
+The extension reads the `requesty-export` provider from `~/.pi/agent/models.json`.
+You can override the provider id with the `REQUESTY_PROVIDER_ID` variable.
+
+Example:
+
+[source,json]
+----
+{
+  "providers": {
+    "requesty-export": {
+      "name": "Requesty",
+      "baseUrl": "https://router.requesty.ai/v1",
+      "apiKey": "rqsty-sk-...",
+      "api": "openai-completions",
+      "models": []
+    }
+  }
+}
+----
+
+IMPORTANT: The `apiKey` from `models.json` is not used by this extension.
+It may contain Pi-specific environment-variable substitution that the extension cannot reliably resolve.
+Set `REQUESTY_API_KEY` instead. This variable is required.
+
+IMPORTANT: Health checks are designed to use only a few tokens, but they still make real Requesty API calls and may consume credits.
+
+On startup, the extension fetches `<baseUrl>/models` using `REQUESTY_API_KEY` as the bearer token and registers discovered and healthy models with Pi.
+
+=== Environment variables
+
+[cols="1,1,1,1,2", options="header"]
+|===
+| Name | Required | Type | Default | Meaning
+
+| `REQUESTY_API_KEY`
+| yes
+| `string`
+|
+| Requesty API key used for model discovery and health checks.
+
+| `REQUESTY_PROVIDER_ID`
+| no
+| `string`
+| `requesty-export`
+| The id of the provider.
+
+| `REQUESTY_HEALTH_CHECK_MODE`
+| no
+| `off`, `basic`, `full`
+| `full`
+| The health-check mode.
+
+| `PI_CODING_AGENT_DIR`
+| no
+| `string`
+| `~/.pi/agent`
+| pi configuration directory
+|===
+
+== Command
+
+Inside Pi:
+
+[source,text]
+----
+/requesty-discover
+----
+
+The command fetches Requesty models using `~/.pi/agent/models.json` and writes the discovered model IDs back to the same file.
+Run `/reload` after syncing.
+
+[source,text]
+----
+/requesty-discover --dry-run
+----
+
+This will not overwrite the `models.json` file, but will do everything else, including the health checks.

package/index.ts

@@ -0,0 +1,4 @@
+// Pi shows package extension provenance based on the manifest entrypoint path.
+// Keep the implementation in src while exposing a stable, user-facing package path
+// instead of identifying the installed extension as "src".
+export { default } from './src'

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "pi-requesty-discover",
+  "version": "1.0.0",
+  "description": "Discover available Requesty models for the Pi Coding Agent",
+  "type": "module",
+  "main": "src/index.ts",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "pi-extensions",
+    "requesty",
+    "openai-compatible",
+    "models"
+  ],
+  "scripts": {
+    "agent-lint": "agnix . -v",
+    "format:check": "prettier --check src test",
+    "format": "prettier --write src test",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "release": "npm version patch && git push --follow-tags",
+    "test": "vitest run",
+    "test:unit": "vitest run src",
+    "test:unit:coverage": "vitest run src --coverage",
+    "test:integration": "vitest run test/integration.test.ts",
+    "test:watch": "vitest"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^26.1.0",
+    "@vitest/coverage-v8": "^4.1.9",
+    "agnix": "^0.37.0",
+    "eslint": "^10.6.0",
+    "globals": "^17.7.0",
+    "jiti": "^2.7.0",
+    "msw": "^2.14.6",
+    "prettier": "^3.9.4",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.62.1",
+    "vitest": "^4.1.9"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
+  }
+}

package/src/env.ts

@@ -0,0 +1,41 @@
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+import { prettifyError, z } from 'zod'
+
+const HealthCheckModeSchema = z.enum(['off', 'basic', 'full']).default('full')
+
+export type Env = {
+  models_json_path: string
+  health_check_log_path: string
+  provider_id: string
+  requesty_api_key: string
+  health_check_mode: z.infer<typeof HealthCheckModeSchema>
+}
+
+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))
+  }
+
+  const apiKey = envVars.REQUESTY_API_KEY
+  if (!apiKey) {
+    throw new Error(`apiKey must be set via REQUESTY_API_KEY env var`)
+  }
+
+  return {
+    models_json_path: path.join(agentPath, 'models.json'),
+    health_check_log_path: path.join(agentPath, 'requesty-health-check.log'),
+    provider_id: envVars.REQUESTY_PROVIDER_ID ?? 'requesty-export',
+    requesty_api_key: apiKey,
+    health_check_mode: result.data,
+  }
+}
+
+export default getEnv

package/src/health-check.ts

@@ -0,0 +1,281 @@
+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
+const HEALTH_CHECK_TIMEOUT_MS = 15_000
+const HEALTH_CHECK_TIMEOUT_RETRIES = 2
+const HEALTH_CHECK_RETRY_DELAY_MS = 500
+
+const defaultHealthCheckOptions = {
+  concurrency: HEALTH_CHECK_CONCURRENCY,
+  timeoutMs: HEALTH_CHECK_TIMEOUT_MS,
+  retries: HEALTH_CHECK_TIMEOUT_RETRIES,
+  retryDelayMs: HEALTH_CHECK_RETRY_DELAY_MS,
+}
+
+const ChatCompletionResponseSchema = z.object({
+  choices: z.array(z.unknown()).min(1),
+})
+
+export type Provider = {
+  baseUrl: string
+  apiKey: string
+}
+
+export type HealthCheckResult = {
+  modelId: string
+  ok: boolean
+  latencyMs: number
+  error?: string
+}
+
+type ModelCheckResult = Omit<HealthCheckResult, 'modelId'>
+
+export type HealthCheckProgress = {
+  completed: number
+  total: number
+  modelId: string
+}
+
+export type HealthCheckOptions = {
+  concurrency?: number
+  timeoutMs?: number
+  retries?: number
+  retryDelayMs?: number
+  onProgress?: (progress: HealthCheckProgress) => void
+}
+
+type ResolvedHealthCheckOptions = Required<Omit<HealthCheckOptions, 'onProgress'>> &
+  Pick<HealthCheckOptions, 'onProgress'>
+
+export async function checkModels(
+  provider: Provider,
+  models: ProviderModelConfig[],
+  checkReasoning: boolean,
+  options: HealthCheckOptions = {},
+): Promise<HealthCheckResult[]> {
+  const healthCheckOptions = resolveHealthCheckOptions(options)
+  const results: HealthCheckResult[] = []
+  const queue = [...models]
+  const total = models.length
+  let active = 0
+  let completed = 0
+
+  await new Promise<void>(resolve => {
+    function next() {
+      while (active < healthCheckOptions.concurrency && queue.length > 0) {
+        // note: due to the single-threaded nature of JS, race conditions are not possible here
+        const model = queue.shift()!
+        active++
+        void checkModel(provider, model, checkReasoning, healthCheckOptions).then(result => {
+          const healthCheckResult = { modelId: model.id, ...result }
+          results.push(healthCheckResult)
+          completed++
+          healthCheckOptions.onProgress?.({ completed, total, modelId: model.id })
+          active--
+          if (queue.length === 0 && active === 0) resolve()
+          else next()
+        })
+      }
+      if (queue.length === 0 && active === 0) resolve()
+    }
+    next()
+  })
+
+  return results
+}
+
+export function formatHealthSummary(results: HealthCheckResult[]): string {
+  const passed = results.filter(r => r.ok)
+  const failed = results.filter(r => !r.ok)
+
+  if (failed.length === 0) {
+    return `Health check: all ${passed.length} OK.`
+  }
+
+  const failedModels = failed.map(r => `- ${r.modelId}`).join('\n')
+
+  return `Health check: ${passed.length} OK, ${failed.length} failed:\n${failedModels}\n`
+}
+
+export function writeHealthCheckLog(provider: Provider, results: HealthCheckResult[], envConfig: Env = getEnv()): void {
+  const passed = results.filter(r => r.ok)
+  const failed = results.filter(r => !r.ok)
+  const lines = [
+    `Requesty health check log`,
+    `Timestamp: ${new Date().toISOString()}`,
+    `Provider: ${envConfig.provider_id}`,
+    `Base URL: ${provider.baseUrl}`,
+    `Total: ${results.length}`,
+    `Passed: ${passed.length}`,
+    `Failed: ${failed.length}`,
+    '',
+  ]
+
+  if (failed.length === 0) {
+    lines.push('No failed models.')
+  } else {
+    lines.push('Failed models:', '')
+    for (const result of failed) {
+      lines.push(
+        `Model: ${result.modelId}`,
+        `Latency: ${result.latencyMs}ms`,
+        'Error:',
+        result.error || 'Unknown error',
+        '',
+        '---',
+        '',
+      )
+    }
+  }
+
+  fs.mkdirSync(path.dirname(envConfig.health_check_log_path), { recursive: true })
+  fs.writeFileSync(envConfig.health_check_log_path, `${lines.join('\n')}\n`, 'utf8')
+}
+
+export async function postChatCompletion(
+  provider: Provider,
+  body: unknown,
+  options: HealthCheckOptions = {},
+): Promise<ModelCheckResult> {
+  const healthCheckOptions = resolveHealthCheckOptions(options)
+  const start = Date.now()
+  try {
+    const response = await fetchWithTimeoutRetries(
+      `${provider.baseUrl}/chat/completions`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${provider.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      },
+      healthCheckOptions,
+    )
+
+    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}` : ''}` }
+    }
+
+    const result = ChatCompletionResponseSchema.safeParse(await response.json())
+    if (!result.success) {
+      return { ok: false, latencyMs, error: 'Empty choices in response' }
+    }
+
+    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),
+    }
+  }
+}
+
+async function checkModel(
+  provider: Provider,
+  model: ProviderModelConfig,
+  checkReasoning: boolean,
+  options: ResolvedHealthCheckOptions,
+): Promise<ModelCheckResult> {
+  const basicResult = await postChatCompletion(
+    provider,
+    {
+      model: model.id,
+      messages: [{ role: 'user', content: 'Say OK' }],
+      max_tokens: 16,
+    },
+    options,
+  )
+
+  if (!basicResult.ok || !model.reasoning || !checkReasoning) {
+    return basicResult
+  }
+
+  const reasoningResult = await postChatCompletion(
+    provider,
+    {
+      model: model.id,
+      messages: [{ role: 'user', content: 'Say OK. Do not call any tools.' }],
+      tools: [
+        {
+          type: 'function',
+          function: {
+            name: 'health_check_noop',
+            description: 'A no-op tool used only to verify tool compatibility during model health checks.',
+            parameters: {
+              type: 'object',
+              properties: {},
+              additionalProperties: false,
+            },
+          },
+        },
+      ],
+      reasoning_effort: 'low',
+    },
+    options,
+  )
+
+  if (!reasoningResult.ok) {
+    return {
+      ok: false,
+      latencyMs: reasoningResult.latencyMs,
+      error: `Reasoning/tool check failed: ${reasoningResult.error}`,
+    }
+  }
+
+  return {
+    ok: true,
+    latencyMs: basicResult.latencyMs + reasoningResult.latencyMs,
+  }
+}
+
+function resolveHealthCheckOptions(options: HealthCheckOptions): ResolvedHealthCheckOptions {
+  return {
+    ...defaultHealthCheckOptions,
+    ...options,
+  }
+}
+
+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')
+}

package/src/index.ts

@@ -0,0 +1,118 @@
+import {
+  BorderedLoader,
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ProviderModelConfig,
+} from '@earendil-works/pi-coding-agent'
+import { getEnv } from './env'
+import { getRequestyConfig, updateModelsJson } from './models-json'
+import { discoverModels } from './requesty-api'
+import { checkModels, formatHealthSummary, writeHealthCheckLog } from './health-check'
+
+const COMMAND_NAME = 'requesty-discover'
+const DRY_RUN_ARG = '--dry-run'
+
+interface AutocompleteItem {
+  value: string
+  label: string
+  description: string
+}
+
+type NotificationLevel = 'info' | 'warning' | 'error'
+
+// noinspection JSUnusedGlobalSymbols
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand(COMMAND_NAME, {
+    description: 'Dynamically discover Requesty models, run health checks, and update the local models.json.',
+    getArgumentCompletions,
+    handler: async (args, ctx) => {
+      await withLoader(ctx, 'Discovering models...', () => runCommand(args, ctx))
+    },
+  })
+}
+
+async function withLoader<T>(ctx: ExtensionCommandContext, message: string, fn: () => Promise<T>): Promise<T> {
+  return ctx.ui.custom<T>((_tui, theme, _kb, done) => {
+    const loader = new BorderedLoader(_tui, theme, message, { cancellable: false })
+    fn().then(done).catch(done)
+    return loader
+  })
+}
+
+function getArgumentCompletions(prefix: string): AutocompleteItem[] {
+  const options = [
+    {
+      value: DRY_RUN_ARG,
+      label: DRY_RUN_ARG,
+      description: 'Preview without writing into the new model.json file',
+    },
+  ]
+  if (!prefix) return options
+  return options.filter(o => o.value.toLowerCase().startsWith(prefix.toLowerCase()))
+}
+
+async function runCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  ctx.ui.setStatus(COMMAND_NAME, 'Discovering Requesty models...')
+  const parts = args.split(' ')
+  const dryRun = parts.includes(DRY_RUN_ARG)
+  if (dryRun) {
+    notify(ctx, 'running in dry mode, no changes will be done')
+  }
+
+  try {
+    const env = getEnv()
+    const { data, provider } = getRequestyConfig(env)
+    const models = await discoverModels(provider)
+    const modelsMap = new Map(models.map(m => [m.id, m]))
+
+    let failed = []
+    let passing: ProviderModelConfig[]
+    let logNote = ''
+    let healthCheckSummary = ''
+
+    if (env.health_check_mode !== 'off') {
+      ctx.ui.setStatus(COMMAND_NAME, `Checking models 0/${models.length}...`)
+      const healthResults = await checkModels(provider, models, env.health_check_mode === 'full', {
+        onProgress: ({ completed, total }) => {
+          ctx.ui.setStatus(COMMAND_NAME, `Checking models ${completed}/${total}...`)
+        },
+      })
+      const sortedResults = healthResults.toSorted((a, b) => a.modelId.localeCompare(b.modelId))
+      failed = sortedResults.filter(r => !r.ok)
+      passing = sortedResults.flatMap(r => {
+        const model = modelsMap.get(r.modelId)
+        return r.ok && model ? [model] : []
+      })
+      healthCheckSummary = formatHealthSummary(sortedResults)
+      writeHealthCheckLog(provider, sortedResults, env)
+      logNote = `Full health check log: ${env.health_check_log_path}\n`
+    } else {
+      passing = models
+    }
+
+    const shouldUpdate = passing.length > 0 && !dryRun
+    if (shouldUpdate) {
+      updateModelsJson(data, passing, env)
+    }
+
+    const writeNote = shouldUpdate ? 'Run /reload to use models.json changes.' : 'models.json was not updated.'
+    const message = `Discovered ${models.length} Requesty model(s).\n${healthCheckSummary}${logNote}${writeNote}`
+
+    if (failed.length === 0) {
+      notify(ctx, message, 'info')
+    } else if (failed.length < models.length) {
+      notify(ctx, message, 'warning')
+    } else {
+      notify(ctx, message, 'error')
+    }
+  } catch (error) {
+    notify(ctx, `Discovery failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+  } finally {
+    ctx.ui.setStatus(COMMAND_NAME, undefined)
+  }
+}
+
+function notify(ctx: ExtensionCommandContext, message: string, level?: NotificationLevel): void {
+  const prefixedMessage = `${COMMAND_NAME}: ${message}`
+  ctx.ui.notify(prefixedMessage, level)
+}

package/src/models-json.ts

@@ -0,0 +1,103 @@
+import type { ProviderConfig, 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 DEFAULT_BASE_URL = 'https://router.requesty.ai/v1'
+const DEFAULT_NAME = 'Requesty'
+
+const ProviderSchema = z
+  .object({
+    name: z.string().optional(),
+    baseUrl: z.string().optional(),
+    apiKey: z.string().optional(),
+  })
+  .catchall(z.unknown())
+
+const ModelsJsonSchema = z
+  .object({
+    providers: z.record(z.string(), ProviderSchema),
+  })
+  .catchall(z.unknown())
+
+type ModelsJson = z.infer<typeof ModelsJsonSchema>
+type ModelsJsonProvider = z.infer<typeof ProviderSchema>
+
+type RequestyProvider = ModelsJsonProvider & {
+  name: string
+  baseUrl: string
+  apiKey: string
+}
+
+type RequestyConfig = {
+  data: ModelsJson
+  provider: RequestyProvider
+}
+
+export function getRequestyConfig(envConfig: Env = getEnv()): RequestyConfig {
+  const data = readModelsJson(envConfig)
+  const provider = data.providers[envConfig.provider_id]
+
+  if (!provider) {
+    throw new Error(`${envConfig.models_json_path} does not define providers.${envConfig.provider_id}`)
+  }
+
+  const apiKey = envConfig.requesty_api_key
+  return {
+    data,
+    provider: {
+      ...provider,
+      name: nonEmptyString(provider.name) ?? DEFAULT_NAME,
+      baseUrl: normalizeBaseUrl(nonEmptyString(provider.baseUrl) ?? DEFAULT_BASE_URL),
+      apiKey,
+    },
+  }
+}
+
+export function updateModelsJson(data: ModelsJson, models: ProviderModelConfig[], envConfig: Env = getEnv()): void {
+  data.providers[envConfig.provider_id] = {
+    ...data.providers[envConfig.provider_id],
+    models: models.map(model => ({
+      id: model.id,
+      name: model.name,
+      reasoning: model.reasoning,
+      input: model.input,
+      cost: model.cost,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens,
+    })),
+  } satisfies ProviderConfig
+
+  writeModelsJson(data, envConfig)
+}
+
+function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/\/+$/, '')
+}
+
+function readModelsJson(envConfig: Env = getEnv()): ModelsJson {
+  if (!fs.existsSync(envConfig.models_json_path)) {
+    throw new Error(`${envConfig.models_json_path} does not exist`)
+  }
+
+  const data = JSON.parse(fs.readFileSync(envConfig.models_json_path, 'utf8')) as unknown
+  const result = ModelsJsonSchema.safeParse(data)
+
+  if (!result.success) {
+    throw new Error(`${envConfig.models_json_path} is invalid: ${z.prettifyError(result.error)}`)
+  }
+
+  return result.data
+}
+
+function writeModelsJson(data: ModelsJson, envConfig: Env = getEnv()): void {
+  fs.mkdirSync(path.dirname(envConfig.models_json_path), { recursive: true })
+  const tmpPath = `${envConfig.models_json_path}.tmp`
+  fs.writeFileSync(tmpPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8')
+  fs.renameSync(tmpPath, envConfig.models_json_path)
+}
+
+function nonEmptyString(value: string | undefined): string | undefined {
+  return value && value.length > 0 ? value : undefined
+}

package/src/requesty-api.ts

@@ -0,0 +1,68 @@
+import type { ProviderModelConfig } from '@earendil-works/pi-coding-agent'
+import { z } from 'zod'
+
+const DEFAULT_CONTEXT_WINDOW = 128000
+const DEFAULT_MAX_TOKENS = 4096
+
+const RequestyModelSchema = z
+  .object({
+    id: z.string().min(1),
+    name: z.string().optional(),
+    supports_reasoning: z.boolean().optional(),
+    supports_vision: z.boolean().optional(),
+    input_price: z.number().optional().nullable(),
+    output_price: z.number().optional().nullable(),
+    cached_price: z.number().optional().nullable(),
+    caching_price: z.number().optional().nullable(),
+    context_window: z.number().optional().nullable(),
+    max_output_tokens: z.number().optional().nullable(),
+  })
+  .catchall(z.unknown())
+
+export type RequestyModel = z.infer<typeof RequestyModelSchema>
+
+const ListModelsResponseSchema = z.object({
+  data: z.array(z.unknown()),
+})
+
+type Provider = {
+  baseUrl: string
+  apiKey: string
+}
+
+export async function discoverModels(provider: Provider): Promise<ProviderModelConfig[]> {
+  const response = await fetch(`${provider.baseUrl}/models`, {
+    headers: { Authorization: `Bearer ${provider.apiKey}` },
+  })
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText}`)
+  }
+
+  const rawData = await response.json()
+  const payload = ListModelsResponseSchema.parse(rawData)
+
+  return payload.data
+    .map(model => RequestyModelSchema.safeParse(model))
+    .filter(result => result.success)
+    .map(result => result.data)
+    .map(model => ({
+      id: model.id,
+      name: model.name && model.name.length > 0 ? model.name : model.id,
+      reasoning: model.supports_reasoning === true,
+      input: model.supports_vision === true ? ['text', 'image'] : ['text'],
+      cost: {
+        input: pricePerMillionTokens(model.input_price),
+        output: pricePerMillionTokens(model.output_price),
+        cacheRead: pricePerMillionTokens(model.cached_price),
+        cacheWrite: pricePerMillionTokens(model.caching_price),
+      },
+      contextWindow: model.context_window || DEFAULT_CONTEXT_WINDOW,
+      maxTokens: model.max_output_tokens || DEFAULT_MAX_TOKENS,
+    }))
+}
+
+function pricePerMillionTokens(value: number | null | undefined): number {
+  const raw = (value ?? 0) * 1_000_000
+  return Number(raw.toFixed(3))
+}