pi-commandcode-provider 0.5.0 → 0.6.0

package/src/models.ts

@@ -1,51 +1,39 @@
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
 import { dirname } from "node:path"
 
-export const DEFAULT_MODELS_URL = "https://api.commandcode.ai/provider/v1/models"
+import {
+  MODEL_EFFORTS,
+  MODEL_INPUT_MODALITIES,
+  MODEL_MAX_OUTPUT_TOKENS,
+  MODEL_REASONING,
+  type CommandCodeInputType,
+  type CommandCodeReasoningEffort,
+} from "./commandcode-catalog.ts"
+
+export { MODEL_EFFORTS, MODEL_INPUT_MODALITIES, MODEL_MAX_OUTPUT_TOKENS, MODEL_REASONING }
+export type { CommandCodeInputType }
+
+export const DEFAULT_PROVIDER_API_BASE = "https://api.commandcode.ai/provider/v1"
+export const DEFAULT_MODELS_URL = `${DEFAULT_PROVIDER_API_BASE}/models`
 export const DEFAULT_MODELS_TIMEOUT_MS = 10_000
 
 const DEFAULT_MAX_OUTPUT_TOKENS = 65_536
 const MODEL_CACHE_VERSION = 1
 
-export type PiThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
+export type CommandCodeApi = "openai-completions" | "anthropic-messages"
+
+const TEXT_INPUT_ONLY = ["text"] as const
+
+export function inputModalitiesForModel(modelId: string): readonly CommandCodeInputType[] {
+  return MODEL_INPUT_MODALITIES[modelId] ?? TEXT_INPUT_ONLY
+}
 
