@inferall/cli 0.2.1 → 0.2.3

package/README.md

@@ -35,6 +35,12 @@ The wizard:
 
 ## Commands
 
+For a project with no existing AI client, `init` writes a first-request example:
+`node inferall-hello.mjs` or `python3 inferall_hello.py`. Both use built-in
+libraries, read your exported key or the `.env` beside the example, and select
+the free model explicitly. A refusal or empty response exits nonzero and prints
+an explanation to stderr. Existing example files are left intact.
+
 - `init`: the wizard above (default).
 - `doctor`: health-check an existing setup. Key present and valid, `.env`
   gitignore hygiene, whether every client call site points at the gateway, and
@@ -84,3 +90,9 @@ apply, and leaves your code otherwise untouched, with no reformatting and no
 renames.
 
 Zero runtime dependencies. Node 18+.
+
+A live test call succeeds only when it returns usable answer text. `init` and
+`doctor` exit nonzero for refused, malformed, empty or interrupted test calls.
+This includes HTTP 402: any file changes already reported by `init` remain,
+but the call has not been verified. Follow the gateway explanation before
+retrying. `chat` sends gateway failure diagnostics to stderr and answer text to stdout.

package/bin/build-info.json

@@ -1 +1 @@
-{"sha":"2a3e95e","ref":"main","offMain":null}
+{"sha":"8abc047","ref":"main","offMain":null}

package/bin/inferall.js

