@tekmidian/pai 0.48.0 → 0.50.0

package/dist/{config-DxMZjpvY.mjs → config-DYXARgk8.mjs}

@@ -1,119 +1,10 @@
 import { a as paiHomePath, o as resolvePaiFile, r as migratePaiFile } from "./pai-home-ChAOupZc.mjs";
-import { n as CONFIG_FILE } from "./config-DCu8THKi.mjs";
-import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { _ as writeYamlFileAtomic, d as readMainConfigRaw, f as writeMainConfigRaw, g as YamlStoreError, n as CONFIG_FILE, v as readJsonStrict, y as writeJsonAtomic } from "./config-Bn9jpblO.mjs";
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { Document, Scalar, parseDocument } from "yaml";
 
-//#region src/config/json-store.ts
-/**
-* json-store.ts — read/write JSON config files without destroying them
-*
-* The failure this exists to prevent:
-*
-*     try { return JSON.parse(read(path)); } catch { return {}; }
-*     ... later ...
-*     write(path, JSON.stringify(ourData));
-*
-* An unreadable file becomes an empty object, and the next write makes that
-* permanent. Silently, exit code 0. This shape appeared three times in this
-* repo against three different files, and twice in AIBroker.
-*
-* The distinction that matters is between *missing* and *unreadable*:
-*
-*   missing     — legitimate first run. Start fresh; writing is safe.
-*   unreadable  — the file exists and we could not parse it. Those bytes are
-*                 the only copy of something. Never overwrite them.
-*
-* Collapsing the second into the first is the bug.
-*
-* NOT everything deserves this guard. For a transient buffer — an undelivered
-* message queue, a cache — starting fresh IS the correct recovery, and
-* refusing to write would disable the feature permanently. Use `writeJsonAtomic`
-* alone there: it still prevents a crash from truncating a good file, without
-* blocking recovery. Reserve `readJsonStrict` for data a user cannot rebuild.
-*/
-/**
-* Read a JSON file, distinguishing "absent" from "damaged".
-*
-* @param path   file to read
-* @param label  how to name it to the user, e.g. "~/.claude.json"
-* @throws if the file exists but cannot be read or parsed
-*/
-function readJsonStrict(path, label = path) {
-	if (!existsSync(path)) return {};
-	let raw;
-	try {
-		raw = readFileSync(path, "utf8");
-	} catch (e) {
-		throw new Error(`Could not read ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — writing now would replace its contents with ours alone.`);
-	}
-	try {
-		return JSON.parse(raw);
-	} catch (e) {
-		throw new Error(`${label} exists but is not valid JSON: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — overwriting it would destroy whatever it holds.\nRepair the file, or move it aside and re-run this command.`);
-	}
-}
-/**
-* Leaf values that mean "type word", not data.
-*
-* A config whose top-level keys map to bare type words is a serialized schema,
-* not a configuration — the exact shape found over the live config on
-* 2026-09-18 (399 bytes: `socketPath: string`, `indexIntervalSecs: int`, …).
-* No real config carries three of these at its top level; a dump carries
-* nothing else.
-*/
-const SCHEMA_TYPE_WORDS = new Set([
-	"string",
-	"int",
-	"integer",
-	"number",
-	"bool",
-	"boolean",
-	"float",
-	"double",
-	"object",
-	"array",
-	"any",
-	"unknown"
-]);
-function schemaDumpHits(data) {
-	let hits = 0;
-	for (const v of Object.values(data)) if (typeof v === "string" && SCHEMA_TYPE_WORDS.has(v.trim())) hits += 1;
-	return hits;
-}
-/**
-* Write JSON without risking the existing file.
-*
-* Keeps a `.bak-pai` copy of the previous contents, then writes to a temp file
-* and renames. Rename is atomic within a filesystem, so a crash mid-write
-* leaves the original intact rather than truncated — which is how these files
-* become corrupt in the first place.
-*/
-function writeJsonAtomic(path, data, opts = {}) {
-	const { backup = true, label = path } = opts;
-	if (schemaDumpHits(data) >= 3) throw new Error(`${label}: refusing to write — the object looks like a type schema, not values (several top-level keys map to bare type words). That is the corruption signature of 2026-09-18: the caller serialized the schema instead of the config. Nothing was written.`);
-	const serialized = JSON.stringify(data, null, 2) + "\n";
-	const dir = dirname(path);
-	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-	if (backup && existsSync(path)) try {
-		copyFileSync(path, `${path}.bak-pai`);
-	} catch (e) {
-		throw new Error(`Could not back up ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to write without a backup.`);
-	}
-	const tmp = `${path}.tmp-pai-${process.pid}`;
-	try {
-		writeFileSync(tmp, serialized, "utf8");
-		renameSync(tmp, path);
-	} catch (e) {
-		try {
-			if (existsSync(tmp)) unlinkSync(tmp);
-		} catch {}
-		throw new Error(`Failed to write ${label}: ${e instanceof Error ? e.message : String(e)}\nThe original is unchanged.`);
-	}
-}
-
-//#endregion
 //#region src/utils/model-window.ts
 /**
 * model-window.ts — facts derivable from a bare model id.
@@ -321,11 +212,21 @@ function parseWorkersYamlDocument(doc, yamlPath) {
 			const provider = typeof target === "string" ? target.split("/")[0] : target.provider;
 			const alias = typeof target === "string" ? target.split("/")[1] : void 0;
 			if (provider !== void 0) {
-				if (provider !== ANTHROPIC_NATIVE && !providers[provider]) withLine(doc, ["classes", cls], yamlPath, new WorkersConfigError(`classes.${cls}: no provider named "${provider}" (configured: ${Object.keys(providers).join(", ") || "(none)"})`));
-				if (alias !== void 0 && !isModelCapability(alias)) withLine(doc, ["classes", cls], yamlPath, new WorkersConfigError(`classes.${cls}: unknown model role "${alias}" (from: ${MODEL_CAPABILITIES.join(", ")})`));
+				const native = provider === ANTHROPIC_NATIVE;
+				if (!native && !providers[provider]) withLine(doc, ["classes", cls], yamlPath, new WorkersConfigError(`classes.${cls}: no provider named "${provider}" (configured: ${Object.keys(providers).join(", ") || "(none)"})`));
+				if (alias !== void 0) {
+					if (!isModelCapability(alias)) withLine(doc, ["classes", cls], yamlPath, new WorkersConfigError(`classes.${cls}: "${alias}" is not a valid capability name (must match ^[a-z][a-z0-9-]*$)`));
+					else if (!native && providers[provider] && alias !== "default" && !providers[provider].models[alias]) withLine(doc, ["classes", cls], yamlPath, new WorkersConfigError(`classes.${cls}: provider "${provider}" has no "${alias}" model configured`));
+				}
 			}
 		}
 	}
+	let capabilities = {};
+	if (r.capabilities !== void 0) try {
+		capabilities = parseCapabilitiesValue(r.capabilities, "capabilities");
+	} catch (e) {
+		withLine(doc, ["capabilities"], yamlPath, e);
+	}
 	let mcpSets = {};
 	if (r.mcp_sets !== void 0) try {
 		mcpSets = parseMcpSetsValue(r.mcp_sets, "mcp_sets");
@@ -339,6 +240,7 @@ function parseWorkersYamlDocument(doc, yamlPath) {
 		active,
 		providers,
 		classes,
+		capabilities,
 		mcpSets,
 		nativeModels
 	};
@@ -392,6 +294,8 @@ function syncWorkersYamlDocument(doc, before, after) {
 	for (const name of Object.keys(before.providers)) if (!(name in after.providers)) doc.deleteIn(["providers", name]);
 	for (const [cls, target] of Object.entries(after.classes)) if (!shallowEqual(before.classes[cls], target)) doc.setIn(["classes", cls], target);
 	for (const cls of Object.keys(before.classes)) if (!(cls in after.classes)) doc.deleteIn(["classes", cls]);
+	for (const [cap, prefs] of Object.entries(after.capabilities)) if (!shallowEqual(before.capabilities[cap], prefs)) doc.setIn(["capabilities", cap], [...prefs]);
+	for (const cap of Object.keys(before.capabilities)) if (!(cap in after.capabilities)) doc.deleteIn(["capabilities", cap]);
 	for (const [set, servers] of Object.entries(after.mcpSets)) if (!shallowEqual(before.mcpSets[set], servers)) doc.setIn(["mcp_sets", set], [...servers]);
 	for (const set of Object.keys(before.mcpSets)) if (!(set in after.mcpSets)) doc.deleteIn(["mcp_sets", set]);
 	if (before.active !== after.active) if (after.active === null) doc.deleteIn(["active"]);
@@ -410,12 +314,16 @@ function writeWorkersYaml(yamlPath, after) {
 		active: null,
 		providers: {},
 		classes: {},
+		capabilities: {},
 		mcpSets: {},
 		nativeModels: { ...NATIVE_ANTHROPIC_MODELS }
 	}, after);
 	writeWorkersYamlText(yamlPath, String(doc));
 }
-/** Atomic write with a .bak-pai backup and a re-validate-or-restore guard. */
+/** Atomic write with a .bak-pai backup and a re-validate-or-restore guard.
+*  The file-I/O tail (backup, temp write at 0600, rename, chmod) is shared
+*  with every other PAI YAML file via writeYamlFileAtomic; only the
+*  workers.yaml-specific validation (parseWorkersYamlDocument) lives here. */
 function writeWorkersYamlText(yamlPath, text) {
 	const probe = parseDocument(text);
 	if (probe.errors.length) throw new WorkersConfigError(`refusing to write ${yamlPath}: ${probe.errors[0].message} (previous file left unchanged)`);
@@ -424,26 +332,10 @@ function writeWorkersYamlText(yamlPath, text) {
 	} catch (e) {
 		throw new WorkersConfigError(`refusing to write ${yamlPath}: ${e instanceof Error ? e.message : String(e)} (previous file left unchanged)`);
 	}
-	const dir = dirname(yamlPath);
-	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-	if (existsSync(yamlPath)) try {
-		copyFileSync(yamlPath, `${yamlPath}.bak-pai`);
-	} catch (e) {
-		throw new WorkersConfigError(`Could not back up ${yamlPath}: ${e instanceof Error ? e.message : String(e)}\nRefusing to write without a backup.`);
-	}
-	const tmp = `${yamlPath}.tmp-pai-${process.pid}`;
 	try {
-		writeFileSync(tmp, text, {
-			encoding: "utf8",
-			mode: 384
-		});
-		renameSync(tmp, yamlPath);
-		chmodSync(yamlPath, 384);
+		writeYamlFileAtomic(yamlPath, text, { label: yamlPath });
 	} catch (e) {
-		try {
-			if (existsSync(tmp)) unlinkSync(tmp);
-		} catch {}
-		throw new WorkersConfigError(`Failed to write ${yamlPath}: ${e instanceof Error ? e.message : String(e)}`);
+		throw new WorkersConfigError(e instanceof YamlStoreError ? e.message : String(e instanceof Error ? e.message : e));
 	}
 }
 /** The exact commented starter shipped as examples/workers.yaml and by `init`. */