-type CommandCodeReasoningEffort = Exclude<PiThinkingLevel, "off">
-
-/**
- * Per-model reasoning efforts supported by Command Code's generate endpoint.
- *
- * The Provider API does not expose reasoning metadata. This is an exact
- * snapshot of `reasoningEfforts` from the command-code@1.14.1 model catalog
- * (`packages/shared/src/model-catalog.ts`, also published in the generated
- * `dist/bundled/command-code-knowledge/reference/models.md`). Models omitted
- * here let Command Code choose their reasoning depth, matching the CLI.
- */
-export const MODEL_EFFORTS: Readonly<Record<string, readonly CommandCodeReasoningEffort[]>> = {
-  "Qwen/Qwen3.8-Max": ["low", "medium", "xhigh"],
-  "claude-fable-5": ["low", "medium", "high", "xhigh", "max"],
-  "claude-opus-4-7": ["low", "medium", "high", "xhigh", "max"],
-  "claude-opus-4-8": ["low", "medium", "high", "xhigh", "max"],
-  "claude-opus-5": ["low", "medium", "high", "xhigh", "max"],
-  "claude-sonnet-4-6": ["low", "medium", "high", "xhigh", "max"],
-  "claude-sonnet-5": ["low", "medium", "high", "xhigh", "max"],
-  "deepseek/deepseek-v4-flash": ["high", "max"],
-  "deepseek/deepseek-v4-pro": ["high", "max"],
-  "gpt-5.3-codex": ["low", "medium", "high", "xhigh"],
-  "gpt-5.4": ["low", "medium", "high", "xhigh"],
-  "gpt-5.4-mini": ["low", "medium", "high"],
-  "gpt-5.5": ["low", "medium", "high", "xhigh"],
-  "gpt-5.6-luna": ["low", "medium", "high", "xhigh", "max"],
-  "gpt-5.6-sol": ["low", "medium", "high", "xhigh", "max"],
-  "gpt-5.6-terra": ["low", "medium", "high", "xhigh", "max"],
-  "google/gemini-3.1-flash-lite": ["low", "medium", "high"],
-  "google/gemini-3.5-flash": ["low", "medium", "high"],
-  "google/gemini-3.5-flash-lite": ["low", "medium", "high"],
-  "google/gemini-3.6-flash": ["low", "medium", "high"],
-  "sakana/fugu-ultra": ["high", "xhigh"],
-  "xai/grok-4.5": ["low", "medium", "high"],
-  "zai-org/GLM-5.2": ["high", "max"],
+export function modelSupportsImageInput(modelId: string): boolean {
+  return inputModalitiesForModel(modelId).includes("image")
 }
 
+export type PiThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
+
 const PI_THINKING_LEVELS: readonly PiThinkingLevel[] = [
   "off",
   "minimal",
@@ -69,7 +57,7 @@ export function thinkingLevelMapForEfforts(
 
 export interface ThinkingMetadata {
   thinkingLevelMap: Partial<Record<PiThinkingLevel, string | null>>
-  thinking: {
+  thinking?: {
     mode: "effort"
     effortMap: Partial<Record<CommandCodeReasoningEffort, string>>
     efforts: readonly CommandCodeReasoningEffort[]
@@ -78,19 +66,26 @@ export interface ThinkingMetadata {
 
 export function thinkingMetadataForModel(modelId: string): ThinkingMetadata | undefined {
   const efforts = MODEL_EFFORTS[modelId]
-  if (!efforts) return undefined
-  return {
-    thinkingLevelMap: thinkingLevelMapForEfforts(efforts),
-    thinking: {
-      mode: "effort",
-      effortMap: Object.fromEntries(efforts.map((effort) => [effort, effort])),
-      efforts,
-    },
+  if (efforts) {
+    return {
+      thinkingLevelMap: thinkingLevelMapForEfforts(efforts),
+      thinking: {
+        mode: "effort",
+        effortMap: Object.fromEntries(efforts.map((effort) => [effort, effort])),
+        efforts,
+      },
+    }
   }
+  if (!isReasoningModel(modelId)) return undefined
+  return { thinkingLevelMap: thinkingLevelMapForEfforts([]) }
 }
 
 function isReasoningModel(modelId: string): boolean {
-  return MODEL_EFFORTS[modelId] !== undefined
+  return MODEL_REASONING[modelId] === true
+}
+
+function maxOutputTokensForModel(modelId: string, contextLength: number): number {
+  return Math.min(contextLength, MODEL_MAX_OUTPUT_TOKENS[modelId] ?? DEFAULT_MAX_OUTPUT_TOKENS)
 }
 
 interface ApiModel {
@@ -102,11 +97,22 @@ interface ApiModel {
 export interface CommandCodeModel {
   id: string
   name: string
+  api: CommandCodeApi
   reasoning: boolean
   contextWindow: number
   maxTokens: number
 }
 
+export function apiForModelId(id: string): CommandCodeApi {
+  return id.startsWith("claude-") ? "anthropic-messages" : "openai-completions"
+}
+
+export function baseUrlForModel(apiBase: string, api: CommandCodeApi): string {
+  const normalized = apiBase.replace(/\/+$/g, "")
+  if (api !== "anthropic-messages") return normalized
+  return normalized.endsWith("/v1") ? normalized.slice(0, -3) : normalized
+}
+
 interface FetchCommandCodeModelsOptions {
   url?: string
   fetchImpl?: typeof fetch
@@ -165,12 +171,15 @@ function parseCachedModel(value: unknown): CommandCodeModel {
 
   const id = stringField(value, "id")
   booleanField(value, "reasoning")
+  positiveNumberField(value, "maxTokens")
+  const contextWindow = positiveNumberField(value, "contextWindow")
   return {
     id,
     name: stringField(value, "name"),
+    api: apiForModelId(id),
     reasoning: isReasoningModel(id),
-    contextWindow: positiveNumberField(value, "contextWindow"),
-    maxTokens: positiveNumberField(value, "maxTokens"),
+    contextWindow,
+    maxTokens: maxOutputTokensForModel(id, contextWindow),
   }
 }
 
@@ -272,9 +281,10 @@ export function commandCodeModelsFromApiResponse(value: unknown): readonly Comma
   return data.map(parseApiModel).map((model) => ({
     id: model.id,
     name: `${model.name} (CC)`,
+    api: apiForModelId(model.id),
     reasoning: isReasoningModel(model.id),
     contextWindow: model.contextLength,
-    maxTokens: Math.min(model.contextLength, DEFAULT_MAX_OUTPUT_TOKENS),
+    maxTokens: maxOutputTokensForModel(model.id, model.contextLength),
   }))
 }
 

package/src/oauth.ts

@@ -1,13 +1,13 @@
 /**
  * Command Code OAuth provider for pi's /login flow.
  *
- * Implements a browser-assisted API key retrieval flow:
- * 1. Starts a local HTTP server on a Command Code CLI-compatible port
- * 2. Opens the Command Code Studio auth page in the browser
- * 3. The user authenticates on the Command Code website
- * 4. The website POSTs the API key back to the local server
- * 5. If browser transfer fails, the user can paste the API key manually
- * 6. The API key is stored in pi's auth.json as OAuth credentials
+ * Implements two API key retrieval flows:
+ * 1. Browser-assisted login opens Command Code Studio and waits for the
+ *    website to POST the API key back to a local callback server.
+ * 2. Direct API key login prompts the user to paste a Studio API key.
+ *
+ * If browser transfer fails, the user can still paste the API key manually.
+ * The API key is stored in pi's auth.json as OAuth credentials.
  *
  * Since Command Code API keys don't expire, we store them as
  * OAuth credentials with a far-future expiry.
@@ -18,7 +18,8 @@ import { startAuthServer } from "./auth-server.ts"
 
 const STUDIO_BASE_URL = "https://commandcode.ai"
 const TEN_YEARS_MS = 10 * 365 * 24 * 60 * 60 * 1000 // API keys don't expire
-const DEFAULT_AUTH_TIMEOUT_MS = 15_000
+const DEFAULT_AUTH_TIMEOUT_MS = 120_000
+const DEFAULT_API_BASE = "https://api.commandcode.ai"
 
 export interface OAuthLoginCallbacks {
   onAuth(params: { url: string }): void
@@ -95,22 +96,70 @@ export function sanitizeApiKey(input: string): string {
     .trim()
 }
 
+export async function validateApiKey(
+  apiKey: string,
+  options: { fetchImpl?: typeof fetch; apiBase?: string } = {},
+): Promise<void> {
+  let response: Response
+  try {
+    response = await (options.fetchImpl ?? fetch)(
+      `${options.apiBase ?? DEFAULT_API_BASE}/alpha/whoami`,
+      {
+        headers: { Authorization: `Bearer ${apiKey}` },
+      },
+    )
+  } catch (error) {
+    throw new Error(
+      `Could not validate the Command Code API key: ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+
+  if (response.status === 401) throw new Error("Invalid Command Code API key")
+  if (!response.ok) {
+    throw new Error(`Could not validate the Command Code API key (${response.status})`)
+  }
+}
+
 async function promptForApiKey(callbacks: OAuthLoginCallbacks, message: string) {
   const apiKey = sanitizeApiKey(await callbacks.onPrompt({ message }))
   if (!apiKey) throw new Error("No Command Code API key provided")
+  await validateApiKey(apiKey)
   return credentialsFromApiKey(apiKey)
 }
 
-/**
- * Starts the browser-based login flow for Command Code.
- *
- * Returns OAuth credentials where access == refresh == the user's API key.
- * The keys don't expire, so we set a far-future expiry.
- */
-export async function login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+type LoginChoice = { type: "browser" } | { type: "prompt" } | { type: "apiKey"; apiKey: string }
+
+async function chooseLoginFlow(callbacks: OAuthLoginCallbacks): Promise<LoginChoice> {
+  const input = sanitizeApiKey(
+    await callbacks.onPrompt({
+      message:
+        "Command Code login: press Enter for browser login, type 'key' to paste an API key, or paste the API key directly:",
+    }),
+  )
+  const normalized = input.toLowerCase()
+
+  if (!input || normalized === "1" || normalized === "b" || normalized === "browser") {
+    return { type: "browser" }
+  }
+
+  if (
+    normalized === "2" ||
+    normalized === "k" ||
+    normalized === "key" ||
+    normalized === "api" ||
+    normalized === "paste"
+  ) {
+    return { type: "prompt" }
+  }
+
+  return { type: "apiKey", apiKey: input }
+}
+
+async function browserLogin(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+  const stateToken = generateStateToken()
   let authServer
   try {
-    authServer = await startAuthServer()
+    authServer = await startAuthServer({ expectedState: stateToken })
   } catch {
     return promptForApiKey(
       callbacks,
@@ -118,7 +167,6 @@ export async function login(callbacks: OAuthLoginCallbacks): Promise<OAuthCreden
     )
   }
 
-  const stateToken = generateStateToken()
   const callbackUrl = `http://localhost:${authServer.port}/callback`
   const authUrl = `${STUDIO_BASE_URL}/studio/auth/cli?callback=${encodeURIComponent(callbackUrl)}&state=${encodeURIComponent(stateToken)}`
 
@@ -142,13 +190,27 @@ export async function login(callbacks: OAuthLoginCallbacks): Promise<OAuthCreden
     throw error
   }
 
-  // Validate state token to prevent CSRF.
-  if (callback.state !== stateToken) {
-    authServer.server.close()
-    throw new Error("State token mismatch. Authentication may have been tampered with.")
+  return credentialsFromApiKey(callback.apiKey)
+}
+
+/**
+ * Starts the login flow for Command Code.
+ *
+ * Returns OAuth credentials where access == refresh == the user's API key.
+ * The keys don't expire, so we set a far-future expiry.
+ */
+export async function login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+  const choice = await chooseLoginFlow(callbacks)
+
+  if (choice.type === "apiKey") {
+    await validateApiKey(choice.apiKey)
+    return credentialsFromApiKey(choice.apiKey)
+  }
+  if (choice.type === "prompt") {
+    return promptForApiKey(callbacks, "Paste your Command Code API key:")
   }
 
-  return credentialsFromApiKey(callback.apiKey)
+  return browserLogin(callbacks)
 }
 
 /**

package/src/pricing.ts

@@ -20,7 +20,7 @@ export interface TemporaryPricing {
 }
 
 export const PRICING_SOURCE_URL = "https://commandcode.ai/docs/resources/pricing-limits"
-export const PRICING_LAST_VERIFIED = "2026-08-04"
+export const PRICING_LAST_VERIFIED = "2026-08-25"
 
 export const ZERO_MODEL_COST: CommandCodeModelCost = {
   input: 0,
@@ -40,7 +40,7 @@ export const ZERO_MODEL_COST: CommandCodeModelCost = {
 export const MODEL_COSTS: Readonly<Record<string, CommandCodeModelCost>> = {
   // Free models
   "poolside/laguna-s-2.1-free": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-  "inclusionai/ling-3.0-flash-free": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  "stealth/ox-alpha": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 
   // Open and open-weight models
   "tencent/hy3-paid": { input: 0.14, output: 0.58, cacheRead: 0.035, cacheWrite: 0 },
@@ -54,6 +54,7 @@ export const MODEL_COSTS: Readonly<Record<string, CommandCodeModelCost>> = {
   },
   "moonshotai/Kimi-K2.6": { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0 },
   "moonshotai/Kimi-K2.5": { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0 },
+  "zai-org/GLM-5.3": { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 },
   "zai-org/GLM-5.2": { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 },
   "zai-org/GLM-5.2-Fast": { input: 3, output: 10.25, cacheRead: 0.5, cacheWrite: 0 },
   "zai-org/GLM-5.1": { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 },
@@ -61,20 +62,28 @@ export const MODEL_COSTS: Readonly<Record<string, CommandCodeModelCost>> = {
   "MiniMaxAI/MiniMax-M3": { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 },
   "MiniMaxAI/MiniMax-M2.7": { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 },
   "MiniMaxAI/MiniMax-M2.5": { input: 0.3, output: 1.2, cacheRead: 0.03, cacheWrite: 0 },
-  // Permanent 75% discount.
+  // DeepSeek V4 uses time-dependent rates. Display the documented off-peak
+  // rates, which apply for 17 hours per day; the Usage page remains authoritative.
   "deepseek/deepseek-v4-pro": {
-    input: 0.435,
-    output: 0.87,
-    cacheRead: 0.003625,
+    input: 0.66,
+    output: 1.98,
+    cacheRead: 0.022,
     cacheWrite: 0,
   },
   "deepseek/deepseek-v4-flash": {
-    input: 0.14,
-    output: 0.28,
-    cacheRead: 0.0028,
+    input: 0.22,
+    output: 0.66,
+    cacheRead: 0.007,
+    cacheWrite: 0,
+  },
+  "deepseek/deepseek-v4-flash-vision-exp": {
+    input: 0.22,
+    output: 0.66,
+    cacheRead: 0.007,
     cacheWrite: 0,
   },
   "Qwen/Qwen3.8-Max": { input: 2, output: 6, cacheRead: 0.25, cacheWrite: 2.5 },
+  "Qwen/Qwen3.8-27B": { input: 0.4, output: 3, cacheRead: 0.04, cacheWrite: 0 },
   "Qwen/Qwen3.7-Max": { input: 2.5, output: 7.5, cacheRead: 0.5, cacheWrite: 3.13 },
   "Qwen/Qwen3.7-Plus": {
     input: 0.4,
@@ -140,6 +149,13 @@ export const MODEL_COSTS: Readonly<Record<string, CommandCodeModelCost>> = {
     cacheWrite: 0,
   },
   "meta/muse-spark-1.1": { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 },
+  "meta/muse-spark-1.2": { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 },
+  "meta/muse-spark-1.2-contributor": {
+    input: 0.1,
+    output: 0.2,
+    cacheRead: 0.002,
+    cacheWrite: 0,
+  },
 
   // Anthropic
   // Introductory pricing through 2026-08-31.
@@ -158,43 +174,20 @@ export const MODEL_COSTS: Readonly<Record<string, CommandCodeModelCost>> = {
 
   // OpenAI
   "gpt-5.6-sol": { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 6.25 },
-  // Discounted rates through 2026-08-14.
-  "gpt-5.6-terra": {
-    input: 1,
-    output: 6,
-    cacheRead: 0.1,
-    cacheWrite: 1.25,
-    tiers: [
-      {
-        inputTokensAbove: 272_000,
-        input: 2,
-        output: 9,
-        cacheRead: 0.2,
-        cacheWrite: 2.5,
-      },
-    ],
-  },
-  "gpt-5.6-luna": {
-    input: 0.1,
-    output: 0.6,
-    cacheRead: 0.01,
-    cacheWrite: 0.125,
-    tiers: [
-      {
-        inputTokensAbove: 272_000,
-        input: 0.2,
-        output: 0.9,
-        cacheRead: 0.02,
-        cacheWrite: 0.25,
-      },
-    ],
-  },
+  "gpt-5.6-terra": { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 2.5 },
+  "gpt-5.6-luna": { input: 0.2, output: 1.2, cacheRead: 0.02, cacheWrite: 0.25 },
   "gpt-5.5": { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 0 },
   "gpt-5.4": { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 },
   "gpt-5.3-codex": { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 },
   "gpt-5.4-mini": { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 },
 
   // Google and xAI
+  "google/gemini-3.7-flash": {
+    input: 0.75,
+    output: 3.75,
+    cacheRead: 0.075,
+    cacheWrite: 0.04167,
+  },
   "google/gemini-3.6-flash": { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 0 },
   "google/gemini-3.5-flash": { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 0 },
   "google/gemini-3.5-flash-lite": {
@@ -210,17 +203,32 @@ export const MODEL_COSTS: Readonly<Record<string, CommandCodeModelCost>> = {
     cacheWrite: 0,
   },
   "xai/grok-4.5": { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 },
+  "xai/grok-4.6": {
+    input: 2,
+    output: 6,
+    cacheRead: 0.5,
+    cacheWrite: 0,
+    tiers: [
+      {
+        inputTokensAbove: 200_000,
+        input: 4,
+        output: 12,
+        cacheRead: 1,
+        cacheWrite: 0,
+      },
+    ],
+  },
 }
 
 export const TEMPORARY_PRICING: readonly TemporaryPricing[] = [
-  {
-    models: ["gpt-5.6-terra", "gpt-5.6-luna"],
-    expiresOn: "2026-08-14",
-    description: "50% promotional rates",
-  },
   {
     models: ["claude-sonnet-5"],
     expiresOn: "2026-08-31",
     description: "introductory pricing",
   },
+  {
+    models: ["google/gemini-3.7-flash"],
+    expiresOn: "2026-12-31",
+    description: "50% promotional pricing",
+  },
 ]

package/src/quota-command.ts

@@ -0,0 +1,66 @@
+import { getConfiguredApiKey } from "./api-key.ts"
+import { pickCommandCodeApiKey } from "./converters.ts"
+import { fetchCommandCodeQuota, redactValue } from "./quota.ts"
+import { formatQuota } from "./quota-format.ts"
+
+export interface QuotaCommandContext {
+  waitForIdle?: () => Promise<void>
+  modelRegistry?: {
+    getApiKeyForProvider?: (provider: string) => Promise<string | undefined>
+  }
+  ui: {
+    notify(message: string, type?: "info" | "warning" | "error"): void
+  }
+}
+
+interface QuotaCommandApi {
+  registerCommand(
+    name: string,
+    options: {
+      description: string
+      handler: (args: string, ctx: QuotaCommandContext) => Promise<void>
+    },
+  ): void
+}
+
+interface RegisterQuotaCommandOptions {
+  apiBase: string
+  headers?: Record<string, string>
+  getConfiguredKey?: () => string | undefined
+  fetchQuota?: typeof fetchCommandCodeQuota
+}
+
+export function registerCommandCodeQuota(
+  pi: QuotaCommandApi,
+  options: RegisterQuotaCommandOptions,
+): void {
+  const getConfiguredKey = options.getConfiguredKey ?? getConfiguredApiKey
+  const fetchQuota = options.fetchQuota ?? fetchCommandCodeQuota
+
+  pi.registerCommand("commandcode-quota", {
+    description: "Show Command Code account usage and quota",
+    handler: async (_args, ctx) => {
+      await ctx.waitForIdle?.()
+      const registryKey = await ctx.modelRegistry?.getApiKeyForProvider?.("commandcode")
+      const apiKey = pickCommandCodeApiKey(registryKey, getConfiguredKey())
+      if (!apiKey) {
+        ctx.ui.notify(
+          "Command Code quota requires an API key. Run /login and select Command Code, or set COMMAND_CODE_API_KEY.",
+          "warning",
+        )
+        return
+      }
+
+      const result = await fetchQuota({
+        apiKey,
+        baseUrl: options.apiBase,
+        extraHeaders: options.headers,
+      })
+      if (!result.ok) {
+        ctx.ui.notify(redactValue(result.error.message), "error")
+        return
+      }
+      ctx.ui.notify(formatQuota(result.quota), "info")
+    },
+  })
+}

package/src/quota-format.ts

@@ -0,0 +1,111 @@
+import type {
+  CommandCodeCredits,
+  CommandCodeQuota,
+  CommandCodeSubscription,
+  CommandCodeWindowLimit,
+} from "./quota-types.ts"
+
+export function formatWindowLimits(
+  limits: readonly CommandCodeWindowLimit[],
+  now: () => number = Date.now,
+): string[] {
+  const labels: Record<CommandCodeWindowLimit["window"], string> = {
+    fiveHour: "5-hour",
+    weekly: "Weekly",
+  }
+
+  return limits.map((limit) => {
+    const used = limit.used.toFixed(2)
+    const cap = limit.cap.toFixed(2)
+    const percent = limit.cap > 0 ? Math.round((limit.used / limit.cap) * 100) : 0
+    const reset = limit.resetAt === null ? "" : ` (resets ${formatResetClock(limit.resetAt, now)})`
+    return `${labels[limit.window]}: ${used} / ${cap} credits (${percent}% used)${reset}`
+  })
+}
+
+function formatResetClock(resetAtSeconds: number, now: () => number): string {
+  const date = new Date(resetAtSeconds * 1000)
+  if (Number.isNaN(date.getTime())) return "unknown"
+  const diffMs = date.getTime() - now()
+  if (diffMs <= 0) return "soon"
+  const minutes = Math.ceil(diffMs / 60_000)
+  if (minutes < 60) return `in ${minutes}m`
+  const hours = Math.floor(minutes / 60)
+  const remainingMinutes = minutes % 60
+  if (hours < 24) {
+    return remainingMinutes > 0 ? `in ${hours}h ${remainingMinutes}m` : `in ${hours}h`
+  }
+  const days = Math.floor(hours / 24)
+  return days === 1 ? "in 1 day" : `in ${days} days`
+}
+
+function creditsDetail(credits: CommandCodeCredits | null): string | undefined {
+  if (!credits) return undefined
+  const parts = [
+    `monthly $${credits.monthlyCredits.toFixed(2)}`,
+    `purchased $${credits.purchasedCredits.toFixed(2)}`,
+  ]
+  if (credits.freeCredits > 0) parts.push(`free $${credits.freeCredits.toFixed(2)}`)
+  return `Sources: ${parts.join(" / ")}`
+}
+
+function subscriptionLine(subscription: CommandCodeSubscription): string {
+  const plan = (subscription.planId ?? "Unknown").replace(/[_-]+/g, " ").trim()
+  const status = subscription.status ? ` (${subscription.status})` : ""
+  return `Plan: ${plan}${status}`
+}
+
+function formatTokens(tokens: number): string {
+  if (tokens >= 1_000_000_000) return `${(tokens / 1_000_000_000).toFixed(1)}B`
+  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`
+  if (tokens >= 1_000) return `${(tokens / 1_000).toFixed(1)}k`
+  return String(tokens)
+}
+
+export function formatQuota(quota: CommandCodeQuota, now: () => number = Date.now): string {
+  const lines: string[] = []
+  const remaining = quota.credits?.remainingCredits ?? 0
+  const spent = quota.summary?.totalCost ?? 0
+  const pool = remaining + spent
+
+  if (quota.credits || quota.summary) {
+    lines.push("Credits")
+    lines.push(`  Remaining: $${remaining.toFixed(2)} of $${pool.toFixed(2)}`)
+    lines.push(`  Used: $${spent.toFixed(2)}`)
+    lines.push(`  ${pool > 0 ? Math.round((spent / pool) * 100) : 0}% used`)
+  }
+
+  const detail = creditsDetail(quota.credits)
+  if (detail) lines.push(detail)
+  if (quota.subscription) lines.push(subscriptionLine(quota.subscription))
+
+  if (quota.summary) {
+    lines.push("")
+    lines.push(quota.subscription?.currentPeriodStart ? "Usage (billing period)" : "Usage")
+    lines.push(`  Cost: $${quota.summary.totalCost.toFixed(2)}`)
+    lines.push(`  Requests: ${quota.summary.totalCount.toLocaleString("en-US")}`)
+    if (quota.summary.totalTokens !== undefined) {
+      lines.push(`  Tokens: ${formatTokens(quota.summary.totalTokens)}`)
+    }
+  }
+
+  lines.push("")
+  lines.push("Account")
+  lines.push(`  ${quota.account.keyName ?? quota.account.login}`)
+
+  const limits = quota.credits?.windowLimits ?? []
+  if (limits.length > 0) {
+    lines.push("")
+    lines.push("Usage windows:")
+    lines.push(...formatWindowLimits(limits, now).map((line) => `  ${line}`))
+  }
+
+  if ((quota.unavailable?.length ?? 0) > 0) {
+    lines.push("")
+    lines.push(`Unavailable: ${quota.unavailable?.join(", ")}`)
+  }
+
+  lines.push("")
+  lines.push("Full detail: https://commandcode.ai/usage")
+  return lines.join("\n")
+}