@@ -981,7 +981,8 @@ async function apiChat(key, messages, model = FREE_MODEL, maxTokens = 512) {
   //
   // Reading the body as text first keeps the distinction, and keeps a snippet
   // so we can quote what actually arrived instead of an empty object.
-  const raw = await res.text().catch(() => "");
+  let readFailed = false;
+  const raw = await res.text().catch(() => { readFailed = true; return ""; });
   let body = {};
   let parseFailed = false;
   if (raw) {
@@ -995,12 +996,100 @@ async function apiChat(key, messages, model = FREE_MODEL, maxTokens = 512) {
     status: res.status,
     body,
     parseFailed,
+    readFailed,
     raw,
     contentType: res.headers.get("content-type") || "",
     retryAfter: res.headers.get("retry-after"),
+    trialUsage: res.headers.get("x-inferall-trial-usage") || "",
+    model,
+    maxTokens,
   };
 }
 
+/**
+ * Did this chat call produce an ANSWER? One verdict shared by `chat`, `doctor`
+ * and `init`, so no command can call a call successful from the status line.
+ *
+ * Success is HTTP 200, a parseable body, and a non-blank string at
+ * choices[0].message.content. Everything else is a failure with a kind:
+ *   unparseable  body is not JSON (HTML page, truncated JSON), any status
+ *   http         parsed body, status other than 200
+ *   length       finish_reason "length" and no usable answer text
+ *   no_answer    200 and JSON, but no usable answer (empty, blank, wrong shape)
+ */
+export function classifyChatResult(reply) {
+  const status = reply?.status;
+  if (reply?.readFailed) return { ok: false, kind: "incomplete", status };
+  if (reply?.parseFailed) return { ok: false, kind: "unparseable", status };
+  if (status !== 200) return { ok: false, kind: "http", status };
+  const choice = reply.body?.choices?.[0];
+  const text = choice?.message?.content;
+  if (typeof text === "string" && text.trim()) return { ok: true, text, status };
+  if (choice?.finish_reason === "length") return { ok: false, kind: "length", status };
+  let reason;
+  if (!(reply.raw || "").trim()) reason = "the response body was empty";
+  else if (!Array.isArray(reply.body?.choices) || !choice) reason = "the response had no choices";
+  else if (text === undefined || text === null) reason = "the message had no content";
+  else if (typeof text !== "string") reason = "the message content was not text";
+  else reason = "the message content was blank";
+  return { ok: false, kind: "no_answer", status, reason };
+}
+
+// One printable line from a provider-supplied string: no newlines, bounded, and
+// never the caller's own key if a gateway echoes it back.
+function safeProviderText(s, key) {
+  let t = String(s).replace(/\s+/g, " ").trim();
+  if (key) t = t.split(key).join("[key]");
+  return t.slice(0, 300);
+}
+
+/**
+ * Plain lines explaining a failed classifyChatResult. Never includes the raw
+ * body, reasoning text or the key. `surface` is "chat" or "probe"; only the
+ * length guidance differs, because init and doctor cannot take --max-tokens.
+ */
+export function chatFailureLines(result, reply, key, surface = "chat") {
+  const status = reply.status;
+  if (result.kind === "incomplete") {
+    return [`HTTP ${status}: the response could not be read completely. This call did not succeed.`];
+  }
+  if (result.kind === "unparseable") {
+    const isHtml = /html/i.test(reply.contentType || "") || /^\s*(?:<!doctype html|<html)/i.test(reply.raw || "");
+    const summary = isHtml ? nonJsonSummary(reply) : "The gateway returned a response that was not valid JSON.";
+    const lines = [safeProviderText(summary, key), `HTTP ${status}. Nothing usable came back, so this call did not succeed.`];
+    if (status >= 500) lines.push("That is an infrastructure error, not a problem with your key. Retry shortly.");
+    return lines;
+  }
+  if (result.kind === "length") {
+    const limit = reply.maxTokens ? ` (max_tokens=${reply.maxTokens})` : "";
+    return [
+      `The model used its whole token budget${limit} before returning any answer text.`,
+      surface === "chat"
+        ? "Retry with a larger --max-tokens, or pick another model with --model."
+        : 'Use npx @inferall/cli chat with --max-tokens to test a larger limit, or --model to choose another model.',
+    ];
+  }
+  if (result.kind === "no_answer") {
+    return [`HTTP 200, but the gateway returned no answer in it (${result.reason}).`];
+  }
+  const err = reply.body?.error;
+  const msg = (typeof err === "string" ? err : typeof err?.message === "string" ? err.message : typeof reply.body?.message === "string" ? reply.body.message : "");
+  const code = typeof err?.code === "string" ? err.code : "";
+  let detail = safeProviderText(msg || code || "the response carried no error message", key);
+  const safeCode = safeProviderText(code, key);
+  if (msg && safeCode && !detail.includes(safeCode)) detail += ` (${safeCode})`;
+  const lines = [`HTTP ${status}: ${detail}`];
+  if (status === 401) lines.push(
+    "The gateway rejected the credential sent with this call.",
+    `Re-running with the same key will not resolve an unchanged credential rejection. Check it at ${KEYS_URL}.`,
+  );
+  else if (status === 403) lines.push("The gateway refused this request. The reason it gave is above; that does not by itself mean the key is wrong.");
+  else if (status === 402) lines.push(`Check your account state: npx @inferall/cli status`);
+  else if (status === 429) lines.push("Rate limited. Retry shortly.");
+  else if (status >= 500) lines.push("That is an infrastructure error, not a problem with your key. Retry shortly.");
+  return lines;
+}
+
 
 /**
  * Read a response as JSON, or say plainly that it was not JSON.
@@ -1877,9 +1966,175 @@ export function isPlausiblePatch(text, site, base) {
 export function writeExample(root, kind) {
   const p = join(root, kind === "python" ? "inferall_hello.py" : "inferall-hello.mjs");
   if (existsSync(p)) return { path: null, problem: null };   // never clobber theirs
+  // The examples are dependency-free (Node fetch, Python urllib) and read the
+  // key from the environment, else from the .env next to the file, so a plain
+  // `node`/`python3` run works right after init. String.raw keeps the regex
+  // backslashes; the generated code avoids backticks and "${" for that reason.
   const body = kind === "python"
-    ? `"""InferAll hello. Run: python inferall_hello.py (pip install inferall-ai)"""\nfrom inferall import Inferall\n\nai = Inferall()  # reads INFERALL_API_KEY from the environment\nprint(ai.text("Explain InferAll in one sentence."))\n`
-    : `// InferAll hello. Run: node --env-file=.env inferall-hello.mjs\nconst res = await fetch("${API_BASE}/chat/completions", {\n  method: "POST",\n  headers: {\n    Authorization: \`Bearer \${process.env.INFERALL_API_KEY}\`,\n    "Content-Type": "application/json",\n  },\n  body: JSON.stringify({\n    model: "${FREE_MODEL}",\n    messages: [{ role: "user", content: "Explain InferAll in one sentence." }],\n  }),\n});\nconsole.log((await res.json()).choices?.[0]?.message?.content ?? (await res.text()));\n`;
+    ? String.raw`"""InferAll hello. Run: python3 inferall_hello.py (no packages needed)"""
+import json
+import http.client
+import os
+import re
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+API_BASE = ${JSON.stringify(API_BASE)}
+MODEL = ${JSON.stringify(FREE_MODEL)}
+
+
+def fail(message):
+    print("inferall: " + message, file=sys.stderr)
+    sys.exit(1)
+
+
+def read_key():
+    # INFERALL_API_KEY from the environment first, else the .env beside this file.
+    key = os.environ.get("INFERALL_API_KEY", "").strip()
+    if key:
+        return key
+    try:
+        text = (Path(__file__).resolve().parent / ".env").read_text(encoding="utf-8-sig")
+    except FileNotFoundError:
+        return ""
+    except OSError as e:
+        fail("could not read .env: %s" % e)
+    pattern = re.compile(r"^\s*(?:export\s+)?INFERALL_API_KEY\s*=(.*)$")
+    for line in text.splitlines():
+        m = pattern.match(line)
+        if m:
+            value = m.group(1).strip()
+            if value[:1] in ('"', "'"):
+                close = value.find(value[0], 1)
+                return value[1:close] if close != -1 else value
+            return re.sub(r"\s+#.*$", "", value).strip()
+    return ""
+
+
+key = read_key()
+if not key:
+    fail("INFERALL_API_KEY is not set. Export it or put it in the .env next to this file.")
+
+request = urllib.request.Request(
+    API_BASE + "/chat/completions",
+    data=json.dumps({
+        "model": MODEL,
+        "messages": [{"role": "user", "content": "Explain InferAll in one sentence."}],
+    }).encode(),
+    headers={
+        "Authorization": "Bearer " + key,
+        "Content-Type": "application/json",
+        "User-Agent": "inferall-hello-example",
+    },
+    method="POST",
+)
+try:
+    try:
+        res = urllib.request.urlopen(request, timeout=120)
+    except urllib.error.HTTPError as e:
+        res = e
+    with res:
+        status, raw = res.status, res.read()
+except (OSError, http.client.HTTPException) as e:
+    fail("request failed: %s" % e)
+
+text = raw.decode("utf-8", "replace")
+try:
+    data = json.loads(text)
+except ValueError:
+    data = None
+if not isinstance(data, dict):
+    data = {}
+
+if not 200 <= status < 300:
+    err = data.get("error")
+    detail = err.get("message") if isinstance(err, dict) else err
+    detail = detail or data.get("message") or text.strip()[:300] or "no response body"
+    fail("HTTP %d: %s" % (status, detail))
+
+try:
+    answer = data["choices"][0]["message"]["content"]
+except (KeyError, IndexError, TypeError):
+    answer = None
+if not isinstance(answer, str) or not answer.strip():
+    fail("the gateway answered HTTP %d but the response had no answer text" % status)
+print(answer)
+`
+    : String.raw`// InferAll hello. Run: node inferall-hello.mjs (Node 18+, no packages needed)
+import { readFileSync } from "node:fs";
+
+const API_BASE = ${JSON.stringify(API_BASE)};
+const MODEL = ${JSON.stringify(FREE_MODEL)};
+
+function fail(message) {
+  console.error("inferall: " + message);
+  process.exit(1);
+}
+
+// INFERALL_API_KEY from the environment first, else the .env beside this file.
+function readKey() {
+  const fromEnv = (process.env.INFERALL_API_KEY || "").trim();
+  if (fromEnv) return fromEnv;
+  let text;
+  try {
+    text = readFileSync(new URL(".env", import.meta.url), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return "";
+    fail("could not read .env: " + err.message);
+  }
+  for (const line of text.split(/\r?\n/)) {
+    const m = line.match(/^\s*(?:export\s+)?INFERALL_API_KEY\s*=(.*)$/);
+    if (m) {
+      const value = m[1].trim();
+      if (value[0] === '"' || value[0] === "'") {
+        const close = value.indexOf(value[0], 1);
+        return close === -1 ? value : value.slice(1, close);
+      }
+      return value.replace(/\s+#.*$/, "").trim();
+    }
+  }
+  return "";
+}
+
+const key = readKey();
+if (!key) fail("INFERALL_API_KEY is not set. Export it or put it in the .env next to this file.");
+
+let res;
+let raw;
+try {
+  res = await fetch(API_BASE + "/chat/completions", {
+    method: "POST",
+    headers: { Authorization: "Bearer " + key, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: MODEL,
+      messages: [{ role: "user", content: "Explain InferAll in one sentence." }],
+    }),
+    signal: AbortSignal.timeout(120_000),
+  });
+  raw = await res.text();
+} catch (err) {
+  fail("request failed: " + (err.name === "TimeoutError" ? "timed out after 120s" : err.message));
+}
+
+let data;
+try {
+  data = JSON.parse(raw);
+} catch {}
+
+if (!res.ok) {
+  const e = data?.error;
+  const detail = (typeof e === "string" ? e : e?.message) || data?.message || raw.trim().slice(0, 300) || res.statusText;
+  fail("HTTP " + res.status + ": " + detail);
+}
+
+const answer = data?.choices?.[0]?.message?.content;
+if (typeof answer !== "string" || !answer.trim()) {
+  fail("the gateway answered HTTP " + res.status + " but the response had no answer text");
+}
+console.log(answer);
+`;
   try {
     writeFileSync(p, body);
     return { path: p, problem: null };
@@ -2007,83 +2262,27 @@ async function chatCmd() {
   const parsedMax = rawMax === undefined ? 512 : parseInt(rawMax, 10);
   const maxTokens = Number.isFinite(parsedMax) && parsedMax > 0 ? parsedMax : 512;
   const reply = await apiChat(key, [{ role: "user", content: prompt }], model, maxTokens);
-  const { status, body } = reply;
-  // 2026-07-27 tick 833: a body we could not parse is a FAILED call whatever
-  // the status line said. Measured: a 200 whose JSON was truncated mid-stream
-  // (a proxy cutting the response) printed `{}` and exited 0, so a script
-  // wrapping this command saw success and an empty answer. Reporting success
-  // for a call that produced nothing is the rung of the ladder this product
-  // keeps landing on, and it is worth its own branch before the status checks.
-  if (reply.parseFailed) {
-    console.log(`${c.red("✗")} ${nonJsonSummary(reply)}`);
-    console.log(`  ${c.dim(`HTTP ${status}. Nothing usable came back, so this call did not succeed.`)}`);
-    if (status >= 500 || status === 502 || status === 503) {
-      console.log(`  That is an infrastructure error, not a problem with your key. Retry shortly.`);
-    }
-    rl.close();
-    exit(1);
-  }
-  if (status === 200) {
-    const choice = body?.choices?.[0];
-    const text = choice?.message?.content;
-    if (text) {
-      console.log(text);
-      /*
-       * Printed to STDERR, deliberately. `chat` is piped: the usage line above
-       * documents `echo "hi" | npx @inferall/cli chat`, and people redirect the
-       * answer into files and other commands. A counter on stdout would corrupt
-       * every one of those, which is a worse bug than the blindness it fixes.
-       * stderr reaches a human at a terminal and stays out of the pipe.
-       */
-      const countdown = trialCountdownLine(reply.trialUsage);
-      if (countdown) process.stderr.write(`${countdown}\n`);
-    } else if (choice?.finish_reason === "length") {
-      // 2026-07-26 tick 817. Reasoning models (nemotron and friends) spend the
-      // token budget on reasoning_content and return content: null with
-      // finish_reason "length". Measured at tick 811: nemotron at max_tokens=64
-      // returns null, at 256 it answers. The old code fell through to
-      // JSON.stringify(body), so a user who asked a question got a JSON blob
-      // back with no hint that the fix is simply a bigger budget.
-      console.log(c.yellow("The model used its whole token budget before answering."));
-      console.log(`  ${c.dim("Reasoning models spend the budget thinking first. Retry with a larger")} ${c.bold("--max-tokens")}${c.dim(", or use a non-reasoning model such as")} ${c.bold(FREE_MODEL)}${c.dim(".")}`);
-      rl.close();
-      exit(1);
-    } else {
-      // 2026-07-27 tick 833: this printed a JSON blob and then fell out of the
-      // function, so the process exited 0. A 200 carrying no answer is still a
-      // call that produced nothing, and a caller piping this into anything had
-      // no way to tell. The blob is kept -- it is the only diagnostic there is
-      // -- but it is labelled and the exit code now says what happened.
-      console.log(`${c.yellow("~")} the gateway returned 200 with no answer in it:`);
-      console.log(`  ${JSON.stringify(body).slice(0, 400)}`);
-      rl.close();
-      exit(1);
-    }
-  } else {
-    // 2026-07-26 tick 817: SHOW THE SERVER'S OWN MESSAGE.
-    //
-    // The gateway writes careful, model-aware 402 and 429 copy (ticks 812 and
-    // 815 were spent making it accurate) and this command threw it away. On 402
-    // it printed "your free allowance is used up or the account isn't activated
-    // yet", which conflates two different states and is simply WRONG for a user
-    // who was never activated: nothing of theirs is used up. The accurate
-    // sentence was in the response we discarded. On 429 it dumped raw JSON at
-    // the user, so the gateway's readable "retry in 42s" arrived wrapped in
-    // braces.
-    //
-    // Both are the same mistake: the client second-guessing a server that knows
-    // more than it does.
-    const serverMsg = body?.error?.message || body?.message;
-    console.log(`${status === 402 ? c.yellow("402") : c.red(`HTTP ${status}`)}: ${serverMsg || JSON.stringify(body).slice(0, 300)}`);
-    // Keep the pointer to `status`, which is genuinely useful and not something
-    // the server can know to suggest. Only for billing states, where "where do
-    // I stand" is the actual next question.
-    if (status === 402) {
-      console.log(`  ${c.dim("check your account:")} ${c.bold("npx @inferall/cli status")}`);
-    }
+  // The verdict is shared with doctor and init (classifyChatResult). Only a 200
+  // with a non-blank string answer is success; every failure is reported on
+  // STDERR so gateway diagnostics stay out of answer pipes.
+  const verdict = classifyChatResult(reply);
+  if (!verdict.ok) {
+    const [first, ...rest] = chatFailureLines(verdict, reply, key, "chat");
+    console.error(`${c.red("✗")} ${first}`);
+    for (const line of rest) console.error(`  ${line}`);
     rl.close();
     exit(1);
   }
+  console.log(verdict.text);
+  /*
+   * Printed to STDERR, deliberately. `chat` is piped: the usage line above
+   * documents `echo "hi" | npx @inferall/cli chat`, and people redirect the
+   * answer into files and other commands. A counter on stdout would corrupt
+   * every one of those, which is a worse bug than the blindness it fixes.
+   * stderr reaches a human at a terminal and stays out of the pipe.
+   */
+  const countdown = trialCountdownLine(reply.trialUsage);
+  if (countdown) process.stderr.write(`${countdown}\n`);
   rl.close();
 }
 
