fullsendai 0.1.0 → 0.2.1

package/README.md

@@ -6,8 +6,9 @@ Connect your coding tools to [FullsendAI](https://fullsendai.com) in one command
 npx fullsendai connect
 ```
 
-It finds the tools on your computer, signs you in through the browser, gives each tool its own API key, writes each
-tool's settings, and makes a real test call through each one. Your existing settings, comments and other providers
+It finds the tools on your computer, signs you in through the browser, lets you pick the model (FullsendAI's own
+Nefarian and Sulfuras first), gives each tool its own API key, writes each tool's settings, and makes a real test call
+through each one. When a model's provider goes down, a backup provider answers, so your tools keep working. Your existing settings, comments and other providers
 are kept, and a backup is made before anything changes.
 
 Works on macOS, Linux and Windows (PowerShell, cmd, Windows Terminal, WSL), with Node.js 18.17 or newer.
@@ -22,17 +23,30 @@ Works on macOS, Linux and Windows (PowerShell, cmd, Windows Terminal, WSL), with
 | Kilo Code CLI | `~/.config/kilo/kilo.json`, a `fullsend` provider |
 | Aider | `~/.aider.conf.yml` |
 | Continue | `~/.continue/config.yaml` (or `CONTINUE_GLOBAL_DIR`), FullsendAI's models added first |
-| Cline, Roo Code, Cursor | These keep settings inside the editor; you get the exact values and the key to paste |
+| Cline (command line) | `~/.cline/data/settings/providers.json`, through Cline's own `cline auth` |
+| Cline and Roo Code (VS Code), Cursor | These keep settings inside the editor; you get the exact values and the key to paste |
+
+Each tool is also told what the models can do, so it uses them fully: the context window (so Claude Code and Codex
+don't compact early), the output limit, whether a model reads images, reasons and calls tools, and its prices (so
+OpenCode and Aider show what a session costs).
 
 `CLAUDE_CONFIG_DIR`, `CODEX_HOME` and `XDG_CONFIG_HOME` are respected.
 
+## Always current
+
+Nothing about FullsendAI's models is built into this package: it reads them from the API every time. When a model is
+added, renamed or given new abilities or prices, `status` and `doctor` notice and offer to update your tools, and
+`npx fullsendai sync` does it. A tool whose model was renamed follows it to its new ID; one whose model was removed
+moves to the recommended model, and says so.
+
 ## Commands
 
 ```sh
 npx fullsendai connect              # find tools, sign in, connect (the default)
-npx fullsendai status               # what's connected, each tool's model and spend this month
-npx fullsendai model glm-5.3-flash  # switch every connected tool to another model
+npx fullsendai status               # each tool's model and spend this month, and calls a backup provider answered
+npx fullsendai model                # switch every connected tool to another model (or name it: model sulfuras)
 npx fullsendai doctor --fix         # check settings, keys and a real request; repair settings
+npx fullsendai sync                 # update every tool with FullsendAI's current models, abilities and prices
 npx fullsendai key codex            # copy a tool's key to the clipboard (--show prints it)
 npx fullsendai disconnect           # put each tool's settings back and revoke the keys it made
 ```

package/dist/cli.mjs

@@ -7322,17 +7322,22 @@ var require_dist = __commonJS({
   }
 });
 
+// src/main.ts
+import { createHash as createHash2 } from "node:crypto";
+
 // src/api.ts
-var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var VERSION = true ? "0.2.1" : "0.0.0-dev";
 var agent = `fullsendai-cli/${VERSION} (${process.platform}; node ${process.versions.node})`;
 var Api = class {
   constructor(origin, timeoutMs = 6e4) {
     this.origin = origin;
     this.timeoutMs = timeoutMs;
   }
-  /** The chat models a key can call, best first as the site lists them. */
+  /** The chat models a key can call: FullsendAI's own first, then the rest as the site lists them. */
   models(key2) {
-    return this.call("GET", "/v1/models", key2).then((result) => result.ok ? { ...result, value: result.value.data.filter((model2) => model2.id !== "fullsend/auto") } : result);
+    return this.call("GET", "/v1/models", key2).then(
+      (result) => result.ok ? { ...result, value: result.value.data.filter((model2) => model2.id !== "fullsend/auto").sort((a, b) => Number(!!b.house) - Number(!!a.house)) } : result
+    );
   }
   /** The key's own details: its name, this month's spend, the balance. */
   key(key2) {
@@ -7359,7 +7364,8 @@ var Api = class {
       const json = await response.json().catch(() => void 0);
       if (response.ok) return { ok: true, value: json, ms };
       const message = typeof json?.error === "string" ? json.error : json?.error?.message;
-      return { ok: false, status: response.status, error: explain(response.status, message, this.origin), ms };
+      const code = typeof json?.error === "string" ? void 0 : json?.error?.code ?? json?.error?.type;
+      return { ok: false, status: response.status, error: explain(response.status, message, this.origin, code), ms };
     } catch (error) {
       const ms = Date.now() - started;
       const timedOut = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
@@ -7368,10 +7374,11 @@ var Api = class {
   }
 };
 var host = (origin) => origin.replace(/^https?:\/\//, "");
-function explain(status2, message, origin) {
+function explain(status2, message, origin, code) {
   if (status2 === 401) return "This key isn't valid or was revoked. Run `npx fullsendai connect` to get new ones.";
   if (status2 === 402) return `Your FullsendAI balance is empty. Add credit at ${origin}/dashboard/billing.`;
   if (status2 === 404 && /model/i.test(message ?? "")) return `${message} Run \`npx fullsendai model\` to pick another.`;
+  if (status2 === 429 && message && code !== "rate_limit_exceeded") return message;
   if (status2 === 429) return "Rate limited for a moment. Try again shortly.";
   return message ? `${message} (${status2})` : `The request failed with status ${status2}.`;
 }
