@turri-dev/cli 0.1.9-next.73bfddf → 0.1.10-next.2abf2db

package/dist/init-config.js

@@ -6,20 +6,122 @@ import { load as loadYaml } from "js-yaml";
 import { adoptLegacyConfig, CONFIG_FILE, CONFIG_KEYS, LEGACY_CONFIG_FILE, ROLE_THINKING } from "./config.js";
 import { withTopLevelValue } from "./config-edit.js";
 import { brand } from "./brand.js";
-/** The geographies Bedrock serves each maker's two models in, as pi knows them - the first the default. */
+import { closestModels, piModelCatalogue } from "./model-check.js";
+/** The geographies turri's own pair for each maker is served in - the first the default. Every other: bedrockMakers. */
 export const BEDROCK_REGIONS = {
     anthropic: ["global", "us", "eu", "jp", "au"],
     openai: ["global", "us"],
 };
-/** An AWS region in each geography, for AWS_REGION: pi calls Bedrock there, us-east-1 when none is set. */
-const AWS_REGION_IN = { global: "us-east-1", us: "us-east-1", eu: "eu-central-1", jp: "ap-northeast-1", au: "ap-southeast-2" };
-/** Bedrock's models for a maker in a geography: Opus 5.5 and Haiku 5.5, or GPT-6 Astra and Luna. */
+/** The geographies an inference profile's id starts with, in the order they are offered. */
+export const BEDROCK_GEOGRAPHIES = ["global", "us", "eu", "jp", "au", "apac", "in", "ca", "us-gov"];
+/** A Bedrock model whose id names no geography: served in the AWS region it is called in. */
+export const BEDROCK_IN_REGION = "in-region";
+/** An AWS region in each geography, for AWS_REGION: pi calls Bedrock there - us-east-1 when nothing names another. */
+const AWS_REGION_IN = {
+    global: "us-east-1",
+    us: "us-east-1",
+    eu: "eu-central-1",
+    jp: "ap-northeast-1",
+    au: "ap-southeast-2",
+    apac: "ap-southeast-1",
+    in: "ap-south-1",
+    ca: "ca-central-1",
+    "us-gov": "us-gov-west-1",
+};
+/** The AWS region to call a geography's models in - AWS_REGION's value. */
+export function bedrockAwsRegion(geography) {
+    return AWS_REGION_IN[geography] ?? "us-east-1";
+}
+/**
+ * Whether a geography's models need AWS_REGION set: every one but global, us and in-region, which pi's us-east-1 serves.
+ * pi calls Bedrock in AWS_REGION, else - with an AWS_PROFILE - the profile's region, else us-east-1. It pins eu's
+ * endpoint itself only with neither AWS_REGION nor AWS_PROFILE set, so eu needs it too.
+ */
+export function bedrockNeedsAwsRegion(geography) {
+    return !["global", "us", BEDROCK_IN_REGION].includes(geography);
+}
+/** Where a Bedrock model is served and whose it is, from its id or spec: `global.xai.grok-4.7` - global, xai; `meta.llama4` - in-region, meta. */
+export function bedrockPlaceOf(model) {
+    const [first = "", second = ""] = model.replace(/^amazon-bedrock\//, "").split(".");
+    return BEDROCK_GEOGRAPHIES.includes(first) ? { geography: first, maker: second } : { geography: BEDROCK_IN_REGION, maker: first };
+}
+/** A maker's name, as the messages and questions say it. */
+const MAKER_LABELS = {
+    anthropic: "Anthropic",
+    openai: "OpenAI",
+    google: "Google",
+    xai: "xAI",
+    meta: "Meta",
+    mistral: "Mistral",
+    qwen: "Qwen",
+    deepseek: "DeepSeek",
+    amazon: "Amazon",
+    moonshot: "Moonshot",
+    moonshotai: "Moonshot AI",
+    zai: "Z.ai",
+    minimax: "MiniMax",
+    nvidia: "NVIDIA",
+    writer: "Writer",
+};
+/** A maker's - or a provider's - name, as the messages say it: xAI for xai; its id when turri has no name for it. */
+export function makerLabel(maker) {
+    return MAKER_LABELS[maker] ?? maker;
+}
+/** Bedrock's chat models in pi's catalogue. */
+const bedrockChat = (catalogue) => catalogue.models("amazon-bedrock").filter((model) => model.type === "chat");
+/** Every maker pi's catalogue serves on Bedrock - Anthropic and OpenAI first, the rest by name - with their geographies. */
+export function bedrockMakers(catalogue) {
+    const regions = new Map();
+    for (const model of bedrockChat(catalogue)) {
+        const { geography, maker } = bedrockPlaceOf(model.id);
+        if (maker === "")
+            continue;
+        regions.set(maker, (regions.get(maker) ?? new Set()).add(geography));
+    }
+    const order = [...BEDROCK_GEOGRAPHIES, BEDROCK_IN_REGION];
+    const first = (maker) => (maker === "anthropic" ? 0 : maker === "openai" ? 1 : 2);
+    return [...regions]
+        .map(([maker, served]) => ({ maker, label: makerLabel(maker), regions: order.filter((region) => served.has(region)) }))
+        .sort((a, b) => first(a.maker) - first(b.maker) || a.label.localeCompare(b.label));
+}
+/** A maker's chat models in a geography, as pi's catalogue has them on Bedrock. */
+export function bedrockModelsIn(catalogue, choice) {
+    return bedrockChat(catalogue).filter((model) => {
+        const place = bedrockPlaceOf(model.id);
+        return place.maker === choice.maker && place.geography === choice.region;
+    });
+}
+/** Whether turri's own pair for the maker is served in the geography. */
+function hasPreset(choice) {
+    const maker = choice.maker ?? BEDROCK_DEFAULT.maker;
+    return (maker === "anthropic" || maker === "openai") && BEDROCK_REGIONS[maker].includes(choice.region);
+}
+/** turri's own pair on Bedrock for a maker in a geography: Opus 5.5 and Haiku 5.5, or GPT-6 Astra and Luna. */
 export function bedrockModels(choice) {
     const at = (id) => `amazon-bedrock/${choice.region}.${id}`;
-    return choice.maker === "anthropic"
+    return (choice.maker ?? "anthropic") === "anthropic"
         ? { harness: at("anthropic.claude-opus-5-5"), coding: at("anthropic.claude-haiku-5-5"), strong: at("anthropic.claude-opus-5-5") }
         : { harness: at("openai.gpt-6-astra"), coding: at("openai.gpt-6-luna"), strong: at("openai.gpt-6.1-sol") };
 }
+/**
+ * The pair to offer for a maker in a geography: turri's own where it has one; else, from pi's catalogue, the strongest
+ * that reasons to talk to - price standing in for strength - and the cheapest costing at least a fifth of it to code,
+ * ties to the newest. Undefined when the catalogue has none of the maker's models there.
+ */
+export function bedrockDefaultModels(catalogue, choice) {
+    if (hasPreset(choice))
+        return bedrockModels(choice);
+    const models = bedrockModelsIn(catalogue, { maker: choice.maker ?? BEDROCK_DEFAULT.maker, region: choice.region });
+    if (models.length === 0)
+        return undefined;
+    const price = (model) => model.cost.input + model.cost.output;
+    const newest = (a, b) => b.id.localeCompare(a.id, undefined, { numeric: true });
+    const reasoning = models.some((model) => model.reasoning) ? models.filter((model) => model.reasoning) : models;
+    const talk = [...reasoning].sort((a, b) => price(b) - price(a) || newest(a, b))[0];
+    const code = models.filter((model) => price(model) >= price(talk) / 5).sort((a, b) => price(a) - price(b) || newest(a, b))[0];
+    const spec = (model) => `amazon-bedrock/${model.id}`;
+    return { harness: spec(talk), coding: spec(code), strong: spec(talk) };
+}
 /** Bedrock's default: Anthropic's models, anywhere. */
 export const BEDROCK_DEFAULT = { maker: "anthropic", region: "global" };
 export const VENDORS = {
@@ -44,10 +146,10 @@ export const VENDORS = {
         strong: "google/gemini-3.1-pro-preview",
         keys: [{ vendor: "Google", variable: "GEMINI_API_KEY" }],
     },
-    // Anthropic's or OpenAI's models on AWS - which, and where, is asked: this is the default, Anthropic's anywhere.
+    // Any maker's models on AWS - whose, where and which, is asked: this is the default, Anthropic's anywhere.
     "amazon-bedrock": {
         label: "Amazon Bedrock",
-        ...bedrockModels(BEDROCK_DEFAULT),
+        ...bedrockModels({ maker: "anthropic", region: BEDROCK_DEFAULT.region }),
         keys: [{ vendor: "AWS", variable: "AWS_PROFILE" }],
     },
     // A mix - the strongest to talk to, a cheap one to code - and the starting point for any other provider pi supports.
@@ -71,9 +173,14 @@ function role(name, model, comment) {
     const fields = [...(model !== undefined ? [`model: ${model}`] : []), `thinking: ${ROLE_THINKING[name]}`].join(", ");
     return `${column(`#   ${name}: { ${fields} }`, 72)}# ${comment}`;
 }
-/** A vendor's three models - for Bedrock, the maker and geography chosen. */
+/** A vendor's three models - for Bedrock, turri's own pair for the maker and geography chosen. */
 function modelsOf(vendor, bedrock) {
-    return vendor === "amazon-bedrock" ? bedrockModels(bedrock ?? BEDROCK_DEFAULT) : VENDORS[vendor];
+    if (vendor !== "amazon-bedrock")
+        return VENDORS[vendor];
+    const choice = bedrock ?? BEDROCK_DEFAULT;
+    if (!hasPreset(choice))
+        throw new Error(`turri has no pair of its own for ${choice.maker ?? BEDROCK_DEFAULT.maker}'s models on Bedrock (${choice.region}): name the two models`);
+    return bedrockModels(choice);
 }
 /** The two model lines: the one you talk to thinking medium, the coding one low - their comments in one column. */
 function modelLines(harness, coding) {
@@ -126,9 +233,9 @@ export const DEFAULTS = {
 export function defaultParallel(cores = availableParallelism()) {
     return Math.min(4, Math.max(1, Math.floor(cores / 2)));
 }
-/** The quick start config.turri.yaml for a vendor's models - for Bedrock, the maker and geography chosen. */
-export function quickStartConfig(vendor = "other", bedrock) {
-    const { harness, coding, strong } = modelsOf(vendor, bedrock);
+/** The quick start config.turri.yaml for a vendor's models - for Bedrock, the maker and geography chosen - or the models given. */
+export function quickStartConfig(vendor = "other", bedrock, models) {
+    const { harness, coding, strong } = models ?? modelsOf(vendor, bedrock);
     return [
         "# Any model pi supports works (https://pi.dev): a capable one to talk to, a smaller, cheaper one for the coding.",
         ...modelLines(harness, coding),
@@ -248,19 +355,23 @@ export function vendorOf(answer) {
         return "amazon-bedrock";
     return byNumber ?? names.find((name) => name === typed || VENDORS[name].label.toLowerCase() === typed);
 }
-/** Bedrock's maker from what was typed: its number - 1 Anthropic, 2 OpenAI - or its name. */
-export function bedrockMakerOf(answer) {
+/** The makers offered, as numbered: pi's catalogue's, or without it turri's two. */
+function makersOffered(catalogue) {
+    return catalogue !== undefined
+        ? bedrockMakers(catalogue)
+        : Object.keys(BEDROCK_REGIONS).map((maker) => ({ maker, label: makerLabel(maker), regions: BEDROCK_REGIONS[maker] }));
+}
+/** Bedrock's maker from what was typed: its number in the list - with no catalogue, 1 Anthropic, 2 OpenAI - or its name. */
+export function bedrockMakerOf(answer, catalogue) {
     const typed = answer.trim().toLowerCase();
-    if (typed === "1" || typed === "anthropic")
-        return "anthropic";
-    if (typed === "2" || typed === "openai")
-        return "openai";
-    return undefined;
+    const offered = makersOffered(catalogue);
+    const byNumber = /^\d+$/.test(typed) ? offered[Number(typed) - 1] : undefined;
+    return (byNumber ?? offered.find((offer) => offer.maker === typed || offer.label.toLowerCase() === typed))?.maker;
 }
-/** A geography the maker's models are served in, from what was typed: its number in the list, or its name. */
-export function bedrockRegionOf(maker, answer) {
+/** A geography the maker's models are served in, from what was typed: its number in the list, or its name - pi's catalogue's, or without it turri's pair's. */
+export function bedrockRegionOf(maker, answer, catalogue) {
     const typed = answer.trim().toLowerCase();
-    const regions = BEDROCK_REGIONS[maker];
+    const regions = makersOffered(catalogue).find((offer) => offer.maker === maker)?.regions ?? [];
     return (/^\d+$/.test(typed) ? regions[Number(typed) - 1] : undefined) ?? regions.find((region) => region === typed);
 }
 /** The shell profile an exported key is kept in, for the shell this person uses. */
@@ -273,8 +384,12 @@ function shellProfile() {
     return "~/.bashrc";
 }
 /** How to sign in to the vendor's models, as pi takes them: a key in the environment, or /login - a few lines. */
-function signInText(vendor, bedrock) {
-    const { keys } = VENDORS[vendor];
+function signInText(vendor, bedrock, models) {
+    // Models given on another vendor's terms - other's, a provider of their own: the keys of the providers they name.
+    const providers = models !== undefined && vendor === "other" ? [...new Set([models.harness, models.coding].map((model) => model.split("/")[0]))] : [];
+    const keys = providers.length > 0
+        ? providers.flatMap((provider) => (provider in VENDORS && provider !== "other" && provider !== "amazon-bedrock" ? VENDORS[provider].keys : [{ vendor: makerLabel(provider), variable: "" }]))
+        : VENDORS[vendor].keys;
     const windows = process.platform === "win32";
     const set = (variable, value = "...") => brand.accent(windows ? `setx ${variable} "${value}"` : `export ${variable}=${value}`);
     // Bedrock's are several; a vendor's own key is one, or the mix's two.
@@ -283,7 +398,8 @@ function signInText(vendor, bedrock) {
         ? `setx keeps ${several ? "them" : "it"} for new terminals - open one before you run turri.`
         : `Add ${several ? "them" : "it"} to ${shellProfile()} to keep ${several ? "them" : "it"}.`;
     if (vendor === "amazon-bedrock") {
-        const region = AWS_REGION_IN[(bedrock ?? BEDROCK_DEFAULT).region] ?? "us-east-1";
+        const geography = (bedrock ?? BEDROCK_DEFAULT).region;
+        const region = bedrockAwsRegion(geography);
         return [
             brand.bold("Sign in to AWS"),
             `  ${set("AWS_PROFILE")}   ${brand.muted("your profile (aws configure, or aws sso login)")}`,
@@ -291,25 +407,107 @@ function signInText(vendor, bedrock) {
             `  ${brand.muted("or, instead of a profile, a Bedrock API key:")} ${set("AWS_BEARER_TOKEN_BEDROCK")}`,
             "",
             brand.muted(keep),
+            ...(bedrockNeedsAwsRegion(geography)
+                ? [brand.muted(`AWS_REGION has to be in ${geography}'s geography, as ${region} is: pi calls Bedrock in us-east-1 unless it - or the profile - names another.`)]
+                : []),
             brand.muted("Your AWS account needs access to the models: Bedrock console, model access."),
         ];
     }
     return [
         brand.bold(`Sign in to ${keys.map((key) => key.vendor).join(" and ")}`),
-        ...keys.map((key) => `  ${set(key.variable)}`),
+        ...keys.map((key) => (key.variable !== "" ? `  ${set(key.variable)}` : `  ${brand.muted(`the key pi reads for ${key.vendor} - https://pi.dev`)}`)),
         "",
         brand.muted(`${keep} Or start turri and type /login.`),
-        ...(vendor === "other" ? [brand.muted("Another provider: change the two models to any pi supports, and set its key - https://pi.dev.")] : []),
+        ...(vendor === "other" && models === undefined ? [brand.muted("Another provider: change the two models to any pi supports, and set its key - https://pi.dev.")] : []),
     ];
 }
-/** Whose models these are, in the message: "OpenAI's", "a mix of", "OpenAI's on Amazon Bedrock (global)". */
-function whose(vendor, bedrock) {
-    if (vendor === "other")
-        return "a mix of";
+/** Names joined as a sentence says them: "a", "a and b", "a, b and c". */
+const and = (names) => (names.length < 2 ? names.join("") : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`);
+/**
+ * Whose models these are, in the message - from the models written: "OpenAI's models", "a mix of models", "xAI's models
+ * on Amazon Bedrock (global)", "Anthropic's and OpenAI's models" for a pair of two providers given.
+ */
+function whose(vendor, models, given) {
+    const pair = [models.harness, models.coding];
+    if (vendor === "amazon-bedrock") {
+        const places = pair.map(bedrockPlaceOf);
+        const makers = [...new Set(places.map((place) => `${makerLabel(place.maker)}'s`))];
+        return `${and(makers)} models on Amazon Bedrock (${[...new Set(places.map((place) => place.geography))].join(", ")})`;
+    }
+    if (vendor !== "other")
+        return `${VENDORS[vendor].label}'s models`;
+    if (!given)
+        return "a mix of models";
+    return `${and([...new Set(pair.map((model) => `${makerLabel(model.split("/")[0])}'s`))])} models`;
+}
+/** The thinking levels a spec may end with - not part of a model given to init-config. */
+const THINKING = /:(off|minimal|low|medium|high|xhigh|max)$/;
+/** Why a model given cannot be written - or undefined when pi's catalogue has it as a chat model. */
+function notInCatalogue(spec, catalogue) {
+    const slash = spec.indexOf("/");
+    if (slash <= 0)
+        return `${spec} is not provider/model-id - amazon-bedrock/global.xai.grok-4.7, say.`;
+    const [provider, id] = [spec.slice(0, slash), spec.slice(slash + 1)];
+    const known = catalogue.models(provider);
+    const model = known.find((entry) => entry.id === id);
+    if (model === undefined) {
+        if (THINKING.test(id) && known.some((entry) => entry.id === id.replace(THINKING, "")))
+            return `${spec} names a thinking level: give the model alone, ${spec.replace(THINKING, "")} - turri writes how hard each thinks.`;
+        if (known.length === 0)
+            return `${spec} is not in pi's model catalogue: pi knows no provider ${provider}.`;
+        const close = closestModels(id, known.filter((entry) => entry.type === "chat").map((entry) => entry.id));
+        return `${spec} is not in pi's model catalogue${close.length > 0 ? ` - did you mean ${close.map((other) => `${provider}/${other}`).join(", ")}?` : "."}`;
+    }
+    if (model.type !== "chat")
+        return `${spec} is pi's ${model.type} model, not a chat model: turri's agents need one to talk to.`;
+    return undefined;
+}
+/** Whose models a vendor's are: the provider its specs start with. */
+const providerOf = (vendor) => (vendor === "other" ? undefined : vendor);
+/**
+ * The models to write, and the vendor and Bedrock choice they are written for - or what is wrong with what was given:
+ * models given, checked against pi's catalogue; a Bedrock maker or geography turri has no pair of its own for, the
+ * catalogue's default pair; otherwise the vendor's own, as before, no catalogue read.
+ */
+async function chosenModels(options) {
+    const catalogue = async () => options.catalogue ?? (await piModelCatalogue());
+    if (options.models !== undefined) {
+        const { harness, coding } = options.models;
+        const models = { harness, coding, strong: options.models.strong ?? harness };
+        const known = await catalogue();
+        const problems = [...new Set([models.harness, models.coding, models.strong])].map((spec) => notInCatalogue(spec, known)).filter((problem) => problem !== undefined);
+        if (problems.length > 0)
+            return { problem: problems.join("\n") };
+        const providers = [...new Set(Object.values(models).map((spec) => spec.split("/")[0]))];
+        const vendor = options.vendor ?? (providers.length === 1 && providers[0] in VENDORS ? providers[0] : "other");
+        const wrong = [...new Set(Object.values(models))].filter((spec) => providerOf(vendor) !== undefined && spec.split("/")[0] !== providerOf(vendor));
+        if (wrong.length > 0)
+            return { problem: `${wrong.join(", ")} ${wrong.length === 1 ? "is not" : "are not"} ${VENDORS[vendor].label}'s: with vendor ${vendor}, every model is ${vendor}/... - or leave the vendor out.` };
+        if (vendor !== "amazon-bedrock")
+            return { vendor, models, given: true };
+        const places = [models.harness, models.coding].map(bedrockPlaceOf);
+        const region = options.bedrock?.region ?? places[0].geography;
+        if (!places.some((place) => place.geography === region))
+            return { problem: `Neither model is served in ${region} on Bedrock: ${models.harness} and ${models.coding} are ${and([...new Set(places.map((place) => place.geography))])}'s.` };
+        const maker = options.bedrock?.maker ?? places[0].maker;
+        if (!places.some((place) => place.maker === maker))
+            return { problem: `Neither model is ${makerLabel(maker)}'s: ${models.harness} and ${models.coding}.` };
+        return { vendor, bedrock: { maker, region }, models, given: true };
+    }
+    const vendor = options.vendor ?? "other";
     if (vendor !== "amazon-bedrock")
-        return `${VENDORS[vendor].label}'s`;
-    const choice = bedrock ?? BEDROCK_DEFAULT;
-    return `${VENDORS[choice.maker].label}'s on Amazon Bedrock (${choice.region})`;
+        return { vendor, models: modelsOf(vendor), given: false };
+    const bedrock = { maker: options.bedrock?.maker ?? BEDROCK_DEFAULT.maker, region: options.bedrock?.region ?? BEDROCK_DEFAULT.region };
+    if (hasPreset(bedrock))
+        return { vendor, bedrock, models: bedrockModels(bedrock), given: false };
+    const known = await catalogue();
+    const offer = bedrockMakers(known).find((entry) => entry.maker === bedrock.maker);
+    if (offer === undefined)
+        return { problem: `pi's catalogue has no models of ${makerLabel(bedrock.maker)}'s on Amazon Bedrock.` };
+    const models = bedrockDefaultModels(known, bedrock);
+    if (models === undefined)
+        return { problem: `Amazon Bedrock serves ${offer.label}'s models in ${and(offer.regions)}, not ${bedrock.region}.` };
+    return { vendor, bedrock, models, given: false };
 }
 /**
  * What a config.yaml in `folder` says that turri reads too - another tool's testing scripts, say - by turri's names
@@ -346,23 +544,26 @@ export function sharedWithLegacy(folder) {
 }
 /**
  * Write the quick start config.turri.yaml in `dir`, with what a config.yaml beside it says that turri reads too. One already
- * there keeps everything but its two models, which are set to the vendor's - `force` writes the whole of it again. Says
- * what it did.
+ * there keeps everything but its two models, which are set to the vendor's - or the ones given - and `force` writes the
+ * whole of it again. Says what it did; a model pi's catalogue does not have writes nothing and says so.
  */
-export function initConfig(dir, options = {}) {
+export async function initConfig(dir, options = {}) {
+    const chosen = await chosenModels(options);
+    if ("problem" in chosen)
+        return { written: false, message: chosen.problem };
+    const { vendor, bedrock, models, given } = chosen;
     const folder = resolve(dir);
     // The old stacks' files, config.<stack>.yaml, copied to their new names; config.turri.yaml is written below.
     adoptLegacyConfig(folder, { projectFile: false });
     const path = join(folder, CONFIG_FILE);
-    const vendor = options.vendor ?? "other";
     const existing = existsSync(path) && options.force !== true;
-    const { harness, coding } = modelsOf(vendor, options.bedrock);
+    const { harness, coding } = models;
     const lines = modelLines(harness, coding);
     // A new file takes what a config.yaml beside it - another tool's, say - says that turri reads too: its testing scripts, say.
     const shared = existing ? { carried: [], left: [] } : sharedWithLegacy(folder);
     const config = existing
         ? withModels(readFileSync(path, "utf8"), lines)
-        : shared.carried.reduce((text, [key, value]) => withTopLevelValue(text, key, value), quickStartConfig(vendor, options.bedrock));
+        : shared.carried.reduce((text, [key, value]) => withTopLevelValue(text, key, value), quickStartConfig(vendor, bedrock, models));
     writeFileSync(path, config);
     const here = resolve(process.cwd()) === folder;
     const [talk, code] = [harness, coding].map((model, at) => `${model}:${at === 0 ? HARNESS_THINKING : ROLE_THINKING.coding}`);
@@ -371,7 +572,7 @@ export function initConfig(dir, options = {}) {
         message: [
             "",
             `${brand.success("✓")} ${existing ? `Set the two models in ${brand.bold(path)}` : `Wrote ${brand.bold(path)}`}`,
-            `  ${brand.muted(`with ${whose(vendor, options.bedrock)} models${existing ? " - everything else in it left as it was (--force writes it all again)" : ""}`)}`,
+            `  ${brand.muted(`with ${whose(vendor, models, given)}${existing ? " - everything else in it left as it was (--force writes it all again)" : ""}`)}`,
             "",
             `  ${brand.muted("you talk to")}   ${talk}`,
             `  ${brand.muted("it codes")}      ${code}`,
@@ -383,7 +584,7 @@ export function initConfig(dir, options = {}) {
                 ]
                 : []),
             "",
-            ...signInText(vendor, options.bedrock),
+            ...signInText(vendor, bedrock, given ? models : undefined),
             "",
             brand.bold("Then"),
             ...(here ? [] : [`  ${brand.accent(`cd ${folder}`)}`]),
@@ -397,12 +598,17 @@ export function initConfig(dir, options = {}) {
     };
 }
 const USAGE = [
-    "usage: turri init-config [--vendor anthropic|openai|google|amazon-bedrock|other] [--maker anthropic|openai] [--region <geography>] [--force] [folder]",
+    "usage: turri init-config [--vendor anthropic|openai|google|amazon-bedrock|other] [--maker <maker>] [--region <geography>]",
+    "                         [--harness-model <spec> --coding-model <spec> [--judge-model <spec>]] [--force] [folder]",
     "",
     "Write a quick start config.turri.yaml in the folder, the current one by default: the model you talk to and the one that",
     "writes the code, from the vendor you use. Asked when --vendor is not given and this is a terminal; otherwise other -",
     "a mix of Anthropic and Google, the starting point for any provider pi supports. On amazon-bedrock, --maker and",
-    "--region say whose models and where (anthropic: global, us, eu, jp, au; openai: global, us) - asked when not given.",
+    "--region say whose models and where - any maker and geography pi's catalogue has there (anthropic, openai, xai, meta,",
+    "...; global, us, eu, jp, au, apac, in, ca, us-gov, or in-region) - asked when not given, then which two, turri's own",
+    "pair or the catalogue's offered first. --harness-model and --coding-model name the two instead, as provider/model-id",
+    "without a thinking level - amazon-bedrock/global.xai.grok-4.7 - any pi's catalogue has; --judge-model the strong one",
+    "the judging examples name, the harness model unless given. The vendor, maker and region are read from them.",
     "A config.turri.yaml already there keeps everything but its two models; --force writes the whole of it again. A new",
     "one takes from a config.yaml beside it - another tool's, say - the keys turri reads too, its testing scripts say, and leaves",
     "config.yaml as it is.",
@@ -416,15 +622,20 @@ async function askUntil(rl, prompt, read, again) {
         console.log(again);
     }
 }
-/** Ask which vendor's models to use - a number or a name - and, for Amazon Bedrock, whose and where: what is not given. */
-async function askVendor(given) {
+/** A model's price, as the list of models shows it: dollars a million tokens in and out. */
+const priced = (model) => `$${model.cost.input}/$${model.cost.output} a million tokens in/out${model.reasoning ? "" : ", no reasoning"}`;
+/**
+ * Ask which vendor's models to use - a number or a name - and, for Amazon Bedrock, whose and where, from pi's catalogue,
+ * then which two: the pair offered taken with Enter, or chosen from the maker's models there. What is given is not asked.
+ */
+async function askVendor(given, catalogue) {
     const names = Object.keys(VENDORS);
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     /** A question: a blank line before it, its choices numbered, each with what it is. */
     const ask = (question, choices) => {
         console.log(`\n${brand.bold(brand.accent(question))}`);
         const width = Math.max(...choices.map(([label]) => label.length)) + 3;
-        choices.forEach(([label, what], index) => console.log(`  ${brand.accent(`${index + 1}`)}  ${label.padEnd(width)}${brand.muted(what)}`));
+        choices.forEach(([label, what], index) => console.log(`  ${brand.accent(`${String(index + 1).padStart(String(choices.length).length)}`)}  ${label.padEnd(width)}${brand.muted(what)}`));
     };
     const choose = (count) => `\n${brand.muted(`Choose 1-${count}:`)} `;
     try {
@@ -433,7 +644,7 @@ async function askVendor(given) {
             ask("Which vendor's models do you use?", names.map((name) => {
                 const { label, harness, coding } = VENDORS[name];
                 const what = name === "amazon-bedrock"
-                    ? "Anthropic's or OpenAI's models on AWS"
+                    ? "Anthropic's, OpenAI's, xAI's, Meta's... models on AWS"
                     : `${name === "other" ? "a mix - " : ""}${harness.split("/")[1]} to talk to, ${coding.split("/")[1]} to code`;
                 return [label, what];
             }));
@@ -441,21 +652,47 @@ async function askVendor(given) {
         }
         if (vendor !== "amazon-bedrock")
             return { vendor };
+        const known = await catalogue();
+        const makers = bedrockMakers(known);
         let maker = given.maker;
         if (maker === undefined) {
-            ask("Whose models, on Amazon Bedrock?", [
-                ["Anthropic", "Claude Opus 5.5 to talk to, Claude Haiku 5.5 to code"],
-                ["OpenAI", "GPT-6 Astra to talk to, GPT-6 Luna to code"],
-            ]);
-            maker = await askUntil(rl, choose(2), bedrockMakerOf, "Type 1 or 2, or anthropic or openai.");
+            ask("Whose models, on Amazon Bedrock?", makers.map((offer) => {
+                const own = offer.maker === "anthropic" || offer.maker === "openai" ? bedrockModels({ maker: offer.maker, region: "global" }) : undefined;
+                return [offer.label, own !== undefined ? `${own.harness.split(".").slice(2).join(".")} to talk to, ${own.coding.split(".").slice(2).join(".")} to code` : offer.regions.join(", ")];
+            }));
+            maker = await askUntil(rl, choose(makers.length), (answer) => bedrockMakerOf(answer, known), `Type a number from 1 to ${makers.length}, or a maker's name.`);
         }
-        const regions = BEDROCK_REGIONS[maker];
-        let region = given.region !== undefined ? bedrockRegionOf(maker, given.region) : undefined;
+        const regions = makers.find((offer) => offer.maker === maker)?.regions ?? [];
+        let region = given.region !== undefined ? bedrockRegionOf(maker, given.region, known) : undefined;
         if (region === undefined) {
-            ask("Which region?", regions.map((entry) => [entry, entry === "global" ? "wherever Bedrock has room" : ""]));
-            region = await askUntil(rl, choose(regions.length), (answer) => bedrockRegionOf(maker, answer), `Type a number from 1 to ${regions.length}, or one of ${regions.join(", ")}.`);
+            ask("Which region?", regions.map((entry) => [entry, entry === "global" ? "wherever Bedrock has room" : entry === BEDROCK_IN_REGION ? "the AWS region it is called in" : ""]));
+            region = await askUntil(rl, choose(regions.length), (answer) => bedrockRegionOf(maker, answer, known), `Type a number from 1 to ${regions.length}, or one of ${regions.join(", ")}.`);
         }
-        return { vendor, bedrock: { maker, region } };
+        const bedrock = { maker, region };
+        const offered = bedrockDefaultModels(known, bedrock);
+        const models = bedrockModelsIn(known, bedrock);
+        if (offered === undefined || models.length < 2)
+            return { vendor, bedrock };
+        const bare = (spec) => spec.replace(/^amazon-bedrock\//, "");
+        console.log(`\n${brand.bold(brand.accent("Which models?"))}`);
+        console.log(`  ${bare(offered.harness)} ${brand.muted("to talk to,")} ${bare(offered.coding)} ${brand.muted("to code")}`);
+        const keep = (await rl.question(`\n${brand.muted("Enter takes them; c chooses others:")} `)).trim().toLowerCase();
+        if (keep !== "c")
+            return { vendor, bedrock };
+        ask("The model you talk to - it writes the specs and plans the work", models.map((model) => [model.id, priced(model)]));
+        const pick = (fallback) => (answer) => {
+            const typed = answer.trim();
+            if (typed === "")
+                return fallback;
+            const model = (/^\d+$/.test(typed) ? models[Number(typed) - 1] : undefined) ?? models.find((entry) => entry.id === typed);
+            return model !== undefined ? `amazon-bedrock/${model.id}` : undefined;
+        };
+        const atOf = (spec) => models.findIndex((model) => `amazon-bedrock/${model.id}` === spec) + 1;
+        const again = `Type a number from 1 to ${models.length}, or Enter for the one offered.`;
+        const harness = await askUntil(rl, `\n${brand.muted(`Choose 1-${models.length}, Enter for ${atOf(offered.harness)}:`)} `, pick(offered.harness), again);
+        ask("The model that writes the code - a smaller, cheaper one", models.map((model) => [model.id, priced(model)]));
+        const coding = await askUntil(rl, `\n${brand.muted(`Choose 1-${models.length}, Enter for ${atOf(offered.coding)}:`)} `, pick(offered.coding), again);
+        return { vendor, bedrock, models: { harness, coding, ...(harness === offered.harness ? { strong: offered.strong } : {}) } };
     }
     finally {
         rl.close();
@@ -466,15 +703,22 @@ function flagOf(args, name) {
     const index = args.findIndex((arg) => arg === `--${name}` || arg.startsWith(`--${name}=`));
     if (index === -1)
         return { at: [] };
-    return args[index].includes("=") ? { value: args[index].split("=")[1], at: [index] } : { value: args[index + 1], at: [index, index + 1] };
+    return args[index].includes("=") ? { value: args[index].slice(args[index].indexOf("=") + 1), at: [index] } : { value: args[index + 1], at: [index, index + 1] };
 }
-/** `turri init-config [--vendor <vendor>] [--maker <maker>] [--region <geography>] [--force] [folder]`. */
+/** `turri init-config [--vendor <vendor>] [--maker <maker>] [--region <geography>] [--harness-model <spec> --coding-model <spec>] [--force] [folder]`. */
 export async function main(args) {
     if (args.includes("-h") || args.includes("--help")) {
         console.log(USAGE);
         return 0;
     }
-    const flags = { vendor: flagOf(args, "vendor"), maker: flagOf(args, "maker"), region: flagOf(args, "region") };
+    const flags = {
+        vendor: flagOf(args, "vendor"),
+        maker: flagOf(args, "maker"),
+        region: flagOf(args, "region"),
+        harness: flagOf(args, "harness-model"),
+        coding: flagOf(args, "coding-model"),
+        judge: flagOf(args, "judge-model"),
+    };
     const taken = new Set(Object.values(flags).flatMap((flag) => flag.at));
     const rest = args.filter((arg, index) => !arg.startsWith("-") && !taken.has(index));
     const folder = rest[0] ?? process.cwd();
@@ -490,21 +734,35 @@ export async function main(args) {
             return 1;
         }
     }
+    // pi's catalogue, read once and only when it is needed: models named, or a maker or region beyond turri's own pair.
+    let read;
+    const catalogue = async () => (read ??= await piModelCatalogue());
+    const [harness, coding, judge] = [flags.harness.value, flags.coding.value, flags.judge.value];
+    if ((harness === undefined) !== (coding === undefined) || (judge !== undefined && harness === undefined)) {
+        console.error(`Name both models - --harness-model and --coding-model - or neither.\n\n${USAGE}`);
+        return 1;
+    }
+    const named = harness !== undefined && coding !== undefined ? { harness, coding, ...(judge !== undefined ? { strong: judge } : {}) } : undefined;
     let maker;
     if (flags.maker.value !== undefined) {
-        maker = bedrockMakerOf(flags.maker.value);
+        const typed = flags.maker.value.trim().toLowerCase();
+        maker = bedrockMakerOf(typed, ["anthropic", "openai"].includes(typed) ? undefined : await catalogue());
         if (maker === undefined) {
-            console.error(`Not one of Bedrock's makers here: ${flags.maker.value}. One of anthropic, openai.\n\n${USAGE}`);
+            console.error(`Not a maker pi's catalogue has on Amazon Bedrock: ${flags.maker.value}. One of ${bedrockMakers(await catalogue()).map((offer) => offer.maker).join(", ")}.\n\n${USAGE}`);
             return 1;
         }
     }
-    const region = flags.region.value;
-    if (region !== undefined && bedrockRegionOf(maker ?? BEDROCK_DEFAULT.maker, region) === undefined) {
-        console.error(`Not a region ${VENDORS[maker ?? BEDROCK_DEFAULT.maker].label}'s models run in on Bedrock: ${region}. One of ${BEDROCK_REGIONS[maker ?? BEDROCK_DEFAULT.maker].join(", ")}.`);
-        return 1;
+    const region = flags.region.value?.trim().toLowerCase();
+    if (region !== undefined && named === undefined) {
+        const of = maker ?? BEDROCK_DEFAULT.maker;
+        if (!hasPreset({ maker: of, region }) && bedrockRegionOf(of, region, await catalogue()) === undefined) {
+            const regions = bedrockMakers(await catalogue()).find((offer) => offer.maker === of)?.regions ?? [];
+            console.error(`Not a region ${makerLabel(of)}'s models run in on Bedrock: ${region}. One of ${regions.join(", ")}.`);
+            return 1;
+        }
     }
     const force = args.includes("--force");
-    const asking = process.stdin.isTTY && process.stdout.isTTY;
+    const asking = process.stdin.isTTY && process.stdout.isTTY && named === undefined;
     let chosen;
     try {
         chosen = await chooseVendor();
@@ -518,14 +776,27 @@ export async function main(args) {
         throw error;
     }
     async function chooseVendor() {
+        if (named !== undefined) {
+            return {
+                ...(vendor !== undefined ? { vendor } : {}),
+                ...(maker !== undefined || region !== undefined ? { bedrock: { ...(maker !== undefined ? { maker } : {}), region: region ?? bedrockPlaceOf(named.harness).geography } } : {}),
+                models: named,
+            };
+        }
         return asking && (vendor === undefined || (vendor === "amazon-bedrock" && (maker === undefined || region === undefined)))
-            ? await askVendor({ ...(vendor !== undefined ? { vendor } : {}), ...(maker !== undefined ? { maker } : {}), ...(region !== undefined ? { region } : {}) })
+            ? await askVendor({ ...(vendor !== undefined ? { vendor } : {}), ...(maker !== undefined ? { maker } : {}), ...(region !== undefined ? { region } : {}) }, catalogue)
             : {
                 vendor: vendor ?? "other",
-                ...(vendor === "amazon-bedrock" ? { bedrock: { maker: maker ?? BEDROCK_DEFAULT.maker, region: bedrockRegionOf(maker ?? BEDROCK_DEFAULT.maker, region ?? BEDROCK_DEFAULT.region) } } : {}),
+                ...(vendor === "amazon-bedrock" ? { bedrock: { maker: maker ?? BEDROCK_DEFAULT.maker, region: region ?? BEDROCK_DEFAULT.region } } : {}),
             };
     }
-    const result = initConfig(folder, { force, vendor: chosen.vendor, ...(chosen.bedrock !== undefined ? { bedrock: chosen.bedrock } : {}) });
+    const result = await initConfig(folder, {
+        force,
+        ...(chosen.vendor !== undefined ? { vendor: chosen.vendor } : {}),
+        ...(chosen.bedrock !== undefined ? { bedrock: chosen.bedrock } : {}),
+        ...(chosen.models !== undefined ? { models: chosen.models } : {}),
+        ...(read !== undefined ? { catalogue: read } : {}),
+    });
     (result.written ? console.log : console.error)(result.message);
     return result.written ? 0 : 1;
 }