pi-requesty-discover 1.2.0 → 2.1.0

package/CONTRIBUTING.adoc

@@ -32,4 +32,5 @@ Notes:
 * Keep implementation in `src/`; root `index.ts` is just the package entrypoint.
 * Edit `README.adoc` if necessary.
 * See `AGENTS.md` for detailed repository conventions.
+* See `docs/DECISIONS.adoc` for deliberate design decisions.
 * I am pretty good at identifying AI slop 😁.

package/README.adoc

@@ -16,7 +16,9 @@ This is a fork of https://github.com/requestyai/pi-requesty[pi-requesty] with ad
 
 * 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
+* 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
+* A footer status line showing your monthly Requesty spend against your monthly limit
 
 == When and why use it
 
@@ -25,7 +27,8 @@ 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
+- you want to health-check models and preview the diff before writing
+- you want to keep in touch with your usage without having to constantly visit the Requesty dashboard
 
 == Installation
 
@@ -124,12 +127,40 @@ Inside Pi:
 /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.
+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`
+- 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
 ----
 
-This will not overwrite the `models.json` file, but will do everything else, including the health checks.
+Same discovery and health checks, but never prompts to write and leaves `models.json` unchanged.
+
+== 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%)
+----
+
+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)
+----
+
+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.
+
+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

@@ -8,7 +8,9 @@ This is a fork of [pi-requesty](https://github.com/requestyai/pi-requesty) with
 
 * 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
+* 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
+* A footer status line showing your monthly Requesty spend against your monthly limit
 
 ## When and why use it
 
@@ -17,7 +19,8 @@ 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
+* you want to health-check models and preview the diff before writing
+* you want to keep in touch with your usage without having to constantly visit the Requesty dashboard
 
 ## Installation
 
@@ -91,11 +94,38 @@ Inside Pi:
 /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.
+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`
+* 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
 ```
 
-This will not overwrite the `models.json` file, but will do everything else, including the health checks.
+Same discovery and health checks, but never prompts to write and leaves `models.json` unchanged.
+
+## 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%)
+```
+
+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)
+```
+
+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.
+
+**📌 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/docs/DECISIONS.adoc

@@ -0,0 +1,36 @@
+= 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.
+
+== 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-requesty-discover",
-  "version": "1.2.0",
+  "version": "2.1.0",
   "description": "Discover available Requesty models for the Pi Coding Agent",
   "repository": {
     "type": "git",

package/src/env.ts

@@ -5,6 +5,8 @@ import { getAgentDir } from '@earendil-works/pi-coding-agent'
 
 const HealthCheckModeSchema = z.enum(['off', 'basic', 'full']).default('full')
 
+export const DEFAULT_PROVIDER_ID = 'requesty-export'
+
 export type Env = {
   models_json_path: string
   health_check_log_path: string
@@ -28,7 +30,7 @@ export function getEnv(): Env {
   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',
+    provider_id: envVars.REQUESTY_PROVIDER_ID ?? DEFAULT_PROVIDER_ID,
     requesty_api_key: apiKey,
     health_check_mode: result.data,
   }

package/src/index.ts

@@ -1,18 +1,24 @@
-import { ExtensionAPI, ExtensionCommandContext, ProviderModelConfig } from '@earendil-works/pi-coding-agent'
-import { getEnv } from './env'
+import {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+  ProviderModelConfig,
+} from '@earendil-works/pi-coding-agent'
+import { type Env, getEnv } from './env'
 import {
   diffModels,
   formatModelsDiffSummary,
   getRequestyConfig,
-  updateModelsJson,
   type ModelsDiff,
+  updateModelsJson,
 } from './models-json'
-import { discoverModels } from './requesty-api'
+import { type ApiKeyInfo, discoverModels, fetchApiUsage } from './requesty-api'
 import { checkModels, formatHealthSummary, writeHealthCheckLog } from './health-check'
 import { RequestyStatusLoader } from './ui/requesty-status-loader.ts'
 
 const COMMAND_NAME = 'requesty-discover'
 const DRY_RUN_ARG = '--dry-run'
+export const USAGE_STATUS_KEY = 'requesty-usage'
 
 interface AutocompleteItem {
   value: string
@@ -26,143 +32,256 @@ 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
-  clear(): 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
+let latestToken: object = {}
+
 // 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 runWithStatusUi(ctx, 'Discovering models...', (status, notifier) => runCommand(args, status, notifier))
+      await runDiscoveryWorkflow(ctx, args)
     },
   })
+
+  pi.on('turn_end', (_event, ctx) => {
+    void updateUsageStatus(ctx)
+  })
+
+  pi.on('session_start', (_event, ctx) => {
+    void updateUsageStatus(ctx)
+  })
+
+  pi.on('model_select', (_event, ctx) => {
+    void updateUsageStatus(ctx)
+  })
+}
+
+export async function runDiscoveryWorkflow(ctx: ExtensionCommandContext, args: string) {
+  // Interactive TUI command; no print/json/rpc path.
+  if (ctx.mode !== 'tui') {
+    return
+  }
+
+  const notifier = createUiNotifier(ctx)
+  const confirmer = createUiConfirmer(ctx)
+
+  // 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 }
+    }
+  })
+
+  if (!evaluationResult.ok) {
+    notifier.notify(formatDiscoveryFailure(evaluationResult.error), 'error')
+    return
+  }
+
+  // Phases B + C: decide, optional write, final notify — outside the loader.
+  await finalizeDiscovery(evaluationResult.value, confirmer, notifier)
 }
 
 async function runWithStatusUi<T>(
   ctx: ExtensionCommandContext,
   initialMessage: string,
-  fn: (status: StatusReporter, notifier: Notifier) => Promise<T>,
+  fn: (status: StatusReporter) => Promise<T>,
 ): Promise<T> {
-  if (ctx.mode !== 'tui') {
-    return fn(createNoopStatusReporter(), createNoopNotifier())
-  }
-
   return ctx.ui.custom<T>((_tui, theme, _kb, done) => {
     const loader = new RequestyStatusLoader(_tui, theme, initialMessage)
-    const notifier = createUiNotifier(ctx)
     const status = createLoaderStatusReporter(loader)
     void Promise.resolve()
-      .then(() => fn(status, notifier))
+      .then(() => fn(status))
       .then(done)
       .catch(done)
     return loader
   })
 }
 
-export async function runCommand(args: string, status: StatusReporter, notifier: Notifier): Promise<void> {
+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 parts = args.split(' ')
-  const dryRun = parts.includes(DRY_RUN_ARG)
-  if (dryRun) {
-    notifier.notify('running in dry mode, no changes will be done', 'info')
+  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)
   }
 
-  try {
-    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 failed = []
-    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))
-      failed = sortedResults.filter(r => !r.ok)
-      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,
+  }
+}
 
-    const shouldUpdate = passing.length > 0 && !dryRun
-    if (shouldUpdate) {
-      updateModelsJson(data, passing, env)
-    }
+async function finalizeDiscovery(
+  evaluation: DiscoveryEvaluation,
+  confirmer: Confirmer,
+  notifier: Notifier,
+): Promise<void> {
+  const level = notificationLevel(evaluation)
+  const summary = buildDiscoverySummary(evaluation)
 
-    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}${formatModelsDiffSummary(diff)}\n${logNote}${writeNote}`
+  // 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 (failed.length === 0) {
-      notifier.notify(message, 'info')
-    } else if (failed.length < models.length) {
-      notifier.notify(message, 'warning')
-    } else {
-      notifier.notify(message, 'error')
+  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.',
     }
