@mars-sea/dsh-commandcode-provider 0.10.4 → 0.10.6

package/lib/index.js

@@ -1024,7 +1024,7 @@ function capabilityDescription(modelId, contextWindow, now = Date.now()) {
 * and API key or subscription, and Command Code's terms apply.
 *
 * Wire protocol (reverse-engineered by the pi plugin, command-code@1.28.4;
-* re-verified against command-code@1.53.0 — endpoints, request shape, and
+* re-verified against command-code@1.53.1 — endpoints, request shape, and
 * stream events unchanged):
 *   POST {apiBase}/alpha/generate
 *   body: { config, memory, taste, skills, params: { model, messages, tools,
@@ -1037,7 +1037,7 @@ function capabilityDescription(modelId, contextWindow, now = Date.now()) {
 * per-request options thunk and an API-key resolver from the plugin entry
 * (src/index.ts), so a settings change reaches the very next request.
 */
-const COMMAND_CODE_CLI_VERSION = "1.53.0";
+const COMMAND_CODE_CLI_VERSION = "1.53.1";
 const DEFAULT_API_BASE = "https://api.commandcode.ai";
 const DEFAULT_GENERATE_MAX_TOKENS = 64e3;
 const DEFAULT_MAX_OUTPUT_TOKENS = 65536;
@@ -1105,6 +1105,124 @@ function recordOrEmpty(value) {
 	} catch {}
 	return {};
 }
+/** How deep a root `$ref` / combinator chain is followed while normalizing. */
+const SCHEMA_NORMALIZE_MAX_DEPTH = 4;
+/**
+* Whether a type-less node is object-shaped enough to be one with the type
+* declared: `properties`/`required`/`additionalProperties` only make sense on
+* an object, and a schema carrying them was meant to be one.
+*/
+function isObjectShaped(node) {
+	return isRecord(node.properties) || isRecord(node.patternProperties) || Array.isArray(node.required) || node.additionalProperties !== void 0;
+}
+/** The `required` names of one schema node, ignoring malformed entries. */
+function requiredNames(node) {
+	return Array.isArray(node.required) ? node.required.filter((name) => typeof name === "string") : [];
+}
+/** Resolve a local `#/...` pointer inside the schema that carried it. */
+function resolveLocalRef(root, ref) {
+	if (!ref.startsWith("#/")) return void 0;
+	let node = root;
+	for (const rawSegment of ref.slice(2).split("/")) {
+		const segment = rawSegment.replace(/~1/g, "/").replace(/~0/g, "~");
+		if (!isRecord(node)) return void 0;
+		node = node[segment];
+	}
+	return isRecord(node) ? node : void 0;
+}
+/**
+* Flatten a type-less combinator node into one object schema, so the model
+* still sees the branch fields instead of an argument-free tool. `allOf`
+* branches must all hold, so their `required` entries are all kept; `anyOf` /
+* `oneOf` branches are alternatives, so only a name required by every branch
+* survives. Returns undefined when no branch describes an object.
+*/
+function mergeCombinatorBranches(node, depth) {
+	if (depth >= SCHEMA_NORMALIZE_MAX_DEPTH) return void 0;
+	const properties = {};
+	const required = /* @__PURE__ */ new Set();
+	const alternatives = [];
+	let sawBranch = false;
+	for (const key of [
+		"allOf",
+		"anyOf",
+		"oneOf"
+	]) {
+		const branches = node[key];
+		if (!Array.isArray(branches)) continue;
+		const objectBranches = [];
+		for (const branch of branches) {
+			if (!isRecord(branch)) continue;
+			objectBranches.push(toolParametersSchema(branch, depth + 1));
+		}
+		if (objectBranches.length === 0) continue;
+		sawBranch = true;
+		const names = objectBranches.map(requiredNames);
+		if (key === "allOf") for (const name of names.flat()) required.add(name);
+		else if (names.length > 0) alternatives.push(names[0].filter((name) => names.every((list) => list.includes(name))));
+		for (const branch of objectBranches) {
+			const branchProperties = isRecord(branch.properties) ? branch.properties : {};
+			for (const [name, schema] of Object.entries(branchProperties)) if (!(name in properties)) properties[name] = schema;
+		}
+	}
+	if (!sawBranch) return void 0;
+	for (const group of alternatives) for (const name of group) required.add(name);
+	const merged = {
+		type: "object",
+		properties
+	};
+	if (required.size > 0) merged.required = [...required];
+	if (node.additionalProperties !== void 0) merged.additionalProperties = node.additionalProperties;
+	for (const key of ["description", "title"]) if (node[key] !== void 0) merged[key] = node[key];
+	return merged;
+}
+/**
+* Normalize one tool's parameters schema to an object-rooted JSON Schema.
+* A schema that already declares an object root is passed through untouched;
+* a type-less object-shaped one gains the type; a root `$ref` or combinator is
+* resolved/merged; anything else (an array/scalar root, or no schema at all)
+* degrades to a permissive free-form object, because a request the provider
+* refuses helps no one and the tool's own description is still in the prompt.
+*/
+function toolParametersSchema(parameters, depth = 0) {
+	if (!isRecord(parameters)) return {
+		type: "object",
+		properties: {},
+		additionalProperties: true
+	};
+	if (parameters.type === "object") return parameters;
+	if (Array.isArray(parameters.type) && parameters.type.includes("object")) return {
+		...parameters,
+		type: "object"
+	};
+	if (parameters.type === void 0 || parameters.type === null) {
+		if (typeof parameters.$ref === "string" && depth < SCHEMA_NORMALIZE_MAX_DEPTH) {
+			const target = resolveLocalRef(parameters, parameters.$ref);
+			if (target !== void 0) {
+				const { $ref: _ref, ...rest } = parameters;
+				return toolParametersSchema({
+					...target,
+					...rest
+				}, depth + 1);
+			}
+		}
+		if (isObjectShaped(parameters)) return {
+			...parameters,
+			type: "object"
+		};
+		const merged = mergeCombinatorBranches(parameters, depth);
+		if (merged !== void 0) return merged;
+		if (typeof parameters.$ref === "string") return {
+			...parameters,
+			type: "object"
+		};
+	}
+	return {
+		type: "object",
+		properties: {},
+		additionalProperties: true
+	};
+}
 function projectSlugFromPath(pathName) {
 	return pathName.toLowerCase().replace(/^[a-z]:/i, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|(?<!-)-+$/g, "") || "project";
 }
@@ -1281,23 +1399,33 @@ function toolResultTextForWire(media) {
 	return media.text || (media.images.length > 0 ? "(image returned; see the attached image)" : "");
 }
 /** Leading line of the user message that carries a tool result's images. */
-const TOOL_RESULT_IMAGE_TEXT = "Attached image(s) from tool result:";
+const TOOL_RESULT_IMAGE_TEXT = "Attached image(s) from tool result";
 /**
 * The model-visible note introducing the images carried out of one tool
 * result. Neither transport merges them back into the tool result, so this
 * line is what tells the model the image it is about to see belongs to the
 * tool it just ran rather than to the user; it also leads the part list,
-* because an image-first content array is what some gateways reject. Count and
-* pixel dimensions are appended when the tool's own text does not already
-* state them (a result that returns the image and nothing else).
+* because an image-first content array is what some gateways reject.
+*
+* The note names the tool call the image came out of, because a turn's
+* carriers are emitted as a group after the whole tool group (issue #33):
+* position alone would have to carry the association, and every `read_image`
+* result renders the same envelope text, so two parallel calls would produce
+* two identical notes. The id is the WIRE id — the one the model saw on the
+* `tool-call` it issued and on the tool message just above — so an overlong
+* cross-provider id is named by the alias that replaced it, not by the
+* harness-side id the model never saw.
+*
+* Count and pixel dimensions are appended when the tool's own text does not
+* already state them (a result that returns the image and nothing else).
 */
-function toolResultImageNote(media) {
+function toolResultImageNote(media, toolCallId) {
+	const lead = `${TOOL_RESULT_IMAGE_TEXT} (${toolCallId}):`;
 	const first = media.images[0];
-	if (first === void 0) return TOOL_RESULT_IMAGE_TEXT;
+	if (first === void 0) return lead;
 	const dimensions = `${first.width}x${first.height} px`;
-	if (first.width <= 0 || first.height <= 0 || media.text.includes(dimensions)) return TOOL_RESULT_IMAGE_TEXT;
-	const count = media.images.length > 1 ? `${media.images.length} images, ` : "";
-	return `${TOOL_RESULT_IMAGE_TEXT} ${count}${dimensions}`;
+	if (first.width <= 0 || first.height <= 0 || media.text.includes(dimensions)) return lead;
+	return `${lead} ${media.images.length > 1 ? `${media.images.length} images, ` : ""}${dimensions}`;
 }
 function hasImageContent(message) {
 	const check = (blocks) => blocks.some((b) => b.type === "image" || b.type === "tool-result" && check(b.content));
@@ -1324,9 +1452,15 @@ async function messagesToCC(messages, readImage) {
 	const out = [];
 	const { ids: paired, names: toolNames } = pairedToolCalls(messages);
 	const wireIds = wireToolCallIds(paired);
+	const pendingImages = [];
+	const flushPendingImages = () => {
+		for (const message of pendingImages) out.push(message);
+		pendingImages.length = 0;
+	};
 	for (const message of messages) {
 		if (message.role === "system") continue;
 		if (message.role === "user" && message.source.kind !== "tool") {
+			flushPendingImages();
 			const parts = [];
 			for (const block of message.content) {
 				if (block.type === "text") parts.push({
@@ -1338,6 +1472,7 @@ async function messagesToCC(messages, readImage) {
 					parts.push(await imageToCommandCode(block.attachment, readImage));
 				}
 			}
+			if (parts.length === 0) continue;
 			out.push({
 				role: "user",
 				content: parts
@@ -1345,11 +1480,16 @@ async function messagesToCC(messages, readImage) {
 			continue;
 		}
 		if (message.role === "assistant") {
+			flushPendingImages();
 			const parts = [];
 			for (const block of message.content) if (block.type === "text") parts.push({
 				type: "text",
 				text: block.text
 			});
+			else if (block.type === "reasoning") parts.push({
+				type: "reasoning",
+				text: block.text
+			});
 			else if (block.type === "tool-call" && paired.has(block.id)) parts.push({
 				type: "tool-call",
 				toolCallId: wireIds.get(block.id) ?? block.id,
@@ -1366,11 +1506,12 @@ async function messagesToCC(messages, readImage) {
 			const block = message.content[0];
 			if (!block || block.type !== "tool-result" || !paired.has(block.toolCallId)) continue;
 			const media = toolResultMedia(block);
+			const wireToolCallId = wireIds.get(block.toolCallId) ?? block.toolCallId;
 			out.push({
 				role: "tool",
 				content: [{
 					type: "tool-result",
-					toolCallId: wireIds.get(block.toolCallId) ?? block.toolCallId,
+					toolCallId: wireToolCallId,
 					toolName: toolNames.get(block.toolCallId) || "unknown",
 					output: block.isError ? {
 						type: "error-text",
@@ -1385,16 +1526,17 @@ async function messagesToCC(messages, readImage) {
 				if (!readImage) throw new LlmError("Image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
 				const carried = [{
 					type: "text",
-					text: toolResultImageNote(media)
+					text: toolResultImageNote(media, wireToolCallId)
 				}];
 				for (const attachment of media.images) carried.push(await imageToCommandCode(attachment, readImage));
-				out.push({
+				pendingImages.push({
 					role: "user",
 					content: carried
 				});
 			}
 		}
 	}
+	flushPendingImages();
 	return out;
 }
 /**
@@ -1422,9 +1564,15 @@ async function messagesToOpenAI(messages, readImage) {
 	const out = [];
 	const { ids: paired } = pairedToolCalls(messages);
 	const wireIds = wireToolCallIds(paired);
+	const pendingImages = [];
+	const flushPendingImages = () => {
+		for (const message of pendingImages) out.push(message);
+		pendingImages.length = 0;
+	};
 	for (const message of messages) {
 		if (message.role === "system") continue;
 		if (message.role === "user" && message.source.kind !== "tool") {
+			flushPendingImages();
 			const parts = [];
 			for (const block of message.content) {
 				if (block.type === "text") parts.push({
@@ -1448,6 +1596,7 @@ async function messagesToOpenAI(messages, readImage) {
 			continue;
 		}
 		if (message.role === "assistant") {
+			flushPendingImages();
 			const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
 			const reasoning = message.content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
 			const toolCalls = message.content.filter((block) => block.type === "tool-call" && paired.has(block.id)).map((block) => ({
@@ -1472,25 +1621,27 @@ async function messagesToOpenAI(messages, readImage) {
 			const block = message.content[0];
 			if (!block || block.type !== "tool-result" || !paired.has(block.toolCallId)) continue;
 			const media = toolResultMedia(block);
+			const wireToolCallId = wireIds.get(block.toolCallId) ?? block.toolCallId;
 			out.push({
 				role: "tool",
-				tool_call_id: wireIds.get(block.toolCallId) ?? block.toolCallId,
+				tool_call_id: wireToolCallId,
 				content: toolResultTextForWire(media)
 			});
 			if (media.images.length > 0) {
 				if (!readImage) throw new LlmError("Image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
 				const carried = [{
 					type: "text",
-					text: toolResultImageNote(media)
+					text: toolResultImageNote(media, wireToolCallId)
 				}];
 				for (const attachment of media.images) carried.push(await imageToOpenAI(attachment, readImage));
-				out.push({
+				pendingImages.push({
 					role: "user",
 					content: carried
 				});
 			}
 		}
 	}
+	flushPendingImages();
 	return out;
 }
 /** Account endpoints fetched by one `getUsage()` run (see the classification there). */
@@ -1595,7 +1746,7 @@ async function buildCliBody(options, connection, facts) {
 				type: "function",
 				name: tool.name,
 				description: tool.description,
-				input_schema: tool.parameters
+				input_schema: toolParametersSchema(tool.parameters)
 			})),
 			system: facts.systemText,
 			max_tokens: facts.maxTokens,
@@ -1617,7 +1768,7 @@ async function buildOpenAIBody(options, facts) {
 		function: {
 			name: tool.name,
 			description: tool.description,
-			parameters: tool.parameters
+			parameters: toolParametersSchema(tool.parameters)
 		}
 	}));
 	return {
@@ -1875,7 +2026,12 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		const access = this.deps.options().filterModelsByPlan === false ? void 0 : await this.loadBillingAccess();
 		const visible = this.deps.options().visibleModels;
 		const allow = Array.isArray(visible) && visible.length > 0 ? new Set(visible.filter((id) => typeof id === "string" && id !== "")) : void 0;
-		return catalog.filter((model) => modelVisibleInPlan(model.id, access)).filter((model) => allow === void 0 || allow.has(model.id)).map(toInfo).sort(compareByPlan);
+		const overrides = this.deps.options().modelVisibility;
+		return catalog.filter((model) => modelVisibleInPlan(model.id, access)).filter((model) => {
+			const override = overrides?.[model.id];
+			if (typeof override === "boolean") return override;
+			return allow === void 0 || allow.has(model.id);
+		}).map(toInfo).sort(compareByPlan);
 	}
 	async resolveModel(provider, model, signal) {
 		const entry = this.catalog.find((m) => m.id === model) ?? (await this.loadCatalog(signal)).find((m) => m.id === model);
@@ -3786,6 +3942,57 @@ var CommandCodeSearchProvider = class {
 const ACTIVE_ACCOUNT_AUTO = "auto";
 /** The selector value meaning "no language override — follow the shell locale". */
 const LANG_AUTO = "auto";
+/** Tier display names, mirroring the web dropdown's headings (`model-select.ts`). */
+const TIER_TITLES = {
+	go: "Go",
+	goat: "GOAT",
+	pro: "Pro",
+	provider: "Provider",
+	max: "Max"
+};
+/** Tiers in picker order; a model outside this set joins the "Other" group. */
+const TIER_ORDER = [
+	"go",
+	"goat",
+	"pro",
+	"provider",
+	"max"
+];
+/** The group holding models this build's catalog does not know. */
+const OTHER_GROUP_ID = "models-other";
+/**
+* Every model this build knows, in checkbox order: plan tier (Go first), then
+* free before paid inside a tier, then by id.
+*
+* The list is the static capability snapshot rather than a live catalog read
+* on purpose — a settings page must draw synchronously, and the snapshot is
+* synced from the same upstream table the picker's tier headings come from.
+* A model added upstream after this build still reaches the user: an empty
+* allowlist shows everything, and a model named in the allowlist but absent
+* here is rendered by the "Other" group instead of disappearing.
+*/
+function commandCodeTuiModelChoices() {
+	return Object.keys(KNOWN_PLANS).map((id) => ({
+		id,
+		tier: KNOWN_PLANS[id] ?? "",
+		free: isFreeModel(id),
+		hint: capabilityDescription(id)
+	})).sort((a, b) => {
+		const tierDelta = tierRank(a.tier) - tierRank(b.tier);
+		if (tierDelta !== 0) return tierDelta;
+		if (a.free !== b.free) return a.free ? -1 : 1;
+		return a.id.localeCompare(b.id);
+	});
+}
+/** Sort rank of a tier key; unknown tiers trail every known one. */
+function tierRank(tier) {
+	const rank = TIER_ORDER.indexOf(tier);
+	return rank === -1 ? TIER_ORDER.length : rank;
+}
+/** The stored allowlist as a clean id list (non-strings and blanks dropped). */
+function storedIds(value) {
+	return Array.isArray(value) ? value.filter((id) => typeof id === "string" && id !== "") : [];
+}
 /**
 * Build the section descriptor. Pure, so tests can pin the exact fields
 * without a dsh-TUI host.
@@ -3795,13 +4002,65 @@ const LANG_AUTO = "auto";
 * cannot express "unset" — cycling only ever lands on a declared option, so a
 * `select` would strand the user on a pinned value with no way back to
 * automatic. The `auto` sentinel plus a `parse` that clears the path keeps the
-* unset state reachable. The two booleans format their EFFECTIVE default
-* (`filterModelsByPlan` unset means true at the adapter), so a fresh install
-* reads true instead of the screen's "(empty)".
+* unset state reachable. `filterModelsByPlan` formats its EFFECTIVE default
+* (unset means true at the adapter), so a fresh install reads true instead of
+* the screen's "(empty)".
 */
 function buildCommandCodeTuiSection(deps) {
 	const ref = deps.apiKeyRef();
 	const slots = deps.accountSlots();
+	const choices = (deps.modelChoices ?? commandCodeTuiModelChoices)();
+	const catalogIds = choices.map((choice) => choice.id);
+	const known = new Set(catalogIds);
+	const stored = storedIds(deps.visibleModels());
+	const overrides = deps.modelVisibility?.() ?? {};
+	const extras = [.../* @__PURE__ */ new Set([...stored, ...Object.keys(overrides)])].filter((id) => !known.has(id));
+	const tierGroups = TIER_ORDER.filter((tier) => choices.some((choice) => choice.tier === tier)).map((tier) => ({
+		id: `models-${tier}`,
+		title: `${TIER_TITLES[tier] ?? tier} models`,
+		descriptions: { zh: `${TIER_TITLES[tier] ?? tier} 模型` }
+	}));
+	const unranked = choices.filter((choice) => tierRank(choice.tier) === TIER_ORDER.length);
+	const otherGroup = unranked.length > 0 || extras.length > 0 ? [{
+		id: OTHER_GROUP_ID,
+		title: "Other models",
+		descriptions: { zh: "其他模型" }
+	}] : [];
+	/**
+	* One checkbox: a boolean at a path of its OWN (`modelVisibility.<id>`).
+	*
+	* The path must be unique per model. dsh-TUI keys a staged draft by the
+	* field's path (`fieldKey`), so N checkboxes sharing `visibleModels` share
+	* ONE draft: every one of them then parses that same draft on save, all N
+	* write ops address the same path, and only the LAST field's op survives —
+	* which silently rewrote the allowlist from the last catalog model instead
+	* of the one that was toggled. A per-model key is what makes a checkbox
+	* express one model's state.
+	*
+	* An override equal to what the array already says is written as a CLEAR, so
+	* toggling a model back to its inherited state leaves no residue and the
+	* document stays minimal.
+	*/
+	const modelField = (id, hint, group) => ({
+		path: ["modelVisibility", id],
+		group,
+		kind: "boolean",
+		label: id,
+		...hint === "" ? {} : { hint },
+		format: (value) => {
+			if (typeof value === "boolean") return String(value);
+			const listed = storedIds(deps.visibleModels());
+			return String(listed.length === 0 || listed.includes(id));
+		},
+		parse: (text) => {
+			const on = text.trim() === "true";
+			const listed = storedIds(deps.visibleModels());
+			return on === (listed.length === 0 || listed.includes(id)) ? { kind: "clear" } : {
+				kind: "set",
+				value: on
+			};
+		}
+	});
 	return {
 		ns: deps.ns,
 		title: deps.title ?? "Command Code",
@@ -3817,6 +4076,8 @@ function buildCommandCodeTuiSection(deps) {
 				title: "Models",
 				descriptions: { zh: "模型" }
 			},
+			...tierGroups,
+			...otherGroup,
 			{
 				id: "advanced",
 				title: "Advanced",
@@ -3865,23 +4126,9 @@ function buildCommandCodeTuiSection(deps) {
 					value: text.trim() === "true"
 				})
 			},
-			{
-				path: ["visibleModels"],
-				group: "models",
-				kind: "text",
-				label: "Visible models",
-				descriptions: { zh: "显示的模型" },
-				hint: "Comma-separated catalog ids; empty shows every model.",
-				hintDescriptions: { zh: "以逗号分隔的模型 id；留空表示显示全部模型。" },
-				format: (value) => (Array.isArray(value) ? value.filter((id) => typeof id === "string" && id !== "") : []).join(", "),
-				parse: (text) => {
-					const ids = text.split(",").map((id) => id.trim()).filter((id) => id !== "");
-					return ids.length === 0 ? { kind: "clear" } : {
-						kind: "set",
-						value: ids
-					};
-				}
-			},
+			...choices.filter((choice) => tierRank(choice.tier) !== TIER_ORDER.length).map((choice) => modelField(choice.id, choice.hint, `models-${choice.tier}`)),
+			...unranked.map((choice) => modelField(choice.id, choice.hint, OTHER_GROUP_ID)),
+			...extras.map((id) => modelField(id, capabilityDescription(id), OTHER_GROUP_ID)),
 			{
 				path: ["activeAccount"],
 				group: "advanced",
@@ -3968,15 +4215,18 @@ function tuiSettingsService(ctx) {
 }
 /**
 * Identity of everything in the section that can change at runtime: the
-* credential reference behind the API-key field and the account slots behind
-* the active-account selector. Re-registration is skipped while this matches,
-* so ordinary settings writes never churn the screen's section list.
+* credential reference behind the API-key field, the account slots behind the
+* active-account selector, and the stored-but-unknown allowlist entries that
+* get a checkbox of their own. Re-registration is skipped while this matches,
+* so ordinary settings writes never churn the screen's section list — the
+* checkboxes themselves read their state live and need no re-declaration.
 */
 function sectionSignature(section) {
 	const active = section.fields.find((field) => field.path.join(".") === "activeAccount");
 	return JSON.stringify({
 		secret: section.fields.find((field) => field.secret !== void 0)?.secret?.ref ?? "",
-		options: active?.options?.map((option) => option.value) ?? []
+		options: active?.options?.map((option) => option.value) ?? [],
+		other: section.fields.filter((field) => field.group === OTHER_GROUP_ID).map((field) => field.label)
 	});
 }
 /**
@@ -4065,6 +4315,15 @@ const Config = z.object({
 	streamIdleTimeoutMs: z.number().min(1).max(MAX_TIMER_DELAY_MS),
 	filterModelsByPlan: z.boolean(),
 	visibleModels: z.array(z.string()),
+	/**
+	* Per-model visibility overrides for the terminal settings page's checkbox
+	* list, keyed by catalog id. dsh-TUI addresses a staged edit by its field
+	* PATH, so two checkboxes sharing one path would overwrite each other's
+	* draft and the section's last model would decide every write; a map gives
+	* each checkbox a path of its own. An id listed here wins over
+	* {@link visibleModels}; ids absent here keep following it.
+	*/
+	modelVisibility: z.dict(z.boolean()),
 	webSearch: z.boolean().default(true),
 	accounts: z.array(z.object({
 		label: z.string(),
@@ -4094,9 +4353,22 @@ function resolveAdapterOptions(config) {
 		requestTimeoutMs: config.requestTimeoutMs ?? 6e4,
 		streamIdleTimeoutMs: config.streamIdleTimeoutMs ?? 3e5,
 		filterModelsByPlan: config.filterModelsByPlan ?? true,
-		visibleModels: Array.isArray(config.visibleModels) ? config.visibleModels.filter((id) => typeof id === "string" && id !== "") : void 0
+		visibleModels: Array.isArray(config.visibleModels) ? config.visibleModels.filter((id) => typeof id === "string" && id !== "") : void 0,
+		modelVisibility: readModelVisibility(config.modelVisibility)
 	};
 }
+/**
+* Per-model visibility overrides, cleaned for the adapter. Programmatic
+* construction may bypass Schemastery normalization, so a non-object or a
+* non-boolean entry is dropped here instead of reaching the picker filter.
+* @param raw - The `modelVisibility` value from any config source.
+* @returns A frozen id → boolean map, or undefined when nothing is set.
+*/
+function readModelVisibility(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+	const entries = Object.entries(raw).filter((entry) => entry[0] !== "" && typeof entry[1] === "boolean");
+	return entries.length === 0 ? void 0 : Object.fromEntries(entries);
+}
 function apply(ctx, config) {
 	let current = () => config;
 	let lastRaw;
@@ -4268,7 +4540,9 @@ function apply(ctx, config) {
 			accountSlots: () => slots().map((slot) => ({
 				id: slot.id,
 				label: slot.label
-			}))
+			})),
+			visibleModels: () => options().visibleModels ?? [],
+			modelVisibility: () => options().modelVisibility
 		});
 		tuiCtx.effect(() => () => {
 			refreshTuiSettings = void 0;