@@ -481,6 +373,18 @@ providers:
       default: k3[1m]
       fast: kimi-for-coding[1m]
 
+# An \`engine: image\` provider does not spawn Claude — \`pai worker run
+# --capability image\` POSTs straight to its OpenAI-compatible images API and
+# writes the PNG it gets back. Uncomment and point it at a real provider
+# (still nested under providers:, above) to enable \`--capability image\`:
+#   pictures:
+#     engine: image
+#     url: https://api.example.com/v1
+#     key: "<your-api-key>"
+#     models:
+#       default: example-image-model
+#       image: example-image-model
+
 # A class names a provider, or provider/role to pick a non-default model.
 # Workers exist to parallelise and to save cost: the default is Sonnet,
 # Haiku for the mechanical classes, and nothing here inherits the
@@ -496,6 +400,13 @@ classes:
   simple: anthropic/fast
   image: glm/image
 
+# Cross-provider capability preference: which provider serves a --capability
+# request, in order, when more than one declares it. Unlisted capabilities
+# fall back to the active provider, then any provider that declares them.
+# capabilities:
+#   image: [pictures, glm]
+#   fast: [anthropic]
+
 mcp_sets:
   desktop: [clickr]
 `;
@@ -541,6 +452,12 @@ function buildWorkersYamlText(data) {
 	lines.push(classEntries.length ? "classes:" : "classes: {}");
 	for (const [cls, target] of classEntries) lines.push(`  ${cls}: ${typeof target === "string" ? target : yamlScalar(target)}`);
 	lines.push("");
+	const capEntries = Object.entries(data.capabilities);
+	if (capEntries.length) {
+		lines.push("capabilities:");
+		for (const [cap, prefs] of capEntries) lines.push(`  ${cap}: [${prefs.join(", ")}]`);
+		lines.push("");
+	}
 	const mcpEntries = Object.entries(data.mcpSets);
 	lines.push(mcpEntries.length ? "mcp_sets:" : "mcp_sets: {}");
 	for (const [set, servers] of mcpEntries) lines.push(`  ${set}: [${servers.join(", ")}]`);
@@ -572,6 +489,7 @@ function migrateWorkersToYaml(jsonPath, opts = {}) {
 		active: workers.active,
 		providers: workers.providers,
 		classes: workers.classes,
+		capabilities: workers.capabilities,
 		mcpSets: workers.mcpSets,
 		nativeModels: workers.nativeModels
 	});
@@ -679,8 +597,8 @@ function inlineWorkersYamlKeys(opts = {}) {
 //#region src/workers/config.ts
 /**
 * config.ts — the `workers` section of the PAI config file (CONFIG_FILE,
-* see src/daemon/config.ts's paiConfigFilePath — ~/.claude/pai/config.json
-* today, pre-2026-09-19 ~/.config/pai/config.json).
+* see src/daemon/config.ts's paiConfigFilePath — ~/.claude/pai/config.yaml
+* today, config.json until `pai config yaml` runs).
 *
 * Everything that knows about worker providers reads this module: the CLI
 * (`pai worker …`), the MCP tools (worker_*), and the Agent-routing hook.
@@ -772,20 +690,26 @@ const WORKER_CLASSES = [
 	"image"
 ];
 /**
-* The named model capabilities a provider may carry a preference for, set
-* per provider under `workers.providers.<name>.models`. "default" is the
-* required catch-all; the others name what a model is *for* — "fast" the
-* cheap tier (spotcheck, haiku-tier spawns), "image" the image class.
-* Everything resolves through resolveModelCapability, falling back to default.
+* The well-known model capabilities — documented, and what the starter
+* workers.yaml and `pai worker model`'s listing show by name. The set is
+* open, though: a provider's `models` block may carry any capability name
+* matching CAPABILITY_NAME_RE (see isModelCapability), e.g. "vision" or
+* "longcontext" for a provider that serves them. "default" is the required
+* catch-all; the others name what a model is *for* — "fast" the cheap tier
+* (spotcheck, haiku-tier spawns), "image" the image class/capability.
+* Everything resolves through resolveModelCapability, falling back to
+* default; cross-provider preference for a capability is `capabilities:` in
+* workers.yaml (see resolveCapability).
 */
 const MODEL_CAPABILITIES = [
 	"default",
 	"fast",
 	"image"
 ];
-/** Is this string the name of a known model capability? */
+const CAPABILITY_NAME_RE = /^[a-z][a-z0-9-]*$/;
+/** Is this string a syntactically valid capability name (open set)? */
 function isModelCapability(v) {
-	return MODEL_CAPABILITIES.includes(v);
+	return CAPABILITY_NAME_RE.test(v);
 }
 /**
 * Which model capability a class runs on when its target names no alias: the
@@ -849,6 +773,7 @@ function defaultWorkersConfig() {
 		providers: {},
 		classes: {},
 		mcpSets: { ...DEFAULT_MCP_SETS },
+		capabilities: {},
 		pane: { ...DEFAULT_PANE },
 		logDir: DEFAULT_LOG_DIR,
 		routing: {
@@ -882,7 +807,7 @@ function parseModelsBlock(pathPrefix, modelsRaw) {
 	const models = { default: defaultModel };
 	for (const key of Object.keys(m)) {
 		if (key === "default") continue;
-		if (!isModelCapability(key)) bad(`${pathPrefix}.${key}`, `"${key}" is not a model capability (from: ${MODEL_CAPABILITIES.join(", ")})`);
+		if (!isModelCapability(key)) bad(`${pathPrefix}.${key}`, `"${key}" is not a valid capability name (must match ^[a-z][a-z0-9-]*$; well-known: ${MODEL_CAPABILITIES.join(", ")}, but any name in that shape is accepted)`);
 		const id = str(m[key]);
 		if (!id) bad(`${pathPrefix}.${key}`, "must be a non-empty model id");
 		models[key] = id;
@@ -897,7 +822,7 @@ function parseProvider(name, raw) {
 	const protocol = p.protocol === void 0 ? "anthropic" : str(p.protocol);
 	if (protocol !== "anthropic" && protocol !== "openai") bad(`.providers.${name}.protocol`, `"${str(p.protocol)}" is neither "anthropic" nor "openai"`);
 	const engine = p.engine === void 0 ? "claude" : str(p.engine);
-	if (engine !== "claude" && engine !== "codex") bad(`.providers.${name}.engine`, `"${str(p.engine)}" is neither "claude" nor "codex"`);
+	if (engine !== "claude" && engine !== "codex" && engine !== "image") bad(`.providers.${name}.engine`, `"${str(p.engine)}" is none of "claude", "codex", "image"`);
 	const baseUrl = str(p.baseUrl);
 	if (!baseUrl && protocol !== "openai") bad(`.providers.${name}.baseUrl`, "is required");
 	const keyFile = p.keyFile === void 0 || p.keyFile === null || str(p.keyFile) === "" ? null : str(p.keyFile);
@@ -1059,6 +984,24 @@ function parseMcpSetsValue(raw, badPathPrefix) {
 	return mcpSets;
 }
 /**
+* Parse a `capabilities` value shared by JSON and YAML loading: capability
+* name (open set, see isModelCapability) → provider names in preference
+* order. Provider names are not cross-checked here — a name that stops
+* existing is simply skipped by resolveCapability at resolve time, the same
+* way routing.order tolerates a removed provider.
+*/
+function parseCapabilitiesValue(raw, badPathPrefix) {
+	const capabilities = {};
+	if (raw === void 0) return capabilities;
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) bad(badPathPrefix, "must be an object of capability name → [provider names]");
+	for (const [name, order] of Object.entries(raw)) {
+		if (!isModelCapability(name)) bad(`${badPathPrefix}.${name}`, `"${name}" is not a valid capability name (must match ^[a-z][a-z0-9-]*$)`);
+		if (!Array.isArray(order) || order.length === 0 || order.some((x) => typeof x !== "string" || !x)) bad(`${badPathPrefix}.${name}`, "must be a non-empty array of provider names");
+		capabilities[name] = order;
+	}
+	return capabilities;
+}
+/**
 * Parse and validate a raw `workers` value. Missing section → defaults.
 * Unknown-but-typed garbage → WorkersConfigError naming the offending field.
 */
@@ -1074,6 +1017,7 @@ function parseWorkersConfig(raw) {
 	}
 	const classes = parseClassesValue(w.classes !== void 0 ? w.classes : w.roles, w.classes !== void 0 ? ".classes" : ".roles");
 	const mcpSets = parseMcpSetsValue(w.mcpSets, ".mcpSets");
+	const capabilities = parseCapabilitiesValue(w.capabilities, ".capabilities");
 	let pane = { ...DEFAULT_PANE };
 	if (w.pane !== void 0) {
 		if (typeof w.pane !== "object" || w.pane === null) bad(".pane", "must be an object");
@@ -1157,6 +1101,7 @@ function parseWorkersConfig(raw) {
 		providers,
 		classes,
 		mcpSets,
+		capabilities,
 		pane,
 		logDir: str(w.logDir) || d.logDir,
 		routing,
@@ -1172,24 +1117,28 @@ function workersYamlDataOf(workers) {
 		providers: workers.providers,
 		classes: workers.classes,
 		mcpSets: workers.mcpSets,
+		capabilities: workers.capabilities,
 		nativeModels: workers.nativeModels
 	};
 }
 /**
 * Read the whole config file and return (raw, workers) — the raw record so
 * callers can rewrite it preserving every other section, the parsed+validated
-* workers section. Unreadable config throws (readJsonStrict), missing is fine.
-* `path` overrides the config location (tests, CLAUDE_SETTINGS_PATH-style
-* dry runs); default CONFIG_FILE (see paiConfigFilePath).
+* workers section. Unreadable config throws, missing is fine. `path`
+* overrides the config location (tests, CLAUDE_SETTINGS_PATH-style dry runs);
+* default CONFIG_FILE (see paiConfigFilePath). Reads via readMainConfigRaw,
+* so a config.yaml next to `path` is preferred over JSON, same as every
+* other main-config reader.
 *
 * Providers, classes, mcpSets and active load from workers.yaml (next to
 * `path`) when it exists; otherwise they fall back to the JSON `workers`
 * section, and then to built-in defaults — nothing breaks before migration
 * (`pai worker config migrate`). Everything else (pane, routing, tree,
-* cacheKeepaliveSecs, fallback, enabled, logDir) always comes from JSON.
+* cacheKeepaliveSecs, fallback, enabled, logDir) always comes from the main
+* config (JSON or YAML).
 */
 function readWorkersSection(path = CONFIG_FILE) {
-	const raw = readJsonStrict(path, path);
+	const raw = readMainConfigRaw(path);
 	const workers = parseWorkersConfig(raw.workers);
 	const yaml = readWorkersYaml(workersYamlPath());
 	if (yaml) {
@@ -1197,6 +1146,7 @@ function readWorkersSection(path = CONFIG_FILE) {
 		workers.providers = yaml.data.providers;
 		workers.classes = yaml.data.classes;
 		workers.mcpSets = yaml.data.mcpSets;
+		workers.capabilities = yaml.data.capabilities;
 		workers.nativeModels = yaml.data.nativeModels;
 	}
 	return {
@@ -1226,7 +1176,7 @@ function writeWorkersSection(raw, workers, path = CONFIG_FILE) {
 		...workers,
 		fallback: void 0
 	};
-	writeJsonAtomic(path, raw, { label: path });
+	writeMainConfigRaw(raw, path);
 }
 /** Expand a leading ~ (config values are written with `~` to stay portable). */
 function expandHome(p) {
@@ -1279,11 +1229,90 @@ function providerCostTier(p) {
 function resolveModelCapability(p, capability) {
 	return p.models[capability] ?? p.models.default;
 }
+/** Runner behind a provider, defaulting to the Claude Code harness. */
+function providerEngine(p) {
+	return p.engine ?? "claude";
+}
+/** Does this provider name a model for the capability ("default" always counts)? */
+function providerDeclaresCapability(p, capability) {
+	return capability === "default" || p.models[capability] !== void 0;
+}
+/** A provider usable for this capability: declares it, enabled, and passes assertProviderRunnable. */
+function providerUsableForCapability(p, capability) {
+	if (!p || !p.enabled || !providerDeclaresCapability(p, capability)) return false;
+	try {
+		assertProviderRunnable("", p);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Cross-provider capability resolution (`workers.yaml`'s `capabilities:`
+* map): which provider+model serves a named capability (e.g. "image"),
+* independent of any one provider's own `models` table.
+*
+* Resolution order:
+*   1. `capabilities.<name>` (explicit preference list) — first provider
+*      that declares the capability, is enabled, and passes
+*      assertProviderRunnable.
+*   2. No preference list: the active provider, if it declares the
+*      capability.
+*   3. Still nothing: any enabled provider that declares the capability
+*      (stable order — provider names sorted, "anthropic" included).
+*   4. Nothing anywhere: the active provider's default model, `fellBack: true`.
+*/
+function resolveCapability(workers, capability) {
+	const order = workers.capabilities[capability];
+	if (order?.length) {
+		for (const name of order) {
+			const p = getProviderOrNative(workers, name);
+			if (providerUsableForCapability(p, capability)) return {
+				provider: name,
+				model: resolveModelCapability(p, capability),
+				engine: providerEngine(p),
+				fellBack: false
+			};
+		}
+		throw new WorkersConfigError(`no configured provider for capability "${capability}" is usable right now (checked, in order: ${order.join(", ")}) — set one with: pai worker capability ${capability} <provider>`);
+	}
+	const activeName = workers.active && workers.active !== "auto" ? workers.active : null;
+	if (activeName) {
+		const p = getProviderOrNative(workers, activeName);
+		if (providerUsableForCapability(p, capability)) return {
+			provider: activeName,
+			model: resolveModelCapability(p, capability),
+			engine: providerEngine(p),
+			fellBack: false
+		};
+	}
+	const candidates = {
+		[ANTHROPIC_NATIVE]: nativeAnthropicProvider(workers.nativeModels),
+		...workers.providers
+	};
+	for (const name of Object.keys(candidates).sort()) {
+		const p = candidates[name];
+		if (providerUsableForCapability(p, capability)) return {
+			provider: name,
+			model: resolveModelCapability(p, capability),
+			engine: providerEngine(p),
+			fellBack: false
+		};
+	}
+	const fallbackName = activeName ?? ANTHROPIC_NATIVE;
+	const fallback = getProviderOrNative(workers, fallbackName) ?? nativeAnthropicProvider(workers.nativeModels);
+	return {
+		provider: fallbackName,
+		model: fallback.models.default,
+		engine: providerEngine(fallback),
+		fellBack: true
+	};
+}
 /** Directory under which inline keys (MCP `key` field) are stored, 0600. */
 function keysDir() {
 	return paiHomePath("keys");
 }
 
 //#endregion
-export { DEFAULT_CONTEXT_WINDOW as A, inlineWorkersYamlKeys as C, relocateWorkersYaml as D, parseWorkersYamlDocument as E, stripModelVariant as M, readJsonStrict as N, workersYamlLegacyNotice as O, writeJsonAtomic as P, initWorkersYaml as S, needsWorkersYamlRelocation as T, providerKeyPath as _, WORKER_CLASSES as a, resolveProviderKey as b, classModelCapability as c, getProviderOrNative as d, isModelCapability as f, providerCostTier as g, nativeAnthropicProvider as h, PROVIDER_TAGS as i, contextWindowFromModelId as j, workersYamlPath as k, defaultWorkersConfig as l, maskKey as m, DEFAULT_LOG_DIR as n, WorkersConfigError as o, keysDir as p, MODEL_CAPABILITIES as r, assertProviderRunnable as s, ANTHROPIC_NATIVE as t, expandHome as u, readWorkersSection as v, migrateWorkersToYaml as w, writeWorkersSection as x, resolveModelCapability as y };
-//# sourceMappingURL=config-DxMZjpvY.mjs.map
+export { migrateWorkersToYaml as A, readWorkersSection as C, writeWorkersSection as D, resolveProviderKey as E, workersYamlPath as F, DEFAULT_CONTEXT_WINDOW as I, contextWindowFromModelId as L, parseWorkersYamlDocument as M, relocateWorkersYaml as N, initWorkersYaml as O, workersYamlLegacyNotice as P, stripModelVariant as R, providerKeyPath as S, resolveModelCapability as T, isModelCapability as _, DEFAULT_PANE as a, nativeAnthropicProvider as b, MODEL_CAPABILITIES as c, WorkersConfigError as d, assertProviderRunnable as f, getProviderOrNative as g, expandHome as h, DEFAULT_LOG_DIR as i, needsWorkersYamlRelocation as j, inlineWorkersYamlKeys as k, PROVIDER_TAGS as l, defaultWorkersConfig as m, CAPABILITY_NAME_RE as n, DEFAULT_ROUTING as o, classModelCapability as p, DEFAULT_CACHE_KEEPALIVE_SECS as r, DEFAULT_TREE as s, ANTHROPIC_NATIVE as t, WORKER_CLASSES as u, keysDir as v, resolveCapability as w, providerCostTier as x, maskKey as y };
+//# sourceMappingURL=config-DYXARgk8.mjs.map