-  } catch (error) {
-    notifier.notify(`Discovery failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
-  } finally {
-    status.clear()
+  }
+  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 without writing into the new model.json file',
+      description: 'Preview discovery without offering to write models.json',
     },
   ]
   if (!prefix) return options
   return options.filter(o => o.value.toLowerCase().startsWith(prefix.toLowerCase()))
 }
 
-function createNoopStatusReporter(): StatusReporter {
-  return {
-    set() {
-      // Status output is only rendered in TUI mode.
-    },
-    clear() {
-      // Status output is only rendered in TUI mode.
-    },
-  }
-}
-
-function createNoopNotifier(): Notifier {
+function createUiNotifier(ctx: ExtensionCommandContext): Notifier {
   return {
-    notify() {
-      // Notifications are only rendered in TUI mode.
+    notify(message: string, level?: NotificationLevel) {
+      const prefixedMessage = `${COMMAND_NAME}: ${message}`
+      ctx.ui.notify(prefixedMessage, level)
     },
   }
 }
 
-function createUiNotifier(ctx: ExtensionCommandContext): Notifier {
+function createUiConfirmer(ctx: ExtensionCommandContext): Confirmer {
   return {
-    notify(message: string, level?: NotificationLevel) {
-      const prefixedMessage = `${COMMAND_NAME}: ${message}`
-      ctx.ui.notify(prefixedMessage, level)
+    confirm(title, message) {
+      return ctx.ui.confirm(title, message)
     },
   }
 }
@@ -172,8 +291,50 @@ function createLoaderStatusReporter(loader: RequestyStatusLoader): StatusReporte
     set(message: string) {
       loader.setMessage(message)
     },
-    clear() {
-      // Nothing to clear: the loader closes when ctx.ui.custom() resolves.
-    },
   }
 }
+
+export async function updateUsageStatus(ctx: ExtensionContext): Promise<void> {
+  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
+  try {
+    if (shouldClear) {
+      ctx.ui.setStatus(USAGE_STATUS_KEY, undefined)
+      return
+    }
+    const info = await fetchUsageStatus()
+    if (latestToken !== token) return
+    ctx.ui.setStatus(USAGE_STATUS_KEY, formatUsageStatus(info))
+  } catch {
+    // best-effort footer update: swallow fetch errors and stale-ctx throws (e.g. after /reload)
+  }
+}
+
+/** 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)`
+  }
+  const limit = `$${info.monthlyLimit.toFixed(2)}`
+  const percent = Math.floor((info.monthlySpend / info.monthlyLimit) * 100)
+  return `Requesty Usage (${info.name}): ${spend}/${limit} (${percent}%)`
+}
+
+async function fetchUsageStatus(): Promise<ApiKeyInfo> {
+  const env = getEnv()
+  const { provider } = getRequestyConfig(env)
+  return await fetchApiUsage(provider)
+}

