@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/settings/health.js

@@ -0,0 +1,247 @@
+import { choiceSites, retiredModelUsage, slotLabels, } from "../model-upkeep/usage.js";
+import { cliPathStatus } from "./cli-paths.js";
+import { keyGuides } from "./key-guides.js";
+import { testProviderKey } from "./key-test.js";
+import { isLocalCliProvider } from "./model.js";
+import { modelReach } from "./model-reach.js";
+import { providerStatuses } from "./readiness.js";
+const signInCommand = {
+    "claude-code": "claude auth login",
+    codex: "codex login",
+    gemini: "gemini",
+};
+function loginSource(id) {
+    return id === "codex-image" ? "codex" : id;
+}
+// Where each provider's models are chosen, as "Text model in template “Weekly”".
+function uses(db) {
+    const found = new Map();
+    for (const site of choiceSites(db))
+        for (const [slot, choice] of Object.entries(site.choices)) {
+            if (choice === undefined || choice.provider === "" || choice.model.trim() === "")
+                continue;
+            // Images drawn by Codex use the image provider id; the text choice uses the CLI's own.
+            const list = found.get(choice.provider) ?? [];
+            list.push({
+                model: choice.model,
+                where: `${slotLabels[slot]} in ${site.kind} “${site.name}”`,
+            });
+            found.set(choice.provider, list);
+        }
+    return found;
+}
+function overall(checks, used, setUp) {
+    if (checks.some((check) => check.state === "problem"))
+        return "problem";
+    if (checks.some((check) => check.state === "warning"))
+        return "warning";
+    return setUp || used ? "ok" : "unused";
+}
+// "Check all" on Settings → Providers: each command-line tool found and signed in, each saved
+// key accepted by its provider, and each chosen model still offered and answering for the key.
+// `only` checks one provider: its row's Check again, or a sign-in fix-it's.
+export async function checkProviderHealth(deps, only) {
+    const statuses = (await providerStatuses(deps)).filter((status) => only === undefined || status.id === only);
+    const inUse = uses(deps.db);
+    const catalogue = deps.catalogue?.();
+    const retired = catalogue === undefined ? [] : retiredModelUsage(deps.db, catalogue);
+    const providers = await Promise.all(statuses.map((status) => status.readiness.kind === "cli"
+        ? cliHealth(deps, status, inUse.get(status.id) ?? [])
+        : status.readiness.kind === "local"
+            ? Promise.resolve(localHealth(status, inUse.get(status.id) ?? []))
+            : keyedHealth(deps, status, inUse.get(status.id) ?? [], retired)));
+    return { checkedAt: deps.clock.now().toISOString(), providers };
+}
+// The system voice: a speech program was found, or not. Nothing to sign in to or pay for.
+function localHealth(status, used) {
+    const { readiness } = status;
+    const base = { id: status.id, displayName: status.displayName, family: status.family };
+    if (readiness.kind !== "local")
+        throw new Error("Expected the system voice.");
+    const found = readiness.available;
+    const checks = [
+        {
+            label: "Speech program found",
+            state: found ? "ok" : used.length > 0 ? "problem" : "skipped",
+            detail: found
+                ? `Speaks with ${readiness.engine ?? "this computer's speech program"}.`
+                : `${readiness.issue ?? "No speech program was found on this computer."}${used.length > 0 ? ` It is chosen for ${describe(used)}.` : ""}`,
+        },
+    ];
+    return { ...base, state: overall(checks, used.length > 0, found), checks };
+}
+async function cliHealth(deps, status, used) {
+    const { readiness } = status;
+    if (readiness.kind !== "cli" || !isLocalCliProvider(status.id))
+        throw new Error("Expected a command-line provider.");
+    const name = status.displayName;
+    const command = status.cliPath?.command ?? loginSource(status.id);
+    const checks = [];
+    const base = { id: status.id, displayName: name, family: status.family };
+    if (!readiness.installed ||
+        readiness.issueKind === "missing" ||
+        readiness.issueKind === "bridge") {
+        checks.push({
+            label: "Installed",
+            state: used.length > 0 ? "problem" : "skipped",
+            detail: readiness.issue ??
+                `${name} was not found on this computer. Install it, sign in once in a terminal, then choose Check all again. If it is installed somewhere unusual, set its path in Settings → Providers.`,
+        });
+        return { ...base, state: used.length > 0 ? "problem" : "unused", checks };
+    }
+    checks.push({
+        label: "Installed",
+        state: readiness.issueKind === "version" ? "problem" : "ok",
+        detail: readiness.issueKind === "version"
+            ? (readiness.issue ?? `Update ${name}, then choose Check all again.`)
+            : `Found ${command}${readiness.version === undefined ? "" : ` (version ${readiness.version})`}.`,
+    });
+    const source = loginSource(status.id);
+    let login = "unknown";
+    if (status.cliPath?.managedOnHost === true && deps.hostCliStatus !== undefined) {
+        login = (await deps.hostCliStatus(status.id)).login;
+    }
+    else if (deps.login !== undefined) {
+        try {
+            login = await deps.login(cliPathStatus(deps.db, status.id).command, source, AbortSignal.timeout(15_000));
+        }
+        catch {
+            login = "unknown";
+        }
+    }
+    checks.push(login === "signed-in"
+        ? { label: "Signed in", state: "ok", detail: `${name} is signed in.` }
+        : login === "signed-out"
+            ? {
+                label: "Signed in",
+                state: "problem",
+                detail: source === "gemini"
+                    ? `Gemini CLI is not signed in: ~/.gemini has no Google sign-in and no GEMINI_API_KEY is set. Open a terminal on the computer running it, run "gemini" and choose Login with Google (or set GEMINI_API_KEY), then choose Check all again.`
+                    : `${name} is not signed in. Open a terminal on the computer running it, run "${signInCommand[source]}" and sign in, then choose Check all again.`,
+            }
+            : {
+                label: "Signed in",
+                state: "skipped",
+                detail: source === "gemini"
+                    ? `Slopify could not tell from the Gemini CLI's files (~/.gemini/settings.json) whether it is signed in. Run "gemini" in a terminal once to confirm it is signed in.`
+                    : `Slopify could not tell whether ${name} is signed in. Run "${signInCommand[source]}" in a terminal if runs fail with a sign-in error.`,
+            });
+    if (used.length > 0)
+        checks.push(await cliModels(deps, status, used));
+    return { ...base, state: overall(checks, used.length > 0, true), checks };
+}
+async function cliModels(deps, status, used) {
+    if (deps.modelsFor === undefined)
+        return {
+            label: "Chosen models",
+            state: "skipped",
+            detail: "The model list is not loaded yet.",
+        };
+    let offered;
+    try {
+        offered = await deps.modelsFor(status.id, status.family);
+    }
+    catch {
+        return {
+            label: "Chosen models",
+            state: "warning",
+            detail: `Slopify could not read ${status.displayName}'s model list, so it could not check the chosen models. Make sure it is signed in and up to date, then choose Check all again.`,
+        };
+    }
+    const ids = new Set(offered.map((model) => model.id));
+    const missing = used.filter((use) => !ids.has(use.model));
+    if (missing.length === 0)
+        return {
+            label: "Chosen models",
+            state: "ok",
+            detail: `Every chosen model (${[...new Set(used.map((use) => use.model))].join(", ")}) is available.`,
+        };
+    return {
+        label: "Chosen models",
+        state: "problem",
+        detail: `${status.displayName} does not offer ${describe(missing)}. Update ${status.displayName}, or pick another model there and save.`,
+    };
+}
+// Asks the provider, with the saved key, for each chosen model: a model the account can't use
+// fails here before a run does.
+async function reachable(deps, status, used) {
+    const name = status.displayName;
+    const found = await modelReach(deps, status.id, used.map((use) => use.model));
+    if (found === undefined)
+        return {
+            label: "Model reachable",
+            state: "skipped",
+            detail: `${name} has no model check Slopify can ask without generating something. The key works; the first run shows whether the model does.`,
+        };
+    const missing = used.filter((use) => found.get(use.model) === "missing");
+    if (missing.length > 0)
+        return {
+            label: "Model reachable",
+            state: "problem",
+            detail: `${name} does not offer ${describe(missing)} to this key: the model id is wrong, retired, or the account has no access to it. Pick another model there and save, or enable the model for your account, then choose Check all again.`,
+        };
+    const unknown = [...found].filter(([, reach]) => reach === "unknown").map(([model]) => model);
+    if (unknown.length > 0)
+        return {
+            label: "Model reachable",
+            state: "warning",
+            detail: `${name} didn't answer for ${unknown.join(", ")}, so Slopify couldn't confirm the key can use ${unknown.length === 1 ? "it" : "them"}. Check your internet connection, then choose Check all again.`,
+        };
+    return {
+        label: "Model reachable",
+        state: "ok",
+        detail: `${name} answered for ${[...found.keys()].join(", ")} with this key.`,
+    };
+}
+function describe(missing) {
+    const shown = missing.slice(0, 3).map((use) => `${use.model} (${use.where})`);
+    return missing.length > 3
+        ? `${shown.join("; ")} and ${missing.length - 3} more`
+        : shown.join("; ");
+}
+async function keyedHealth(deps, status, used, retired) {
+    const { readiness } = status;
+    const base = { id: status.id, displayName: status.displayName, family: status.family };
+    const guide = keyGuides[status.id];
+    const checks = [];
+    const hasKey = readiness.kind === "keyed" && readiness.hasKey;
+    if (!hasKey) {
+        checks.push({
+            label: "Key saved",
+            state: used.length > 0 ? "problem" : "skipped",
+            detail: `No key is saved.${used.length > 0 ? ` It is chosen for ${describe(used)}.` : ""} Make one at ${guide?.keyPage.url ?? "the provider's website"}, paste it in Settings → Providers → ${status.displayName} and choose Save.`,
+        });
+        return { ...base, state: used.length > 0 ? "problem" : "unused", checks };
+    }
+    const test = await testProviderKey(deps, status.id);
+    checks.push({
+        label: "Key valid",
+        state: test.ok
+            ? "ok"
+            : test.result === "rate-limited" ||
+                test.result === "provider-down" ||
+                test.result === "unreachable"
+                ? "warning"
+                : "problem",
+        detail: test.message,
+    });
+    const mine = retired.filter((usage) => usage.provider === status.id);
+    if (mine.length > 0)
+        checks.push({
+            label: "Chosen models",
+            state: "problem",
+            detail: `${describe(mine.map((usage) => ({
+                model: usage.model,
+                where: `${slotLabels[usage.slot]} in ${usage.kind} “${usage.name}”`,
+            })))} ${mine.length === 1 ? "is" : "are"} no longer offered. Use Switch in Settings → Models → Retired models in use.`,
+        });
+    else if (used.length > 0)
+        checks.push({
+            label: "Chosen models",
+            state: "ok",
+            detail: "Every chosen model is still offered.",
+        });
+    if (used.length > 0 && test.ok)
+        checks.push(await reachable(deps, status, used));
+    return { ...base, state: overall(checks, used.length > 0, true), checks };
+}

