pi-requesty-discover 2.1.0 → 2.2.0

package/README.adoc

@@ -8,13 +8,14 @@ endif::[]
 
 = pi-requesty-discover
 
-image:https://img.shields.io/npm/v/pi-requesty-discover.svg[npm version, link=https://www.npmjs.com/package/pi-requesty-discover]
+image:https://img.shields.io/npm/v/pi-requesty-discover.svg[npm version,link=https://www.npmjs.com/package/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
+* Use the `apiKey` from the model registry allowing you to use
+https://pi.dev/docs/latest/models#value-resolution[pi's full value resolution] capabilities
 * Health-check available models and write a log about them
 * Brief information about what was found, including added/removed models, health summary
 * Confirm before writing `models.json`, with a dry-run mode that only previews
@@ -70,35 +71,24 @@ Example:
     "requesty-export": {
       "name": "Requesty",
       "baseUrl": "https://router.requesty.ai/v1",
-      "apiKey": "$REQUESTY_API_KEY",
       "api": "openai-completions",
+      "apiKey": "$REQUESTY_API_KEY",
       "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.
-You can configure the real `apiKey` as you like, but it would be recommended to use the same variable as for the model discovery.
-
-IMPORTANT: Health checks are designed to use only a few tokens, but they still make real Requesty API calls and may consume credits.
+IMPORTANT: Health checks are designed to use only a few tokens, but they still make real Requesty API calls and **will** 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.
+On startup, the extension fetches `<baseUrl>/models` using the configured `apiKey` as the bearer token and registers discovered and healthy models with Pi.
 
 === Environment variables
 
-[cols="1,1,1,1,2", options="header"]
+[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`
@@ -132,12 +122,11 @@ The command:
 - discovers Requesty models (and optional health checks)
 - shows a summary notification (added/removed IDs, health summary)
 - asks for confirmation before writing `~/.pi/agent/models.json`
+- refreshes Pi's model registry so the new models are immediately available in `/model`
 - reports whether the file was updated
 
 If there are no model ID changes, confirmation still offers a metadata refresh write, which might have changed as well.
 
-After a successful write, run `/reload`.
-
 [source,text]
 ----
 /requesty-discover --dry-run
@@ -145,22 +134,31 @@ After a successful write, run `/reload`.
 
 Same discovery and health checks, but never prompts to write and leaves `models.json` unchanged.
 
+[source,bash]
+----
+pi -p "/requesty-discover"
+pi -p "/requesty-discover --dry-run"
+----
+
+You can also run the command from the CLI in a non-interactive mode.
+
 == Usage status
 
 The extension shows your current Requesty monthly spend as a persistent line in Pi's footer, e.g.:
 
 [source,text]
 ----
-Requesty Usage (<API Key Name>): $63.55/$150.00 (42%)
+<API Key Name>: $63.55/$150.00 (42%)
 ----
 
 When your API key has no monthly limit (`monthly_limit` is `0`), the limit is treated as unlimited:
 
 [source,text]
 ----
-Requesty Usage (<API Key Name>): $63.55 (unlimited)
+<API Key Name>: $63.55 (unlimited)
 ----
 
-When you select a model from a provider other than `REQUESTY_PROVIDER_ID`, the status is cleared — there is no Requesty usage to show for it. If `REQUESTY_API_KEY` is not configured, the status is left untouched.
+When you select a model from a provider other than `REQUESTY_PROVIDER_ID`, the status is cleared — there is no Requesty usage to show for it.
 
-NOTE: The footer update is best-effort and never blocks a turn. If it fails (network error, stale context after `/reload`), it fails silently without spamming notifications.
+NOTE: The footer update is best-effort and never blocks a turn.
+If it fails (network error, stale context after `/reload`), it fails silently without spamming notifications.

package/README.md

@@ -6,7 +6,8 @@ This extension helps you discover currently available models in requesty.ai for
 
 This is a fork of [pi-requesty](https://github.com/requestyai/pi-requesty) with additional features:
 
-* Use `REQUESTY_API_KEY` from the environment
+* Use the `apiKey` from the model registry allowing you to use
+[pi’s full value resolution](https://pi.dev/docs/latest/models#value-resolution) capabilities
 * Health-check available models and write a log about them
 * Brief information about what was found, including added/removed models, health summary
 * Confirm before writing `models.json`, with a dry-run mode that only previews
@@ -58,8 +59,8 @@ Example:
     "requesty-export": {
       "name": "Requesty",
       "baseUrl": "https://router.requesty.ai/v1",
-      "apiKey": "$REQUESTY_API_KEY",
       "api": "openai-completions",
+      "apiKey": "$REQUESTY_API_KEY",
       "models": []
     }
   }
@@ -67,21 +68,14 @@ Example:
 ```
 
 **❗ 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.
-You can configure the real `apiKey` as you like, but it would be recommended to use the same variable as for the model discovery.
+Health checks are designed to use only a few tokens, but they still make real Requesty API calls and ***will*** consume credits.
 
-**❗ 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.
+On startup, the extension fetches `<baseUrl>/models` using the configured `apiKey` as the bearer token and registers discovered and healthy models with Pi.
 
 ### Environment variables
 
 | 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 |
@@ -99,33 +93,40 @@ The command:
 * discovers Requesty models (and optional health checks)
 * shows a summary notification (added/removed IDs, health summary)
 * asks for confirmation before writing `~/.pi/agent/models.json`
+* refreshes Pi’s model registry so the new models are immediately available in `/model`
 * reports whether the file was updated
 
 If there are no model ID changes, confirmation still offers a metadata refresh write, which might have changed as well.
 
-After a successful write, run `/reload`.
-
 ```text
 /requesty-discover --dry-run
 ```
 
 Same discovery and health checks, but never prompts to write and leaves `models.json` unchanged.
 
+```bash
+pi -p "/requesty-discover"
+pi -p "/requesty-discover --dry-run"
+```
+
+You can also run the command from the CLI in a non-interactive mode.
+
 ## Usage status
 
 The extension shows your current Requesty monthly spend as a persistent line in Pi’s footer, e.g.:
 
 ```text
-Requesty Usage (<API Key Name>): $63.55/$150.00 (42%)
+<API Key Name>: $63.55/$150.00 (42%)
 ```
 
 When your API key has no monthly limit (`monthly_limit` is `0`), the limit is treated as unlimited:
 
 ```text
-Requesty Usage (<API Key Name>): $63.55 (unlimited)
+<API Key Name>: $63.55 (unlimited)
 ```
 
-When you select a model from a provider other than `REQUESTY_PROVIDER_ID`, the status is cleared — there is no Requesty usage to show for it. If `REQUESTY_API_KEY` is not configured, the status is left untouched.
+When you select a model from a provider other than `REQUESTY_PROVIDER_ID`, the status is cleared — there is no Requesty usage to show for it.
 
 **📌 NOTE**\
-The footer update is best-effort and never blocks a turn. If it fails (network error, stale context after `/reload`), it fails silently without spamming notifications.
+The footer update is best-effort and never blocks a turn.
+If it fails (network error, stale context after `/reload`), it fails silently without spamming notifications.

package/docs/DECISIONS.adoc

@@ -14,6 +14,22 @@ 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 `src/discovery.ts`, and documents intent just as well.
+
+Decision: keep the hand-rolled `Try<T>`. No `monads.ts` module either — rule of
+three. 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
@@ -34,3 +50,4 @@ The provider-like parts (API model fetch, usage footer, wanting Pi-managed auth)
 real, but the health check and the snapshot model break the provider fit.
 
 Decision: stay a `/requesty-discover` command that writes `models.json`.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-requesty-discover",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Discover available Requesty models for the Pi Coding Agent",
   "repository": {
     "type": "git",
@@ -47,7 +47,8 @@
     ]
   },
   "devDependencies": {
-    "@earendil-works/pi-tui": "^0.80.3",
+    "@earendil-works/pi-tui": "^0.85.0",
+    "@earendil-works/pi-coding-agent": "^0.85.0",
     "@eslint/js": "^10.0.1",
     "@types/node": "^26.1.0",
     "@vitest/coverage-v8": "^4.1.9",

package/src/discovery.ts

@@ -0,0 +1,224 @@
+import { ProviderModelConfig } from '@earendil-works/pi-coding-agent'
+import { type Env } from './env'
+import {
+  diffModels,
+  formatModelsDiffSummary,
+  GetApiKey,
+  getRequestyConfig,
+  type ModelsDiff,
+  ModelsJson,
+  updateModelsJson,
+} from './models-json'
+import { checkModels, formatHealthSummary, writeHealthCheckLog } from './health-check'
+import { discoverModels } from './requesty-api'
+
+const DRY_RUN_ARG = '--dry-run'
+
+interface AutocompleteItem {
+  value: string
+  label: string
+  description: string
+}
+
+export type NotificationLevel = 'info' | 'warning' | 'error'
+
+/** Everything the discovery workflow needs from the UI. One port, two adapters (tui/console) in index.ts. */
+export type DiscoveryUi = {
+  notify(message: string, level: NotificationLevel): void
+  confirm(title: string, message: string): Promise<boolean>
+  setStatus(message: string): void
+}
+
+export type RefreshModelsRegistry = () => Promise<void>
+
+export type DiscoveryEvaluation = {
+  dryRun: boolean
+  modelCount: number
+  failedCount: number
+  passing: ProviderModelConfig[]
+  diff: ModelsDiff
+  healthCheckSummary: string
+  logNote: string
+  data: ModelsJson
+}
+
+export type Try<T> = { ok: true; value: T } | { ok: false; error: unknown }
+
+export function formatDiscoveryFailure(error: unknown): string {
+  const detail = formatError(error)
+  return `Discovery failed: ${detail}`
+}
+
+export async function evaluateDiscovery(
+  args: string,
+  env: Env,
+  ui: DiscoveryUi,
+  getApiKey: GetApiKey,
+): Promise<DiscoveryEvaluation> {
+  ui.setStatus('Discovering Requesty models...')
+  const dryRun = args.split(' ').includes(DRY_RUN_ARG)
+
+  const { data, provider, existingModelIds } = await getRequestyConfig(getApiKey, env)
+  const models = await discoverModels(provider)
+  const modelsMap = new Map(models.map(m => [m.id, m]))
+
+  let diff: ModelsDiff
+  let failedCount = 0
+  let passing: ProviderModelConfig[]
+  let logNote = ''
+  let healthCheckSummary = ''
+
+  if (env.health_check_mode !== 'off') {
+    ui.setStatus(`Checking models 0/${models.length}...`)
+    const healthResults = await checkModels(provider, models, env.health_check_mode === 'full', {
+      onProgress: ({ completed, total }) => {
+        ui.setStatus(`Checking models ${completed}/${total}...`)
+      },
+    })
+    const sortedResults = healthResults.toSorted((a, b) => a.modelId.localeCompare(b.modelId))
+    failedCount = sortedResults.filter(r => !r.ok).length
+    passing = sortedResults.flatMap(r => {
+      const model = modelsMap.get(r.modelId)
+      return r.ok && model ? [model] : []
+    })
+    diff = diffModels(existingModelIds, passing)
+    healthCheckSummary = formatHealthSummary(sortedResults)
+    writeHealthCheckLog(provider, sortedResults, diff, env)
+    logNote = `Full health check log: ${env.health_check_log_path}\n`
+  } else {
+    passing = models
+    diff = diffModels(existingModelIds, passing)
+  }
+
+  return {
+    dryRun,
+    modelCount: models.length,
+    failedCount,
+    passing,
+    diff,
+    healthCheckSummary,
+    logNote,
+    data,
+  }
+}
+
+export async function finalizeDiscovery(
+  evaluation: DiscoveryEvaluation,
+  env: Env,
+  ui: DiscoveryUi,
+  refresh?: RefreshModelsRegistry,
+): Promise<void> {
+  const level = notificationLevel(evaluation)
+  const summary = buildDiscoverySummary(evaluation)
+
+  // Always surface the discovery result first (toast styling), then decide.
+  if (evaluation.dryRun) {
+    ui.notify(
+      `${summary}
+Dry run: left models.json unchanged.`,
+      level,
+    )
+    return
+  }
+
+  if (evaluation.passing.length === 0) {
+    ui.notify(
+      `${summary}
+Left models.json unchanged.`,
+      level,
+    )
+    return
+  }
+
+  ui.notify(summary, level)
+  const { title, message } = buildConfirmPrompt(evaluation)
+  const shouldUpdate = await ui.confirm(title, message)
+  if (shouldUpdate) {
+    updateModelsJson(evaluation.data, evaluation.passing, env)
+    if (!refresh) {
+      ui.notify('Updated models.json.', 'info')
+      return
+    }
+    const refreshResult = await runCatchingAsync(() => refresh())
+    if (refreshResult.ok) {
+      ui.notify('Updated models.json. New models are available in /model.', 'info')
+    } else {
+      ui.notify(
+        `Updated models.json, but the model registry could not be refreshed: ${formatError(refreshResult.error)}. Run /reload or restart Pi to use the changes.`,
+        'warning',
+      )
+    }
+    return
+  }
+
+  ui.notify('Left models.json unchanged.', 'info')
+}
+
+function buildDiscoverySummary(evaluation: DiscoveryEvaluation): string {
+  return [
+    `Discovered ${evaluation.modelCount} Requesty model(s).`,
+    evaluation.healthCheckSummary.trimEnd(),
+    formatModelsDiffSummary(evaluation.diff),
+    evaluation.logNote.trimEnd(),
+  ]
+    .filter(part => part.length > 0)
+    .join('\n')
+}
+
+function buildConfirmPrompt(evaluation: DiscoveryEvaluation): { title: string; message: string } {
+  const hasIdChanges = evaluation.diff.added.length > 0 || evaluation.diff.removed.length > 0
+  if (hasIdChanges) {
+    return {
+      title: `Write ${evaluation.passing.length} model(s)?`,
+      message: 'Update models.json with the discovery result above.',
+    }
+  }
+  return {
+    title: 'Refresh models.json?',
+    message: 'No model ID changes. Rewrite the file to refresh metadata anyway?',
+  }
+}
+
+function notificationLevel(evaluation: DiscoveryEvaluation): NotificationLevel {
+  if (evaluation.failedCount === 0) return 'info'
+  if (evaluation.failedCount < evaluation.modelCount) return 'warning'
+  return 'error'
+}
+
+export function getArgumentCompletions(prefix: string): AutocompleteItem[] {
+  const options = [
+    {
+      value: DRY_RUN_ARG,
+      label: DRY_RUN_ARG,
+      description: 'Preview discovery without offering to write models.json',
+    },
+  ]
+  if (!prefix) return options
+  return options.filter(o => o.value.toLowerCase().startsWith(prefix.toLowerCase()))
+}
+
+export function formatError(error: unknown) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+export function runCatching<T>(fn: () => T): Try<T> {
+  try {
+    return { ok: true, value: fn() }
+  } catch (error) {
+    return { ok: false, error }
+  }
+}
+
+export async function runCatchingAsync<T>(fn: () => Promise<T>): Promise<Try<T>> {
+  try {
+    return { ok: true, value: await fn() }
+  } catch (error) {
+    return { ok: false, error }
+  }
+}
+
+export function complainOnBrokenEnv(ui: DiscoveryUi, env: Try<Env>) {
+  if (!env.ok) {
+    ui.notify(`failed to load env: ${formatError(env.error)}`, 'error')
+  }
+}

package/src/env.ts

@@ -11,7 +11,6 @@ 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>
 }
 
@@ -22,16 +21,11 @@ export function getEnv(): Env {
     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`)
-  }
   const agentPath = getAgentDir()
   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 ?? DEFAULT_PROVIDER_ID,
-    requesty_api_key: apiKey,
     health_check_mode: result.data,
   }
 }

package/src/index.ts

@@ -1,312 +1,128 @@
-import {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
-  ProviderModelConfig,
-} from '@earendil-works/pi-coding-agent'
+import { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from '@earendil-works/pi-coding-agent'
 import { type Env, getEnv } from './env'
-import {
-  diffModels,
-  formatModelsDiffSummary,
-  getRequestyConfig,
-  type ModelsDiff,
-  updateModelsJson,
-} from './models-json'
-import { type ApiKeyInfo, discoverModels, fetchApiUsage } from './requesty-api'
-import { checkModels, formatHealthSummary, writeHealthCheckLog } from './health-check'
+import { GetApiKey, getRequestyConfig } from './models-json'
+import { type ApiKeyInfo, fetchApiUsage } from './requesty-api'
 import { RequestyStatusLoader } from './ui/requesty-status-loader.ts'
+import {
+  complainOnBrokenEnv,
+  type DiscoveryEvaluation,
+  type DiscoveryUi,
+  evaluateDiscovery,
+  finalizeDiscovery,
+  formatDiscoveryFailure,
+  getArgumentCompletions,
+  RefreshModelsRegistry,
+  runCatching,
+  runCatchingAsync,
+  type Try,
+} from './discovery'
+
+export { type Try }
 
 const COMMAND_NAME = 'requesty-discover'
-const DRY_RUN_ARG = '--dry-run'
 export const USAGE_STATUS_KEY = 'requesty-usage'
 
-interface AutocompleteItem {
-  value: string
-  label: string
-  description: string
-}
-
-export type NotificationLevel = 'info' | 'warning' | 'error'
-
-export type Notifier = {
-  notify(message: string, level: NotificationLevel): void
-}
-
-export type Confirmer = {
-  confirm(title: string, message: string): Promise<boolean>
-}
-
-export type StatusReporter = {
-  set(message: string): void
-}
-
-type ModelsJsonData = ReturnType<typeof getRequestyConfig>['data']
-
-type DiscoveryEvaluation = {
-  dryRun: boolean
-  modelCount: number
-  failedCount: number
-  passing: ProviderModelConfig[]
-  diff: ModelsDiff
-  healthCheckSummary: string
-  logNote: string
-  data: ModelsJsonData
-  env: Env
-}
-
-type EvaluationResult =
-  | {
-      ok: true
-      value: DiscoveryEvaluation
-    }
-  | { ok: false; error: unknown }
-
-// A per-instance token suppresses stale writes when turns overlap
+// token suppresses stale writes when turns overlap
 let latestToken: object = {}
 
 // noinspection JSUnusedGlobalSymbols
 export default function (pi: ExtensionAPI) {
+  const env = runCatching(() => getEnv())
+
   pi.registerCommand(COMMAND_NAME, {
     description: 'Dynamically discover Requesty models, run health checks, and update the local models.json.',
     getArgumentCompletions,
     handler: async (args, ctx) => {
-      await runDiscoveryWorkflow(ctx, args)
+      await runDiscoveryWorkflow(ctx, env, args)
     },
   })
 
   pi.on('turn_end', (_event, ctx) => {
-    void updateUsageStatus(ctx)
+    void updateUsageStatus(ctx, env)
   })
 
   pi.on('session_start', (_event, ctx) => {
-    void updateUsageStatus(ctx)
+    const ui = createTuiUi(ctx)
+    complainOnBrokenEnv(ui, env)
+    void updateUsageStatus(ctx, env)
   })
 
   pi.on('model_select', (_event, ctx) => {
-    void updateUsageStatus(ctx)
+    void updateUsageStatus(ctx, env)
   })
 }
 
-export async function runDiscoveryWorkflow(ctx: ExtensionCommandContext, args: string) {
-  // Interactive TUI command; no print/json/rpc path.
+export async function runDiscoveryWorkflow(ctx: ExtensionCommandContext, env: Try<Env>, args: string) {
+  const ui = ctx.mode === 'tui' ? createTuiUi(ctx) : createConsoleUi()
+  complainOnBrokenEnv(ui, env)
+  if (!env.ok) {
+    return
+  }
+
   if (ctx.mode !== 'tui') {
+    return runSilentDiscoveryWorkflow(ctx, env.value, args, ui)
+  } else {
+    return runInteractiveDiscoverWorkflow(ctx, env.value, args, ui)
+  }
+}
+
+async function runSilentDiscoveryWorkflow(
+  ctx: ExtensionCommandContext,
+  env: Env,
+  args: string,
+  ui: DiscoveryUi,
+): Promise<void> {
+  const evaluationResult = await runCatchingAsync(() => evaluateDiscovery(args, env, ui, createGetApiKey(ctx)))
+  if (!evaluationResult.ok) {
+    ui.notify(formatDiscoveryFailure(evaluationResult.error), 'error')
     return
   }
 
-  const notifier = createUiNotifier(ctx)
-  const confirmer = createUiConfirmer(ctx)
+  await finalizeDiscovery(evaluationResult.value, env, ui)
+}
 
-  // Phase A: progress UI only. Loader must close before confirm (Phase B).
-  // Errors are wrapped because ctx.ui.custom resolves via done() and does not reject.
-  const evaluationResult: EvaluationResult = await runWithStatusUi(ctx, 'Discovering models...', async status => {
-    try {
-      const evaluation = await evaluateDiscovery(args, status)
-      return { ok: true, value: evaluation }
-    } catch (error) {
-      return { ok: false, error }
-    }
-  })
+async function runInteractiveDiscoverWorkflow(ctx: ExtensionCommandContext, env: Env, args: string, ui: DiscoveryUi) {
+  const evaluationResult: Try<DiscoveryEvaluation> = await runWithStatusUi(
+    ctx,
+    'Discovering models...',
+    async statusUi => await runCatchingAsync(() => evaluateDiscovery(args, env, statusUi, createGetApiKey(ctx))),
+  )
 
   if (!evaluationResult.ok) {
-    notifier.notify(formatDiscoveryFailure(evaluationResult.error), 'error')
+    ui.notify(formatDiscoveryFailure(evaluationResult.error), 'error')
     return
   }
 
-  // Phases B + C: decide, optional write, final notify — outside the loader.
-  await finalizeDiscovery(evaluationResult.value, confirmer, notifier)
+  await finalizeDiscovery(evaluationResult.value, env, ui, createRefreshRegistry(ctx))
 }
 
 async function runWithStatusUi<T>(
   ctx: ExtensionCommandContext,
   initialMessage: string,
-  fn: (status: StatusReporter) => Promise<T>,
+  fn: (statusUi: DiscoveryUi) => Promise<T>,
 ): Promise<T> {
-  return ctx.ui.custom<T>((_tui, theme, _kb, done) => {
-    const loader = new RequestyStatusLoader(_tui, theme, initialMessage)
-    const status = createLoaderStatusReporter(loader)
+  return ctx.ui.custom<T>((tui, theme, _kb, done) => {
+    const loader = new RequestyStatusLoader(tui, theme, initialMessage)
     void Promise.resolve()
-      .then(() => fn(status))
+      .then(() => fn(createTuiUi(ctx, loader)))
       .then(done)
       .catch(done)
     return loader
   })
 }
 
-function formatDiscoveryFailure(error: unknown): string {
-  const detail = error instanceof Error ? error.message : String(error)
-  return `Discovery failed: ${detail}`
-}
-
-async function evaluateDiscovery(args: string, status: StatusReporter): Promise<DiscoveryEvaluation> {
-  status.set('Discovering Requesty models...')
-  const dryRun = args.split(' ').includes(DRY_RUN_ARG)
-
-  const env = getEnv()
-  const { data, provider, existingModelIds } = getRequestyConfig(env)
-  const models = await discoverModels(provider)
-  const modelsMap = new Map(models.map(m => [m.id, m]))
-
-  let diff: ModelsDiff
-  let failedCount = 0
-  let passing: ProviderModelConfig[]
-  let logNote = ''
-  let healthCheckSummary = ''
-
-  if (env.health_check_mode !== 'off') {
-    status.set(`Checking models 0/${models.length}...`)
-    const healthResults = await checkModels(provider, models, env.health_check_mode === 'full', {
-      onProgress: ({ completed, total }) => {
-        status.set(`Checking models ${completed}/${total}...`)
-      },
-    })
-    const sortedResults = healthResults.toSorted((a, b) => a.modelId.localeCompare(b.modelId))
-    failedCount = sortedResults.filter(r => !r.ok).length
-    passing = sortedResults.flatMap(r => {
-      const model = modelsMap.get(r.modelId)
-      return r.ok && model ? [model] : []
-    })
-    diff = diffModels(existingModelIds, passing)
-    healthCheckSummary = formatHealthSummary(sortedResults)
-    writeHealthCheckLog(provider, sortedResults, diff, env)
-    logNote = `Full health check log: ${env.health_check_log_path}\n`
-  } else {
-    passing = models
-    diff = diffModels(existingModelIds, passing)
-  }
-
-  return {
-    dryRun,
-    modelCount: models.length,
-    failedCount,
-    passing,
-    diff,
-    healthCheckSummary,
-    logNote,
-    data,
-    env,
-  }
-}
-
-async function finalizeDiscovery(
-  evaluation: DiscoveryEvaluation,
-  confirmer: Confirmer,
-  notifier: Notifier,
-): Promise<void> {
-  const level = notificationLevel(evaluation)
-  const summary = buildDiscoverySummary(evaluation)
-
-  // Always surface the discovery result first (toast styling), then decide.
-  if (evaluation.dryRun) {
-    notifier.notify(
-      `${summary}
-Dry run: left models.json unchanged.`,
-      level,
-    )
-    return
-  }
-
-  if (evaluation.passing.length === 0) {
-    notifier.notify(
-      `${summary}
-Left models.json unchanged.`,
-      level,
-    )
-    return
-  }
-
-  notifier.notify(summary, level)
-  const { title, message } = buildConfirmPrompt(evaluation)
-  const shouldUpdate = await confirmer.confirm(title, message)
-  if (shouldUpdate) {
-    updateModelsJson(evaluation.data, evaluation.passing, evaluation.env)
-    notifier.notify('Updated models.json. Run /reload to use the changes.', 'info')
-    return
-  }
-
-  notifier.notify('Left models.json unchanged.', 'info')
-}
-
-function buildDiscoverySummary(evaluation: DiscoveryEvaluation): string {
-  return [
-    `Discovered ${evaluation.modelCount} Requesty model(s).`,
-    evaluation.healthCheckSummary.trimEnd(),
-    formatModelsDiffSummary(evaluation.diff),
-    evaluation.logNote.trimEnd(),
-  ]
-    .filter(part => part.length > 0)
-    .join('\n')
-}
-
-function buildConfirmPrompt(evaluation: DiscoveryEvaluation): { title: string; message: string } {
-  const hasIdChanges = evaluation.diff.added.length > 0 || evaluation.diff.removed.length > 0
-  if (hasIdChanges) {
-    return {
-      title: `Write ${evaluation.passing.length} model(s)?`,
-      message: 'Update models.json with the discovery result above.',
-    }
-  }
-  return {
-    title: 'Refresh models.json?',
-    message: 'No model ID changes. Rewrite the file to refresh metadata anyway?',
-  }
-}
-
-function notificationLevel(evaluation: DiscoveryEvaluation): NotificationLevel {
-  if (evaluation.failedCount === 0) return 'info'
-  if (evaluation.failedCount < evaluation.modelCount) return 'warning'
-  return 'error'
-}
-
-function getArgumentCompletions(prefix: string): AutocompleteItem[] {
-  const options = [
-    {
-      value: DRY_RUN_ARG,
-      label: DRY_RUN_ARG,
-      description: 'Preview discovery without offering to write models.json',
-    },
-  ]
-  if (!prefix) return options
-  return options.filter(o => o.value.toLowerCase().startsWith(prefix.toLowerCase()))
-}
-
-function createUiNotifier(ctx: ExtensionCommandContext): Notifier {
-  return {
-    notify(message: string, level?: NotificationLevel) {
-      const prefixedMessage = `${COMMAND_NAME}: ${message}`
-      ctx.ui.notify(prefixedMessage, level)
-    },
-  }
-}
-
-function createUiConfirmer(ctx: ExtensionCommandContext): Confirmer {
-  return {
-    confirm(title, message) {
-      return ctx.ui.confirm(title, message)
-    },
-  }
-}
-
-function createLoaderStatusReporter(loader: RequestyStatusLoader): StatusReporter {
-  return {
-    set(message: string) {
-      loader.setMessage(message)
-    },
-  }
-}
-
-export async function updateUsageStatus(ctx: ExtensionContext): Promise<void> {
+async function updateUsageStatus(ctx: ExtensionContext, env: Try<Env>): Promise<void> {
+  if (!env.ok) return
   if (!ctx.hasUI) return // no footer to write to (print/json mode): skip the wasted fetch
   const token: object = {}
   latestToken = token
-  const providerId = getRequestyProviderId()
-  if (providerId === undefined) return // not configured for Requesty: nothing to do
-  const shouldClear = ctx.model?.provider !== providerId
+  const shouldClear = ctx.model?.provider !== env.value.provider_id
   try {
     if (shouldClear) {
       ctx.ui.setStatus(USAGE_STATUS_KEY, undefined)
       return
     }
-    const info = await fetchUsageStatus()
+    const info = await fetchUsageStatus(createGetApiKey(ctx), env.value)
     if (latestToken !== token) return
     ctx.ui.setStatus(USAGE_STATUS_KEY, formatUsageStatus(info))
   } catch {
@@ -314,27 +130,69 @@ export async function updateUsageStatus(ctx: ExtensionContext): Promise<void> {
   }
 }
 
-/** Returns the configured Requesty provider id, or undefined when Requesty is not configured. */
-function getRequestyProviderId(): string | undefined {
-  try {
-    return getEnv().provider_id
-  } catch {
-    return undefined
-  }
-}
-
 export function formatUsageStatus(info: ApiKeyInfo): string {
   const spend = `$${info.monthlySpend.toFixed(2)}`
   if (info.monthlyLimit <= 0) {
-    return `Requesty Usage (${info.name}): ${spend} (unlimited)`
+    return `${info.name}: ${spend} (unlimited)`
   }
   const limit = `$${info.monthlyLimit.toFixed(2)}`
   const percent = Math.floor((info.monthlySpend / info.monthlyLimit) * 100)
-  return `Requesty Usage (${info.name}): ${spend}/${limit} (${percent}%)`
+  return `${info.name}: ${spend}/${limit} (${percent}%)`
+}
+
+let lastFetched: { value: ApiKeyInfo; time: Date } | undefined
+
+async function fetchUsageStatus(getApiKey: GetApiKey, env: Env): Promise<ApiKeyInfo> {
+  const now = new Date()
+  if (lastFetched?.time && now.getTime() - lastFetched.time.getTime() < 2000) {
+    return lastFetched.value
+  }
+  const { provider } = await getRequestyConfig(getApiKey, env)
+  const value = await fetchApiUsage(provider)
+  lastFetched = { value, time: new Date() }
+  return value
+}
+
+/**
+ * For testing purposes, reset the cache after each run
+ */
+export function resetUsageStatusCache(): void {
+  lastFetched = undefined
+}
+
+/** TUI adapter: routes the workflow's UI needs to Pi's ctx.ui. */
+export function createTuiUi(ctx: ExtensionContext, loader?: RequestyStatusLoader): DiscoveryUi {
+  return {
+    notify: (message, level) => ctx.ui.notify(`${COMMAND_NAME}: ${message}`, level),
+    confirm: (title, message) => ctx.ui.confirm(title, message),
+    setStatus: message => loader?.setMessage(message),
+  }
+}
+
+/**
+ * Console adapter for non-interactive modes. Always confirms: print mode is
+ * non-interactive, so the write proceeds without a confirmation dialog.
+ */
+export function createConsoleUi(): DiscoveryUi {
+  return {
+    notify: (message, level) => console.log(`[${level}] ${message}`),
+    // eslint-disable-next-line @typescript-eslint/require-await -- must match the DiscoveryUi promise signature
+    confirm: async () => true,
+    setStatus: message => console.log(message),
+  }
+}
+
+/** Re-reads models.json through Pi's model registry so new models are usable without /reload. */
+export function createRefreshRegistry(ctx: ExtensionContext): RefreshModelsRegistry {
+  return () =>
+    ctx.modelRegistry.refresh({ allowNetwork: false }).then(result => {
+      if (result.aborted || result.errors.size > 0) {
+        const detail = [...result.errors.entries()].map(([id, error]) => `${id}: ${error.message}`).join(', ')
+        throw new Error(detail || 'refresh aborted')
+      }
+    })
 }
 
-async function fetchUsageStatus(): Promise<ApiKeyInfo> {
-  const env = getEnv()
-  const { provider } = getRequestyConfig(env)
-  return await fetchApiUsage(provider)
+function createGetApiKey(ctx: ExtensionContext): GetApiKey {
+  return providerId => ctx.modelRegistry.getApiKeyForProvider(providerId)
 }

package/src/models-json.ts

@@ -1,17 +1,21 @@
-import type { ProviderConfig, ProviderModelConfig } from '@earendil-works/pi-coding-agent'
+import { 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'
+import { type Env, getEnv } from './env'
 
 const DEFAULT_BASE_URL = 'https://router.requesty.ai/v1'
 const DEFAULT_NAME = 'Requesty'
 
+/** Resolves the API key for a provider through Pi's model registry. */
+export type GetApiKey = (providerId: string) => Promise<string | undefined>
+
 const ProviderSchema = z
   .object({
     name: z.string().optional(),
     baseUrl: z.string().optional(),
     apiKey: z.string().optional(),
+    api: z.string().optional(),
     models: z.array(z.object({ id: z.string() }).catchall(z.unknown())).optional(),
   })
   .catchall(z.unknown())
@@ -22,10 +26,10 @@ const ModelsJsonSchema = z
   })
   .catchall(z.unknown())
 
-type ModelsJson = z.infer<typeof ModelsJsonSchema>
+export type ModelsJson = z.infer<typeof ModelsJsonSchema>
 type ModelsJsonProvider = z.infer<typeof ProviderSchema>
 
-type RequestyProvider = ModelsJsonProvider & {
+export type RequestyProvider = ModelsJsonProvider & {
   name: string
   baseUrl: string
   apiKey: string
@@ -42,7 +46,7 @@ export type ModelsDiff = {
   removed: string[]
 }
 
-export function getRequestyConfig(envConfig: Env = getEnv()): RequestyConfig {
+export async function getRequestyConfig(getApiKey: GetApiKey, envConfig: Env = getEnv()): Promise<RequestyConfig> {
   const data = readModelsJson(envConfig)
   const provider = data.providers[envConfig.provider_id]
 
@@ -50,7 +54,10 @@ export function getRequestyConfig(envConfig: Env = getEnv()): RequestyConfig {
     throw new Error(`${envConfig.models_json_path} does not define providers.${envConfig.provider_id}`)
   }
 
-  const apiKey = envConfig.requesty_api_key
+  const apiKey = await getApiKey(envConfig.provider_id)
+  if (!apiKey) {
+    throw new Error(`No API key found for provider ${envConfig.provider_id}`)
+  }
   return {
     data,
     existingModelIds: (provider.models ?? []).map(m => m.id),
@@ -83,9 +90,13 @@ export function formatModelsDiffSummary(diff: ModelsDiff): string {
 
 export function updateModelsJson(data: ModelsJson, models: ProviderModelConfig[], envConfig: Env = getEnv()): void {
   const provider = data.providers[envConfig.provider_id]
+  const { name, baseUrl, api, apiKey, models: _existingModels, ...passthrough } = provider
   data.providers[envConfig.provider_id] = {
-    ...provider,
-    apiKey: nonEmptyString(provider.apiKey) ?? '$REQUESTY_API_KEY',
+    name,
+    baseUrl,
+    api,
+    apiKey,
+    ...passthrough,
     models: models.map(model => ({
       id: model.id,
       name: model.name,

package/src/requesty-api.ts

@@ -31,9 +31,14 @@ type Provider = {
   apiKey: string
 }
 
-export async function discoverModels(provider: Provider): Promise<ProviderModelConfig[]> {
+export async function discoverModels(
+  provider: Provider,
+  options: { timeoutMs?: number } = {},
+): Promise<ProviderModelConfig[]> {
+  const timeoutMs = options.timeoutMs ?? 5_000
   const response = await fetch(`${provider.baseUrl}/models`, {
     headers: { Authorization: `Bearer ${provider.apiKey}` },
+    signal: AbortSignal.timeout(timeoutMs),
   })
 
   if (!response.ok) {
@@ -82,10 +87,12 @@ const ApiKeyInfoSchema = z
 
 export type ApiKeyInfo = z.infer<typeof ApiKeyInfoSchema>
 
-export async function fetchApiUsage(provider: Provider): Promise<ApiKeyInfo> {
+export async function fetchApiUsage(provider: Provider, options: { timeoutMs?: number } = {}): Promise<ApiKeyInfo> {
   const url = `${REQUESTY_MANAGE_URL}/apikey/self`
+  const timeoutMs = options.timeoutMs ?? 2_000
   const response = await fetch(url, {
     headers: { Authorization: `Bearer ${provider.apiKey}` },
+    signal: AbortSignal.timeout(timeoutMs),
   })
 
   if (!response.ok) {