package/src/requesty-api.ts

@@ -3,6 +3,7 @@ import { z } from 'zod'
 
 const DEFAULT_CONTEXT_WINDOW = 128000
 const DEFAULT_MAX_TOKENS = 4096
+const REQUESTY_MANAGE_URL = 'https://api-v2.requesty.ai/v1/manage'
 
 const RequestyModelSchema = z
   .object({
@@ -66,3 +67,31 @@ function pricePerMillionTokens(value: number | null | undefined): number {
   const raw = (value ?? 0) * 1_000_000
   return Number(raw.toFixed(3))
 }
+
+const ApiKeyInfoSchema = z
+  .object({
+    name: z.string().min(1),
+    monthly_spend: z.coerce.number(),
+    monthly_limit: z.coerce.number(),
+  })
+  .transform(value => ({
+    name: value.name,
+    monthlySpend: value.monthly_spend,
+    monthlyLimit: value.monthly_limit,
+  }))
+
+export type ApiKeyInfo = z.infer<typeof ApiKeyInfoSchema>
+
+export async function fetchApiUsage(provider: Provider): Promise<ApiKeyInfo> {
+  const url = `${REQUESTY_MANAGE_URL}/apikey/self`
+  const response = await fetch(url, {
+    headers: { Authorization: `Bearer ${provider.apiKey}` },
+  })
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText}`)
+  }
+
+  const rawData = await response.json()
+  return ApiKeyInfoSchema.parse(rawData)
+}