@@ -7513,6 +7520,8 @@ var paths = {
   opencode: (w) => preferExisting([join2(configHome(w), "opencode", "opencode.jsonc"), join2(configHome(w), "opencode", "opencode.json")]),
   kilo: (w) => preferExisting([join2(configHome(w), "kilo", "kilo.jsonc"), join2(configHome(w), "kilo", "kilo.json")]),
   aider: (w) => join2(w.home, ".aider.conf.yml"),
+  /** Cline's command line keeps its providers here (its VS Code extension keeps them inside VS Code). */
+  cline: (w) => join2(w.home, ".cline", "data", "settings", "providers.json"),
   continue: (w) => join2(w.env.CONTINUE_GLOBAL_DIR || join2(w.home, ".continue"), "config.yaml")
 };
 function preferExisting(candidates) {
@@ -7522,7 +7531,7 @@ function onPath(command, w) {
   const dirs = (w.env.PATH || w.env.Path || "").split(w.platform === "win32" ? ";" : delimiter).filter(Boolean);
   const extensions = w.platform === "win32" ? (w.env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";") : [""];
   for (const dir of dirs)
-    for (const ext of w.platform === "win32" ? ["", ...extensions] : extensions) {
+    for (const ext of w.platform === "win32" ? /\.[^\\/]+$/.test(command) ? [""] : extensions : extensions) {
       const file = join2(dir, command + ext);
       try {
         if (statSync(file).isFile()) return file;
@@ -7573,8 +7582,8 @@ function copy(text, w) {
 
 // src/tools.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync3, readdirSync } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync, rmSync as rmSync2 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
@@ -9706,7 +9715,7 @@ function assertValid(text) {
 }
 
 // src/tools.ts
-var CLAUDE_KEYS = ["ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_API_KEY", "ANTHROPIC_MODEL", "ANTHROPIC_DEFAULT_OPUS_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_HAIKU_MODEL", "CLAUDE_CODE_SUBAGENT_MODEL"];
+var CLAUDE_KEYS = ["ANTHROPIC_BASE_URL", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_API_KEY", "ANTHROPIC_MODEL", "ANTHROPIC_DEFAULT_OPUS_MODEL", "ANTHROPIC_DEFAULT_SONNET_MODEL", "ANTHROPIC_DEFAULT_HAIKU_MODEL", "CLAUDE_CODE_SUBAGENT_MODEL", "CLAUDE_CODE_MAX_CONTEXT_TOKENS", "CLAUDE_CODE_MAX_OUTPUT_TOKENS"];
 var claudeCode = {
   id: "claude-code",
   name: "Claude Code",
@@ -9727,7 +9736,12 @@ var claudeCode = {
       ANTHROPIC_DEFAULT_OPUS_MODEL: ctx.model,
       ANTHROPIC_DEFAULT_SONNET_MODEL: ctx.model,
       ANTHROPIC_DEFAULT_HAIKU_MODEL: ctx.model,
-      CLAUDE_CODE_SUBAGENT_MODEL: ctx.model
+      CLAUDE_CODE_SUBAGENT_MODEL: ctx.model,
+      // Claude Code doesn't know our model IDs, so it would assume 200K tokens and compact there; this is the real
+      // window (code.claude.com/docs/en/model-config, "Correct the window for a gateway or custom model ID").
+      CLAUDE_CODE_MAX_CONTEXT_TOKENS: windowOf(ctx),
+      // Claude Code asks for up to 32K tokens of output by default; this is what the model can give.
+      CLAUDE_CODE_MAX_OUTPUT_TOKENS: outputOf(ctx) ? String(outputOf(ctx)) : void 0
     };
     write(file, sameEndings(text, setJson(text, Object.entries(values).map(([name, value]) => [["env", name], value]))));
     return { files: [file], previous };
@@ -9739,6 +9753,12 @@ var claudeCode = {
     const env2 = parseJson(text, file).env ?? {};
     return { connected: env2.ANTHROPIC_BASE_URL === ctx.origin && !!env2.ANTHROPIC_AUTH_TOKEN, key: env2.ANTHROPIC_AUTH_TOKEN, model: env2.ANTHROPIC_MODEL, file };
   },
+  now(w) {
+    const text = read(paths.claude(w));
+    const env2 = (text && parseJson(text, paths.claude(w)).env) ?? {};
+    const where = env2.ANTHROPIC_BASE_URL ? hostOf(env2.ANTHROPIC_BASE_URL) : env2.ANTHROPIC_API_KEY ? "Anthropic API key" : "Anthropic";
+    return [where, env2.ANTHROPIC_MODEL].filter(Boolean).join(" \xB7 ");
+  },
   disconnect(ctx, previous) {
     const file = paths.claude(ctx.w);
     const text = read(file);
@@ -9753,6 +9773,8 @@ var claudeCode = {
   }
 };
 var PROVIDER = "model_providers.fullsend";
+var CODEX_KEYS = ["model", "model_provider", "model_context_window", "model_auto_compact_token_limit", "model_supports_reasoning_summaries"];
+var tomlValue = (value) => typeof value === "string" ? tomlString(value) : typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" ? String(value) : void 0;
 var codex = {
   id: "codex",
   name: "Codex CLI",
@@ -9763,8 +9785,18 @@ var codex = {
     const file = paths.codex(ctx.w);
     const text = read(file) ?? "";
     const parsed = tomlOf(text, file);
-    const previous = { model: parsed.model ?? null, model_provider: parsed.model_provider ?? null };
-    let updated = setTopLevel(text, { model: tomlString(ctx.model), model_provider: tomlString("fullsend") });
+    const previous = Object.fromEntries(CODEX_KEYS.map((name) => [name, parsed[name] ?? null]));
+    const model2 = modelOf(ctx);
+    const window = model2?.context_length;
+    let updated = setTopLevel(text, {
+      model: tomlString(ctx.model),
+      model_provider: tomlString("fullsend"),
+      // Codex doesn't know our models, so it's told their window and compacts near its end, as it does for its own.
+      model_context_window: window ? String(window) : void 0,
+      model_auto_compact_token_limit: window ? String(Math.floor(window * 0.9)) : void 0,
+      // A reasoning model's thinking is asked for and shown as Codex shows its own models'.
+      model_supports_reasoning_summaries: model2?.reasoning ? "true" : void 0
+    });
     updated = setTable(updated, PROVIDER, {
       name: tomlString("FullsendAI"),
       base_url: tomlString(ctx.base),
@@ -9783,6 +9815,12 @@ var codex = {
     const problem = provider && provider.wire_api !== "responses" ? `wire_api isn't "responses", which current Codex needs` : void 0;
     return { connected: parsed.model_provider === "fullsend" && provider?.base_url === ctx.base, key: provider?.experimental_bearer_token, model: parsed.model, file, problem };
   },
+  now(w) {
+    const text = read(paths.codex(w));
+    const parsed = text ? tomlOf(text, paths.codex(w)) : {};
+    const provider = typeof parsed.model_provider === "string" && parsed.model_provider !== "openai" ? parsed.model_provider : "OpenAI";
+    return [provider, parsed.model].filter(Boolean).join(" \xB7 ");
+  },
   disconnect(ctx, previous) {
     const file = paths.codex(ctx.w);
     const text = read(file);
@@ -9790,10 +9828,7 @@ var codex = {
     const parsed = tomlOf(text, file);
     let updated = removeTable(text, PROVIDER);
     if (parsed.model_provider === "fullsend")
-      updated = setTopLevel(updated, {
-        model: typeof previous.model === "string" ? tomlString(previous.model) : void 0,
-        model_provider: typeof previous.model_provider === "string" ? tomlString(previous.model_provider) : void 0
-      });
+      updated = setTopLevel(updated, Object.fromEntries(CODEX_KEYS.map((name) => [name, tomlValue(previous[name])])));
     write(file, sameEndings(text, assertValid(updated)));
     return [file];
   }
@@ -9818,10 +9853,16 @@ function openCodeStyle(id, name, binary, file, extensionPrefix) {
           model2.id,
           {
             name: model2.name ?? model2.id,
-            tool_call: true,
-            ...model2.reasoning !== void 0 && { reasoning: model2.reasoning },
-            ...model2.images && { attachment: true },
-            ...model2.context_length && { limit: { context: model2.context_length, output: 32768 } }
+            tool_call: model2.tools ?? true,
+            reasoning: !!model2.reasoning,
+            attachment: !!model2.images,
+            temperature: true,
+            modalities: { input: model2.images ? ["text", "image"] : ["text"], output: ["text"] },
+            ...model2.context_length && { limit: { context: model2.context_length, output: model2.max_output_tokens ?? 8192 } },
+            // Per million tokens, as OpenCode shows a session's cost.
+            ...model2.pricing && {
+              cost: { input: model2.pricing.input, output: model2.pricing.output, ...model2.pricing.cached_input != null && { cache_read: model2.pricing.cached_input } }
+            }
           }
         ])
       );
@@ -9840,6 +9881,10 @@ function openCodeStyle(id, name, binary, file, extensionPrefix) {
       const provider = parsed.provider?.fullsend;
       return { connected: provider?.options?.baseURL === ctx.base, key: provider?.options?.apiKey, model: parsed.model?.replace(/^fullsend\//, ""), file: path };
     },
+    now(w) {
+      const text = read(file(w));
+      return text && parseJson(text, file(w)).model || void 0;
+    },
     disconnect(ctx, previous) {
       const path = file(ctx.w);
       const text = read(path);
@@ -9854,7 +9899,9 @@ function openCodeStyle(id, name, binary, file, extensionPrefix) {
     }
   };
 }
-var AIDER_KEYS = ["model", "openai-api-base", "openai-api-key"];
+var AIDER_KEYS = ["model", "openai-api-base", "openai-api-key", "model-metadata-file", "model-settings-file"];
+var aiderMetadata = (w) => join4(stateDir(w), "aider.model.metadata.json");
+var aiderSettings = (w) => join4(stateDir(w), "aider.model.settings.yml");
 var aider = {
   id: "aider",
   name: "Aider",
@@ -9869,8 +9916,31 @@ var aider = {
     doc.set("model", `openai/${ctx.model}`);
     doc.set("openai-api-base", ctx.base);
     doc.set("openai-api-key", key2);
+    doc.set("model-metadata-file", aiderMetadata(ctx.w));
+    doc.set("model-settings-file", aiderSettings(ctx.w));
+    const names = ctx.models.map((model2) => `openai/${model2.id}`);
+    const metadata = Object.fromEntries(
+      ctx.models.map((model2, index) => [
+        names[index],
+        {
+          ...model2.context_length && { max_input_tokens: model2.context_length },
+          ...model2.max_output_tokens && { max_tokens: model2.max_output_tokens, max_output_tokens: model2.max_output_tokens },
+          ...model2.pricing && { input_cost_per_token: model2.pricing.input / 1e6, output_cost_per_token: model2.pricing.output / 1e6 },
+          litellm_provider: "openai",
+          mode: "chat",
+          supports_vision: !!model2.images,
+          supports_function_calling: model2.tools ?? true,
+          supports_reasoning: !!model2.reasoning
+        }
+      ])
+    );
+    const settings = ctx.models.map((model2, index) => ({ name: names[index], edit_format: "diff", use_repo_map: true, ...model2.reasoning && { accepts_settings: ["reasoning_effort"] } }));
+    mkdirSync3(stateDir(ctx.w), { recursive: true, mode: 448 });
+    write(aiderMetadata(ctx.w), `${JSON.stringify(metadata, null, 2)}
+`);
+    write(aiderSettings(ctx.w), (0, import_yaml.stringify)(settings));
     write(file, sameEndings(text, String(doc)));
-    return { files: [file], previous };
+    return { files: [file, aiderMetadata(ctx.w), aiderSettings(ctx.w)], previous };
   },
   read(ctx) {
     const file = paths.aider(ctx.w);
@@ -9879,6 +9949,10 @@ var aider = {
     const doc = yamlOf(text, file);
     return { connected: doc.get("openai-api-base") === ctx.base, key: doc.get("openai-api-key"), model: String(doc.get("model") ?? "").replace(/^openai\//, ""), file };
   },
+  now(w) {
+    const text = read(paths.aider(w));
+    return text && yamlOf(text, paths.aider(w)).get("model") || void 0;
+  },
   disconnect(ctx, previous) {
     const file = paths.aider(ctx.w);
     const text = read(file);
@@ -9891,6 +9965,8 @@ var aider = {
       else doc.delete(name);
     }
     write(file, sameEndings(text, String(doc)));
+    rmSync2(aiderMetadata(ctx.w), { force: true });
+    rmSync2(aiderSettings(ctx.w), { force: true });
     return [file];
   }
 };
@@ -9912,7 +9988,21 @@ var cont = {
     models.items = models.items.filter((item) => !(item instanceof import_yaml.YAMLMap && item.get("apiBase") === ctx.base));
     const ordered = [...ctx.models].sort((a, b) => Number(b.id === ctx.model) - Number(a.id === ctx.model));
     ordered.forEach(
-      (model2, index) => models.items.splice(index, 0, doc.createNode({ name: `FullsendAI: ${model2.name ?? model2.id}`, provider: "openai", model: model2.id, apiBase: ctx.base, apiKey: key2, roles: ["chat", "edit", "apply"] }))
+      (model2, index) => models.items.splice(
+        index,
+        0,
+        doc.createNode({
+          name: `FullsendAI: ${model2.name ?? model2.id}`,
+          provider: "openai",
+          model: model2.id,
+          apiBase: ctx.base,
+          apiKey: key2,
+          roles: ["chat", "edit", "apply"],
+          // What it can do, so Continue offers agent mode (tools) and image input only where they work.
+          capabilities: [...model2.tools ?? true ? ["tool_use"] : [], ...model2.images ? ["image_input"] : []],
+          ...model2.context_length && { defaultCompletionOptions: { contextLength: model2.context_length, ...model2.max_output_tokens && { maxTokens: model2.max_output_tokens } } }
+        })
+      )
     );
     write(file, sameEndings(text, String(doc)));
     return { files: [file], previous: {} };
@@ -9925,6 +10015,12 @@ var cont = {
     const ours = models instanceof import_yaml.YAMLSeq ? models.items.filter((item) => item instanceof import_yaml.YAMLMap && item.get("apiBase") === ctx.base) : [];
     return { connected: ours.length > 0, key: ours[0]?.get("apiKey"), model: ours[0]?.get("model"), file };
   },
+  now(w) {
+    const text = read(paths.continue(w));
+    const models = text ? yamlOf(text, paths.continue(w)).get("models") : void 0;
+    const first = models instanceof import_yaml.YAMLSeq ? models.items.find((item) => item instanceof import_yaml.YAMLMap) : void 0;
+    return first?.get("name") ?? void 0;
+  },
   disconnect(ctx) {
     const file = paths.continue(ctx.w);
     const text = read(file);
@@ -9936,6 +10032,7 @@ var cont = {
     return [file];
   }
 };
+var CLINE_PROVIDER = "openai-compatible";
 var cline = {
   id: "cline",
   name: "Cline",
@@ -9945,20 +10042,60 @@ var cline = {
     const result = found(w, "cline", false);
     return result.installed ? result : extensionFound(w, "saoudrizwan.claude-dev-") ? { installed: true, how: "VS Code extension" } : result;
   },
+  files: (w) => [paths.cline(w)],
   connect(ctx, key2) {
     const command = onPath("cline", ctx.w);
     if (!command) throw new Error("Cline's command line isn't installed; set up the VS Code extension with the steps shown.");
+    const file = paths.cline(ctx.w);
+    const before = parseJson(read(file) ?? "{}", file);
+    const previous = { lastUsedProvider: before.lastUsedProvider ?? null, entry: before.providers?.[CLINE_PROVIDER] ?? null };
     const result = run(command, ["auth", "-p", "openai", "-k", key2, "-m", ctx.model, "-b", ctx.base], ctx.w);
     if (result.status !== 0) throw new Error(`cline auth failed: ${(result.stderr || result.stdout).trim().split("\n").pop()}`);
-    return { files: [], previous: {} };
+    const text = read(file);
+    if (!text) throw new ConfigError(`cline auth didn't write ${file}.`);
+    const model2 = modelOf(ctx);
+    const capabilities = ["streaming", ...model2?.tools ?? true ? ["tools"] : [], ...model2?.images ? ["vision"] : [], ...model2?.reasoning ? ["reasoning"] : []];
+    write(
+      file,
+      sameEndings(
+        text,
+        setJson(text, [
+          [["providers", CLINE_PROVIDER, "settings", "capabilities"], capabilities],
+          [["providers", CLINE_PROVIDER, "settings", "contextWindow"], model2?.context_length ?? void 0],
+          [["providers", CLINE_PROVIDER, "settings", "maxTokens"], model2?.max_output_tokens ?? void 0]
+        ])
+      )
+    );
+    return { files: [file], previous };
+  },
+  read(ctx) {
+    const file = paths.cline(ctx.w);
+    const text = read(file);
+    if (!text) return { connected: false, file, problem: "Cline's providers.json is missing" };
+    const settings = parseJson(text, file).providers?.[CLINE_PROVIDER]?.settings;
+    return { connected: settings?.baseUrl === ctx.base, key: settings?.apiKey, model: settings?.model, file };
+  },
+  disconnect(ctx, previous) {
+    const file = paths.cline(ctx.w);
+    const text = read(file);
+    if (!text) return [];
+    const parsed = parseJson(text, file);
+    if (parsed.providers?.[CLINE_PROVIDER]?.settings?.baseUrl !== ctx.base) return [];
+    write(
+      file,
+      sameEndings(
+        text,
+        setJson(text, [
+          [["providers", CLINE_PROVIDER], previous.entry ?? void 0],
+          [["lastUsedProvider"], previous.lastUsedProvider ?? void 0]
+        ])
+      )
+    );
+    return [file];
   },
   guide: (ctx) => ({
-    steps: ["Open Cline's settings (the gear in its panel).", "Set API Provider to OpenAI Compatible.", "Paste the values below, then Save."],
-    values: [
-      ["Base URL", ctx.base],
-      ["API Key", "(copied to your clipboard)"],
-      ["Model ID", ctx.model]
-    ]
+    steps: ["Open Cline's settings (the gear in its panel).", "Set API Provider to OpenAI Compatible.", "Paste the values below; the rest go under Model Configuration. Then Save."],
+    values: [["Base URL", ctx.base], ["API Key", "(copied to your clipboard)"], ["Model ID", ctx.model], ...modelConfiguration(ctx)]
   })
 };
 var cursor = {
@@ -9983,12 +10120,8 @@ var roo = {
   kind: "guided",
   detect: (w) => ({ installed: extensionFound(w, "rooveterinaryinc.roo-cline-"), how: "VS Code extension" }),
   guide: (ctx) => ({
-    steps: ["Open Roo Code's settings (the gear in its panel) \u203A Providers.", "Set API Provider to OpenAI Compatible.", "Paste the values below, then Save."],
-    values: [
-      ["Base URL", ctx.base],
-      ["API Key", "(copied to your clipboard)"],
-      ["Model", ctx.model]
-    ]
+    steps: ["Open Roo Code's settings (the gear in its panel) \u203A Providers.", "Set API Provider to OpenAI Compatible.", "Paste the values below; the rest go under Model Configuration. Then Save."],
+    values: [["Base URL", ctx.base], ["API Key", "(copied to your clipboard)"], ["Model", ctx.model], ...modelConfiguration(ctx)]
   })
 };
 var TOOLS = [claudeCode, codex, openCodeStyle("opencode", "OpenCode", "opencode", paths.opencode), openCodeStyle("kilo", "Kilo Code", "kilo", paths.kilo, "kilocode.kilo-code-"), aider, cont, cline, cursor, roo];
@@ -9997,7 +10130,7 @@ function found(w, binary, configured) {
   const command = onPath(binary, w);
   if (!command) return { installed: configured, how: configured ? "settings found" : void 0 };
   const result = run(command, ["--version"], w, 4e3);
-  const version = (result.stdout || result.stderr).match(/\d+\.\d+\.\d+(?:[-.][\w.]+)?/)?.[0];
+  const version = (result.stdout || result.stderr || "").match(/\d+\.\d+\.\d+(?:[-.][\w.]+)?/)?.[0];
   return { installed: true, version, how: "command line" };
 }
 function extensionFound(w, prefix) {
@@ -10016,6 +10149,30 @@ function run(command, args, w, timeout = 3e4) {
 }
 var ConfigError = class extends Error {
 };
+function modelConfiguration(ctx) {
+  const model2 = modelOf(ctx);
+  if (!model2) return [];
+  return [
+    ...model2.context_length ? [["Context Window Size", String(model2.context_length)]] : [],
+    ...model2.max_output_tokens ? [["Max Output Tokens", String(model2.max_output_tokens)]] : [],
+    ["Supports Images", model2.images ? "on" : "off"],
+    ...model2.pricing ? [["Input Price / 1M tokens", String(model2.pricing.input)], ["Output Price / 1M tokens", String(model2.pricing.output)]] : []
+  ];
+}
+var modelOf = (ctx) => ctx.models.find((model2) => model2.id === ctx.model);
+var outputOf = (ctx) => modelOf(ctx)?.max_output_tokens ?? void 0;
+var windowOf = (ctx) => {
+  const tokens = ctx.models.find((model2) => model2.id === ctx.model)?.context_length;
+  return tokens ? String(tokens) : void 0;
+};
+var hostOf = (url) => url.replace(/^https?:\/\//, "").split("/")[0];
+function currentSetup(tool, w) {
+  try {
+    return tool.now?.(w);
+  } catch {
+    return void 0;
+  }
+}
 function parseJson(text, file) {
   const errors = [];
   const value = parse2(text, errors, { allowTrailingComma: true });
@@ -10145,6 +10302,7 @@ async function checklist(question, choices) {
   const chosen = () => choices.filter((choice) => choice.checked && !choice.disabled).map((choice) => choice.id);
   if (!interactive || !choices.length) return chosen();
   let at = Math.max(0, choices.findIndex((choice) => !choice.disabled));
+  const width = Math.min(24, Math.max(...choices.map((choice) => choice.label.length)) + 1);
   const lines = choices.length + 2;
   const draw = (first) => {
     if (!first) out.write(`\x1B[${lines}A`);
@@ -10153,19 +10311,20 @@ async function checklist(question, choices) {
     choices.forEach((choice, index) => {
       const pointer = index === at ? cyan(sym.pointer) : " ";
       const box = choice.disabled ? dim(sym.off) : choice.checked ? green(sym.on) : sym.off;
-      const label = choice.disabled ? dim(choice.label) : index === at ? bold(choice.label) : choice.label;
+      const padded = choice.label.padEnd(width);
+      const label = choice.disabled ? dim(padded) : index === at ? bold(padded) : padded;
       const hint = choice.disabled ? dim(choice.disabled) : choice.hint ? dim(choice.hint) : "";
-      out.write(`\x1B[2K  ${pointer} ${box} ${label.padEnd(22)} ${hint}
+      out.write(`\x1B[2K  ${pointer} ${box} ${label} ${hint}
 `);
     });
     out.write(`\x1B[2K
 `);
   };
-  out.write("\x1B[?25l");
-  draw(true);
   emitKeypressEvents(process.stdin);
   process.stdin.setRawMode?.(true);
   process.stdin.resume();
+  out.write("\x1B[?25l");
+  draw(true);
   return new Promise((resolve) => {
     const move = (step) => {
       for (let tries = 0; tries < choices.length; tries++) {
@@ -10196,6 +10355,49 @@ async function checklist(question, choices) {
     process.stdin.on("keypress", onKey);
   });
 }
+async function select(question, options, initial) {
+  if (!interactive || !options.length) return initial;
+  let at = Math.max(0, options.findIndex((option) => option.id === initial));
+  const width = Math.min(28, Math.max(...options.map((option) => option.label.length)) + 1);
+  const hintWidth = Math.min(56, Math.max(...options.map((option) => (option.hint ?? "").length)));
+  const lines = options.length + 2;
+  const draw = (first) => {
+    if (!first) out.write(`\x1B[${lines}A`);
+    out.write(`\x1B[2K  ${cyan("?")} ${question} ${dim("(\u2191/\u2193 to move, enter to choose)")}
+`);
+    options.forEach((option, index) => {
+      const here2 = index === at;
+      const tag = option.tag ? ` ${volt(option.tag)}` : "";
+      out.write(`\x1B[2K  ${here2 ? cyan(sym.pointer) : " "} ${here2 ? bold(option.label.padEnd(width)) : option.label.padEnd(width)} ${dim((option.hint ?? "").padEnd(hintWidth))}${tag}
+`);
+    });
+    out.write("\x1B[2K\n");
+  };
+  emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode?.(true);
+  process.stdin.resume();
+  out.write("\x1B[?25l");
+  draw(true);
+  return new Promise((resolve) => {
+    const onKey = (text, key2 = {}) => {
+      if (key2.ctrl && key2.name === "c") {
+        restoreTerminal();
+        process.exit(130);
+      }
+      if (key2.name === "up" || text === "k") at = (at - 1 + options.length) % options.length;
+      else if (key2.name === "down" || text === "j") at = (at + 1) % options.length;
+      else if (key2.name === "return" || key2.name === "enter") {
+        process.stdin.off("keypress", onKey);
+        process.stdin.setRawMode?.(false);
+        process.stdin.pause();
+        out.write("\x1B[?25h");
+        return resolve(options[at].id);
+      }
+      draw(false);
+    };
+    process.stdin.on("keypress", onKey);
+  });
+}
 function restoreTerminal() {
   if (out.isTTY) out.write("\x1B[?25h");
   if (process.stdin.isTTY) process.stdin.setRawMode?.(false);
@@ -10208,7 +10410,6 @@ for (const signal of ["SIGINT", "SIGTERM"])
 
 // src/main.ts
 var DEFAULT_ORIGIN = "https://fullsendai.com";
-var PREFERRED = ["nefarian-6.1-flash", "sulfuras", "deepseek-v4.1-flash", "glm-5.3-flash"];
 async function main(argv) {
   const { command, args, flags } = parse4(argv);
   setJson2(flags.json);
@@ -10224,6 +10425,8 @@ async function main(argv) {
       return model(api, origin, args[0] ?? flags.model, flags);
     case "doctor":
       return doctor(api, origin, flags);
+    case "sync":
+      return sync(api, origin, flags);
     case "disconnect":
       return disconnect(api, origin, flags);
     case "key":
@@ -10253,16 +10456,22 @@ async function connect(api, origin, flags) {
     print(`  ${dim(`or see ${origin}/agents for every tool's setup.`)}`);
     return output(flags, { connected: [], reason: "no tools found" }, 0);
   }
-  print("  Found on this machine:");
-  for (const { tool, found: found2 } of installed) row("ok", tool.name, dim([found2.version, found2.how].filter(Boolean).join(sym.dot === "\xB7" ? " \xB7 " : " - ")));
-  print();
+  const asking = !flags.tools && interactive;
+  if (!asking) {
+    print("  Found on this machine:");
+    for (const { tool, found: found2 } of installed) row("ok", tool.name, dim([found2.version, found2.how].filter(Boolean).join(sym.dot === "\xB7" ? " \xB7 " : " - ")));
+    print();
+  } else {
+    print(`  Found ${installed.length === 1 ? "1 coding tool" : `${installed.length} coding tools`}. What each uses now is backed up, and ${cyan("npx fullsendai disconnect")} brings it back.`);
+    print();
+  }
   const chosen = flags.tools ? flags.tools : await checklist(
-    "Connect which tools?",
+    "Connect which tools to FullsendAI?",
     installed.map(({ tool }) => ({
       id: tool.id,
       label: tool.name,
       checked: !state.tools[tool.id],
-      hint: state.tools[tool.id] ? "already connected" : tool.kind === "guided" ? "you paste 3 settings" : tool.kind === "command" ? "runs its setup command" : "settings written for you"
+      hint: state.tools[tool.id] ? "already connected" : hintFor(tool, w)
     }))
   );
   if (!chosen.length) {
@@ -10275,7 +10484,7 @@ async function connect(api, origin, flags) {
     for (const tool of tools) row("info", tool.name, tool.kind === "file" ? fileFor(tool, origin) : tool.kind === "command" ? "its own setup command" : "settings you paste in the app");
     return output(flags, { dryRun: true, tools: tools.map((tool) => tool.id) }, 0);
   }
-  if (!flags.yes && !await confirm(`Connect ${tools.length === 1 ? tools[0].name : `these ${tools.length} tools`} to FullsendAI?`)) {
+  if (!flags.yes && !asking && !await confirm(`Connect ${tools.length === 1 ? tools[0].name : `these ${tools.length} tools`} to FullsendAI?`)) {
     print("  Nothing changed.");
     return output(flags, { connected: [] }, 0);
   }
@@ -10299,15 +10508,19 @@ async function connect(api, origin, flags) {
   const firstKey = Object.values(keys)[0];
   const models = await spin("Fetching the models\u2026", () => api.models(firstKey));
   if (!models.ok) return fail(models.error, flags);
-  const modelId = pickModel(models.value, flags.model ?? state.tools[tools[0].id]?.model);
-  if (!modelId) return fail(`There's no model called ${flags.model}. Live models: ${models.value.map((model2) => model2.id).join(", ")}.`, flags);
-  const pretty = models.value.find((model2) => model2.id === modelId)?.name ?? modelId;
-  print(`  Model for all tools: ${bold(pretty)} ${dim(`(${modelId} \xB7 change any time with: npx fullsendai model)`)}`);
+  const suggested = pickModel(models.value, flags.model ?? state.tools[tools[0].id]?.model);
+  if (!suggested) return fail(`There's no model called ${flags.model}. Live models: ${models.value.map((model2) => model2.id).join(", ")}.`, flags);
+  const ask2 = !flags.model && !flags.yes && !state.tools[tools[0].id]?.model && models.value.length > 1;
+  if (ask2) print();
+  const modelId = ask2 ? await select("Which model should your tools use?", modelOptions(models.value, suggested), suggested) : suggested;
+  const chosenModel = models.value.find((model2) => model2.id === modelId);
+  print(`  Model for all tools: ${bold(chosenModel?.name ?? modelId)} ${dim(`(${modelId} \xB7 change any time with: npx fullsendai model)`)}`);
   print();
   const folder = backupFolder(w);
   const ctx = { w, origin, base: `${origin}/v1`, model: modelId, models: models.value };
   const results = [];
   const guided = [];
+  let unpaid = false;
   for (const tool of tools) {
     const secret = keys[tool.id];
     if (!secret) {
@@ -10317,16 +10530,16 @@ async function connect(api, origin, flags) {
     }
     if (tool.kind === "guided" || tool.kind === "command" && !tool.detect(w).how?.includes("command")) {
       guided.push(tool);
-      state.tools[tool.id] = { key: secret, model: modelId, connectedAt: (/* @__PURE__ */ new Date()).toISOString(), kind: "guided", files: [], previous: {}, backups: [], ...given ? { given: true } : {} };
+      state.tools[tool.id] = { key: secret, model: modelId, modelUid: uidOf(models.value, modelId), connectedAt: (/* @__PURE__ */ new Date()).toISOString(), kind: "guided", files: [], previous: {}, backups: [], ...given ? { given: true } : {} };
       saveState(w, { ...state, origin, account });
       continue;
     }
     try {
       const earlier = state.tools[tool.id];
-      const files = tool.kind === "file" ? [fileFor(tool, origin)] : [];
+      const files = tool.files?.(w) ?? (tool.kind === "file" ? [fileFor(tool, origin)] : []);
       const backups = files.flatMap((file) => backup(file, folder, tool.id) ?? []);
       const applied = tool.connect(ctx, secret);
-      const connection = { key: secret, model: modelId, connectedAt: (/* @__PURE__ */ new Date()).toISOString(), kind: tool.kind, files: applied.files, previous: earlier?.previous ?? applied.previous, backups: [...earlier?.backups ?? [], ...backups], ...given ? { given: true } : {} };
+      const connection = { key: secret, model: modelId, modelUid: uidOf(models.value, modelId), connectedAt: (/* @__PURE__ */ new Date()).toISOString(), kind: tool.kind, files: applied.files, previous: earlier?.previous ?? applied.previous, backups: [...earlier?.backups ?? [], ...backups], ...given ? { given: true } : {} };
       state.tools[tool.id] = connection;
       saveState(w, { ...state, origin, account });
       if (earlier && earlier.key !== secret && !earlier.given) void api.revoke(earlier.key);
@@ -10335,6 +10548,10 @@ async function connect(api, origin, flags) {
       if (probe.ok) {
         row("ok", tool.name, `${where}   ${green(`${sym.ok} answered in ${(probe.ms / 1e3).toFixed(1)}s`)}`);
         results.push({ id: tool.id, ok: true, detail: where });
+      } else if (probe.status === 402) {
+        row("warn", tool.name, `${where}   ${yellow("waiting for credit")}`);
+        results.push({ id: tool.id, ok: false, detail: probe.error });
+        unpaid = true;
       } else {
         row("warn", tool.name, `${where}, but the test call failed: ${probe.error}`);
         results.push({ id: tool.id, ok: false, detail: probe.error });
@@ -10351,12 +10568,31 @@ async function connect(api, origin, flags) {
   for (const tool of guided) await showGuide(tool, { ...ctx }, keys[tool.id], w);
   const good = results.filter((result) => result.ok).length + guided.length;
   print();
+  if (unpaid) {
+    print(`  ${yellow(bold("Add credit to start."))} Your FullsendAI balance is empty, so the test calls were refused.`);
+    print(`  Your tools are set up and work as soon as you add credit at ${cyan(`${origin}/dashboard/billing`)}.`);
+    print(`  ${dim("Then check them with: npx fullsendai doctor")}`);
+    print();
+  }
   if (good) {
     print(`  ${green(bold("Done."))} ${good === 1 ? "1 tool uses" : `${good} tools use`} FullsendAI${account?.email ? ` as ${account.email}` : ""}.`);
+    for (const line of whatYouGet(chosenModel ?? { id: modelId })) print(`  ${line}`);
+    const other = models.value.find((model2) => model2.id !== modelId)?.id;
+    const tips = results.filter((result) => result.ok).flatMap((result) => {
+      const tip = tipFor(result.id, other);
+      return tip ? [[toolById(result.id)?.name ?? result.id, tip]] : [];
+    });
+    if (tips.length) {
+      print();
+      print(`  ${bold("Using them")}`);
+      const width = Math.max(...tips.map(([name]) => name.length)) + 2;
+      for (const [name, tip] of tips) print(`    ${name.padEnd(width)}${tip}`);
+      print(`    ${dim(`Cap what a tool can spend: ${origin.replace(/^https?:\/\//, "")}/dashboard/keys, then that tool's key, Monthly spend cap.`)}`);
+    }
+    print();
     print(`  ${dim(`Backups: ${short(folder, w.home)}   ${sym.dot} Spend per tool: npx fullsendai status   ${sym.dot} Undo: npx fullsendai disconnect`)}`);
-    const tryIt = results.filter((result) => result.ok).map((result) => ({ "claude-code": "claude", codex: "codex", opencode: "opencode", kilo: "kilo", aider: "aider", continue: "cn", cline: "cline" })[result.id]).filter(Boolean);
-    if (tryIt.length) print(`  ${dim("Try it:")} ${tryIt.map((command) => cyan(command)).join(dim(", "))}`);
   }
+  saveState(w, { ...loadState(w, origin), catalog: fingerprint(models.value) });
   return output(flags, { connected: results.filter((result) => result.ok).map((result) => result.id), guided: guided.map((tool) => tool.id), failed: results.filter((result) => !result.ok), model: modelId, backups: folder }, results.some((result) => !result.ok) ? 1 : 0);
 }
 async function signInFlow(origin, tools, w) {
@@ -10421,11 +10657,17 @@ async function status(api, origin, flags) {
     const drift = reading && !reading.connected ? yellow(" \xB7 settings changed since connect (npx fullsendai doctor --fix)") : reading?.problem ? yellow(` \xB7 ${reading.problem}`) : "";
     row(info.ok && !drift ? "ok" : "warn", tool?.name ?? "?", `${dim(reading?.model ?? connection.model)}  ${spend}${drift}`);
   }
+  const byKey = new Map(report.flatMap(({ connection, info }) => info.ok ? [[connection.key, info.value.failovers ?? 0]] : []));
+  const failovers = [...byKey.values()].reduce((sum, each) => sum + each, 0);
+  const allowance = report.find(({ info }) => info.ok)?.info;
+  const empty = balance !== void 0 && balance <= 0 && allowance?.ok && (allowance.value.plan_allowance_remaining ?? 0) <= 0;
   if (balance !== void 0) print(`
-  ${dim("Balance:")} $${balance.toFixed(2)}`);
+  ${dim("Balance:")} ${empty ? yellow("$0.00, so your tools' calls are refused.") : `$${balance.toFixed(2)}`}${empty ? ` Add credit at ${cyan(`${origin}/dashboard/billing`)}.` : ""}`);
+  if (failovers) print(`  ${volt(sym.ok)} ${failovers === 1 ? "1 call" : `${failovers} calls`} this month kept working when a provider failed: a backup answered.`);
+  await noticeChanges(api, origin, flags, false);
   return output(
     flags,
-    { tools: report.map(({ id, connection, reading, info }) => ({ id, model: reading?.model ?? connection.model, connected: reading?.connected ?? true, usage: info.ok ? info.value.usage : null, error: info.ok ? null : info.error })), balance },
+    { tools: report.map(({ id, connection, reading, info }) => ({ id, model: reading?.model ?? connection.model, connected: reading?.connected ?? true, usage: info.ok ? info.value.usage : null, failovers: info.ok ? info.value.failovers ?? 0 : null, error: info.ok ? null : info.error })), balance, failovers },
     0
   );
 }
@@ -10439,9 +10681,9 @@ async function model(api, origin, wanted, flags) {
   let id = wanted;
   if (!id) {
     header2("pick a model");
-    models.value.forEach((option, index) => print(`  ${dim(`${index + 1}.`)} ${option.name ?? option.id} ${dim(option.id)}`));
-    const answer = (await ask("Number or model ID:")).trim();
-    id = /^\d+$/.test(answer) ? models.value[Number(answer) - 1]?.id : answer;
+    const current = state.tools[ids[0]].model;
+    if (!interactive) return fail(`Name the model: npx fullsendai model <id>. Live models: ${models.value.map((option) => option.id).join(", ")}.`, flags);
+    id = await select("Switch every tool to:", modelOptions(models.value, pickModel(models.value, void 0) ?? current).map((option) => option.id === current ? { ...option, tag: "current" } : option), current);
   }
   if (!id || !models.value.some((option) => option.id === id)) return fail(`There's no model called ${id ?? "(none)"}. Live models: ${models.value.map((option) => option.id).join(", ")}.`, flags);
   const ctx = { w, origin, base: `${origin}/v1`, model: id, models: models.value };
@@ -10450,19 +10692,85 @@ async function model(api, origin, wanted, flags) {
     const connection = state.tools[toolId];
     if (connection.kind === "guided") {
       row("info", tool.name, `set the model to ${cyan(id)} in its settings`);
+      state.tools[toolId] = { ...connection, model: id, modelUid: uidOf(models.value, id) };
       continue;
     }
     try {
       tool.connect(ctx, connection.key);
-      state.tools[toolId] = { ...connection, model: id };
+      state.tools[toolId] = { ...connection, model: id, modelUid: uidOf(models.value, id) };
       row("ok", tool.name, `now uses ${bold(id)}`);
     } catch (error) {
       row("fail", tool.name, error.message);
     }
   }
-  saveState(w, state);
+  saveState(w, { ...state, catalog: fingerprint(models.value) });
+  const picked = models.value.find((option) => option.id === id);
+  if (picked) {
+    print();
+    for (const line of whatYouGet(picked)) print(`  ${line}`);
+  }
   return output(flags, { model: id }, 0);
 }
+async function sync(api, origin, flags, quiet = false) {
+  const w = here();
+  const state = loadState(w, origin);
+  const ids = Object.keys(state.tools);
+  if (!quiet) header2("sync", "Brings each connected tool up to date with FullsendAI's models.");
+  if (!ids.length) {
+    print(`  No tools are connected. Run ${cyan("npx fullsendai connect")}.`);
+    return output(flags, { synced: [], moved: [] }, 0);
+  }
+  const models = await spin("Fetching the models\u2026", () => api.models(state.tools[ids[0]].key));
+  if (!models.ok) return fail(models.error, flags);
+  const folder = backupFolder(w);
+  const synced = [];
+  const moved = [];
+  for (const id of ids) {
+    const tool = toolById(id);
+    const connection = state.tools[id];
+    if (!tool) continue;
+    const stays = models.value.some((model2) => model2.id === connection.model);
+    const renamed = stays ? void 0 : models.value.find((model2) => connection.modelUid && model2.uid === connection.modelUid)?.id;
+    const modelId = stays ? connection.model : renamed ?? pickModel(models.value, void 0);
+    if (!modelId) continue;
+    if (!stays) moved.push({ id, from: connection.model, to: modelId });
+    const gone = stays ? "" : renamed ? `${connection.model} is now called ${bold(modelId)}` : `${connection.model} is no longer offered, so it now uses ${bold(modelId)}`;
+    if (connection.kind === "guided" || !tool.connect) {
+      if (!stays) row("warn", tool.name, `${gone}: set it in ${tool.name}'s settings`);
+      state.tools[id] = { ...connection, model: modelId, modelUid: uidOf(models.value, modelId) };
+      continue;
+    }
+    try {
+      for (const file of tool.files?.(w) ?? (tool.kind === "file" ? [fileFor(tool, origin)] : [])) backup(file, folder, id);
+      tool.connect({ w, origin, base: `${origin}/v1`, model: modelId, models: models.value }, connection.key);
+      state.tools[id] = { ...connection, model: modelId, modelUid: uidOf(models.value, modelId) };
+      synced.push(id);
+      row(stays ? "ok" : "warn", tool.name, stays ? dim("up to date") : gone);
+    } catch (error) {
+      row("fail", tool.name, error.message);
+    }
+  }
+  saveState(w, { ...state, catalog: fingerprint(models.value) });
+  return output(flags, { synced, moved }, 0);
+}
+async function noticeChanges(api, origin, flags, apply) {
+  const w = here();
+  const state = loadState(w, origin);
+  const first = Object.values(state.tools).find((connection) => connection.kind !== "guided");
+  if (!first) return;
+  const models = await api.models(first.key);
+  if (!models.ok || fingerprint(models.value) === state.catalog) return;
+  print();
+  print(`  ${yellow(sym.warn)} FullsendAI's models have changed since your tools were set up ${dim("(new or renamed models, abilities or prices)")}.`);
+  const update = apply || interactive && !flags.json && await confirm("Update your tools now?");
+  if (update) await sync(api, origin, flags, true);
+  else print(`  Run ${cyan("npx fullsendai sync")} to update them.`);
+}
+var uidOf = (models, id) => models.find((model2) => model2.id === id)?.uid;
+function fingerprint(models) {
+  const described = [...models].sort((a, b) => a.id.localeCompare(b.id)).map((model2) => [model2.id, model2.name, model2.context_length, model2.max_output_tokens, model2.images, model2.reasoning, model2.tools, model2.pricing?.input, model2.pricing?.output, model2.pricing?.cached_input]);
+  return createHash2("sha256").update(JSON.stringify(described)).digest("hex").slice(0, 16);
+}
 async function doctor(api, origin, flags) {
   const w = here();
   const state = loadState(w, origin);
@@ -10498,9 +10806,14 @@ async function doctor(api, origin, flags) {
     else row(fixed ? "ok" : "warn", tool.name, fixed ? `fixed: ${issues.join("; ")}` : issues.join("; "));
     for (const issue of issues) problems.push({ id, problem: issue, fixed });
   }
+  await noticeChanges(api, origin, flags, flags.fix);
   const open = problems.filter((problem) => !problem.fixed);
+  const billing = `${origin}/dashboard/billing`;
+  const settings = open.filter((problem) => !problem.problem.includes(billing));
   print();
-  print(open.length ? `  ${yellow(`${open.length} problem${open.length > 1 ? "s" : ""}.`)} ${flags.fix ? "" : `Run ${cyan("npx fullsendai doctor --fix")} to repair settings.`}` : `  ${green("Everything works.")}`);
+  if (!open.length) print(`  ${green("Everything works.")}`);
+  else if (!settings.length) print(`  ${yellow("Your balance is empty.")} Add credit at ${cyan(billing)}; the settings themselves are fine.`);
+  else print(`  ${yellow(`${open.length} problem${open.length > 1 ? "s" : ""}.`)} ${flags.fix ? "" : `Run ${cyan("npx fullsendai doctor --fix")} to repair settings.`}`);
   return output(flags, { problems }, open.length ? 1 : 0);
 }
 async function disconnect(api, origin, flags) {
@@ -10523,9 +10836,9 @@ async function disconnect(api, origin, flags) {
     const connection = state.tools[id];
     if (!tool || !connection) continue;
     try {
-      const files = connection.kind === "file" ? tool.disconnect?.({ w, origin, base: `${origin}/v1` }, connection.previous) ?? [] : [];
+      const files = connection.kind !== "guided" ? tool.disconnect?.({ w, origin, base: `${origin}/v1` }, connection.previous) ?? [] : [];
       const revoked = flags.keepKeys || connection.given ? void 0 : await api.revoke(connection.key);
-      const note = connection.kind === "file" ? files.length ? "settings restored" : "settings were already changed, left as they are" : `remove FullsendAI from ${tool.name}'s settings yourself`;
+      const note = connection.kind !== "guided" && tool.disconnect ? files.length ? "settings restored" : "settings were already changed, left as they are" : `remove FullsendAI from ${tool.name}'s settings yourself`;
       row("ok", tool.name, `${note}${revoked ? revoked.ok ? ", key revoked" : ", key was already revoked" : connection.given ? ", your key still works" : ""}`);
       delete state.tools[id];
       done.push(id);
@@ -10550,8 +10863,42 @@ function key(origin, id, flags) {
 }
 function pickModel(models, wanted) {
   if (wanted) return models.some((model2) => model2.id === wanted) ? wanted : void 0;
-  return PREFERRED.find((id) => models.some((model2) => model2.id === id)) ?? models[0]?.id;
+  return (models.find((model2) => model2.recommended) ?? models.find((model2) => model2.house) ?? models[0])?.id;
+}
+function tipFor(id, other) {
+  const switchTo = (example) => other ? `${dim("Another model for one run:")} ${cyan(example)}` : "";
+  const tips = {
+    "claude-code": `Start a new ${cyan("claude")} session ${dim("(open ones keep their old settings)")}.`,
+    codex: `Run ${cyan("codex")}. ${switchTo(`codex -m ${other}`)}`,
+    opencode: `Run ${cyan("opencode")}. ${dim("/models lists every FullsendAI model.")}`,
+    kilo: `Run ${cyan("kilo")}. ${dim("/models lists every FullsendAI model.")}`,
+    aider: `Run ${cyan("aider")}. ${switchTo(`aider --model openai/${other}`)}`,
+    continue: `In VS Code, reload the window; FullsendAI's models top Continue's model menu. ${dim("In a terminal: cn")}`
+  };
+  return tips[id]?.trim();
+}
+function hintFor(tool, w) {
+  const now = currentSetup(tool, w);
+  if (now) return `now: ${now}`;
+  return tool.kind === "guided" ? "you paste 3 settings" : tool.kind === "command" ? "runs its setup command" : "not set up yet";
+}
+function modelOptions(models, suggested) {
+  return models.map((model2) => ({
+    id: model2.id,
+    label: model2.name ?? model2.id,
+    hint: model2.house && model2.tagline ? model2.tagline : model2.pricing ? `${price(model2.pricing.input)} in \xB7 ${price(model2.pricing.output)} out per 1M tokens` : model2.id,
+    tag: model2.id === suggested ? "recommended" : model2.house ? "FullsendAI" : void 0
+  }));
+}
+function whatYouGet(model2) {
+  const name = bold(model2.name ?? model2.id);
+  return [
+    model2.house ? `Your tools now run ${name}, FullsendAI's own model${model2.tagline ? `: ${lowerFirst(model2.tagline)}` : ""}.` : `Your tools now run ${name}.`,
+    ...model2.backup ? [`${volt(sym.ok)} If its provider goes down, a backup answers and your tools keep working. ${dim("You pay the same price.")}`] : []
+  ];
 }
+var lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
+var price = (usd) => `$${usd < 1 ? usd.toFixed(2) : usd.toFixed(usd % 1 ? 2 : 0)}`;
 function fileFor(tool, origin) {
   const reading = tool.read?.({ w: here(), origin, base: `${origin}/v1` });
   return reading?.file ?? "";
@@ -10581,6 +10928,7 @@ function help() {
     status             What's connected, each tool's model and spend this month
     model [id]         Switch every connected tool to another model
     doctor [--fix]     Check settings, keys and a real request; --fix repairs settings
+    sync               Update every tool with FullsendAI's current models, abilities and prices
     disconnect         Put each tool's settings back and revoke its key
     key <tool>         Copy a tool's key to the clipboard (--show prints it)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullsendai",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Connect Claude Code, Codex, OpenCode, Aider, Continue and more to FullsendAI in one command.",
   "keywords": ["fullsendai", "claude-code", "codex", "opencode", "aider", "continue", "cline", "cursor", "llm", "cli"],
   "homepage": "https://fullsendai.com/docs/agents",