@m8t-stack/cli 0.2.37 → 0.2.38

package/dist/cli.js

@@ -1298,7 +1298,7 @@ var init_enable_hosted_brain = __esm({
 import { Builtins, Cli } from "clipanion";
 
 // src/lib/package-version.ts
-var CLI_VERSION = "0.2.37";
+var CLI_VERSION = "0.2.38";
 
 // src/lib/render-error.ts
 init_errors();
@@ -16963,7 +16963,7 @@ async function listModelQuota(region) {
 function usageModelName(usageName) {
   return usageName.split(".").slice(2).join(".");
 }
-var REASONING_USAGE_RE = /gpt-5|o[1-9]/i;
+var REASONING_USAGE_RE = /gpt-5|o[1-9]|grok-4/i;
 function isReasoningModel(modelDeployment) {
   return REASONING_USAGE_RE.test(modelDeployment);
 }
@@ -25476,7 +25476,7 @@ async function ensureDeployment(args) {
     "--model-version",
     args.modelVersion,
     "--model-format",
-    "OpenAI",
+    args.format ?? "OpenAI",
     "--sku-name",
     "GlobalStandard",
     "--sku-capacity",
@@ -27466,6 +27466,7 @@ async function deploySimpleStacey(args) {
       repoRoot: args.repoRoot,
       persona: SIMPLE_STACEY_PERSONA,
       agentName: SIMPLE_STACEY_AGENT,
+      model: args.model,
       fieldOverrides: args.fieldOverrides
     });
   } catch (e) {
@@ -27534,6 +27535,7 @@ async function deploySimpleStaceyWithRetry(args) {
         credential: args.credential,
         endpoint: args.endpoint,
         repoRoot: args.repoRoot,
+        model: args.model,
         fieldOverrides: args.fieldOverrides
       });
     } catch (error) {
@@ -27930,6 +27932,257 @@ function stopOnboardingUi(home = os17.homedir()) {
   return uiStopped || relayStopped;
 }
 
+// src/lib/model-catalog.ts
+async function listAgentModels(region) {
+  let out;
+  try {
+    out = await runAz(["cognitiveservices", "model", "list", "-l", region, "--output", "json"]);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const denied = /AuthorizationFailed|Forbidden|\b403\b|does not have authorization/i.test(msg);
+    return { ok: false, error: denied ? "denied" : "unavailable" };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(out);
+  } catch {
+    return { ok: false, error: "malformed" };
+  }
+  if (!Array.isArray(raw) || raw.some((e) => typeof e !== "object" || e === null)) {
+    return { ok: false, error: "malformed" };
+  }
+  try {
+    const rows = raw.map((e) => ({
+      format: e.model?.format ?? "",
+      name: e.model?.name ?? "",
+      version: e.model?.version ?? "",
+      skus: [...new Set((e.model?.skus ?? []).map((s) => s.name ?? "").filter(Boolean))],
+      agentsV2: e.model?.capabilities?.agentsV2 === "true"
+    }));
+    return { ok: true, rows };
+  } catch {
+    return { ok: false, error: "malformed" };
+  }
+}
+
+// src/lib/model-cascade.ts
+var WHITELIST = [
+  { model: "gpt-5.6-luna", format: "OpenAI", version: "2026-07-09", capacity: 100 },
+  { model: "gpt-5.6-sol", format: "OpenAI", version: "2026-07-09", capacity: 100 },
+  { model: "gpt-5.6-terra", format: "OpenAI", version: "2026-07-09", capacity: 100 },
+  { model: "gpt-5.4", format: "OpenAI", version: "2026-03-05", capacity: 100 },
+  { model: "grok-4.3", format: "xAI", version: "1", capacity: 100 },
+  { model: "gpt-4.1-mini", format: "OpenAI", version: "2025-04-14", capacity: 50 }
+];
+var GLOBAL_STANDARD = "GlobalStandard";
+function planCascade(whitelist, catalog, quota) {
+  if (!catalog.ok) {
+    return {
+      candidates: [],
+      skipped: whitelist.map((r) => ({ model: r.model, outcome: "catalog-unverified", detail: catalog.error }))
+    };
+  }
+  const rowsByName = /* @__PURE__ */ new Map();
+  for (const row of catalog.rows) {
+    const list = rowsByName.get(row.name);
+    if (list) list.push(row);
+    else rowsByName.set(row.name, [row]);
+  }
+  const candidates = [];
+  const skipped = [];
+  for (const rung of whitelist) {
+    const rows = rowsByName.get(rung.model);
+    if (!rows || rows.length === 0) {
+      skipped.push({ model: rung.model, outcome: "not-in-catalog" });
+      continue;
+    }
+    const agentRows = rows.filter((r) => r.agentsV2);
+    if (agentRows.length === 0) {
+      skipped.push({ model: rung.model, outcome: "not-agent-eligible" });
+      continue;
+    }
+    if (!agentRows.some((r) => r.skus.includes(GLOBAL_STANDARD))) {
+      skipped.push({ model: rung.model, outcome: "no-global-standard" });
+      continue;
+    }
+    if (modelQuotaVerdict(quota, rung.model).verdict === "no_quota") {
+      skipped.push({ model: rung.model, outcome: "no-quota" });
+      continue;
+    }
+    candidates.push(rung);
+  }
+  return { candidates, skipped };
+}
+var QUOTA_RE = /insufficient\s*quota|not enough quota|quota limit|quota\b[^.]{0,40}exceed|exceed\w*\b[^.]{0,40}quota|capacity[^.]{0,40}exceed|exceed\w*\b[^.]{0,40}capacity/i;
+var REGION_RE = /not available in|not supported in|NotAvailableInRegion|InvalidResourceLocation/i;
+var CONFLICT_RE = /\bconflict\b|\b409\b/i;
+function classifyDeployError(message) {
+  if (QUOTA_RE.test(message)) return "deploy-rejected-quota";
+  if (REGION_RE.test(message)) return "deploy-rejected-region";
+  return "deploy-unverified";
+}
+async function walkCascade(whitelist, plan, deploy, opts) {
+  const outcomes = /* @__PURE__ */ new Map();
+  for (const s of plan.skipped) outcomes.set(s.model, s);
+  let chosen = null;
+  let aborted = false;
+  for (const rung of plan.candidates) {
+    if (chosen) break;
+    if (opts.now() >= opts.deadlineAt) {
+      aborted = true;
+      break;
+    }
+    let row;
+    try {
+      await deploy(rung);
+      row = { model: rung.model, outcome: "deployed" };
+      chosen = rung;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (CONFLICT_RE.test(msg)) {
+        try {
+          await deploy(rung);
+          row = { model: rung.model, outcome: "deployed" };
+          chosen = rung;
+        } catch (e2) {
+          const msg2 = e2 instanceof Error ? e2.message : String(e2);
+          row = {
+            model: rung.model,
+            outcome: CONFLICT_RE.test(msg2) ? "deploy-unverified" : classifyDeployError(msg2),
+            detail: msg2
+          };
+        }
+      } else {
+        row = { model: rung.model, outcome: classifyDeployError(msg), detail: msg };
+      }
+    }
+    outcomes.set(rung.model, row);
+    opts.onRung?.(row.model, row.outcome);
+  }
+  const trace = whitelist.map(
+    (r) => outcomes.get(r.model) ?? { model: r.model, outcome: aborted ? "aborted-deadline" : "not-reached" }
+  );
+  return { chosen, trace };
+}
+var CERTAIN_UNAVAILABLE = /* @__PURE__ */ new Set([
+  "not-in-catalog",
+  "not-agent-eligible",
+  "no-global-standard",
+  "deploy-rejected-region"
+]);
+var QUOTA_BLOCKED = /* @__PURE__ */ new Set(["no-quota", "deploy-rejected-quota"]);
+function decideNote(whitelist, result) {
+  const chosenIdx = result.chosen ? whitelist.findIndex((r) => r.model === result.chosen?.model) : whitelist.length;
+  const better = result.trace.slice(0, Math.max(chosenIdx, 0));
+  const runningModel = result.chosen?.model ?? null;
+  if (chosenIdx === 0) {
+    return { status: "top", runningModel, pitchModel: null, unavailableAbovePitch: [] };
+  }
+  const pitch = better.find((t) => QUOTA_BLOCKED.has(t.outcome));
+  if (pitch) {
+    const pitchIdx = better.findIndex((t) => t.model === pitch.model);
+    return {
+      status: "lesser-quota",
+      runningModel,
+      pitchModel: pitch.model,
+      unavailableAbovePitch: better.slice(0, pitchIdx).filter((t) => CERTAIN_UNAVAILABLE.has(t.outcome)).map((t) => t.model)
+    };
+  }
+  const allCertain = better.length > 0 && better.every((t) => CERTAIN_UNAVAILABLE.has(t.outcome));
+  return {
+    status: allCertain ? "lesser-unavailable" : "lesser-unverified",
+    runningModel,
+    pitchModel: null,
+    unavailableAbovePitch: []
+  };
+}
+var listNames = (names) => names.length <= 1 ? names[0] ?? "" : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+function renderChosenModelNote(d) {
+  const subject = d.runningModel ? `You are running on ${d.runningModel}.` : "You are running on this install's default model.";
+  switch (d.status) {
+    case "top":
+      return `${subject} That is the best available model for this install.`;
+    case "lesser-quota": {
+      const aside = d.unavailableAbovePitch.length > 0 ? ` ${listNames(d.unavailableAbovePitch)} ${d.unavailableAbovePitch.length > 1 ? "are" : "is"} not offered for this install.` : "";
+      return `${subject} A stronger model, ${d.pitchModel ?? ""}, is offered here, but this subscription has no quota for it.${aside} You can offer to help request that quota.`;
+    }
+    case "lesser-unavailable":
+      return `${subject} No stronger model is offered for this install right now.`;
+    case "lesser-unverified":
+      return `${subject} It was not possible to check which stronger models this subscription can run, so do not make claims about what is or is not available.`;
+  }
+}
+
+// src/lib/intake-model.ts
+var DEFAULT_DEADLINE_MS = 18e4;
+var SCOPE_RE = /\/resourceGroups\/([^/]+)\/providers\/Microsoft\.CognitiveServices\/accounts\/([^/]+)/i;
+function parseAccountScope(scope) {
+  const m = SCOPE_RE.exec(scope);
+  return m ? { resourceGroup: m[1], account: m[2] } : null;
+}
+function narrate(model, outcome, region) {
+  if (outcome === "deployed") return `${model} - ready`;
+  return `${model} - not available for your subscription in ${region}`;
+}
+async function accountRegion(account, resourceGroup, fallback) {
+  try {
+    const out = await runAz([
+      "cognitiveservices",
+      "account",
+      "show",
+      "--name",
+      account,
+      "--resource-group",
+      resourceGroup,
+      "--query",
+      "location",
+      "-o",
+      "tsv"
+    ]);
+    return out.trim() || fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function resolveIntakeModel(args) {
+  const floorTrace = (outcome, detail) => WHITELIST.map((r) => ({ model: r.model, outcome, ...detail === void 0 ? {} : { detail } }));
+  const degradeToFloor = (detail) => {
+    const trace = floorTrace("catalog-unverified", detail);
+    return { model: void 0, note: renderChosenModelNote(decideNote(WHITELIST, { chosen: null, trace })), trace };
+  };
+  const parsed = parseAccountScope(args.accountScope);
+  if (!parsed) return degradeToFloor(`unparseable account scope: ${args.accountScope}`);
+  try {
+    const region = await accountRegion(parsed.account, parsed.resourceGroup, args.fallbackRegion);
+    args.onNarrate?.("choosing the best model your subscription can run...");
+    const [catalog, quota] = await Promise.all([listAgentModels(region), listModelQuota(region)]);
+    const plan = planCascade(WHITELIST, catalog, quota);
+    const deploy = async (rung) => {
+      await ensureDeployment({
+        account: parsed.account,
+        resourceGroup: parsed.resourceGroup,
+        model: rung.model,
+        modelVersion: rung.version,
+        capacity: rung.capacity,
+        format: rung.format
+      });
+    };
+    const start = Date.now();
+    const result = await walkCascade(WHITELIST, plan, deploy, {
+      now: () => Date.now(),
+      deadlineAt: start + (args.deadlineMs ?? DEFAULT_DEADLINE_MS),
+      onRung: (model, outcome) => args.onNarrate?.(narrate(model, outcome, region))
+    });
+    return {
+      model: result.chosen?.model,
+      note: renderChosenModelNote(decideNote(WHITELIST, result)),
+      trace: result.trace
+    };
+  } catch (e) {
+    return degradeToFloor(e instanceof Error ? e.message : String(e));
+  }
+}
+
 // src/commands/bootstrap/ui.ts
 function renderDeploySuccess(version, envPath) {
   return `${colors.success("\u2713")} Simple Stacey is live (stacey-intake v${version}).
@@ -28031,13 +28284,24 @@ var BootstrapUiCommand = class extends M8tCommand {
     await ensureFounderFoundryRole({ credential: credential2, subscriptionId: state.subscriptionId, principalId: oid, accountScope });
     const identity = await getSignedInUserIdentity();
     out("deploying Simple Stacey (stacey-intake) in the background...");
-    const deployOutcome = deploySimpleStaceyWithRetry({
-      credential: credential2,
-      endpoint,
-      repoRoot,
-      fieldOverrides: { founder_identity_note: composeFounderIdentityNote(identity) },
-      onWait: out
-    }).then(
+    const deployOutcome = (async () => {
+      const choice = await resolveIntakeModel({
+        accountScope,
+        fallbackRegion: state.location,
+        onNarrate: out
+      });
+      return deploySimpleStaceyWithRetry({
+        credential: credential2,
+        endpoint,
+        repoRoot,
+        model: choice.model,
+        fieldOverrides: {
+          founder_identity_note: composeFounderIdentityNote(identity),
+          chosen_model_note: choice.note
+        },
+        onWait: out
+      });
+    })().then(
       (version) => ({ ok: true, version }),
       (error) => ({ ok: false, error: error instanceof Error ? error : new Error(String(error)) })
     );