@genex-ai/cli-demo 1.35.0-dev.741 → 1.35.0-dev.743

package/dist/index.js

@@ -23288,7 +23288,7 @@ import path35 from "path";
 import fs33 from "fs/promises";
 import path34 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
-var SUBS3 = ["models", "bench", "price"];
+var SUBS3 = ["models", "bench", "price", "status", "cancel"];
 var LLM_BENCH_APPROVAL_REQUIRED = "STOP: `genex llm bench` runs the real model and spends YOUR OWN coin \u2014 your wallet, not a player's, and one this build's asset allowance cannot see. Re-run with --max-coins <n> --user-approved only after the person at the keyboard agreed to the number.";
 var LLM_LANE_OFF_LINE = "The runtime LLM lane is off on this stand \u2014 in-game generate() answers 404 here, and nothing can be benchmarked.";
 var LLM_TOOLS_CONVERT_HINT = [
@@ -23297,14 +23297,34 @@ var LLM_TOOLS_CONVERT_HINT = [
   "Ask the user first; on their yes run `npx genex init --convert`, then load the genex-tool-llm card."
 ];
 var LLM_BENCH_FILE = ".genex/llm-bench.json";
+function serverSlotCounts(body) {
+  if (!body || typeof body.slotsHeld !== "number" || typeof body.slotLimit !== "number" || body.slotLimit <= 0) return null;
+  return { held: body.slotsHeld, limit: body.slotLimit };
+}
+var PENDING_SLOT_RELEASE_MINUTES = 10;
+var LLM_STATUS_LEGEND = `"awaiting bill" = the call has stopped but the provider's bill is not final, so its coin stays held until the bill resolves; such a row stops holding a slot ${PENDING_SLOT_RELEASE_MINUTES} minutes after dispatch.`;
+var LLM_STATUS_NO_COUNT_LINE = "This stand does not report how many slots are held across your projects, so no count is shown.";
+var LLM_CANCEL_AWAITING_BILL = "this call already stopped; its bill is awaiting the provider";
+var LLM_CANCEL_ALREADY_FINAL = "this call is already final";
+function benchSlotsHeldSentence(counts) {
+  const count = counts === null ? "every ad-hoc slot is" : `${counts.held} of ${counts.limit} ad-hoc slots are`;
+  return `refused before it started, nothing spent: ${count} held on this stand \u2014 \`genex llm status\` shows the calls holding them; wait for a bill to resolve or cancel an active one, then re-run.`;
+}
+var LLM_PROVIDER_KEY_REJECTED_LINE = "This stand's provider key is refused \u2014 every in-game call answers provider_http_401 until an operator replaces it.";
 var DEFAULT_BENCH_SAMPLES = 3;
 var DEFAULT_SAMPLE_TIMEOUT_SEC = 180;
+function parseProviderKey(value) {
+  return value === "ok" || value === "rejected" || value === "unknown" ? value : null;
+}
 async function readRuntimeLane(apiUrl, token) {
   const empty = (state) => ({
     state,
     models: null,
     recommendedDeclaredHeadroomBps: null,
-    externalProviders: null
+    externalProviders: null,
+    total: null,
+    featuredCount: null,
+    providerKey: null
   });
   try {
     const res = await apiFetch(`${apiUrl}/api/runtime/models`, {
@@ -23320,7 +23340,10 @@ async function readRuntimeLane(apiUrl, token) {
       state: "live",
       models: body.models,
       recommendedDeclaredHeadroomBps: typeof body.recommendedDeclaredHeadroomBps === "number" && Number.isFinite(body.recommendedDeclaredHeadroomBps) ? body.recommendedDeclaredHeadroomBps : null,
-      externalProviders: Array.isArray(body.externalProviders) ? body.externalProviders : null
+      externalProviders: Array.isArray(body.externalProviders) ? body.externalProviders : null,
+      total: typeof body.total === "number" && Number.isFinite(body.total) ? body.total : null,
+      featuredCount: typeof body.featuredCount === "number" && Number.isFinite(body.featuredCount) ? body.featuredCount : null,
+      providerKey: parseProviderKey(body.providerKey)
     };
   } catch {
     return empty("unknown");
@@ -23363,6 +23386,11 @@ async function runLlm(opts = {}) {
   }
   const ws = await resolveWorkspace(cwd);
   const toolsOnly = ws.mode === "tools" && !ws.hosted;
+  const projectBound = sub === "bench" || sub === "status" || sub === "cancel";
+  if (sub === "cancel" && !opts.generationId?.trim()) {
+    fail4("llm cancel", "`genex llm cancel` needs the id of the call to stop, e.g. genex llm cancel <id> \u2014 `genex llm status` lists the open ones.");
+    return;
+  }
   if (sub === "bench") {
     if (opts.maxCoins === void 0 || opts.userApproved !== true) {
       fail4("llm bench", LLM_BENCH_APPROVAL_REQUIRED);
@@ -23380,22 +23408,22 @@ async function runLlm(opts = {}) {
       fail4("llm bench", "Pass --json-output or --text, not both.");
       return;
     }
-    if (toolsOnly) {
-      if (opts.json) writeJsonLine({ command: "llm bench", status: "failed", error: "`genex llm bench` is not part of Genex Tools." });
-      else {
-        reportPlatformRefused(log, "llm bench");
-        log.plain(`  ${c.cyan("\u2192")} A model that runs while people PLAY is a platform feature: the player pays and approves it.`);
-        log.plain(`    Ask the user, and on their yes: ${c.cyan("npx genex init --convert")} \u2014 then the ${c.cyan("genex-tool-llm")} card.`);
-      }
-      process.exitCode = 1;
-      return;
+  }
+  if (projectBound && toolsOnly) {
+    if (opts.json) writeJsonLine({ command: `llm ${sub}`, status: "failed", error: `\`genex llm ${sub}\` is not part of Genex Tools.` });
+    else {
+      reportPlatformRefused(log, `llm ${sub}`);
+      log.plain(`  ${c.cyan("\u2192")} A model that runs while people PLAY is a platform feature: the player pays and approves it.`);
+      log.plain(`    Ask the user, and on their yes: ${c.cyan("npx genex init --convert")} \u2014 then the ${c.cyan("genex-tool-llm")} card.`);
     }
+    process.exitCode = 1;
+    return;
   }
   const meta = await readProject(cwd);
-  if (sub === "bench" && !meta?.id) {
+  if (projectBound && !meta?.id) {
     fail4(
-      "llm bench",
-      "This folder isn't linked to a game \u2014 a benchmark is billed to a project you own."
+      `llm ${sub}`,
+      sub === "bench" ? "This folder isn't linked to a game \u2014 a benchmark is billed to a project you own." : `This folder isn't linked to a game \u2014 \`genex llm ${sub}\` works on the development calls of a project you own.`
     );
     if (!opts.json) {
       log.dim(`  Run ${c.cyan("genex link")} (or ${c.cyan("genex list")} to find the slug) first.`);
@@ -23432,6 +23460,14 @@ async function runLlm(opts = {}) {
     await reportModels(apiUrl, token, opts, log, toolsOnly);
     return;
   }
+  if (sub === "status") {
+    await reportStatus({ apiUrl, token, projectId: meta.id, opts, log });
+    return;
+  }
+  if (sub === "cancel") {
+    await cancelCall({ apiUrl, token, projectId: meta.id, id: opts.generationId.trim(), opts, log });
+    return;
+  }
   await runBench({ apiUrl, token, projectId: meta.id, cwd, opts, log });
 }
 async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
@@ -23457,6 +23493,12 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
         models: null,
         externalProviders: null,
         recommendedDeclaredHeadroomBps: null,
+        total: null,
+        featuredCount: null,
+        // The stand was never asked, so the verdict is unknown — but the key is
+        // present, like every other lane key, so a reader tells "no verdict"
+        // from "a CLI that predates the probe".
+        providerKey: null,
         convertHint: toolsOnly ? LLM_TOOLS_CONVERT_HINT.join(" ") : null
       });
     }
@@ -23470,9 +23512,16 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
       status: lane.state,
       error: null,
       enabled: lane.state === "live",
+      // --json ALWAYS carries every row with its `featured` flag. The short
+      // list is a rendering decision for a person reading a terminal; a program
+      // reading this object gets the whole catalog and decides for itself.
       models: lane.models,
       externalProviders: lane.externalProviders,
       recommendedDeclaredHeadroomBps: lane.recommendedDeclaredHeadroomBps,
+      total: lane.total ?? lane.models?.length ?? null,
+      featuredCount: lane.featuredCount ?? (lane.models ? lane.models.filter((m) => m.featured).length : null),
+      // `null` when the lane is not live or the server predates the probe.
+      providerKey: lane.providerKey,
       // Always present, `null` off a tools workspace — the same
       // every-key-always-present rule the other keys follow, so a reader can
       // tell "no hint" from "a CLI that predates the hint".
@@ -23507,16 +23556,29 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
     process.exitCode = 1;
     return;
   }
-  log.plain(`  ${lane.models.length} model${lane.models.length === 1 ? "" : "s"} live:`);
-  for (const m of lane.models) {
+  const featured = lane.models.filter((m) => m.featured);
+  const shown = opts.all || featured.length === 0 ? lane.models : featured;
+  const hiddenCount = lane.models.length - shown.length;
+  log.plain(
+    shown === lane.models ? `  ${lane.models.length} model${lane.models.length === 1 ? "" : "s"} live:` : `  ${shown.length} featured model${shown.length === 1 ? "" : "s"} of ${lane.models.length} live:`
+  );
+  for (const m of shown) {
+    const plan = m.personalPlan ? `  \xB7  personal plan: ${m.personalPlan}` : "";
     log.plain(
-      `    ${c.cyan(m.id)}  ${m.label} \u2014 ${usdPerMillion(m.inputUsdPerMillion)} in / ${usdPerMillion(m.outputUsdPerMillion)} out per million tokens`
+      `    ${c.cyan(m.id)}  ${m.label} \u2014 ${usdPerMillion(m.inputUsdPerMillion)} in / ${usdPerMillion(m.outputUsdPerMillion)} out per million tokens${plan}`
     );
   }
+  if (hiddenCount > 0) {
+    log.dim(`  ${hiddenCount} more available \u2014 ${c.cyan("genex llm models --all")} to list them.`);
+  }
   if (lane.externalProviders && lane.externalProviders.length > 0) {
     log.plain("");
     log.plain(`  Personal plans offered here: ${lane.externalProviders.map((p) => p.label).join(", ")}`);
   }
+  if (lane.providerKey === "rejected") {
+    log.plain("");
+    log.warn(`  ${LLM_PROVIDER_KEY_REJECTED_LINE}`);
+  }
   log.plain("");
   if (lane.recommendedDeclaredHeadroomBps === null) {
     log.dim("  This stand serves no recommended headroom, so no price can be recommended from a bench.");
@@ -23530,6 +23592,32 @@ async function reportModels(apiUrl, token, opts, log, toolsOnly = false) {
   log.dim("  Those per-million rates are the PROVIDER's; what your game is charged is the platform");
   log.dim(`  tariff on top, which only a real call reveals: ${c.cyan('genex llm bench "<prompt>" --max-coins <n> --user-approved')}`);
 }
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["requires_confirmation", "queued", "dispatching", "awaiting_external"]);
+function rowState(row) {
+  if (row.status && ACTIVE_STATUSES.has(row.status)) return "active";
+  if (row.billingStatus === "pending") return "awaiting bill";
+  return "done";
+}
+function rowHoldsSlot(row) {
+  if (typeof row.slotHeld === "boolean") return row.slotHeld;
+  const state = rowState(row);
+  return state === "active" || state === "awaiting bill" && (row.reservedCoins ?? 0) > 0;
+}
+function providerRefusalStatus(error) {
+  const m = /^provider_http_(\d{3})$/.exec(error ?? "");
+  return m ? Number(m[1]) : null;
+}
+function formatAge(iso, now = Date.now()) {
+  const t = iso ? Date.parse(iso) : Number.NaN;
+  if (!Number.isFinite(t)) return "\u2014";
+  const sec = Math.max(0, Math.floor((now - t) / 1e3));
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m`;
+  const hr = Math.floor(min / 60);
+  if (hr < 48) return `${hr}h`;
+  return `${Math.floor(hr / 24)}d`;
+}
 async function runBench(args) {
   const { apiUrl, token, projectId, cwd, opts, log } = args;
   const maxCoins = opts.maxCoins;
@@ -23573,6 +23661,14 @@ async function runBench(args) {
     benchFailed(opts, log, `This stand does not serve ${modelId}. Run \`genex llm models\` for the ids it does.`);
     return;
   }
+  if (lane.providerKey === "rejected") {
+    benchFailed(
+      opts,
+      log,
+      `${LLM_PROVIDER_KEY_REJECTED_LINE} A bench against a refused key is ${samples} refusal${samples === 1 ? "" : "s"} and a slot lock-out, not a measurement \u2014 nothing was sent, nothing was spent. Tell the operator; re-run once \`genex llm models\` stops saying so.`
+    );
+    return;
+  }
   const balanceBefore = await readCoinBalance(apiUrl, token);
   if (!opts.json) {
     log.plain(c.bold("genex llm bench"));
@@ -23588,6 +23684,8 @@ async function runBench(args) {
   }
   const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
   const results = [];
+  let refusal = null;
+  let providerRefused = 0;
   let inflight = null;
   const onSigint = () => {
     const target = inflight;
@@ -23618,13 +23716,14 @@ async function runBench(args) {
         })
       });
       if (!res.ok) {
-        const stop2 = await explainBenchRefusal(res, log, opts, i, results.length);
-        if (stop2) break;
+        const verdict = await explainBenchRefusal(res, call, base, log, opts, i, results.length);
+        if (verdict.refusal) refusal = verdict.refusal;
+        if (verdict.stop) break;
         continue;
       }
       const started = await res.json().catch(() => ({}));
       if (!started.id) {
-        results.push({ id: null, status: null, billingStatus: null, chargedCoins: null, costUsd: null, error: "no_generation_id" });
+        results.push({ id: null, status: null, billingStatus: null, chargedCoins: null, costUsd: null, error: "no_generation_id", providerMessage: null });
         continue;
       }
       inflight = started.id;
@@ -23636,19 +23735,23 @@ async function runBench(args) {
         billingStatus: settled?.billingStatus ?? null,
         chargedCoins: typeof settled?.chargedCoins === "number" ? settled.chargedCoins : null,
         costUsd: typeof settled?.usage?.costUsd === "number" ? settled.usage.costUsd : null,
-        error: settled?.error ?? (settled ? null : "timed_out")
+        error: settled?.error ?? (settled ? null : "timed_out"),
+        providerMessage: typeof settled?.providerMessage === "string" && settled.providerMessage.trim() ? settled.providerMessage.trim() : null
       };
       results.push(row);
+      const refusedAt = providerRefusalStatus(row.error);
+      if (refusedAt !== null) providerRefused++;
       if (!opts.json) {
         log.plain(
           `  ${row.status === "succeeded" ? c.green("\u2713") : c.yellow("!")} sample ${i + 1}  ${String(row.chargedCoins ?? "\u2014").padStart(4)} coin charged \xB7 provider ${usd(row.costUsd)}${row.error ? ` \xB7 ${row.error}` : ""}`
         );
+        if (refusedAt !== null) printProviderRefusal(log, refusedAt, row.providerMessage, row.status === "unknown");
       }
     }
   } finally {
     process.removeListener("SIGINT", onSigint);
   }
-  const charged = results.filter((r) => r.billingStatus === "final" && typeof r.chargedCoins === "number").map((r) => r.chargedCoins);
+  const charged = results.filter((r) => r.status === "succeeded" && r.billingStatus === "final" && typeof r.chargedCoins === "number").map((r) => r.chargedCoins);
   const settledCount = charged.length;
   const p50 = percentile2(charged, 50);
   const p95 = percentile2(charged, 95);
@@ -23693,6 +23796,9 @@ async function runBench(args) {
       balanceBefore,
       balanceAfter,
       results,
+      // The create-time refusal that ended the run, or null. Beside the
+      // samples, never among them: no attempt existed and nothing was spent.
+      refusal,
       chargedCoins: { p50, p95, max },
       recommendedDeclaredHeadroomBps: headroomBps,
       recommendedEstimateCoins: recommended,
@@ -23704,7 +23810,9 @@ async function runBench(args) {
   }
   log.plain("");
   if (charged.length === 0) {
-    log.error("  No sample settled, so there is nothing to price from.");
+    log.error(
+      providerRefused > 0 && providerRefused === results.length ? "  No sample ran \u2014 the provider refused every attempt at its door \u2014 so there is nothing to price from." : "  No sample settled, so there is nothing to price from."
+    );
     process.exitCode = 1;
     return;
   }
@@ -23738,31 +23846,53 @@ function printRecommendation(log, record) {
     log.dim("  The ceiling is the price's room to be wrong; declaring one under the price is refused.");
   }
 }
-async function explainBenchRefusal(res, log, opts, index, settledSoFar) {
-  if (printedStructuredError(res)) return true;
+async function explainBenchRefusal(res, call, base, log, opts, index, settledSoFar) {
+  if (printedStructuredError(res)) return { stop: true, refusal: { status: res.status, error: null, slotsHeld: null, slotLimit: null } };
   const body = await res.json().catch(() => ({}));
-  if (opts.json) return res.status !== 429;
+  const refusal = { status: res.status, error: body.error ?? null, slotsHeld: null, slotLimit: null };
+  if (res.status === 429 && body.error === "generation_limit") {
+    const counts = serverSlotCounts(body) ?? await readSlotCounts(call, base);
+    refusal.slotsHeld = counts?.held ?? null;
+    refusal.slotLimit = counts?.limit ?? null;
+    if (!opts.json) log.error(`  Sample ${index + 1} ${benchSlotsHeldSentence(counts)}`);
+    return { stop: true, refusal };
+  }
+  if (opts.json) return { stop: res.status !== 429, refusal };
   if (res.status === 404 && body.error === "not_found") {
     log.error(`  ${LLM_LANE_OFF_LINE}`);
-    return true;
+    return { stop: true, refusal };
   }
   if (res.status === 403 && body.error === "credential_scope") {
     log.error("  This credential can't reach the runtime lane \u2014 an API key or MCP token is scoped out.");
     log.dim(`  Sign in with ${c.cyan("genex auth")} and re-run.`);
-    return true;
+    return { stop: true, refusal };
   }
   if (res.status === 403 && body.error === "project_owner_required") {
     log.error("  A benchmark is billed to a project YOU own, and this one isn't yours.");
-    return true;
+    return { stop: true, refusal };
   }
   if (res.status === 402) {
     log.error("  Not enough coin to start the attempt.");
-    return true;
+    return { stop: true, refusal };
   }
   log.error(
     `  Sample ${index + 1} was refused: ${body.message ?? body.error ?? `HTTP ${res.status}`}${settledSoFar > 0 ? " (earlier samples still count)" : ""}`
   );
-  return res.status >= 500 || res.status === 401 || res.status === 403;
+  return { stop: res.status >= 500 || res.status === 401 || res.status === 403, refusal };
+}
+function printProviderRefusal(log, status2, message, awaitingBill = false) {
+  if (awaitingBill) log.dim(`      The provider answered ${status2} after routing \u2014 its bill is not final, so this call's coin stays held until it resolves (see \`genex llm status\`); it is not a sample.`);
+  else log.dim("      The provider refused this call at its door \u2014 no inference ran, it cost nothing, and it is not a sample.");
+  if (message) log.dim(`      Provider said: ${message}`);
+  if (status2 === 401 || status2 === 403) {
+    log.dim(`      A ${status2} here is this stand's provider configuration refusing the model \u2014 a message for the operator, not something to fix in the game.`);
+  }
+}
+async function readSlotCounts(call, base) {
+  const res = await call(`${base}?scope=open`).catch(() => null);
+  if (!res?.ok) return null;
+  const body = await res.json().catch(() => null);
+  return serverSlotCounts(body);
 }
 async function pollSettled(call, url, timeoutSec) {
   const deadline = Date.now() + timeoutSec * 1e3;
@@ -23820,6 +23950,7 @@ function emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCoi
     balanceBefore: null,
     balanceAfter: null,
     results: [],
+    refusal: null,
     chargedCoins: { p50: null, p95: null, max: null },
     recommendedDeclaredHeadroomBps: null,
     recommendedEstimateCoins: null,
@@ -23827,6 +23958,166 @@ function emptyBenchJson(apiUrl, projectId, prompt, outputFormat, samples, maxCoi
     savedTo: null
   };
 }
+async function reportStatus(args) {
+  const { apiUrl, token, projectId, opts, log } = args;
+  const call = (url, init2) => apiFetch(url, { ...init2, headers: { Authorization: `Bearer ${token}`, ...init2?.headers ?? {} } });
+  const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
+  const res = await call(`${base}?scope=open`).catch(() => null);
+  if (!res || !res.ok) {
+    if (res && printedStructuredError(res)) {
+      if (opts.json) writeJsonLine(statusJson(apiUrl, projectId, "failed", `http_${res.status}`, [], null, null));
+      process.exitCode = 1;
+      return;
+    }
+    const body2 = res ? await res.json().catch(() => ({})) : {};
+    const error = body2.error ?? (res ? `http_${res.status}` : "unreachable");
+    if (opts.json) {
+      writeJsonLine(statusJson(apiUrl, projectId, res?.status === 404 && body2.error === "not_found" ? "off" : "failed", error, [], null, null));
+      if (!(res?.status === 404 && body2.error === "not_found")) process.exitCode = 1;
+      return;
+    }
+    if (res?.status === 404 && body2.error === "not_found") {
+      log.plain(LLM_LANE_OFF_LINE);
+      return;
+    }
+    if (res?.status === 403 && body2.error === "credential_scope") {
+      log.error("  This credential can't reach the runtime lane \u2014 an API key or MCP token is scoped out.");
+      log.dim(`  Sign in with ${c.cyan("genex auth")} and re-run.`);
+    } else if (res?.status === 403 && body2.error === "project_owner_required") {
+      log.error("  Development calls belong to a project YOU own, and this one isn't yours.");
+    } else if (!res) {
+      log.error(`  Couldn't reach ${apiUrl}.`);
+      log.dim(`  Check the network, then ${c.cyan("genex doctor")}.`);
+    } else {
+      log.error(`  Couldn't read the open calls: ${error}.`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const body = await res.json().catch(() => null);
+  if (!body || !Array.isArray(body.generations)) {
+    if (opts.json) writeJsonLine(statusJson(apiUrl, projectId, "failed", "unreadable_response", [], null, null));
+    else log.error(`  ${apiUrl} answered, but not with a list of calls.`);
+    process.exitCode = 1;
+    return;
+  }
+  const rows = body.generations;
+  const counts = serverSlotCounts(body);
+  if (opts.json) {
+    writeJsonLine(statusJson(apiUrl, projectId, "ok", null, rows, counts?.held ?? null, counts?.limit ?? null));
+    return;
+  }
+  log.plain(c.bold("genex llm status"));
+  log.dim(`  ${apiUrl} \xB7 project ${projectId}`);
+  log.plain("");
+  if (rows.length === 0) {
+    log.plain("  No open calls in this project \u2014 nothing active, nothing awaiting a bill.");
+  } else {
+    const now = Date.now();
+    for (const row of rows) {
+      const state = rowState(row);
+      const mark = state === "active" ? c.cyan("\u25CF") : state === "awaiting bill" ? c.yellow("\u25D0") : c.green("\u25CB");
+      const reserved = typeof row.reservedCoins === "number" ? `${row.reservedCoins} coin reserved` : "reserved \u2014";
+      log.plain(
+        `  ${mark} ${row.id ?? "?"}  ${row.modelId ?? "?"}  ${state.padEnd(13)}  ${formatAge(row.createdAt, now).padStart(4)} old  ${reserved}${row.error ? `  ${row.error}` : ""}${rowHoldsSlot(row) ? "" : c.dim("  (no slot)")}`
+      );
+      if (row.providerMessage?.trim()) log.dim(`      Provider said: ${row.providerMessage.trim()}`);
+    }
+  }
+  log.plain("");
+  log.dim(`  ${LLM_STATUS_LEGEND}`);
+  if (counts === null) {
+    log.dim(`  ${LLM_STATUS_NO_COUNT_LINE}`);
+    return;
+  }
+  log.plain(`  ${counts.held} of ${counts.limit} slots held${counts.held > rows.filter(rowHoldsSlot).length ? " \u2014 across every project, this one's rows included" : ""}`);
+  if (counts.held >= counts.limit) {
+    log.dim(`  Every slot is held, so a new ad-hoc call answers generation_limit until one frees: ${c.cyan("genex llm cancel <id>")} stops an active one; a stopped one frees on its own.`);
+  }
+}
+function statusJson(apiUrl, projectId, status2, error, rows, slotsHeld, slotLimit) {
+  return {
+    command: "llm status",
+    status: status2,
+    error,
+    apiUrl,
+    projectId,
+    // Every row verbatim, plus the CLI's own reading of it — so a program
+    // gets both the server's fields and the three words a person sees.
+    generations: rows.map((row) => ({ ...row, state: rowState(row), holdsSlot: rowHoldsSlot(row) })),
+    slotsHeld,
+    slotLimit,
+    pendingSlotReleaseMinutes: PENDING_SLOT_RELEASE_MINUTES
+  };
+}
+async function cancelCall(args) {
+  const { apiUrl, token, projectId, id, opts, log } = args;
+  const call = (url, init2) => apiFetch(url, { ...init2, headers: { Authorization: `Bearer ${token}`, ...init2?.headers ?? {} } });
+  const base = `${apiUrl}/api/runtime/development/projects/${encodeURIComponent(projectId)}/generations`;
+  const rowUrl = `${base}/${encodeURIComponent(id)}`;
+  const done = (status2, error, reason, row2) => {
+    if (opts.json) writeJsonLine({ command: "llm cancel", status: status2, error, id, cancelled: reason === "cancelled", reason, generation: row2 });
+    if (status2 === "failed") process.exitCode = 1;
+  };
+  const read = await call(rowUrl).catch(() => null);
+  if (!read || !read.ok) {
+    if (read && printedStructuredError(read)) return done("failed", `http_${read.status}`, null, null);
+    const body = read ? await read.json().catch(() => ({})) : {};
+    const error = body.error ?? (read ? `http_${read.status}` : "unreachable");
+    if (!opts.json) {
+      if (read?.status === 404) {
+        log.error(`  No call ${id} in this project \u2014 ${c.cyan("genex llm status")} lists the open ones.`);
+      } else if (read?.status === 403 && body.error === "credential_scope") {
+        log.error("  This credential can't reach the runtime lane \u2014 an API key or MCP token is scoped out.");
+        log.dim(`  Sign in with ${c.cyan("genex auth")} and re-run.`);
+      } else if (!read) {
+        log.error(`  Couldn't reach ${apiUrl}.`);
+      } else {
+        log.error(`  Couldn't read call ${id}: ${error}.`);
+      }
+    }
+    return done("failed", error, null, null);
+  }
+  const row = await read.json().catch(() => null);
+  if (!row?.id) {
+    if (!opts.json) log.error(`  ${apiUrl} answered, but not with a call.`);
+    return done("failed", "unreadable_response", null, null);
+  }
+  const state = rowState(row);
+  if (state !== "active") {
+    const sentence = state === "awaiting bill" ? LLM_CANCEL_AWAITING_BILL : LLM_CANCEL_ALREADY_FINAL;
+    if (!opts.json) {
+      log.warn(`  ${row.id} (${row.status ?? "?"}) \u2014 ${sentence}.`);
+      if (state === "awaiting bill") {
+        log.dim(`  Nothing to cancel: its coin releases when the bill resolves, and it stops holding a slot ${PENDING_SLOT_RELEASE_MINUTES} minutes after dispatch.`);
+        if (row.providerMessage?.trim()) log.dim(`  Provider said: ${row.providerMessage.trim()}`);
+      } else {
+        log.dim(`  ${typeof row.chargedCoins === "number" ? `${row.chargedCoins} coin charged` : "charge unknown"}${row.error ? ` \xB7 ${row.error}` : ""}.`);
+      }
+    }
+    return done("ok", null, state === "awaiting bill" ? "awaiting_bill" : "already_final", row);
+  }
+  const res = await call(`${rowUrl}/cancel`, { method: "POST" }).catch(() => null);
+  if (!res || !res.ok) {
+    if (res && printedStructuredError(res)) return done("failed", `http_${res.status}`, null, row);
+    const body = res ? await res.json().catch(() => ({})) : {};
+    const error = body.error ?? (res ? `http_${res.status}` : "unreachable");
+    if (!opts.json) {
+      if (res?.status === 409 && body.error === "already_dispatched") {
+        log.error(`  ${row.id} is already running at the provider and cannot be cancelled now; it settles on its own \u2014 ${c.cyan("genex llm status")} shows it.`);
+      } else {
+        log.error(`  Couldn't cancel ${row.id}: ${error}.`);
+      }
+    }
+    return done("failed", error, null, row);
+  }
+  const after = await res.json().catch(() => null) ?? row;
+  if (!opts.json) {
+    log.success(`  Cancelled ${row.id} (was ${row.status ?? "active"}).`);
+    log.dim(`  Its coin releases once the bill settles; ${c.cyan("genex llm status")} shows it until then.`);
+  }
+  return done("ok", null, "cancelled", after);
+}
 async function reportSavedPrice(cwd, opts, log) {
   let record = null;
   try {
@@ -24139,10 +24430,11 @@ function runtimeRow(state, lane, toolsOnly = false) {
   switch (lane?.state) {
     case "live": {
       const n = lane.models?.length ?? 0;
+      const keyRefused = lane.providerKey === "rejected";
       return {
         label: "Runtime",
-        value: `in-game LLM lane live \xB7 ${n} model${n === 1 ? "" : "s"}`,
-        fix: toolsOnly ? convertFix : 'Price a call before a game declares one: `npx genex llm bench "<prompt>" --max-coins <n> --user-approved`.'
+        value: `in-game LLM lane live \xB7 ${n} model${n === 1 ? "" : "s"}${keyRefused ? ` \xB7 ${c.yellow("provider key refused")}` : ""}`,
+        fix: keyRefused ? LLM_PROVIDER_KEY_REJECTED_LINE : toolsOnly ? convertFix : 'Price a call before a game declares one: `npx genex llm bench "<prompt>" --max-coins <n> --user-approved`.'
       };
     }
     case "off":
@@ -26076,17 +26368,20 @@ ${c.bold("Usage")}
                                      the asset table against it. --assets <credits>
                                      --user-approved raises it, only once the player
                                      has agreed to the number.
-  genex llm <sub> [options]          In-game model calls: models | bench | price.
-                                     "models" says whether this stand serves the
-                                     runtime LLM lane at all, and at what provider
-                                     rates. "bench" runs the real model on YOUR OWN
-                                     coin and reports what each attempt was charged;
-                                     it needs --max-coins <n> --user-approved, like
-                                     any spend the player has to agree to. "price"
-                                     reprints the last run's recommended
-                                     estimateCoins. Declare a game's price from a
-                                     bench, never from a guess: a started attempt is
-                                     charged in full, including one that fails.
+  genex llm <sub> [options]          In-game model calls: models | bench | price |
+                                     status | cancel. "models" says whether this
+                                     stand serves the runtime LLM lane at all, and
+                                     at what provider rates. "bench" runs the real
+                                     model on YOUR OWN coin and reports what each
+                                     attempt was charged; it needs --max-coins <n>
+                                     --user-approved, like any spend the player has
+                                     to agree to. "price" reprints the last run's
+                                     recommended estimateCoins. "status" lists this
+                                     project's open calls and the slots they hold;
+                                     "cancel <id>" stops an active one. Declare a
+                                     game's price from a bench, never from a guess:
+                                     a started attempt is charged in full, including
+                                     one that fails.
   genex player <sub> [options]       Answer the in-game model requests you approve, on your
                                      OWN Claude or ChatGPT subscription: install | run |
                                      status | stop | uninstall. "install" signs this machine
@@ -26520,8 +26815,11 @@ ${c.bold("Examples")}
   genex shop test sku_123
   genex shop remove sku_123
   genex llm models
+  genex llm models --all
   genex llm bench "Reply with one short taunt." --samples 5 --max-coins 20 --user-approved
   genex llm price
+  genex llm status
+  genex llm cancel <id>
   genex player install
   genex player status --json
   genex player uninstall
@@ -26758,11 +27056,13 @@ ${c.bold("How the allowance works")}
   llm: `${c.bold("genex llm")} \u2014 in-game model calls: is the lane live, what does one call cost, what should the game declare?
 
 ${c.bold("Usage")}
-  genex llm models [--json]          Which models this stand serves, their provider rates per
+  genex llm models [--all] [--json]  Which models this stand serves, their provider rates per
                                      million tokens, and the headroom it recommends over a
-                                     benchmark. Off on this stand: it says so and exits 0 \u2014
-                                     build the feature without a model rather than promising
-                                     a 404.
+                                     benchmark. The catalog is synced from OpenRouter, so the
+                                     FEATURED short list is printed by default and --all
+                                     prints every row (--json always carries every row). Off
+                                     on this stand: it says so and exits 0 \u2014 build the feature
+                                     without a model rather than promising a 404.
   genex llm bench "<prompt>" --max-coins <n> --user-approved [options]
                                      Run the real model <n> times through the development
                                      lane and report what each attempt was CHARGED. Refused
@@ -26771,6 +27071,14 @@ ${c.bold("Usage")}
                                      cannot see. Needs a folder linked to a game you own.
   genex llm price [--json]           The recommendation from the last bench in this folder.
                                      Reads a file; spends nothing.
+  genex llm status [--json]          This project's open development calls: active, or
+                                     stopped but awaiting the provider's bill \u2014 with the
+                                     provider's own message when it refused one \u2014 and
+                                     how many of the ad-hoc slots they hold. A bench
+                                     refused as generation_limit sends you here.
+  genex llm cancel <id> [--json]     Stop one ACTIVE call. A call that already stopped
+                                     is reported as such: awaiting its bill (the hold
+                                     resolves on its own) or already final.
 
 ${c.bold("Bench options")}
   --model <id>         One of the ids \`genex llm models\` prints (default: the first one).
@@ -27280,7 +27588,11 @@ function parseArgs(argv) {
             (parsed.options.selectors ??= []).push(arg);
           }
         } else if (parsed.command === "llm") {
-          parsed.options.benchPrompt = parsed.options.benchPrompt ? `${parsed.options.benchPrompt} ${arg}` : arg;
+          if (parsed.options.name === "cancel" && parsed.options.generationId === void 0) {
+            parsed.options.generationId = arg;
+          } else {
+            parsed.options.benchPrompt = parsed.options.benchPrompt ? `${parsed.options.benchPrompt} ${arg}` : arg;
+          }
         } else if (parsed.command === "shop") {
           if (!parsed.options.hostname) parsed.options.hostname = arg;
           else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genex-ai/cli-demo",
-  "version": "1.35.0-dev.741",
+  "version": "1.35.0-dev.743",
   "description": "Set up your project's agent workspace (.claude/.codex/.cursor in the game folder), authorize, create a game project, generate AI assets, and publish (genex CLI).",
   "type": "module",
   "bin": {

package/templates/skills/genex-llm-in-games/SKILL.md

@@ -31,24 +31,36 @@ or two per session means a grant.
 npx genex llm models
 ```
 
-- **live** — it prints the models this stand serves. Build the feature.
+- **live** — it prints the FEATURED models this stand serves, and how many more
+  there are. Build the feature.
 - **off on this stand** — the routes answer 404. Build the feature behind a
   graceful `unavailable` state (the NPC uses its authored lines, the quest falls
   back to the written one) and **say so plainly in the handoff**. Never promise
   the player something that 404s.
 - **misconfigured** — say that too; it is an operator fix, not a game bug.
 
+The stand's catalog is synced and filtered, so it can hold far more rows than
+anyone wants to read. **Offer the featured set. Run `npx genex llm models --all`
+only when the user asks for more**, and put the full list in front of them
+rather than picking an obscure row for them.
+
 Model ids come from that command and from `getGenerationModels()` at runtime.
 Never write one into the game's source: they differ per stand, and a hardcoded
-id is a feature that dies on somebody else's environment.
+id is a feature that dies on somebody else's environment. **A picker's label
+must be the model's own `label`** — a name you invent for a row ("Fast", "Smart")
+is a label that differs from the model the player is billed for.
 
 ## The SDK surface (exact — do not invent methods)
 
 From `@genex-ai/embed-sdk`, already installed. `initEmbed()` must have run and
 identity must be resolved first — `$genex-threejs-embed-auth`.
 
-- `getGenerationModels()` — the models this stand serves. Any picker renders
-  from this, never from a list you wrote.
+- `getGenerationModels()` — `{ models, featuredCount, … }`, featured first. Any
+  picker renders from this, never from a list you wrote: show the rows where
+  `featured` is true (or all of them when `featuredCount` is 0) and offer the
+  rest only if the player asks. Each row carries `label`, `vendor`,
+  `contextLength`, `personalPlan` and `structuredOutputs`; render `label`
+  verbatim, so the name on screen is the model that gets billed.
 - `generate({ modelId, prompt, outputFormat, schema?, estimateCoins,
   allowExternal?, idempotencyKey?, grantId?, timeoutMs? })` →
   `{ status, generationId, output, source, error }` plus billing fields
@@ -108,6 +120,41 @@ the price and makes `requestSpendGrant()` refuse before it reaches the network.
 loop into disclosure numbers, re-benchmarking after a prompt change — is in
 [references/pricing.md](references/pricing.md).
 
+Only samples that **succeeded and settled** are priced from. A sample the
+provider refused at its door (`provider_http_<status>`) ran no inference and
+cost nothing; the bench prints the code, the provider's own message and, for a
+401 or 403, that this is the stand's provider configuration refusing the model
+— an operator's problem, never something to fix in the game. A sample refused
+as `generation_limit` never started: you already have the lane's three ad-hoc
+calls open, or recently stopped with their bill still pending. The bench says
+how many slots are held and stops. Do not re-run it into the same refusal —
+read `npx genex llm status`, then wait for a bill to resolve or
+`npx genex llm cancel <id>` an active call.
+
+```bash
+npx genex llm status        # this project's open calls: active, or awaiting their bill; N of 3 slots held
+npx genex llm cancel <id>   # stop an ACTIVE call; a stopped one is reported, not cancelled
+```
+
+## The schema dialect (exact — anything else is refused)
+
+`schema` is validated by the platform before the call, and a refused schema is
+`invalid_schema` at the door — nothing is charged, nothing runs. The accepted
+subset, and it is the whole subset:
+
+- `type`: `object`, `array`, `string`, `number`, `integer`, `boolean`, `null`
+- objects: `properties`, `required`, and `additionalProperties: false` on
+  **every** object (required, not optional)
+- arrays: `items`
+- `enum` (strings, numbers, booleans, `null`)
+- `minimum` / `maximum`, `minLength` / `maxLength`, `minItems` / `maxItems`
+- `description` and `title`, on any node
+
+Everything else is refused, including `$schema`, `default`, `examples`,
+`pattern`, `format`, `anyOf` / `oneOf` / `allOf` and `$ref`. Keep the schema
+in one file (`./answer.schema.json`), benchmark with that file, and ship the
+same object — a schema that passed the bench passes the game.
+
 ## Standing budgets
 
 ```ts
@@ -183,7 +230,9 @@ There is no compensation lane, so this is all work you do before the call:
 
 - **Validate inputs first** — a malformed prompt is still charged.
 - **Always set `schema` for `outputFormat: 'json'`** — unschema'd JSON is the
-  commonest way a call is charged and the result is unusable.
+  commonest way a call is charged and the result is unusable. Write it in the
+  accepted dialect above; a refused schema is `invalid_schema` and costs
+  nothing, but it is a feature that never runs.
 - **Keep prompts short.** Long context is the price.
 - **Never loop `generate()` without a grant**, and never retry in a loop — each
   attempt is a separate charge.
@@ -222,7 +271,10 @@ These are source contracts, not a claim that every stand runs this lane —
 
 - [ ] `npx genex llm models` was run and its verdict is in the handoff
 - [ ] Model ids come from `getGenerationModels()`, never from source
+- [ ] The picker offers the featured set, labelled with the server's own `label`
 - [ ] `estimateCoins` came from `npx genex llm bench`, not from judgement
+- [ ] The schema uses only the accepted dialect (no `$ref`, `pattern`, `format`, `anyOf`, `default`)
+- [ ] A bench refused as `generation_limit` was answered with `npx genex llm status`, never a retry
 - [ ] `generate()` / `requestSpendGrant()` is the first statement of a click handler
 - [ ] A repeated-call feature uses a grant; a one-off uses `generate()`
 - [ ] Disclosure numbers derive from the real loop and are written in `DESIGN.md`
@@ -256,6 +308,25 @@ cause rather than showing it for both.
 **`grant_price_unreasonable`** — the declared per-call price is far above what
 that prompt can cost on that model. Re-benchmark and declare what it prints.
 
+**`generation_limit`** — three ad-hoc calls are already in flight for this
+account, or recently stopped with their bill still pending; a pending call
+stops counting ten minutes after it was dispatched. From the bench: run
+`npx genex llm status`, then wait or `npx genex llm cancel <id>` an active one —
+never re-run into the same refusal. In the game: the player is clicking faster
+than one-off calls are meant for, which is the signal that this feature wants a
+grant.
+
+**`provider_http_<status>`** — the provider refused the call at its door, before
+any inference: it cost nothing and is not a sample. Read the provider's own
+message (`npx genex llm status` prints it under the row). A 401 or 403 is this
+stand's provider configuration refusing the model — tell the operator, and
+build nothing around it in the game.
+
+**`invalid_schema`** — the schema uses a keyword outside the accepted dialect
+(`$ref`, `pattern`, `format`, `anyOf`, `default`, `examples`, `$schema`), or an
+object without `additionalProperties: false`. Nothing was charged. Rewrite it in
+the subset above; `description` and `title` are allowed.
+
 **`grant_concurrency` / `grant_rate_limited`** — the game calls faster than the
 grant's own limits. Batch and cache; do not raise the limits to hide it.
 

package/templates/skills/genex-llm-in-games/references/pricing.md

@@ -49,7 +49,19 @@ npx genex llm bench "<the frozen prompt, one real example filled in>" \
 ## 3. Read the output
 
 Each sample prints what it actually charged. The aggregate prints p50, p95 and
-max of the charged coins, plus one recommendation.
+max of the charged coins **over the samples that succeeded and settled**, plus
+one recommendation. A sample that failed is printed with its code and stays
+out of the numbers; a sample the provider refused at its door
+(`provider_http_<status>`) ran no inference, cost nothing, and prints the
+provider's own message under its row — on a 401 or 403 that is the stand's
+provider configuration refusing the model, which is the operator's to fix. A
+sample refused as `generation_limit` never started and ends the run: the
+account's three ad-hoc calls are open or recently stopped with a pending
+bill. `npx genex llm status` lists them with what each holds;
+`npx genex llm cancel <id>` stops an active one; a stopped one frees on its
+own once its bill resolves, and stops holding a slot ten minutes after
+dispatch. Re-running the bench into the same refusal spends nothing and
+learns nothing.
 
 - **p50** is what a typical call costs. It is the number to reason about when
   you ask "can the game afford this loop?" — multiply it by the calls per

package/templates/skills/genex-tool-llm/SKILL.md

@@ -53,7 +53,11 @@ expand the offer into a pitch — one line, one question.
    which models. It answers in this folder as it is, before anything is
    converted, so it comes first: if it says the lane is off, in-game calls
    answer 404 here — tell the user so plainly, build the graceful fallback, and
-   do not convert a folder for a feature the stand does not serve.
+   do not convert a folder for a feature the stand does not serve. It prints
+   the FEATURED models; `--all` lists the whole catalog, and you run that only
+   when the user asks for more. Whatever they pick, the picker in the game
+   shows the server's own label for it — a name you invent is a name that
+   differs from the model they are billed for.
 2. `npx genex init --convert` — it connects this folder to a hosted Genex game
    in place. The code, the files and this toolkit stay exactly as they are, and
    generations still land in `./assets`. It is the user's yes that runs it, so