@narumitw/pi-usage 0.60.0 → 0.60.2

package/dist/index.ts

@@ -136,7 +136,20 @@ var UsageCache = class {
 };
 function fingerprintResolvedAuth(auth, salt) {
   const headers = Object.entries(auth.headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]).sort(([left], [right]) => left.localeCompare(right));
-  const canonical = JSON.stringify({ apiKey: auth.apiKey ?? "", headers });
+  const env = Object.entries(auth.env ?? {}).sort(([left], [right]) => left.localeCompare(right));
+  const providerHeaders = Object.entries(auth.providerAuth?.headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]).sort(([left], [right]) => left.localeCompare(right));
+  const canonical = JSON.stringify({
+    apiKey: auth.apiKey ?? "",
+    headers,
+    baseUrl: auth.baseUrl ?? "",
+    env,
+    source: auth.source ?? "",
+    providerAuth: {
+      apiKey: auth.providerAuth?.apiKey ?? "",
+      headers: providerHeaders,
+      baseUrl: auth.providerAuth?.baseUrl ?? ""
+    }
+  });
   return createHmac("sha256", salt).update(canonical).digest("hex");
 }
 async function runWithConcurrency(items, limit, worker, signal) {
@@ -572,6 +585,9 @@ var INT64_MIN = -(2n ** 63n);
 var INT64_MAX = 2n ** 63n - 1n;
 var MAX_UNITS_CHARS = 20;
 var MAX_NANOS_CHARS = 11;
+var FIREWORKS_BILLING_SUMMARY_ORIGIN = "https://api.fireworks.ai";
+var FIREWORKS_SPEND_WINDOW_DAYS = 30;
+var FIREWORKS_MAX_ACCOUNT_PAGES = 5;
 var SERIES_KEYS = ["serverless", "dedicated", "training", "other"];
 var SERIES_LABELS = {
   serverless: "Serverless",
@@ -605,6 +621,67 @@ function normalizeFireworksAccountsPayload(payload) {
   }
   return accounts;
 }
+function createFireworksAdapter(fetchProviderJson2) {
+  return {
+    id: "fireworks",
+    displayName: "Fireworks",
+    semantics: { kind: "api-key", label: "Fireworks API spend" },
+    targets: {
+      singularLabel: "account",
+      pluralLabel: "accounts",
+      async list(auth, signal, timeoutMs, guard) {
+        const startedAt = Date.now();
+        const accounts = [];
+        let pageToken;
+        for (let page = 0; page < FIREWORKS_MAX_ACCOUNT_PAGES; page += 1) {
+          await guard();
+          const payload = await fetchProviderJson2(
+            fireworksAccountsUrl(pageToken),
+            auth,
+            signal,
+            remainingTimeout(timeoutMs, startedAt, "fetching Fireworks accounts"),
+            "Fireworks accounts endpoint",
+            { redirect: "error" }
+          );
+          await guard();
+          for (const accountId of normalizeFireworksAccountsPayload(payload)) {
+            if (accounts.includes(accountId)) {
+              throw new Error(`Fireworks accounts listing repeated ${accountId}.`);
+            }
+            accounts.push(accountId);
+          }
+          pageToken = fireworksNextPageToken(payload.nextPageToken);
+          if (!pageToken) break;
+        }
+        if (pageToken) {
+          throw new Error(
+            `Fireworks account listing exceeded ${FIREWORKS_MAX_ACCOUNT_PAGES} pages.`
+          );
+        }
+        return accounts.map((id) => ({ id, label: id }));
+      }
+    },
+    async query(auth, signal, timeoutMs, guard, targetId) {
+      if (!guard) throw new Error("Fireworks API spend requires request-boundary revalidation.");
+      if (!isFireworksAccountId(targetId)) {
+        throw new Error("Fireworks billing requires a safe selected account slug.");
+      }
+      const startedAt = Date.now();
+      await guard();
+      const billingWindowAt = Date.now();
+      const payload = await fetchProviderJson2(
+        fireworksBillingSummaryUrl(targetId, billingWindowAt),
+        auth,
+        signal,
+        remainingTimeout(timeoutMs, startedAt, "fetching Fireworks rated spend"),
+        "Fireworks billing summary endpoint",
+        { redirect: "error" }
+      );
+      await guard();
+      return normalizeFireworksBillingSummaryPayload(payload, targetId, Date.now());
+    }
+  };
+}
 function normalizeFireworksBillingSummaryPayload(payload, accountId, capturedAt) {
   if (!isFireworksAccountId(accountId)) {
     throw new Error("Fireworks billing summary received an unsafe account identifier.");
@@ -711,6 +788,38 @@ function formatMoneyAmount(amount2) {
   const nanos = (magnitude % NANOS_PER_UNIT).toString().padStart(9, "0").replace(/0+$/u, "");
   return `${negative ? "-" : ""}${units.toString()}${nanos ? `.${nanos}` : ""}`;
 }
+function fireworksAccountsUrl(pageToken) {
+  const url = new URL("/v1/accounts", FIREWORKS_BILLING_SUMMARY_ORIGIN);
+  url.searchParams.set("pageSize", "200");
+  if (pageToken !== void 0) url.searchParams.set("pageToken", pageToken);
+  return url.toString();
+}
+function fireworksNextPageToken(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || !value || value.length > 512) {
+    throw new Error("Fireworks accounts listing returned an invalid page token.");
+  }
+  return value;
+}
+function fireworksBillingSummaryUrl(accountId, startedAt) {
+  const dayMs = 24 * 60 * 60 * 1e3;
+  const dayFloor = (time) => `${new Date(time).toISOString().slice(0, 10)}T00:00:00Z`;
+  const url = new URL(
+    `/v1/accounts/${accountId}/billing/summary`,
+    FIREWORKS_BILLING_SUMMARY_ORIGIN
+  );
+  url.searchParams.set(
+    "startTime",
+    dayFloor(startedAt - (FIREWORKS_SPEND_WINDOW_DAYS - 1) * dayMs)
+  );
+  url.searchParams.set("endTime", dayFloor(startedAt + dayMs));
+  return url.toString();
+}
+function remainingTimeout(timeoutMs, startedAt, description) {
+  const remaining = timeoutMs - (Date.now() - startedAt);
+  if (remaining <= 0) throw new Error(`Timed out while ${description}.`);
+  return remaining;
+}
 function asObject4(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
@@ -1145,6 +1254,26 @@ function normalizeWindow(row, fields) {
   }
   const total = nonnegativeInteger(row[fields.totalField], fields.totalField);
   const count = nonnegativeInteger(row[fields.countField], fields.countField);
+  if (total === 0) {
+    if (count !== 0) {
+      throw new Error(`MiniMax Token Plan ${fields.label} counts were inconsistent.`);
+    }
+    if (percent === void 0) {
+      throw new Error(`MiniMax Token Plan ${fields.label} returned no quota and no percent.`);
+    }
+    return {
+      id: fields.id,
+      label: fields.label,
+      groupId: fields.groupId,
+      groupLabel: fields.groupLabel,
+      remaining: percent,
+      used: 100 - percent,
+      limit: 0,
+      unit: "percent",
+      windowMinutes,
+      resetsAt
+    };
+  }
   const resolved = resolveQuotaCounts(count, total, percent);
   if (!resolved) throw new Error(`MiniMax Token Plan ${fields.label} counts were inconsistent.`);
   return {
@@ -1787,14 +1916,104 @@ function clampPercent3(value) {
   return Math.min(100, Math.max(0, value));
 }
 
+// src/usage-targets.ts
+var MAX_TARGETS = 1e3;
+var MAX_TARGET_ID_CHARS = 256;
+var MAX_TARGET_LABEL_CHARS = 120;
+var MAX_TARGET_DESCRIPTION_CHARS = 180;
+async function resolveUsageTarget(adapter, auth, rememberedTargetId, signal, timeoutMs, guard) {
+  if (!adapter.targets) return { kind: "selected" };
+  if (rememberedTargetId !== void 0 && !isBoundedTargetId(rememberedTargetId)) {
+    throw new Error(`The remembered ${adapter.targets.singularLabel} identifier was invalid.`);
+  }
+  const choices = await listUsageTargets(adapter, auth, signal, timeoutMs, guard);
+  if (rememberedTargetId) {
+    return choices.some((choice) => choice.id === rememberedTargetId) ? { kind: "selected", targetId: rememberedTargetId } : { kind: "selection-required", choices };
+  }
+  if (choices.length === 1) return { kind: "selected", targetId: choices[0]?.id };
+  return { kind: "selection-required", choices };
+}
+async function listUsageTargets(adapter, auth, signal, timeoutMs, guard) {
+  if (!adapter.targets) return [];
+  const startedAt = Date.now();
+  await guard();
+  const listed = await adapter.targets.list(
+    auth,
+    signal,
+    remainingTargetTimeout(timeoutMs, startedAt),
+    guard
+  );
+  await guard();
+  remainingTargetTimeout(timeoutMs, startedAt);
+  const choices = normalizeUsageTargets(listed);
+  if (choices.length === 0) {
+    throw new Error(`${adapter.targets.pluralLabel} discovery returned no choices.`);
+  }
+  return choices;
+}
+function normalizeUsageTargets(targets) {
+  if (!Array.isArray(targets)) throw new Error("Target discovery did not return a choices array.");
+  if (targets.length > MAX_TARGETS) {
+    throw new Error(`Target discovery exceeded ${MAX_TARGETS} choices.`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return targets.map((target) => {
+    if (!target || typeof target !== "object" || Array.isArray(target)) {
+      throw new Error("Target discovery returned an invalid choice.");
+    }
+    const { id, label, description } = target;
+    if (!isBoundedTargetId(id)) throw new Error("Target discovery returned an invalid ID.");
+    if (seen.has(id)) throw new Error(`Target discovery repeated ${id}.`);
+    seen.add(id);
+    if (typeof label !== "string") {
+      throw new Error("Target discovery returned an invalid display label.");
+    }
+    if (description !== void 0 && typeof description !== "string") {
+      throw new Error("Target discovery returned an invalid description.");
+    }
+    const safeLabel2 = sanitizeDisplayText(label, MAX_TARGET_LABEL_CHARS);
+    if (!safeLabel2) throw new Error("Target discovery returned an empty display label.");
+    const safeDescription = description ? sanitizeDisplayText(description, MAX_TARGET_DESCRIPTION_CHARS) : void 0;
+    return { id, label: safeLabel2, ...safeDescription ? { description: safeDescription } : {} };
+  });
+}
+function createUsageTargetSelectOptions(targets) {
+  const normalized = normalizeUsageTargets(targets);
+  const ids = /* @__PURE__ */ new Map();
+  const options = normalized.map((target) => {
+    const base = target.description ? `${target.label} \u2014 ${target.description}` : target.label;
+    let option = base;
+    if (ids.has(option)) {
+      const safeId = sanitizeDisplayText(target.id, 80) || "target";
+      option = `${base} \xB7 ${safeId}`;
+      let duplicate = 2;
+      while (ids.has(option)) {
+        option = `${base} \xB7 ${safeId} (${duplicate})`;
+        duplicate += 1;
+      }
+    }
+    ids.set(option, target.id);
+    return option;
+  });
+  return { options, targetIdFor: (option) => ids.get(option) };
+}
+function remainingTargetTimeout(timeoutMs, startedAt) {
+  const remaining = timeoutMs - (Date.now() - startedAt);
+  if (remaining <= 0) throw new Error("Timed out while discovering provider targets.");
+  return remaining;
+}
+function isBoundedTargetId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_TARGET_ID_CHARS && ![...value].some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+  });
+}
+
 // src/query.ts
 var BASETEN_BILLING_USAGE_URL = "https://api.baseten.co/v1/billing/usage_summary";
 var BASETEN_USAGE_WINDOW_DAYS = 30;
 var CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 var DEEPSEEK_BALANCE_URL = "https://api.deepseek.com/user/balance";
-var FIREWORKS_BILLING_SUMMARY_ORIGIN = "https://api.fireworks.ai";
-var FIREWORKS_SPEND_WINDOW_DAYS = 30;
-var FIREWORKS_MAX_ACCOUNT_PAGES = 5;
 var GITHUB_COPILOT_USAGE_URL = "https://api.github.com/copilot_internal/user";
 var OPENROUTER_KEY_URL = "https://openrouter.ai/api/v1/key";
 var VERCEL_AI_GATEWAY_CREDITS_URL = "https://ai-gateway.vercel.sh/v1/credits";
@@ -1833,7 +2052,7 @@ var SUPPORTED_ADAPTERS = [
         basetenBillingUsageUrl(windowAt),
         auth,
         signal,
-        remainingTimeout(timeoutMs, startedAt, "fetching Baseten billing usage"),
+        remainingTimeout2(timeoutMs, startedAt, "fetching Baseten billing usage"),
         "Baseten billing usage endpoint",
         { redirect: "error" }
       );
@@ -1926,7 +2145,7 @@ var SUPPORTED_ADAPTERS = [
         VERCEL_AI_GATEWAY_CREDITS_URL,
         auth,
         signal,
-        remainingTimeout(timeoutMs, startedAt, "fetching Vercel AI Gateway credits"),
+        remainingTimeout2(timeoutMs, startedAt, "fetching Vercel AI Gateway credits"),
         "Vercel AI Gateway credits endpoint",
         { redirect: "error" }
       );
@@ -1934,35 +2153,7 @@ var SUPPORTED_ADAPTERS = [
       return normalizeVercelAIGatewayCreditsPayload(payload, Date.now());
     }
   },
-  {
-    id: "fireworks",
-    displayName: "Fireworks",
-    semantics: { kind: "api-key", label: "Fireworks API spend" },
-    async query(auth, signal, timeoutMs, guard, settings) {
-      if (!guard) throw new Error("Fireworks API spend requires request-boundary revalidation.");
-      const startedAt = Date.now();
-      await guard();
-      const accountId = await resolveFireworksAccountId(
-        auth,
-        signal,
-        remainingTimeout(timeoutMs, startedAt, "resolving the Fireworks account"),
-        guard,
-        settings?.fireworksAccountId
-      );
-      await guard();
-      const billingWindowAt = Date.now();
-      const payload = await fetchProviderJson(
-        fireworksBillingSummaryUrl(accountId, billingWindowAt),
-        auth,
-        signal,
-        remainingTimeout(timeoutMs, startedAt, "fetching Fireworks rated spend"),
-        "Fireworks billing summary endpoint",
-        { redirect: "error" }
-      );
-      await guard();
-      return normalizeFireworksBillingSummaryPayload(payload, accountId, Date.now());
-    }
-  },
+  createFireworksAdapter(fetchProviderJson),
   {
     id: "opencode-go",
     displayName: "OpenCode Go",
@@ -2063,7 +2254,7 @@ var XAI_ADAPTER = {
       XAI_USER_URL,
       clientAuth,
       signal,
-      remainingTimeout(timeoutMs, startedAt),
+      remainingTimeout2(timeoutMs, startedAt),
       "xAI consumer identity endpoint",
       { redirect: "error", userAgent: false }
     );
@@ -2079,7 +2270,7 @@ var XAI_ADAPTER = {
       XAI_BILLING_URL,
       billingAuth,
       signal,
-      remainingTimeout(timeoutMs, startedAt),
+      remainingTimeout2(timeoutMs, startedAt),
       "xAI consumer billing endpoint",
       { redirect: "error", userAgent: false }
     );
@@ -2107,6 +2298,12 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
   );
   if (!model) return void 0;
   const registry = ctx.modelRegistry;
+  const provider = registry.getProvider?.(adapter.id);
+  if (provider?.baseUrl && !hasOfficialUrlOrigin(provider.baseUrl, adapter.id)) {
+    throw new Error(
+      `${adapter.displayName} usage cannot send an overridden provider credential to the official usage endpoint.`
+    );
+  }
   let modelAuth;
   const currentModel = ctx.model?.provider === adapter.id ? ctx.model : void 0;
   const resolveCurrentModelAuth = async () => {
@@ -2129,25 +2326,64 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
     );
   }
   if (resolveSelectedAuthLast) modelAuth = await resolveCurrentModelAuth();
+  if (modelAuth?.baseUrl && !hasOfficialUrlOrigin(modelAuth.baseUrl, adapter.id)) {
+    throw new Error(
+      `${adapter.displayName} usage cannot send model-resolved proxy credentials to the official usage endpoint.`
+    );
+  }
   const auth = modelAuth ?? providerResult?.auth;
   if (!auth) return void 0;
+  const finalize = (resolved) => {
+    const preservedAuth = { ...providerResult?.auth ?? auth };
+    const env = providerResult?.env ?? modelAuth?.env;
+    const source = providerResult?.source;
+    const effectiveBaseUrl = modelAuth?.baseUrl ?? providerResult?.auth.baseUrl ?? provider?.baseUrl ?? model.baseUrl;
+    const redactionInputs = [
+      preservedAuth.apiKey,
+      ...Object.values(preservedAuth.headers ?? {}),
+      ...Object.values(env ?? {}),
+      modelAuth?.apiKey,
+      ...Object.values(modelAuth?.headers ?? {})
+    ].filter((value) => typeof value === "string" && value.length > 0);
+    return {
+      ...resolved,
+      auth: preservedAuth,
+      ...env ? { env: { ...env } } : {},
+      ...source ? { source } : {},
+      effectiveBaseUrl,
+      secrets: [.../* @__PURE__ */ new Set([...resolved.secrets, ...redactionInputs])],
+      fingerprint: fingerprintResolvedAuth(
+        {
+          apiKey: resolved.apiKey,
+          headers: resolved.headers,
+          baseUrl: effectiveBaseUrl,
+          env,
+          source,
+          providerAuth: preservedAuth
+        },
+        salt
+      )
+    };
+  };
   if (adapter.id === "github-copilot") {
     const offered = candidateReader ? candidateReader(ctx, adapter.id) : fallbackOAuthCredentialCandidates(adapter.id, credentialReader);
     if (!offered.ok) {
       throw new Error("GitHub Copilot OAuth credential discovery failed closed.");
     }
-    return resolveGitHubCopilotUsageAuth(
-      auth,
-      model,
-      salt,
-      offered.candidates,
-      offered.offeredCount === 0
+    return finalize(
+      resolveGitHubCopilotUsageAuth(
+        auth,
+        model,
+        salt,
+        offered.candidates,
+        offered.offeredCount === 0
+      )
     );
   }
   if (adapter.id === "xai") {
     const offered = candidateReader ? candidateReader(ctx, adapter.id) : fallbackOAuthCredentialCandidates(adapter.id, credentialReader);
     if (!offered.ok) throw new Error("xAI OAuth credential discovery failed closed.");
-    return resolveXaiUsageAuth(auth, model, salt, offered.candidates);
+    return finalize(resolveXaiUsageAuth(auth, model, salt, offered.candidates));
   }
   if (adapter.id === "deepseek") {
     const resolvedAuthorization = authorizationFrom(auth);
@@ -2155,10 +2391,10 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
     if (!access) throw new Error("DeepSeek API balance requires Bearer authentication.");
     const authorization2 = `Bearer ${access}`;
     const headers2 = { Authorization: authorization2 };
-    return {
+    return finalize({
       apiKey: access,
       headers: headers2,
-      fingerprint: fingerprintResolvedAuth({ headers: headers2 }, salt),
+      fingerprint: "",
       secrets: [
         access,
         auth.apiKey,
@@ -2167,7 +2403,7 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
         authorization2
       ].filter((value) => Boolean(value)),
       model
-    };
+    });
   }
   const authorization = authorizationFrom(auth);
   if (!authorization) return void 0;
@@ -2175,17 +2411,41 @@ async function resolveUsageAuth(ctx, adapter, salt = AUTH_FINGERPRINT_SALT, cred
   const secrets = [auth.apiKey, headerValue(auth.headers, "Authorization"), authorization].filter(
     (value) => Boolean(value)
   );
-  return {
+  return finalize({
     apiKey: auth.apiKey,
     headers,
-    fingerprint: fingerprintResolvedAuth({ headers }, salt),
+    fingerprint: "",
     secrets,
     model
-  };
+  });
 }
-async function queryProviderUsage(adapter, auth, signal, timeoutMs, guard, settings) {
+async function queryProviderUsage(adapter, auth, signal, timeoutMs, guard, targetOrSettings) {
+  const startedAt = Date.now();
+  let targetId = typeof targetOrSettings === "string" ? targetOrSettings : adapter.id === "fireworks" ? targetOrSettings?.fireworksAccountId : void 0;
+  let resolvedLegacyFireworksTarget = false;
   try {
-    return await adapter.query(auth, signal, timeoutMs, guard, settings);
+    if (adapter.id === "fireworks" && typeof targetOrSettings !== "string" && adapter.targets && guard) {
+      const target = await resolveUsageTarget(
+        adapter,
+        auth,
+        targetId,
+        signal,
+        remainingTimeout2(timeoutMs, startedAt, "resolving the Fireworks account"),
+        guard
+      );
+      if (target.kind === "selection-required") {
+        throw new Error("Fireworks account selection is required.");
+      }
+      targetId = target.targetId;
+      resolvedLegacyFireworksTarget = true;
+    }
+    return await adapter.query(
+      auth,
+      signal,
+      resolvedLegacyFireworksTarget ? remainingTimeout2(timeoutMs, startedAt, `querying ${adapter.displayName} usage`) : timeoutMs,
+      guard,
+      targetId
+    );
   } catch (error) {
     if (isStaleExtensionContextError(error) || isAbortError(error)) throw error;
     throw new Error(redactUsageError(errorMessage(error), auth.secrets));
@@ -2484,7 +2744,7 @@ function hasOfficialUrlOrigin(value, providerId) {
     }
     if (providerId === "openai-codex") return url.origin === "https://chatgpt.com";
     if (providerId === "deepseek") return url.origin === "https://api.deepseek.com";
-    if (providerId === "fireworks") return url.origin === FIREWORKS_BILLING_SUMMARY_ORIGIN;
+    if (providerId === "fireworks") return url.origin === "https://api.fireworks.ai";
     if (providerId === "openrouter") return url.origin === "https://openrouter.ai";
     if (providerId === "vercel-ai-gateway") return url.origin === "https://ai-gateway.vercel.sh";
     if (providerId === "opencode-go") return url.origin === "https://opencode.ai";
@@ -2540,7 +2800,7 @@ async function queryMiniMaxUsage(providerId, auth, signal, timeoutMs, guard) {
     `${MINIMAX_API_ROOTS[providerId]}${path}`,
     auth,
     signal,
-    remainingTimeout(timeoutMs, startedAt, "fetching MiniMax usage"),
+    remainingTimeout2(timeoutMs, startedAt, "fetching MiniMax usage"),
     "MiniMax usage endpoint",
     { redirect: "error" }
   );
@@ -2555,94 +2815,18 @@ async function queryMoonshotBalance(providerId, auth, signal, timeoutMs, guard)
     MOONSHOT_BALANCE_URLS[providerId],
     auth,
     signal,
-    remainingTimeout(timeoutMs, startedAt, "fetching Moonshot AI balance"),
+    remainingTimeout2(timeoutMs, startedAt, "fetching Moonshot AI balance"),
     "Moonshot AI balance endpoint",
     { redirect: "error" }
   );
   await guard();
   return normalizeMoonshotBalancePayload(providerId, payload, Date.now());
 }
-function remainingTimeout(timeoutMs, startedAt, description = "fetching xAI consumer usage") {
+function remainingTimeout2(timeoutMs, startedAt, description = "fetching xAI consumer usage") {
   const remaining = timeoutMs - (Date.now() - startedAt);
   if (remaining <= 0) throw new Error(`Timed out while ${description}.`);
   return remaining;
 }
-async function resolveFireworksAccountId(auth, signal, timeoutMs, guard, configuredAccountId) {
-  if (configuredAccountId !== void 0 && !isFireworksAccountId(configuredAccountId)) {
-    throw new Error("The Fireworks account setting was not a safe account slug.");
-  }
-  const startedAt = Date.now();
-  const accounts = [];
-  let pageToken;
-  for (let page = 0; page < FIREWORKS_MAX_ACCOUNT_PAGES; page += 1) {
-    await guard();
-    const payload = await fetchProviderJson(
-      fireworksAccountsUrl(pageToken),
-      auth,
-      signal,
-      remainingTimeout(timeoutMs, startedAt, "fetching Fireworks accounts"),
-      "Fireworks accounts endpoint",
-      { redirect: "error" }
-    );
-    for (const accountId of normalizeFireworksAccountsPayload(
-      payload
-    )) {
-      if (accounts.includes(accountId)) {
-        throw new Error(`Fireworks accounts listing repeated ${accountId}.`);
-      }
-      accounts.push(accountId);
-      if (configuredAccountId === accountId) return accountId;
-    }
-    pageToken = fireworksNextPageToken(payload.nextPageToken);
-    if (!pageToken) break;
-  }
-  if (pageToken) {
-    throw new Error(
-      configuredAccountId ? `The configured Fireworks account was not found within the first ${FIREWORKS_MAX_ACCOUNT_PAGES} listing pages.` : `Fireworks account listing exceeded ${FIREWORKS_MAX_ACCOUNT_PAGES} pages; set fireworksAccountId in pi-usage.json to an account returned in those pages.`
-    );
-  }
-  if (accounts.length === 0) {
-    throw new Error("Fireworks account discovery returned no accounts for this API key.");
-  }
-  if (configuredAccountId) {
-    throw new Error(
-      "The configured Fireworks account does not match an account visible to this API key."
-    );
-  }
-  if (accounts.length === 1) return accounts[0];
-  const preview = accounts.slice(0, 8).join(", ");
-  const suffix = accounts.length > 8 ? ` \u2026and ${accounts.length - 8} more` : "";
-  throw new Error(
-    `The Fireworks key can see ${accounts.length} accounts (${preview}${suffix}); set fireworksAccountId in pi-usage.json to one of them.`
-  );
-}
-function fireworksAccountsUrl(pageToken) {
-  const url = new URL("/v1/accounts", FIREWORKS_BILLING_SUMMARY_ORIGIN);
-  url.searchParams.set("pageSize", "200");
-  if (pageToken !== void 0) url.searchParams.set("pageToken", pageToken);
-  return url.toString();
-}
-function fireworksNextPageToken(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "string" || !value || value.length > 512) {
-    throw new Error("Fireworks accounts listing returned an invalid page token.");
-  }
-  return value;
-}
-function fireworksBillingSummaryUrl(accountId, startedAt) {
-  const dayMs = 24 * 60 * 60 * 1e3;
-  const dayFloor = (time) => `${new Date(time).toISOString().slice(0, 10)}T00:00:00Z`;
-  const url = new URL(
-    `/v1/accounts/${accountId}/billing/summary`,
-    FIREWORKS_BILLING_SUMMARY_ORIGIN
-  );
-  url.searchParams.set(
-    "startTime",
-    dayFloor(startedAt - (FIREWORKS_SPEND_WINDOW_DAYS - 1) * dayMs)
-  );
-  url.searchParams.set("endTime", dayFloor(startedAt + dayMs));
-  return url.toString();
-}
 function zaiOrigin(baseUrl) {
   const base = baseUrl?.trim();
   if (!base) throw new Error("Z.AI model base URL is unavailable.");
@@ -2665,7 +2849,7 @@ async function queryZaiUsage(providerId, providerName, auth, signal, timeoutMs,
     zaiMonitorUrl(auth.model.baseUrl),
     zaiMonitorAuth(auth),
     signal,
-    remainingTimeout(timeoutMs, startedAt, `fetching ${providerName} quota`),
+    remainingTimeout2(timeoutMs, startedAt, `fetching ${providerName} quota`),
     `${providerName} quota endpoint`
   );
   await guard();
@@ -3016,6 +3200,10 @@ function formatProviderStates(states) {
   return states.map((state) => {
     if (state.status === "ready") return formatUsageReport(state.report, state.displayState);
     const label = state.displayState === "current" ? "Current" : "Configured";
+    if (state.status === "selection-required") {
+      return `${state.providerName} \xB7 ${label}
+Selection required: choose this provider's ${state.singularLabel} by viewing it individually.`;
+    }
     const status = state.status === "auth-unavailable" ? "Authentication unavailable" : state.status === "unsupported" ? "Unsupported" : "Query failed";
     return `${state.providerName} \xB7 ${label}
 ${status}: ${state.message}`;
@@ -3250,7 +3438,7 @@ function formatMiniMaxReport(lines, report2) {
     if (bucket.groupId !== previousGroup) lines.push(`${bucket.groupLabel ?? "Token Plan"}:`);
     previousGroup = bucket.groupId;
     const reset = bucket.resetsAt ? ` (resets ${formatReset(bucket.resetsAt)})` : "";
-    const value = bucket.period === "unlimited" ? "unlimited" : bucket.limit && bucket.remaining !== void 0 ? `${bucket.remaining} of ${bucket.limit} left \xB7 ${percentRemaining(bucket)}%${reset}` : "unavailable";
+    const value = bucket.period === "unlimited" ? "unlimited" : bucket.unit === "percent" && bucket.remaining !== void 0 ? `${bucket.remaining}% remaining${reset}` : bucket.limit !== void 0 && bucket.remaining !== void 0 ? `${bucket.remaining} of ${bucket.limit} left \xB7 ${percentRemaining(bucket)}%${reset}` : "unavailable";
     lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${value}`);
   }
 }
@@ -3271,7 +3459,11 @@ function formatMiniMaxStatusline(report2, model) {
       parts.push(`unlimited ${window}`);
       continue;
     }
-    if (!bucket.limit || bucket.remaining === void 0) continue;
+    if (bucket.unit === "percent" && bucket.remaining !== void 0) {
+      parts.push(`${bucket.remaining}% ${window}`);
+      continue;
+    }
+    if (bucket.limit === void 0 || bucket.remaining === void 0) continue;
     parts.push(`${percentRemaining(bucket)}% ${window}`);
   }
   return parts.length > 1 ? parts.join(" ") : void 0;
@@ -3283,22 +3475,26 @@ function selectMiniMaxGroup(report2, model) {
     )
   ];
   if (groups.length <= 1) return groups[0];
-  if (model?.provider !== report2.providerId) return void 0;
-  const modelKeys = [model.id, model.name].map(normalizeMiniMaxModelKey).filter((key) => key !== void 0);
-  const candidates = groups.map((group) => {
-    const bucket = report2.buckets.find((candidate) => candidate.groupId === group);
-    const patterns = [bucket?.groupLabel, ...bucket?.modelKeys ?? [], group].map(normalizeMiniMaxModelKey).filter((key) => key !== void 0);
-    return { group, patterns };
-  });
-  const exact = candidates.find(
-    ({ patterns }) => patterns.some((pattern) => !pattern.includes("*") && modelKeys.includes(pattern))
-  );
-  if (exact) return exact.group;
-  return candidates.find(
-    ({ patterns }) => patterns.some(
-      (pattern) => pattern.includes("*") && modelKeys.some((key) => wildcardKeyMatches(pattern, key))
-    )
-  )?.group;
+  if (model && model.provider !== report2.providerId) return void 0;
+  if (model) {
+    const modelKeys = [model.id, model.name].map(normalizeMiniMaxModelKey).filter((key) => key !== void 0);
+    const candidates = groups.map((group) => {
+      const bucket = report2.buckets.find((candidate) => candidate.groupId === group);
+      const patterns = [bucket?.groupLabel, ...bucket?.modelKeys ?? [], group].map(normalizeMiniMaxModelKey).filter((key) => key !== void 0);
+      return { group, patterns };
+    });
+    const exact = candidates.find(
+      ({ patterns }) => patterns.some((pattern) => !pattern.includes("*") && modelKeys.includes(pattern))
+    );
+    if (exact) return exact.group;
+    const wildcard = candidates.find(
+      ({ patterns }) => patterns.some(
+        (pattern) => pattern.includes("*") && modelKeys.some((key) => wildcardKeyMatches(pattern, key))
+      )
+    );
+    if (wildcard) return wildcard.group;
+  }
+  return groups.find((group) => group === "general");
 }
 function normalizeMiniMaxModelKey(value) {
   const key = value?.toLowerCase().replace(/[^a-z0-9*]+/gu, "");
@@ -3552,7 +3748,8 @@ var USAGE_SETTINGS_FILE = "pi-usage.json";
 var MAX_USAGE_SETTINGS_BYTES = 64 * 1024;
 var DEFAULT_USAGE_SETTINGS = Object.freeze({
   codexFastMode: false,
-  codexStatusResetCountdown: true
+  codexStatusResetCountdown: true,
+  selectedTargets: Object.freeze({})
 });
 function usageSettingsPath() {
   return join(getAgentDir(), USAGE_SETTINGS_FILE);
@@ -3568,10 +3765,16 @@ function normalizeUsageSettings(value) {
   if (Object.hasOwn(value, "fireworksAccountId") && !isFireworksAccountId(value.fireworksAccountId)) {
     return void 0;
   }
+  const selectedTargets = normalizeSelectedTargets(value.selectedTargets);
+  if (Object.hasOwn(value, "selectedTargets") && !selectedTargets) return void 0;
+  const effectiveTargets = { ...selectedTargets ?? {} };
+  if (!effectiveTargets.fireworks && isFireworksAccountId(value.fireworksAccountId)) {
+    effectiveTargets.fireworks = value.fireworksAccountId;
+  }
   return {
     codexFastMode: typeof value.codexFastMode === "boolean" ? value.codexFastMode : DEFAULT_USAGE_SETTINGS.codexFastMode,
     codexStatusResetCountdown: typeof value.codexStatusResetCountdown === "boolean" ? value.codexStatusResetCountdown : DEFAULT_USAGE_SETTINGS.codexStatusResetCountdown,
-    ...isFireworksAccountId(value.fireworksAccountId) ? { fireworksAccountId: value.fireworksAccountId } : {}
+    selectedTargets: effectiveTargets
   };
 }
 async function loadUsageSettings(path = usageSettingsPath(), signal) {
@@ -3647,19 +3850,84 @@ function createUsageSettingsRuntime(options = {}) {
       state = saved;
       return structuredClone(state);
     }),
+    updateSelectedTarget: (providerId, targetId, signal, checkPublishedSelection) => enqueue(async () => {
+      const transaction = await saveUsageTargetSelection(
+        path,
+        providerId,
+        targetId,
+        operations,
+        signal
+      );
+      try {
+        await checkPublishedSelection?.();
+        throwIfAborted(signal);
+      } catch (error) {
+        try {
+          await restoreUsageSettingsState(
+            path,
+            transaction.saved,
+            transaction.previous,
+            operations
+          );
+          state = transaction.previous;
+        } catch (rollbackError) {
+          state = await loadUsageSettings(path);
+          throw new AggregateError(
+            [error, rollbackError],
+            "Target selection changed after publication and pi-usage.json rollback failed"
+          );
+        }
+        throw error;
+      }
+      state = transaction.saved;
+      return structuredClone(state);
+    }),
     flush: () => queue
   };
 }
 async function saveUsageSettingsPatch(path, patch, operations, signal) {
+  return saveUsageSettingsDocument(
+    path,
+    (document) => {
+      for (const [key, value] of Object.entries(patch)) {
+        if (value === void 0) delete document[key];
+        else document[key] = value;
+      }
+    },
+    operations,
+    signal
+  );
+}
+async function saveUsageTargetSelection(path, providerId, targetId, operations, signal) {
+  if (!isProviderId(providerId) || !isBoundedTargetId(targetId)) {
+    throw new Error("Refusing to save an invalid usage target selection");
+  }
+  const previous = await loadUsageSettings(path, signal);
+  const saved = await saveUsageSettingsDocument(
+    path,
+    (document) => {
+      document.selectedTargets = {
+        ...normalizeSelectedTargets(document.selectedTargets) ?? {},
+        [providerId]: targetId
+      };
+      if (providerId === "fireworks") delete document.fireworksAccountId;
+    },
+    operations,
+    signal,
+    previous
+  );
+  return { saved, previous };
+}
+async function saveUsageSettingsDocument(path, mutate, operations, signal, expected) {
   const latest = await loadUsageSettings(path, signal);
   if (latest.kind === "invalid") {
     throw new Error("Cannot overwrite an invalid pi-usage.json; repair it and reload first");
   }
-  const document = { ...latest.document };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === void 0) delete document[key];
-    else document[key] = value;
+  if (expected && !sameUsageSettingsDocument(latest, expected)) {
+    throw new Error("pi-usage.json changed while saving; retry the action");
   }
+  const document = { ...latest.document };
+  mutate(document);
   const settings = normalizeUsageSettings(document);
   if (!settings) throw new Error("Refusing to save invalid pi-usage settings");
   const directory = dirname(path);
@@ -3686,6 +3954,32 @@ async function saveUsageSettingsPatch(path, patch, operations, signal) {
   }
   return { kind: "loaded", path, settings, document };
 }
+async function restoreUsageSettingsState(path, published, previous, operations) {
+  if (previous.kind === "missing") {
+    const current = await loadUsageSettings(path);
+    if (!sameUsageSettingsDocument(current, published)) {
+      throw new Error("pi-usage.json changed before target selection rollback");
+    }
+    await rm(path);
+    return;
+  }
+  if (previous.kind !== "loaded" || !previous.document) {
+    throw new Error("Cannot restore invalid prior pi-usage.json settings");
+  }
+  await saveUsageSettingsDocument(
+    path,
+    (document) => {
+      for (const key of Object.keys(document)) delete document[key];
+      Object.assign(document, previous.document);
+    },
+    operations,
+    void 0,
+    published
+  );
+}
+function sameUsageSettingsDocument(left, right) {
+  return left.kind === right.kind && JSON.stringify(left.document) === JSON.stringify(right.document);
+}
 async function chmodPrivate(path) {
   await chmod(path, 384);
 }
@@ -3698,6 +3992,19 @@ function isRecord3(value) {
 function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
+function normalizeSelectedTargets(value) {
+  if (value === void 0) return {};
+  if (!isRecord3(value)) return void 0;
+  const targets = {};
+  for (const [providerId, targetId] of Object.entries(value)) {
+    if (!isProviderId(providerId) || !isBoundedTargetId(targetId)) return void 0;
+    targets[providerId] = targetId;
+  }
+  return targets;
+}
+function isProviderId(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._~-]{0,127}$/u.test(value);
+}
 
 // src/usage.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -3908,8 +4215,6 @@ import {
   SettingsList,
   Text
 } from "@earendil-works/pi-tui";
-var AUTO = "Auto";
-var EDIT = "Edit\u2026";
 var OFF = "Off";
 var ON = "On";
 async function showUsageSettings(ctx, settingsRuntime, parentSignal, isCurrent, onApplied) {
@@ -3917,31 +4222,13 @@ async function showUsageSettings(ctx, settingsRuntime, parentSignal, isCurrent,
     if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${settingsRuntime.get().path}`, "info");
     return false;
   }
-  let changed = false;
-  while (!parentSignal.aborted && isCurrent()) {
-    const result = await showSettingsList(ctx, settingsRuntime, parentSignal, isCurrent, onApplied);
-    if (!result) return changed;
-    changed ||= result.changed;
-    if (!result.editFireworksAccount) return changed;
-    changed ||= await editFireworksAccount(
-      ctx,
-      settingsRuntime,
-      parentSignal,
-      isCurrent,
-      onApplied
-    );
-  }
-  return changed;
-}
-async function showSettingsList(ctx, settingsRuntime, parentSignal, isCurrent, onApplied) {
-  return ctx.ui.custom((tui, theme, _keybindings, done) => {
+  return await ctx.ui.custom((tui, theme, _keybindings, done) => {
     const localController = new AbortController();
     const signal = AbortSignal.any([parentSignal, localController.signal]);
     let changed = false;
     let closing = false;
     let saveQueue = Promise.resolve();
     const state = settingsRuntime.get();
-    const fireworksValue = state.settings.fireworksAccountId ?? AUTO;
     const items = [
       {
         id: "codexFastMode",
@@ -3956,13 +4243,6 @@ async function showSettingsList(ctx, settingsRuntime, parentSignal, isCurrent, o
         description: "Show time remaining until each Codex usage limit resets.",
         currentValue: state.settings.codexStatusResetCountdown ? ON : OFF,
         values: [OFF, ON]
-      },
-      {
-        id: "fireworksAccountId",
-        label: "Fireworks account",
-        description: "Select Edit to enter a visible account slug, or submit blank to clear it.",
-        currentValue: fireworksValue,
-        values: state.settings.fireworksAccountId ? [state.settings.fireworksAccountId, EDIT] : [AUTO, EDIT]
       }
     ];
     const container = new Container();
@@ -3972,13 +4252,13 @@ async function showSettingsList(ctx, settingsRuntime, parentSignal, isCurrent, o
       if (closing) return;
       closing = true;
       localController.abort();
-      done({ changed, editFireworksAccount: false });
+      done(changed);
     };
     const queueUpdate = (id, requested, display) => {
       saveQueue = saveQueue.then(async () => {
         const previous = settingsRuntime.get().settings[id];
         if (settingsRuntime.get().kind === "invalid") {
-          settingsList.updateValue(id, displaySetting(id, previous));
+          settingsList.updateValue(id, previous ? ON : OFF);
           if (!signal.aborted && isCurrent()) {
             ctx.ui.notify("Repair pi-usage.json and reload before changing settings.", "error");
             tui.requestRender();
@@ -3989,7 +4269,7 @@ async function showSettingsList(ctx, settingsRuntime, parentSignal, isCurrent, o
           await settingsRuntime.update({ [id]: requested }, signal);
         } catch (error) {
           if (signal.aborted || !isCurrent()) return;
-          settingsList.updateValue(id, displaySetting(id, previous));
+          settingsList.updateValue(id, previous ? ON : OFF);
           ctx.ui.notify(`Could not save pi-usage.json: ${errorMessage(error)}`, "error");
           tui.requestRender();
           return;
@@ -4009,18 +4289,7 @@ async function showSettingsList(ctx, settingsRuntime, parentSignal, isCurrent, o
       getSettingsListTheme(),
       (id, value) => {
         if (closing || signal.aborted || !isCurrent()) return;
-        if (id === "fireworksAccountId") {
-          if (value === EDIT) {
-            saveQueue = saveQueue.then(() => {
-              if (closing || signal.aborted || !isCurrent()) return;
-              closing = true;
-              done({ changed, editFireworksAccount: true });
-            });
-          }
-          return;
-        }
-        const settingId = id;
-        queueUpdate(settingId, value !== OFF, value);
+        queueUpdate(id, value !== OFF, value);
       },
       cancel
     );
@@ -4040,43 +4309,7 @@ async function showSettingsList(ctx, settingsRuntime, parentSignal, isCurrent, o
         parentSignal.removeEventListener("abort", cancel);
       }
     };
-  });
-}
-async function editFireworksAccount(ctx, settingsRuntime, signal, isCurrent, onApplied) {
-  while (!signal.aborted && isCurrent()) {
-    const state = settingsRuntime.get();
-    if (state.kind === "invalid") {
-      ctx.ui.notify("Repair pi-usage.json and reload before changing settings.", "error");
-      return false;
-    }
-    const entered = await ctx.ui.input(
-      "Fireworks account slug \xB7 submit blank for Auto",
-      state.settings.fireworksAccountId ?? "Example: acme",
-      { signal }
-    );
-    if (signal.aborted || !isCurrent() || entered === void 0) return false;
-    const normalized = entered.trim();
-    const requested = normalized || void 0;
-    if (requested !== void 0 && !isFireworksAccountId(requested)) {
-      ctx.ui.notify("Enter a URL-safe Fireworks account slug.", "warning");
-      continue;
-    }
-    if (requested === state.settings.fireworksAccountId) return false;
-    try {
-      await settingsRuntime.update({ fireworksAccountId: requested }, signal);
-    } catch (error) {
-      if (signal.aborted || !isCurrent()) return false;
-      ctx.ui.notify(`Could not save pi-usage.json: ${errorMessage(error)}`, "error");
-      return false;
-    }
-    onApplied("fireworksAccountId");
-    return true;
-  }
-  return false;
-}
-function displaySetting(id, value) {
-  if (id === "fireworksAccountId") return typeof value === "string" ? value : AUTO;
-  return value ? ON : OFF;
+  }) ?? false;
 }
 
 // src/usage.ts
@@ -4093,6 +4326,9 @@ var VIEW_ALL = "View all configured providers\u2026";
 var CLOSE = "Close";
 var SETTINGS = "Settings";
 var REDEEM_CODEX_RESET = "Redeem usage limit reset\u2026";
+var UsageTargetSelectionChangedError = class extends Error {
+  name = "UsageTargetSelectionChangedError";
+};
 function usageExtension(pi, dependencies = {}) {
   const credentialReader = dependencies.credentialReader;
   const credentialCandidates = createOAuthCredentialCandidateReader(pi, credentialReader);
@@ -4162,10 +4398,8 @@ function usageExtension(pi, dependencies = {}) {
       return;
     }
     if (outcome.state.status !== "ready") {
-      if (safeSetStatus(
-        ctx,
-        outcome.state.status === "auth-unavailable" ? "auth unavailable" : "usage error"
-      )) {
+      const chip = outcome.state.status === "auth-unavailable" ? "auth unavailable" : outcome.state.status === "selection-required" ? "selection required" : `usage err: ${outcome.state.message.slice(0, 50)}`;
+      if (safeSetStatus(ctx, chip)) {
         if (shouldSchedule && sessionActive) scheduleStatusRefresh(ctx, model);
       }
       return;
@@ -4217,8 +4451,8 @@ function usageExtension(pi, dependencies = {}) {
     const expectedSessionGeneration = sessionGeneration;
     const expectedSessionId = ctx.sessionManager.getSessionId();
     const expectedModelIdentity = modelIdentity(ctx.model);
-    const expectedFireworksAccountId = adapter.id === "fireworks" ? settingsRuntime.get().settings.fireworksAccountId : void 0;
-    const querySettings = adapter.id === "fireworks" ? { fireworksAccountId: expectedFireworksAccountId } : void 0;
+    const expectedTargetId = adapter.targets ? settingsRuntime.get().settings.selectedTargets[adapter.id] : void 0;
+    const providerName = providerDisplayName(ctx, adapter.id);
     let auth;
     try {
       auth = await awaitWithDeadline(
@@ -4235,17 +4469,16 @@ function usageExtension(pi, dependencies = {}) {
       return {
         state: {
           providerId: adapter.id,
-          providerName: adapter.displayName,
+          providerName,
           displayState,
           status: isTimeoutError(error) ? "query-failed" : "auth-unavailable",
           message: errorMessage(error)
         }
       };
     }
-    const requiresRequestBoundaryGuard = [
+    const requiresRequestBoundaryGuard = adapter.targets !== void 0 || [
       "baseten",
       "deepseek",
-      "fireworks",
       "minimax",
       "minimax-cn",
       "moonshotai",
@@ -4255,7 +4488,7 @@ function usageExtension(pi, dependencies = {}) {
       "zai",
       "zai-coding-cn"
     ].includes(adapter.id);
-    const requestContextChanged = () => expectedSessionGeneration !== sessionGeneration || ctx.sessionManager.getSessionId() !== expectedSessionId || modelIdentity(ctx.model) !== expectedModelIdentity || adapter.id === "fireworks" && settingsRuntime.get().settings.fireworksAccountId !== expectedFireworksAccountId;
+    const requestContextChanged = () => expectedSessionGeneration !== sessionGeneration || ctx.sessionManager.getSessionId() !== expectedSessionId || modelIdentity(ctx.model) !== expectedModelIdentity || adapter.targets !== void 0 && settingsRuntime.get().settings.selectedTargets[adapter.id] !== expectedTargetId;
     if (requiresRequestBoundaryGuard && requestContextChanged()) throw abortError();
     if (!auth) {
       if (displayState === "current") {
@@ -4264,98 +4497,145 @@ function usageExtension(pi, dependencies = {}) {
       return {
         state: {
           providerId: adapter.id,
-          providerName: adapter.displayName,
+          providerName,
           displayState,
           status: "auth-unavailable",
-          message: `No runtime credential is configured for ${adapter.displayName}.`
+          message: `No runtime credential is configured for ${providerName}.`
         },
         authState: "unavailable"
       };
     }
-    const queryFingerprint = adapter.id === "fireworks" ? `${auth.fingerprint}:account:${expectedFireworksAccountId ?? "auto"}` : auth.fingerprint;
-    if (displayState === "current") {
-      transitionCurrentIdentity(`${adapter.id}:${queryFingerprint}`, adapter.id);
-    }
-    const cached = !force ? cache.get(adapter.id, queryFingerprint) : void 0;
-    if (cached) {
-      return {
-        state: {
-          providerId: adapter.id,
-          providerName: adapter.displayName,
-          displayState,
-          status: "ready",
-          report: cached
-        },
-        fingerprint: auth.fingerprint
-      };
-    }
-    const failureKey = `${adapter.id}:${queryFingerprint}`;
-    const previousFailure = failureBackoff.get(failureKey);
-    if (!force && previousFailure && previousFailure.until > Date.now()) {
-      return {
-        state: {
-          providerId: adapter.id,
-          providerName: adapter.displayName,
-          displayState,
-          status: "query-failed",
-          message: previousFailure.message
-        },
-        fingerprint: auth.fingerprint
-      };
-    }
-    failureBackoff.delete(failureKey);
-    querySequence += 1;
-    const queryId = querySequence;
-    setBoundedMap(latestQueries, failureKey, queryId, MAX_ACCOUNT_STATES);
     let retryableAuthChanged = false;
+    const guard = async () => {
+      if (signal.aborted || requestContextChanged()) throw abortError();
+      if (!requiresRequestBoundaryGuard) return;
+      const revalidated = await awaitWithDeadline(
+        resolveUsageAuth(ctx, adapter, void 0, credentialReader, credentialCandidates),
+        signal,
+        Math.max(1, deadlineAt - Date.now()),
+        `revalidating ${providerName} runtime auth`
+      );
+      if (signal.aborted || requestContextChanged()) throw abortError();
+      if (revalidated?.fingerprint !== auth.fingerprint) {
+        if (["deepseek", "minimax", "minimax-cn"].includes(adapter.id)) {
+          retryableAuthChanged = true;
+          throw new Error(`${providerName} runtime credential changed during the usage query.`);
+        }
+        throw abortError();
+      }
+    };
+    let queryFingerprint = adapter.targets ? `${auth.fingerprint}:target:${expectedTargetId ?? "unresolved"}` : auth.fingerprint;
+    let failureKey = `${adapter.id}:${queryFingerprint}`;
+    let queryId;
     try {
-      const remainingMs = Math.max(1, deadlineAt - Date.now());
-      const guard = requiresRequestBoundaryGuard ? async () => {
-        if (signal.aborted || requestContextChanged()) throw abortError();
-        const revalidated = await awaitWithDeadline(
-          resolveUsageAuth(ctx, adapter, void 0, credentialReader, credentialCandidates),
-          signal,
-          Math.max(1, deadlineAt - Date.now()),
-          `revalidating ${adapter.displayName} runtime auth`
-        );
-        if (signal.aborted || requestContextChanged()) throw abortError();
-        if (revalidated?.fingerprint !== auth.fingerprint) {
-          if (["deepseek", "minimax", "minimax-cn"].includes(adapter.id)) {
-            retryableAuthChanged = true;
-            throw new Error(
-              `${adapter.displayName} runtime credential changed during the usage query.`
-            );
-          }
-          throw abortError();
+      const previousDiscoveryFailure = failureBackoff.get(failureKey);
+      if (!force && previousDiscoveryFailure && previousDiscoveryFailure.until > Date.now()) {
+        return {
+          state: {
+            providerId: adapter.id,
+            providerName,
+            displayState,
+            status: "query-failed",
+            message: previousDiscoveryFailure.message
+          },
+          fingerprint: auth.fingerprint,
+          rememberedTargetId: expectedTargetId
+        };
+      }
+      const target = await resolveUsageTarget(
+        adapter,
+        auth,
+        expectedTargetId,
+        signal,
+        Math.max(1, deadlineAt - Date.now()),
+        guard
+      );
+      if (target.kind === "selection-required") {
+        if (displayState === "current") {
+          transitionCurrentIdentity(`${adapter.id}:${queryFingerprint}`, adapter.id);
         }
-      } : void 0;
+        return {
+          state: {
+            providerId: adapter.id,
+            providerName,
+            displayState,
+            status: "selection-required",
+            singularLabel: adapter.targets?.singularLabel ?? "target",
+            pluralLabel: adapter.targets?.pluralLabel ?? "targets",
+            choices: target.choices
+          },
+          fingerprint: auth.fingerprint,
+          rememberedTargetId: expectedTargetId
+        };
+      }
+      queryFingerprint = adapter.targets ? `${auth.fingerprint}:target:${target.targetId ?? "none"}` : auth.fingerprint;
+      failureKey = `${adapter.id}:${queryFingerprint}`;
+      if (displayState === "current") {
+        transitionCurrentIdentity(`${adapter.id}:${queryFingerprint}`, adapter.id);
+      }
+      const cached = !force ? cache.get(adapter.id, queryFingerprint) : void 0;
+      if (cached) {
+        return {
+          state: {
+            providerId: adapter.id,
+            providerName,
+            displayState,
+            status: "ready",
+            report: cached
+          },
+          fingerprint: auth.fingerprint,
+          rememberedTargetId: expectedTargetId
+        };
+      }
+      const previousFailure = failureBackoff.get(failureKey);
+      if (!force && previousFailure && previousFailure.until > Date.now()) {
+        return {
+          state: {
+            providerId: adapter.id,
+            providerName,
+            displayState,
+            status: "query-failed",
+            message: previousFailure.message
+          },
+          fingerprint: auth.fingerprint,
+          rememberedTargetId: expectedTargetId
+        };
+      }
+      failureBackoff.delete(failureKey);
+      querySequence += 1;
+      queryId = querySequence;
+      setBoundedMap(latestQueries, failureKey, queryId, MAX_ACCOUNT_STATES);
       const report2 = await queryProviderUsage(
         adapter,
         auth,
         signal,
-        remainingMs,
-        guard,
-        querySettings
+        Math.max(1, deadlineAt - Date.now()),
+        requiresRequestBoundaryGuard ? guard : void 0,
+        target.targetId
       );
-      if (guard) await guard();
+      if (requiresRequestBoundaryGuard) await guard();
+      const effectiveReport = { ...report2, providerName };
       if (latestQueries.get(failureKey) === queryId) {
-        cache.set(adapter.id, queryFingerprint, report2);
+        cache.set(adapter.id, queryFingerprint, effectiveReport);
         failureBackoff.delete(failureKey);
       }
       return {
         state: {
           providerId: adapter.id,
-          providerName: adapter.displayName,
+          providerName,
           displayState,
           status: "ready",
-          report: report2
+          report: effectiveReport
         },
-        fingerprint: auth.fingerprint
+        fingerprint: auth.fingerprint,
+        rememberedTargetId: expectedTargetId
       };
     } catch (error) {
       if (isStaleExtensionContextError(error) || isAbortError3(error)) throw error;
       if (retryableAuthChanged && authRetry === 0 && !signal.aborted && !requestContextChanged() && Date.now() < deadlineAt) {
-        if (latestQueries.get(failureKey) === queryId) latestQueries.delete(failureKey);
+        if (queryId !== void 0 && latestQueries.get(failureKey) === queryId) {
+          latestQueries.delete(failureKey);
+        }
         return queryAdapterState(
           ctx,
           adapter,
@@ -4371,7 +4651,7 @@ function usageExtension(pi, dependencies = {}) {
       for (const [key, failure] of failureBackoff) {
         if (failure.until <= now) failureBackoff.delete(key);
       }
-      if (latestQueries.get(failureKey) === queryId) {
+      if (queryId === void 0 || latestQueries.get(failureKey) === queryId) {
         setBoundedMap(
           failureBackoff,
           failureKey,
@@ -4382,15 +4662,52 @@ function usageExtension(pi, dependencies = {}) {
       return {
         state: {
           providerId: adapter.id,
-          providerName: adapter.displayName,
+          providerName,
           displayState,
           status: "query-failed",
           message
         },
-        fingerprint: auth.fingerprint
+        fingerprint: auth.fingerprint,
+        rememberedTargetId: expectedTargetId
       };
     }
   };
+  const loadTargetChoices = async (ctx, adapter, signal) => {
+    if (!adapter.targets) throw new Error("Provider does not support usage targets.");
+    const expectedSessionGeneration = sessionGeneration;
+    const expectedSessionId = ctx.sessionManager.getSessionId();
+    const expectedModel = modelIdentity(ctx.model);
+    const expectedTargetId = settingsRuntime.get().settings.selectedTargets[adapter.id];
+    const deadlineAt = Date.now() + DEFAULT_TIMEOUT_MS;
+    const changed = () => expectedSessionGeneration !== sessionGeneration || ctx.sessionManager.getSessionId() !== expectedSessionId || modelIdentity(ctx.model) !== expectedModel || settingsRuntime.get().settings.selectedTargets[adapter.id] !== expectedTargetId;
+    const auth = await awaitWithDeadline(
+      resolveUsageAuth(ctx, adapter, void 0, credentialReader, credentialCandidates),
+      signal,
+      Math.max(1, deadlineAt - Date.now()),
+      `resolving ${providerDisplayName(ctx, adapter.id)} runtime auth`
+    );
+    if (!auth || signal.aborted || changed()) throw abortError();
+    const guard = async () => {
+      if (signal.aborted || changed()) throw abortError();
+      const revalidated = await awaitWithDeadline(
+        resolveUsageAuth(ctx, adapter, void 0, credentialReader, credentialCandidates),
+        signal,
+        Math.max(1, deadlineAt - Date.now()),
+        `revalidating ${providerDisplayName(ctx, adapter.id)} runtime auth`
+      );
+      if (signal.aborted || changed() || revalidated?.fingerprint !== auth.fingerprint) {
+        throw abortError();
+      }
+    };
+    const choices = await listUsageTargets(
+      adapter,
+      auth,
+      signal,
+      Math.max(1, deadlineAt - Date.now()),
+      guard
+    );
+    return { choices, fingerprint: auth.fingerprint };
+  };
   const queryCurrentState = async (ctx, model, force, signal) => {
     const adapter = adapterForProvider(model?.provider);
     if (!adapter) {
@@ -4446,7 +4763,9 @@ function usageExtension(pi, dependencies = {}) {
   const startStatusRefresh = (ctx, model, force) => {
     void refreshCurrentStatus(ctx, model, force).catch((error) => {
       if (isStaleExtensionContextError(error) || isAbortError3(error)) return;
-      safeSetStatus(ctx, "usage error");
+      const message = errorMessage(error);
+      console.error("[pi-usage] refresh failed:", message);
+      safeSetStatus(ctx, `usage err: ${message.slice(0, 50)}`);
     });
   };
   const runMenuOperation = async (ctx, label, parentSignal, operation, cancellable = true) => {
@@ -4474,6 +4793,8 @@ function usageExtension(pi, dependencies = {}) {
       return false;
     }
     const adapter = adapterForProvider(model?.provider);
+    const selectionStillCurrent = !adapter?.targets || settingsRuntime.get().settings.selectedTargets[adapter.id] === outcome.rememberedTargetId;
+    if (!selectionStillCurrent) return false;
     if (outcome.authState === "unavailable") {
       if (!adapter) return false;
       try {
@@ -4483,7 +4804,7 @@ function usageExtension(pi, dependencies = {}) {
           DEFAULT_TIMEOUT_MS,
           `revalidating ${adapter.displayName} runtime auth`
         );
-        return generation === statusGeneration && modelIdentity(ctx.model) === modelIdentity(model) && auth === void 0;
+        return generation === statusGeneration && modelIdentity(ctx.model) === modelIdentity(model) && (!adapter.targets || settingsRuntime.get().settings.selectedTargets[adapter.id] === outcome.rememberedTargetId) && auth === void 0;
       } catch (error) {
         if (isAbortError3(error) || isStaleExtensionContextError(error)) throw error;
         return false;
@@ -4498,7 +4819,7 @@ function usageExtension(pi, dependencies = {}) {
         DEFAULT_TIMEOUT_MS,
         `revalidating ${adapter.displayName} runtime auth`
       );
-      return generation === statusGeneration && modelIdentity(ctx.model) === modelIdentity(model) && auth?.fingerprint === outcome.fingerprint;
+      return generation === statusGeneration && modelIdentity(ctx.model) === modelIdentity(model) && (!adapter.targets || settingsRuntime.get().settings.selectedTargets[adapter.id] === outcome.rememberedTargetId) && auth?.fingerprint === outcome.fingerprint;
     } catch (error) {
       if (isAbortError3(error) || isStaleExtensionContextError(error)) throw error;
       return false;
@@ -4554,6 +4875,88 @@ function usageExtension(pi, dependencies = {}) {
       let redemptionId;
       let resetOutcome;
       let resetFailure;
+      const actionableTargetState = () => {
+        if (visibleStates.length !== 1) return void 0;
+        const state = visibleStates[0];
+        return state && (state.status === "ready" || state.status === "selection-required") && adapterForProvider(state.providerId)?.targets ? state : void 0;
+      };
+      const promptForTarget = async (state, stateFingerprint) => {
+        const adapter = adapterForProvider(state.providerId);
+        if (!adapter?.targets) return false;
+        const expectedRememberedTargetId = settingsRuntime.get().settings.selectedTargets[adapter.id];
+        const snapshot = state.status === "selection-required" && stateFingerprint ? { choices: state.choices, fingerprint: stateFingerprint } : await runMenuOperation(
+          ctx,
+          `Loading ${adapter.targets.pluralLabel}\u2026`,
+          controller.signal,
+          (signal) => loadTargetChoices(ctx, adapter, signal)
+        );
+        if (!snapshot || controller.signal.aborted || statusGeneration !== menuGeneration) {
+          return false;
+        }
+        const selectOptions = createUsageTargetSelectOptions(snapshot.choices);
+        const selected = await ctx.ui.select(
+          `Select ${adapter.targets.singularLabel} for ${providerDisplayName(ctx, adapter.id)}`,
+          [...selectOptions.options],
+          { signal: controller.signal }
+        );
+        if (selected === void 0 || controller.signal.aborted || statusGeneration !== menuGeneration || settingsRuntime.get().settings.selectedTargets[adapter.id] !== expectedRememberedTargetId) {
+          return false;
+        }
+        const targetId = selectOptions.targetIdFor(selected);
+        if (!targetId) return false;
+        const revalidated = await runMenuOperation(
+          ctx,
+          `Revalidating ${adapter.targets.singularLabel}\u2026`,
+          controller.signal,
+          (signal) => loadTargetChoices(ctx, adapter, signal)
+        );
+        if (!revalidated || controller.signal.aborted || statusGeneration !== menuGeneration || settingsRuntime.get().settings.selectedTargets[adapter.id] !== expectedRememberedTargetId) {
+          return false;
+        }
+        if (revalidated.fingerprint !== snapshot.fingerprint || !revalidated.choices.some((choice) => choice.id === targetId)) {
+          ctx.ui.notify(
+            `${providerDisplayName(ctx, adapter.id)} ${adapter.targets.pluralLabel} changed; choose again.`,
+            "warning"
+          );
+          return false;
+        }
+        let saved;
+        try {
+          saved = await runMenuOperation(
+            ctx,
+            `Saving ${adapter.targets.singularLabel}\u2026`,
+            controller.signal,
+            (signal) => settingsRuntime.updateSelectedTarget(adapter.id, targetId, signal, async () => {
+              let published;
+              try {
+                published = await loadTargetChoices(ctx, adapter, signal);
+              } catch (error) {
+                if (signal.aborted || controller.signal.aborted || statusGeneration !== menuGeneration || isStaleExtensionContextError(error)) {
+                  throw error;
+                }
+                throw new UsageTargetSelectionChangedError();
+              }
+              if (published.fingerprint !== snapshot.fingerprint || !published.choices.some((choice) => choice.id === targetId)) {
+                throw new UsageTargetSelectionChangedError();
+              }
+            })
+          );
+        } catch (error) {
+          if (error instanceof UsageTargetSelectionChangedError) {
+            ctx.ui.notify(
+              `${providerDisplayName(ctx, adapter.id)} ${adapter.targets.pluralLabel} changed; choose again.`,
+              "warning"
+            );
+            return false;
+          }
+          throw error;
+        }
+        if (!saved || controller.signal.aborted || statusGeneration !== menuGeneration) {
+          return false;
+        }
+        invalidateProviderState(adapter.id);
+        return true;
+      };
       const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
       if (controller.signal.aborted || statusGeneration !== menuGeneration) return;
       const menu = defineMenu({
@@ -4561,6 +4964,8 @@ function usageExtension(pi, dependencies = {}) {
         screens: {
           main: () => {
             const fastAvailability = fastRuntime.availability(ctx.model);
+            const targetState = actionableTargetState();
+            const targetAdapter = adapterForProvider(targetState?.providerId);
             const fastLines = fastAvailability.kind === "available" ? [`Fast mode: ${fastAvailability.enabled ? "On" : "Off"}`, FAST_USAGE_WARNING] : fastAvailability.kind === "unavailable" ? [`Fast mode: Unavailable \xB7 ${fastAvailability.reason}`] : [];
             return {
               kind: "actions",
@@ -4569,6 +4974,13 @@ function usageExtension(pi, dependencies = {}) {
               items: [
                 { id: "refresh", label: REFRESH_CURRENT, action: "refresh" },
                 { id: "settings", label: SETTINGS, action: "settings" },
+                ...targetState && targetAdapter?.targets ? [
+                  {
+                    id: "target",
+                    label: `${targetState.status === "selection-required" ? "Select" : "Change"} ${targetAdapter.targets.singularLabel}\u2026`,
+                    action: "target"
+                  }
+                ] : [],
                 ...fastAvailability.kind === "available" ? [
                   {
                     id: "toggle-fast",
@@ -4599,7 +5011,7 @@ function usageExtension(pi, dependencies = {}) {
             title: "Select a configured provider",
             items: configuredAdapters(ctx).filter((adapter) => adapter.id !== ctx.model?.provider).map((adapter) => ({
               id: adapter.id,
-              label: adapter.displayName,
+              label: providerDisplayName(ctx, adapter.id),
               action: "provider"
             })),
             hint: "back"
@@ -4661,6 +5073,58 @@ function usageExtension(pi, dependencies = {}) {
           })
         },
         actions: {
+          target: async () => {
+            const targetState = actionableTargetState();
+            if (!targetState) return { kind: "rejected" };
+            try {
+              const stateFingerprint = targetState === current.state ? current.fingerprint : void 0;
+              if (!await promptForTarget(targetState, stateFingerprint)) {
+                return { kind: "stay" };
+              }
+              const adapter = adapterForProvider(targetState.providerId);
+              if (!adapter) return { kind: "rejected" };
+              if (targetState.providerId === ctx.model?.provider) {
+                const refreshed = await queryStableCurrent(
+                  ctx,
+                  true,
+                  controller,
+                  `Checking ${providerDisplayName(ctx, adapter.id)} usage\u2026`
+                );
+                if (!refreshed) return { kind: "stay" };
+                stableCurrent = refreshed;
+                current = refreshed.outcome;
+                visibleStates = [current.state];
+                publishStableCurrent(ctx, refreshed);
+                return { kind: "stay" };
+              }
+              const outcome = await runMenuOperation(
+                ctx,
+                `Checking ${providerDisplayName(ctx, adapter.id)} usage\u2026`,
+                controller.signal,
+                (signal) => queryAdapterState(ctx, adapter, "configured", true, signal)
+              );
+              if (!outcome) return { kind: "stay" };
+              const revalidated = await queryStableCurrent(
+                ctx,
+                false,
+                controller,
+                "Revalidating current usage\u2026"
+              );
+              if (!revalidated) return { kind: "stay" };
+              stableCurrent = revalidated;
+              current = revalidated.outcome;
+              visibleStates = [
+                outcome.state.providerId === current.state.providerId ? current.state : { ...outcome.state, displayState: "configured" }
+              ];
+              return { kind: "stay" };
+            } catch (error) {
+              if (isAbortError3(error) || isStaleExtensionContextError(error)) {
+                return { kind: "stay" };
+              }
+              ctx.ui.notify(`Could not select target: ${errorMessage(error)}`, "error");
+              return { kind: "stay" };
+            }
+          },
           settings: async () => {
             await showUsageSettings(
               ctx,
@@ -4869,13 +5333,25 @@ function usageExtension(pi, dependencies = {}) {
               (candidate) => candidate.id === itemId && candidate.id !== ctx.model?.provider
             );
             if (!adapter) return { kind: "back" };
-            const outcome = await runMenuOperation(
+            let outcome = await runMenuOperation(
               ctx,
-              `Checking ${adapter.displayName} usage\u2026`,
+              `Checking ${providerDisplayName(ctx, adapter.id)} usage\u2026`,
               controller.signal,
               (signal) => queryAdapterState(ctx, adapter, "configured", false, signal)
             );
             if (!outcome) return { kind: "back" };
+            if (outcome.state.status === "selection-required") {
+              if (!await promptForTarget(outcome.state, outcome.fingerprint)) {
+                return { kind: "back" };
+              }
+              outcome = await runMenuOperation(
+                ctx,
+                `Checking ${providerDisplayName(ctx, adapter.id)} usage\u2026`,
+                controller.signal,
+                (signal) => queryAdapterState(ctx, adapter, "configured", true, signal)
+              );
+              if (!outcome) return { kind: "back" };
+            }
             const revalidated = await queryStableCurrent(
               ctx,
               false,
@@ -4918,7 +5394,7 @@ function usageExtension(pi, dependencies = {}) {
               const adapter = adapters[index];
               return {
                 providerId: adapter.id,
-                providerName: adapter.displayName,
+                providerName: providerDisplayName(ctx, adapter.id),
                 displayState: "configured",
                 status: "query-failed",
                 message: errorMessage(result.reason)
@@ -5032,15 +5508,19 @@ export {
   codexFastStatusLabel,
   consumeCodexResetCredit,
   correctCodexFastMessageCost,
+  createFireworksAdapter,
   createUsageSettingsRuntime,
+  createUsageTargetSelectOptions,
   usageExtension as default,
   errorMessage,
   fingerprintResolvedAuth,
   formatProviderStates,
   formatUsageReport,
   formatUsageStatusline,
+  isBoundedTargetId,
   isStaleExtensionContextError,
   listCodexResetCredits,
+  listUsageTargets,
   loadUsageSettings,
   miniMaxUsageKind,
   normalizeBasetenBillingUsagePayload,
@@ -5056,6 +5536,7 @@ export {
   normalizeOpenCodeZenPayload,
   normalizeOpenRouterKeyPayload,
   normalizeUsageSettings,
+  normalizeUsageTargets,
   normalizeVercelAIGatewayCreditsPayload,
   normalizeXaiBillingPayload,
   normalizeZaiQuotaPayload,
@@ -5065,6 +5546,7 @@ export {
   redactUsageError,
   resolveCodexResetAuth,
   resolveUsageAuth,
+  resolveUsageTarget,
   rewriteCodexFastPayload,
   runWithConcurrency,
   sanitizeDisplayText,