@@ -2427,14 +2626,12 @@ async function doctor() {
   // 5. live account state
   process.stdout.write(`  live call (${FREE_MODEL}) … `);
   const test = await apiChat(key, [{ role: "user", content: "Reply with the single word: ready" }]);
-  if (test.status === 200) {
-    console.log(c.green("account active ✓"));
-  } else if (test.status === 402) {
-    console.log(c.yellow("account not activated (402)"));
-    console.log(`    One-time ${c.bold("$5 activation")} (becomes spendable balance): ${c.cyan(BILLING_URL)}`);
-    ok = false;
+  const probe = classifyChatResult(test);
+  if (probe.ok) {
+    console.log(c.green("answered ✓"));
   } else {
-    console.log(c.red(`HTTP ${test.status}`));
+    console.log(c.red("failed"));
+    for (const line of chatFailureLines(probe, test, key, "probe")) console.log(`    ${line}`);
     ok = false;
   }
 
@@ -2858,6 +3055,10 @@ async function main() {
       console.log(`  ${c.red("✗")} ${example.problem}`);
       envResult.problems.push(example.problem);
     }
+    if (example.path) {
+      const run = project.kind === "node" ? "node inferall-hello.mjs" : "python3 inferall_hello.py";
+      console.log(`  ${c.dim("run:")} ${c.bold(run)} ${c.dim("(reads INFERALL_API_KEY from the environment or .env)")}`);
+    }
     if (project.kind === "node") console.log(`  ${c.dim("optional:")} npm install @inferall/sdk`);
     else console.log(`  ${c.dim("optional:")} pip install inferall-ai`);
   }
@@ -2883,7 +3084,8 @@ async function main() {
   const testModel = flagValue("model") || FREE_MODEL;
   process.stdout.write(`\n  test call (${testModel}${testModel === FREE_MODEL ? ", $0 model" : ""}) … `);
   const test = await apiChat(key, [{ role: "user", content: "Reply with the single word: ready" }], testModel);
-  if (test.status === 200) {
+  const probe = classifyChatResult(test);
+  if (probe.ok) {
     console.log(c.green("success ✓"));
     // 2026-07-26 tick 804: do not claim the project is wired when we have just
     // printed guidance saying specific files were NOT changed. Saying "Done.
@@ -2934,59 +3136,19 @@ async function main() {
     } else {
       console.log(`\n${c.green(c.bold("Done."))} Your project is wired to InferAll. Models list: ${API_BASE}/models\n`);
     }
-  } else if (test.status === 402) {
-    console.log(c.yellow("blocked (402)"));
-    console.log(`\n  Everything is wired up, but your account isn't activated yet.`);
-    // Real account state beats a generic message: trial counter + whether a
-    // checkout was already started (settle vs start are different next steps).
-    const st = await fetch(`${ANTHROPIC_BASE}/ai/v1/key/status`, {
-      signal: timeoutSignal(),
-      headers: { Authorization: `Bearer ${key}` },
-    }).then((r) => (r.ok ? r.json() : null)).catch(() => null);
-    if (st?.trial) {
-      console.log(`  Trial: ${st.trial.used}/${st.trial.cap} free calls used. ${st.trial.remaining === 0 ? "none left" : `${st.trial.remaining} still available`}${st.has_card ? c.dim(" · checkout started but not settled, and finishing it activates you") : ""}.`);
-    }
-    // Same correction as printGeminiGuidance above; see the note there.
-  console.log(`  The 10+ free NIM models are ${c.bold("$0 in/out")}; premium tokens bill at InferAll's published per-token rate. A one-time ${c.bold("$5 activation")} (it becomes spendable`);
-    console.log(`  balance, not a fee) unlocks every model, including the 10+ free NIM models.`);
-    console.log(`  Activate: ${c.cyan(BILLING_URL)}`);
-    console.log(`  The code changes above are done. The first call will work the moment you activate.`);
-    console.log(`  Check anytime: ${c.bold("npx @inferall/cli status")}\n`);
-  } else if (test.status === 401 || test.status === 403) {
-    // 2026-07-27 tick 826: this fell into the generic branch below, which
-    // printed a bare "HTTP 401", advised re-running init, and exited 0.
-    //
-    // Three separate things were wrong with that, in increasing order of harm.
-    // The wizard printed "verifying key ... ok" four lines earlier, so it
-    // contradicted its own output with no acknowledgement. Retrying an
-    // authentication failure with the same credential cannot succeed, so the
-    // remedy we printed was a dead end. And exiting 0 told every calling
-    // script that setup had worked, while the codemod had already repointed a
-    // working project at a gateway that rejects its key. A tool that breaks a
-    // project and reports success is the worst rung of the severity ladder,
-    // and this is the second time the exit status has been the tell (t824).
-    //
-    // The pre-flight hits /ai/v1/key/status and this hits /v1/chat/completions,
-    // so a key revoked between the two, or valid for a different account,
-    // produces exactly this split. Measured against a stub that answers 200 on
-    // status and 401 on chat.
-    console.log(c.red("rejected (401)"));
-    console.log(`\n  The gateway accepted this key a moment ago and has now rejected it.`);
-    console.log(`  That usually means the key was revoked or rotated between the two checks,`);
-    console.log(`  or that it belongs to a different account than the one you are setting up.`);
-    console.log(`\n  ${c.bold("Your files were already changed.")} The code and .env now point at InferAll,`);
-    console.log(`  so calls will keep failing until the key works. Re-running with the same key`);
-    console.log(`  cannot help.`);
-    console.log(`\n  Mint a fresh key at ${c.cyan(KEYS_URL)}, then re-run:`);
-    console.log(`    ${c.bold("npx @inferall/cli init --key ifu_your_new_key")}\n`);
-    rl.close();
-    exit(1);
   } else {
-    // Transient or unexpected. Retrying IS the right advice here, unlike the
-    // 401 case above, but the run still failed to verify so it must not exit 0.
-    console.log(c.red(`HTTP ${test.status}`));
-    console.log(`  ${JSON.stringify(test.body).slice(0, 300)}`);
-    console.log(`  Setup files were written; re-run ${c.bold("npx @inferall/cli init")} to retry the verify step.\n`);
+    // Any failed probe (401, 402, 403, 429, 5xx, non-JSON, blank or empty
+    // answer, token limit). Report what the gateway actually said, claim no
+    // cause we have no evidence for, and never exit 0: the call did not work.
+    console.log(c.red("failed"));
+    const [first, ...rest] = chatFailureLines(probe, test, key, "probe");
+    console.log(`\n  ${c.red("✗")} ${first}`);
+    for (const line of rest) console.log(`    ${line}`);
+    if (envResult.problems.length) {
+      console.log(`  ${envResult.keyWritten ? `Your key is in .env, but ${c.bold(".gitignore")} was not updated.` : c.bold("Your key was not saved.")}`);
+    }
+    console.log(`\n  The setup changes reported above were applied, but the live call did not return an answer, so this setup is ${c.bold("not verified")}.`);
+    console.log(`  Once the cause above is resolved, re-run ${c.bold("npx @inferall/cli init")} to retry the verify step.\n`);
     rl.close();
     exit(1);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferall/cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Install InferAll into your project in one command: npx @inferall/cli init",
   "bin": {
     "inferall": "bin/inferall.js"