package/dist/slices/settings/key-guides.js

@@ -0,0 +1,138 @@
+const openAi = {
+    signUp: { label: "platform.openai.com/signup", url: "https://platform.openai.com/signup" },
+    keyPage: { label: "platform.openai.com/api-keys", url: "https://platform.openai.com/api-keys" },
+    billing: {
+        label: "Billing",
+        url: "https://platform.openai.com/settings/organization/billing/overview",
+    },
+    steps: [
+        "Sign up or sign in to the OpenAI platform.",
+        "Open Billing and buy prepaid credit (new accounts need at least $5 before any call works).",
+        "Open API keys, choose Create new secret key, and copy it (it is shown once).",
+        "Paste it here, choose Save, then Test.",
+    ],
+    permissions: "A key with All permissions works. A restricted key needs Models: Read (for Test) and Model capabilities: Request (for speech and images). GPT Image models may also need Verify Organization under Settings → Organization → General on the OpenAI platform.",
+    docs: {
+        label: "OpenAI API docs",
+        url: "https://developers.openai.com/api/docs/guides/error-codes",
+    },
+};
+const google = {
+    signUp: { label: "aistudio.google.com", url: "https://aistudio.google.com" },
+    keyPage: { label: "aistudio.google.com/apikey", url: "https://aistudio.google.com/apikey" },
+    billing: { label: "Projects → Set up billing", url: "https://aistudio.google.com/projects" },
+    steps: [
+        "Sign in to Google AI Studio with your Google account.",
+        "Open Projects and choose Set up billing next to your project: Gemini image models are not available on the free tier.",
+        "Open API keys, choose Create API key, and copy it.",
+        "Paste it here, choose Save, then Test.",
+    ],
+    permissions: "Use a key made in AI Studio. An older Google Cloud key must be set to Restrict to Gemini API only, or Google rejects it.",
+    docs: { label: "Gemini API keys", url: "https://ai.google.dev/gemini-api/docs/api-key" },
+};
+export const keyGuides = {
+    openrouter: {
+        signUp: { label: "openrouter.ai/sign-up", url: "https://openrouter.ai/sign-up" },
+        keyPage: { label: "openrouter.ai/settings/keys", url: "https://openrouter.ai/settings/keys" },
+        billing: { label: "Credits", url: "https://openrouter.ai/settings/credits" },
+        steps: [
+            "Sign up at OpenRouter.",
+            "Open Credits and buy credit (paid models are charged from it; a negative balance stops even free models).",
+            "Open Keys, choose Create API key, and copy it.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "Keys have no scopes. If you set a credit limit on the key, keep it above what a run costs.",
+        docs: { label: "OpenRouter docs", url: "https://openrouter.ai/docs/api-reference/limits" },
+    },
+    "openai-tts": openAi,
+    "openai-image": openAi,
+    "google-image": google,
+    "google-tts": {
+        ...google,
+        steps: [
+            "Sign in to Google AI Studio with your Google account.",
+            "Open API keys, choose Create API key, and copy it.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: `The same Gemini API key as Google images: with one saved there, Gemini voices use it and nothing is needed here. ${google.permissions}`,
+    },
+    fal: {
+        signUp: { label: "fal.ai/login", url: "https://fal.ai/login" },
+        keyPage: { label: "fal.ai/dashboard/keys", url: "https://fal.ai/dashboard/keys" },
+        billing: { label: "Billing", url: "https://fal.ai/dashboard/billing" },
+        steps: [
+            "Sign up at fal.ai.",
+            "Open Billing and buy credit: fal.ai is prepaid and locks the account when the balance runs out.",
+            "Open Keys, choose Add key with the API scope, and copy it.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "The API scope is enough; Slopify does not need an ADMIN key.",
+        docs: {
+            label: "fal.ai authentication",
+            url: "https://fal.ai/docs/model-apis/authentication",
+        },
+    },
+    replicate: {
+        signUp: { label: "replicate.com/signin", url: "https://replicate.com/signin" },
+        keyPage: {
+            label: "replicate.com/account/api-tokens",
+            url: "https://replicate.com/account/api-tokens",
+        },
+        billing: { label: "Billing", url: "https://replicate.com/account/billing" },
+        steps: [
+            "Sign in to Replicate.",
+            "Open Billing and buy credit: Replicate needs credit up front before it runs paid models.",
+            "Open API tokens, create a token, and copy it (it starts with r8_).",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "Tokens have no scopes.",
+        docs: { label: "Replicate billing", url: "https://replicate.com/docs/topics/billing" },
+    },
+    elevenlabs: {
+        signUp: { label: "elevenlabs.io/app/sign-up", url: "https://elevenlabs.io/app/sign-up" },
+        keyPage: {
+            label: "elevenlabs.io/app/developers/api-keys",
+            url: "https://elevenlabs.io/app/developers/api-keys",
+        },
+        steps: [
+            "Sign up at ElevenLabs.",
+            "Open Developers → API keys, choose Create key, and copy it.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "A restricted key needs Text to Speech access and Models read access (models_read) for Test; Voices read helps when picking voices. Remove any credit quota or IP allowlist that would block this computer.",
+        docs: {
+            label: "ElevenLabs API keys",
+            url: "https://elevenlabs.io/docs/api-reference/models/list",
+        },
+    },
+    cartesia: {
+        signUp: { label: "play.cartesia.ai/sign-up", url: "https://play.cartesia.ai/sign-up" },
+        keyPage: { label: "play.cartesia.ai/keys", url: "https://play.cartesia.ai/keys" },
+        steps: [
+            "Sign up at Cartesia (the free plan needs no card).",
+            "Open API Keys, create a key, and copy it (it starts with sk_car_).",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "Keys have no scopes.",
+        docs: {
+            label: "Cartesia authentication",
+            url: "https://docs.cartesia.ai/get-started/authenticate-your-client-applications",
+        },
+    },
+    inworld: {
+        signUp: { label: "platform.inworld.ai/signup", url: "https://platform.inworld.ai/signup" },
+        keyPage: {
+            label: "platform.inworld.ai/api-keys",
+            url: "https://platform.inworld.ai/api-keys",
+        },
+        billing: { label: "Billing", url: "https://platform.inworld.ai/billing" },
+        steps: [
+            "Sign up at the Inworld platform.",
+            "Open API Keys and choose Generate new key (a Standard key, not Realtime-only).",
+            "Copy the Base64 credentials value exactly as shown, without encoding it again.",
+            "Paste it here, choose Save, then Test.",
+        ],
+        permissions: "A Standard key covers speech and reading voices. Realtime-only keys do not work.",
+        docs: { label: "Inworld API keys", url: "https://docs.inworld.ai/portal/api-keys" },
+    },
+};

package/dist/slices/settings/key-test.js

@@ -0,0 +1,93 @@
+import { keyGuides } from "./key-guides.js";
+import { keyWithShared } from "./keys.js";
+import { providerById } from "./model.js";
+// What the Test button found. `ok` is the only thing the screen needs to colour the line;
+// `message` says what happened and, when it failed, exactly what to do.
+export const keyTestResults = [
+    "valid",
+    "no-key",
+    "rejected",
+    "forbidden",
+    "no-credit",
+    "rate-limited",
+    "provider-down",
+    "unreachable",
+    "unexpected",
+];
+// The mapping from what came back to what the user reads. Pure, so every branch is tested
+// without a network.
+export function keyTestOutcome(provider, answer, checkedAt, badKey) {
+    const name = providerById(provider).displayName;
+    const guide = keyGuides[provider];
+    const keyPage = guide === undefined ? "the provider's website" : guide.keyPage.url;
+    const billing = guide?.billing?.url;
+    const place = `Settings → Providers → ${name}`;
+    const done = (result, message) => ({
+        provider,
+        result,
+        ok: result === "valid",
+        message,
+        checkedAt,
+    });
+    if ("failure" in answer) {
+        if (answer.failure === "no-key")
+            return done("no-key", `No ${name} key is saved yet. Make one at ${keyPage}, paste it in ${place} and choose Save, then Test.`);
+        return done("unreachable", answer.failure === "timeout"
+            ? `${name} did not answer within 15 seconds, so the key could not be checked. Check your internet connection, then choose Test again.`
+            : `Slopify could not reach ${name}, so the key could not be checked. Check your internet connection (and any firewall or proxy), then choose Test again.`);
+    }
+    const { status } = answer;
+    if (status >= 200 && status < 300)
+        return done("valid", provider === "openrouter"
+            ? `${name} accepted this key.`
+            : `${name} accepted this key. The account's credit is only checked when Slopify first generates with it.`);
+    if (status === 401 || badKey?.(status, answer.body ?? "") === true)
+        return done("rejected", `${name} did not accept this key (HTTP ${status}): it is mistyped, revoked or for another account. Make a new key at ${keyPage}, paste it in ${place}, choose Save, then Test again.`);
+    if (status === 402)
+        return done("no-credit", `${name} accepted the key but the account has no credit or payment method (HTTP 402). Add credit${billing === undefined ? " in your account" : ` at ${billing}`}, then choose Test again.`);
+    if (status === 403)
+        return done("forbidden", `${name} recognised the key but refused this request (HTTP 403). The key may be restricted, or the account may need verifying or billing set up. ${guide?.permissions ?? ""} Fix it at ${keyPage}, then choose Test again.`.replace(/\s+/g, " "));
+    if (status === 429)
+        return done("rate-limited", `${name} said "too many requests" (HTTP 429), so the key could not be checked just now. It is usually valid; wait a minute and choose Test again. If it keeps happening, check the account's limits and credit${billing === undefined ? "" : ` at ${billing}`}.`);
+    if (status >= 500)
+        return done("provider-down", `${name} had a problem on its side (HTTP ${status}), so the key could not be checked. Wait a few minutes and choose Test again.`);
+    return done("unexpected", `${name} answered the key check with HTTP ${status}, which Slopify did not expect. Check the key at ${keyPage}, then choose Test again; if it keeps happening, use Download diagnostics in Settings and report it.`);
+}
+// The Test button. The key is read for this one request, sent only to its own provider, and
+// never appears in the answer, a log line or an error. `pasted` is a key typed into the field
+// and not saved yet: it is tried instead of the saved one and is not stored.
+export async function testProviderKey(deps, provider, pasted) {
+    const at = () => deps.clock.now().toISOString();
+    const probe = Object.hasOwn(deps.probes, provider) ? deps.probes[provider] : undefined;
+    if (probe === undefined || providerById(provider).auth !== "key")
+        throw new Error(`${provider} has no key to test`);
+    const candidate = pasted?.trim();
+    const key = candidate === undefined || candidate === "" ? keyWithShared(deps.db, provider) : candidate;
+    if (key === undefined)
+        return keyTestOutcome(provider, { failure: "no-key" }, at());
+    const outcome = await probeKey(deps, provider, probe, key, at);
+    return candidate === undefined || candidate === "" || !outcome.ok
+        ? outcome
+        : { ...outcome, message: `${outcome.message} It is not saved yet: choose Save to keep it.` };
+}
+async function probeKey(deps, provider, probe, key, at) {
+    let status;
+    let body = "";
+    try {
+        const response = await deps.fetch(probe.url, {
+            headers: probe.headers(key),
+            signal: AbortSignal.timeout(15_000),
+            redirect: "error",
+        });
+        status = response.status;
+        // Only an error body is read, and only its start: enough for the provider's error code.
+        body = status >= 400 ? (await response.text()).slice(0, 4096) : "";
+        if (status < 400)
+            await response.body?.cancel().catch(() => { });
+    }
+    catch (error) {
+        const timeout = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
+        return keyTestOutcome(provider, { failure: timeout ? "timeout" : "network" }, at());
+    }
+    return keyTestOutcome(provider, { status, body }, at(), probe.badKey);
+}

package/dist/slices/settings/keys.js

@@ -1,4 +1,4 @@
-import { providerById } from "./model.js";
+import { providerById, sharedKeyOf } from "./model.js";
 import { deleteKey, hasKey, keyOf, upsertKey } from "./repo.js";
 // The Settings field shows a stored key masked, with nothing legible in it, and a key never
 // appears outside a provider call. So the mask is a constant: it carries no character of
@@ -12,7 +12,7 @@ export function keyStatus(deps, provider) {
 // Trimmed, stored as given, overwriting any previous one. No format
 // check and no test call.
 export function saveProviderKey(deps, provider, key) {
-    if (providerById(provider).auth === "cli") {
+    if (providerById(provider).auth !== "key") {
         return { ok: false, reason: "cli-provider" };
     }
     const trimmed = key.trim();
@@ -31,7 +31,7 @@ export function saveProviderKey(deps, provider, key) {
     return { ok: true };
 }
 export function removeProviderKey(deps, provider) {
-    if (providerById(provider).auth === "cli") {
+    if (providerById(provider).auth !== "key") {
         return { ok: false, reason: "cli-provider" };
     }
     return deleteKey(deps.db, provider) ? { ok: true } : { ok: false, reason: "absent" };
@@ -40,12 +40,17 @@ export function removeProviderKey(deps, provider) {
 // every time and hands back a plain string, so an attempt holds the value it started
 // with and a save or a remove landing mid-run reaches the next attempt only.
 export function keyForAttempt(deps, provider) {
-    if (providerById(provider).auth === "cli") {
+    if (providerById(provider).auth !== "key") {
         return { ok: false, reason: "cli-provider" };
     }
-    const key = keyOf(deps.db, provider);
+    const key = keyWithShared(deps.db, provider);
     return key === undefined ? { ok: false, reason: "key-missing" } : { ok: true, key };
 }
+// The provider's own key, else the key of the provider it shares one with (`sharedKeyOf`).
+export function keyWithShared(db, provider) {
+    const shared = sharedKeyOf[provider];
+    return keyOf(db, provider) ?? (shared === undefined ? undefined : keyOf(db, shared));
+}
 function codeOf(error) {
     if (error instanceof Error && "errcode" in error && typeof error.errcode === "number") {
         return `sqlite error ${String(error.errcode)}`;

package/dist/slices/settings/model-reach.js

@@ -0,0 +1,52 @@
+import { keyOf } from "./repo.js";
+// ceiling: a provider chosen in many templates still costs a handful of reads, not one per
+// model anywhere in the library.
+const modelsChecked = 5;
+export async function modelReach(deps, provider, models) {
+    const probe = Object.hasOwn(deps.probes, provider) ? deps.probes[provider] : undefined;
+    const key = keyOf(deps.db, provider);
+    if (probe?.model === undefined || key === undefined)
+        return undefined;
+    const reads = new Map();
+    const read = (url) => {
+        const known = reads.get(url);
+        if (known !== undefined)
+            return known;
+        const started = (async () => {
+            try {
+                const response = await deps.fetch(url, {
+                    headers: probe.headers(key),
+                    signal: AbortSignal.timeout(15_000),
+                    redirect: "error",
+                });
+                // A list is read whole; a single model's page only for its status.
+                const body = probe.model?.lists === undefined ? "" : await response.text();
+                if (probe.model?.lists === undefined)
+                    await response.body?.cancel().catch(() => { });
+                return { status: response.status, body };
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        reads.set(url, started);
+        return started;
+    };
+    const found = new Map();
+    for (const model of [...new Set(models)].slice(0, modelsChecked)) {
+        const answer = await read(probe.model.url(model));
+        found.set(model, verdict(answer, model, probe.model.lists));
+    }
+    return found;
+}
+function verdict(answer, model, lists) {
+    if (answer === undefined)
+        return "unknown";
+    if (answer.status >= 200 && answer.status < 300) {
+        if (lists === undefined)
+            return "found";
+        const listed = lists(answer.body, model);
+        return listed === undefined ? "unknown" : listed ? "found" : "missing";
+    }
+    return answer.status === 404 && lists === undefined ? "missing" : "unknown";
+}

package/dist/slices/settings/model.js

@@ -1,4 +1,5 @@
 // The provider catalogue and the settings domain types.
+import { defaultLoudness } from "../loudness/model.js";
 // The three families are the three ports, so the set is named beside them.
 export { providerFamilies } from "../../kernel/ports/model.js";
 // The supported set. OpenAI ships two adapters with two ids, one per family:
@@ -13,6 +14,8 @@ export const providerIds = [
     "openai-tts",
     "cartesia",
     "inworld",
+    "system-voice",
+    "google-tts",
     "fal",
     "replicate",
     "openai-image",
@@ -27,6 +30,12 @@ export function isLocalCliProvider(id) {
 export function localCliConcurrency(id) {
     return id === "codex-image" ? 4 : 3;
 }
+export const systemVoiceProvider = "system-voice";
+// A provider Slopify's model list (models.yaml) does not carry: an agent CLI lists its own
+// models, and the system voice's "models" are the speech programs found on this computer.
+export function isUncataloguedProvider(id) {
+    return isLocalCliProvider(id) || id === systemVoiceProvider;
+}
 export const providers = [
     { id: "openrouter", family: "llm", displayName: "OpenRouter", auth: "key" },
     {
@@ -57,6 +66,8 @@ export const providers = [
     { id: "openai-tts", family: "tts", displayName: "OpenAI", auth: "key" },
     { id: "cartesia", family: "tts", displayName: "Cartesia", auth: "key" },
     { id: "inworld", family: "tts", displayName: "Inworld", auth: "key" },
+    { id: "system-voice", family: "tts", displayName: "System voice", auth: "local" },
+    { id: "google-tts", family: "tts", displayName: "Google Gemini", auth: "key" },
     { id: "fal", family: "image", displayName: "fal.ai", auth: "key" },
     { id: "replicate", family: "image", displayName: "Replicate", auth: "key" },
     { id: "openai-image", family: "image", displayName: "OpenAI", auth: "key" },
@@ -70,6 +81,45 @@ export const providers = [
         versionArgs: ["--version"],
     },
 ];
+// One Gemini API key pays for Google's speech and its images, so Gemini TTS uses the key saved
+// for Google images until one of its own is saved.
+export const sharedKeyOf = {
+    "google-tts": "google-image",
+};
+// The 30 prebuilt voices Gemini TTS speaks with (https://ai.google.dev/gemini-api/docs/speech-generation#voices),
+// each with the style Google gives it. Settings → Voices offers them for Google Gemini.
+export const geminiVoices = [
+    { name: "Zephyr", style: "Bright" },
+    { name: "Puck", style: "Upbeat" },
+    { name: "Charon", style: "Informative" },
+    { name: "Kore", style: "Firm" },
+    { name: "Fenrir", style: "Excitable" },
+    { name: "Leda", style: "Youthful" },
+    { name: "Orus", style: "Firm" },
+    { name: "Aoede", style: "Breezy" },
+    { name: "Callirrhoe", style: "Easy-going" },
+    { name: "Autonoe", style: "Bright" },
+    { name: "Enceladus", style: "Breathy" },
+    { name: "Iapetus", style: "Clear" },
+    { name: "Umbriel", style: "Easy-going" },
+    { name: "Algieba", style: "Smooth" },
+    { name: "Despina", style: "Smooth" },
+    { name: "Erinome", style: "Clear" },
+    { name: "Algenib", style: "Gravelly" },
+    { name: "Rasalgethi", style: "Informative" },
+    { name: "Laomedeia", style: "Upbeat" },
+    { name: "Achernar", style: "Soft" },
+    { name: "Alnilam", style: "Firm" },
+    { name: "Schedar", style: "Even" },
+    { name: "Gacrux", style: "Mature" },
+    { name: "Pulcherrima", style: "Forward" },
+    { name: "Achird", style: "Friendly" },
+    { name: "Zubenelgenubi", style: "Casual" },
+    { name: "Vindemiatrix", style: "Gentle" },
+    { name: "Sadachbia", style: "Lively" },
+    { name: "Sadaltager", style: "Knowledgeable" },
+    { name: "Sulafat", style: "Warm" },
+];
 export function providerById(id) {
     const found = providers.find((provider) => provider.id === id);
     if (found === undefined) {
@@ -81,4 +131,8 @@ export function providerById(id) {
 }
 // The theme override the Appearance control writes.
 export const appearances = ["system", "light", "dark"];
-export const defaultSettings = { silenceGapSeconds: 3, appearance: "system" };
+export const defaultSettings = {
+    silenceGapSeconds: 3,
+    appearance: "system",
+    loudness: defaultLoudness,
+};