@gajae-code/coding-agent 0.11.7 → 0.11.9

package/src/config/keybindings.ts

@@ -5,6 +5,7 @@ import {
 	type KeybindingDefinitions,
 	type KeybindingsConfig,
 	type KeyId,
+	parseKeyId,
 	setKeybindings,
 	TUI_KEYBINDINGS,
 	KeybindingsManager as TuiKeybindingsManager,
@@ -352,10 +353,29 @@ function toKeybindingsConfig(value: unknown): KeybindingsConfig {
 			logger.info("Ignoring unknown keybinding entry", { key });
 			continue;
 		}
-		if (val === undefined) config[key] = undefined;
-		else if (typeof val === "string") config[key] = val as KeyId;
-		else if (Array.isArray(val) && val.every(v => typeof v === "string")) config[key] = val as KeyId[];
-		else logger.info("Ignoring malformed keybinding entry", { key });
+		if (val === undefined) {
+			config[key] = undefined;
+			continue;
+		}
+
+		const keys = typeof val === "string" ? [val] : Array.isArray(val) ? val : undefined;
+		if (!keys?.every(keyValue => typeof keyValue === "string")) {
+			logger.info("Ignoring malformed keybinding entry", { key });
+			continue;
+		}
+
+		const normalizedKeys: KeyId[] = [];
+		for (const keyValue of keys) {
+			const parsedKey = parseKeyId(keyValue);
+			if (!parsedKey) {
+				logger.info("Ignoring invalid keybinding entry", { key, category: "invalid-keybinding" });
+				normalizedKeys.length = 0;
+				break;
+			}
+			normalizedKeys.push(parsedKey.keyId);
+		}
+		if (normalizedKeys.length !== keys.length) continue;
+		config[key] = typeof val === "string" ? normalizedKeys[0] : normalizedKeys;
 	}
 	return config;
 }
@@ -461,11 +481,18 @@ function migrateKeybindingsConfigFile(agentDir: string): void {
  */
 export class KeybindingsManager extends TuiKeybindingsManager {
 	#configPath: string | undefined;
+	#displayContext: KeyDisplayContext = runtimeKeyDisplayContext;
 
 	constructor(userBindings: KeybindingsConfig = {}, configPath?: string) {
-		super(KEYBINDINGS, userBindings);
+		super(KEYBINDINGS, toKeybindingsConfig(userBindings));
 		this.#configPath = configPath;
 	}
+	/**
+	 * Replace user bindings only after canonical grammar validation.
+	 */
+	override setUserBindings(userBindings: KeybindingsConfig): void {
+		super.setUserBindings(toKeybindingsConfig(userBindings));
+	}
 
 	/**
 	 * Create from config file at agentDir/keybindings.json.
@@ -485,6 +512,13 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 	static inMemory(userBindings: KeybindingsConfig = {}): KeybindingsManager {
 		return new KeybindingsManager(userBindings);
 	}
+	/**
+	 * Set the default display context used by composed surfaces that do not
+	 * supply an explicit context.
+	 */
+	setDisplayContext(context: KeyDisplayContext): void {
+		this.#displayContext = context;
+	}
 
 	/**
 	 * Reload keybindings from the config file.
@@ -504,9 +538,29 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 	/**
 	 * Get display string for a keybinding (e.g., "ctrl+c/escape").
 	 */
-	getDisplayString(keybinding: Keybinding): string {
+	getDisplayString(keybinding: Keybinding, context: KeyDisplayContext = this.#displayContext): string {
+		const keys = this.getKeys(keybinding);
+		return formatKeyHints(keys, context);
+	}
+	/**
+	 * Get an accessibility-oriented display string for help surfaces.
+	 * Darwin chords include both the concise glyphs and expanded key names.
+	 */
+	getAccessibleDisplayString(keybinding: Keybinding, context: KeyDisplayContext = this.#displayContext): string {
 		const keys = this.getKeys(keybinding);
-		return formatKeyHints(keys.length === 0 ? [] : keys);
+		return formatAccessibleKeyHints(keys, context);
+	}
+	/**
+	 * Format a fixed key chord using this manager's display context.
+	 */
+	formatKeyHint(key: string): string {
+		return formatKeyHint(key, this.#displayContext);
+	}
+	/**
+	 * Format a fixed key chord for accessibility-oriented help surfaces.
+	 */
+	formatAccessibleKeyHint(key: string): string {
+		return formatAccessibleKeyHint(key, this.#displayContext);
 	}
 
 	/**
@@ -520,13 +574,20 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 /**
  * Key hint formatting utilities for UI labels.
  */
-const MODIFIER_LABELS: Record<string, string> = {
+export interface KeyDisplayContext {
+	platform: NodeJS.Platform;
+}
+
+const runtimeKeyDisplayContext: KeyDisplayContext = { platform: process.platform };
+
+const TEXTUAL_MODIFIER_LABELS: Record<string, string> = {
 	ctrl: "Ctrl",
-	shift: "Shift",
 	alt: "Alt",
+	shift: "Shift",
+	super: "Super",
 };
 
-const KEY_LABELS: Record<string, string> = {
+const TEXTUAL_KEY_LABELS: Record<string, string> = {
 	esc: "Esc",
 	escape: "Esc",
 	enter: "Enter",
@@ -535,33 +596,105 @@ const KEY_LABELS: Record<string, string> = {
 	tab: "Tab",
 	backspace: "Backspace",
 	delete: "Delete",
+	insert: "Insert",
+	clear: "Clear",
 	home: "Home",
 	end: "End",
-	pageup: "PgUp",
-	pagedown: "PgDn",
+	pageUp: "PgUp",
+	pageDown: "PgDn",
 	up: "Up",
 	down: "Down",
 	left: "Left",
 	right: "Right",
 };
 
-function formatKeyPart(part: string): string {
-	const lower = part.toLowerCase();
-	const modifier = MODIFIER_LABELS[lower];
-	if (modifier) return modifier;
-	const label = KEY_LABELS[lower];
+const DARWIN_MODIFIER_LABELS: Record<string, string> = {
+	ctrl: "⌃",
+	alt: "⌥",
+	shift: "⇧",
+	super: "⌘",
+};
+
+const DARWIN_KEY_LABELS: Record<string, string> = {
+	...TEXTUAL_KEY_LABELS,
+	esc: "⎋",
+	escape: "⎋",
+	enter: "↩",
+	return: "↩",
+	tab: "⇥",
+	backspace: "⌫",
+	delete: "⌦",
+	up: "↑",
+	down: "↓",
+	left: "←",
+	right: "→",
+};
+const DARWIN_ACCESSIBLE_MODIFIER_LABELS: Record<string, string> = {
+	ctrl: "Control",
+	alt: "Option",
+	shift: "Shift",
+	super: "Command",
+};
+
+const DARWIN_ACCESSIBLE_KEY_LABELS: Record<string, string> = {
+	...TEXTUAL_KEY_LABELS,
+	esc: "Escape",
+	escape: "Escape",
+	pageUp: "Page Up",
+	pageDown: "Page Down",
+};
+
+const DISPLAY_MODIFIER_ORDER = ["ctrl", "alt", "shift", "super"] as const;
+const INVALID_KEYBINDING_DISPLAY = "Invalid keybinding";
+
+function formatBaseKey(baseKey: string, labels: Record<string, string>): string {
+	const label = labels[baseKey];
 	if (label) return label;
-	if (part.length === 1) return part.toUpperCase();
-	return `${part.charAt(0).toUpperCase()}${part.slice(1)}`;
+	if (baseKey.length === 1) return baseKey.toUpperCase();
+	return `${baseKey.charAt(0).toUpperCase()}${baseKey.slice(1)}`;
+}
+
+export function formatKeyHint(key: string, context: KeyDisplayContext = runtimeKeyDisplayContext): string {
+	const parsed = parseKeyId(key);
+	if (!parsed) return INVALID_KEYBINDING_DISPLAY;
+
+	const darwin = context.platform === "darwin";
+	const modifierLabels = darwin ? DARWIN_MODIFIER_LABELS : TEXTUAL_MODIFIER_LABELS;
+	const baseLabels = darwin ? DARWIN_KEY_LABELS : TEXTUAL_KEY_LABELS;
+	const modifiers = DISPLAY_MODIFIER_ORDER.filter(modifier => parsed.modifiers.includes(modifier)).map(
+		modifier => modifierLabels[modifier],
+	);
+	const parts = [...modifiers, formatBaseKey(parsed.baseKey, baseLabels)];
+	return parts.join(darwin ? "" : "+");
+}
+
+export function formatAccessibleKeyHint(key: string, context: KeyDisplayContext = runtimeKeyDisplayContext): string {
+	const concise = formatKeyHint(key, context);
+	if (context.platform !== "darwin" || concise === INVALID_KEYBINDING_DISPLAY) return concise;
+
+	const parsed = parseKeyId(key);
+	if (!parsed) return INVALID_KEYBINDING_DISPLAY;
+	const modifiers = DISPLAY_MODIFIER_ORDER.filter(modifier => parsed.modifiers.includes(modifier)).map(
+		modifier => DARWIN_ACCESSIBLE_MODIFIER_LABELS[modifier],
+	);
+	const expanded = [...modifiers, formatBaseKey(parsed.baseKey, DARWIN_ACCESSIBLE_KEY_LABELS)].join("+");
+	return concise === expanded ? concise : `${concise} (${expanded})`;
 }
 
-export function formatKeyHint(key: KeyId): string {
-	return key.split("+").map(formatKeyPart).join("+");
+export function formatKeyHints(
+	keys: string | readonly string[],
+	context: KeyDisplayContext = runtimeKeyDisplayContext,
+): string {
+	const list: readonly string[] = typeof keys === "string" ? [keys] : keys;
+	return list.map(key => formatKeyHint(key, context)).join("/");
 }
 
-export function formatKeyHints(keys: KeyId | KeyId[]): string {
-	const list = Array.isArray(keys) ? keys : [keys];
-	return list.map(formatKeyHint).join("/");
+export function formatAccessibleKeyHints(
+	keys: string | readonly string[],
+	context: KeyDisplayContext = runtimeKeyDisplayContext,
+): string {
+	const list: readonly string[] = typeof keys === "string" ? [keys] : keys;
+	return list.map(key => formatAccessibleKeyHint(key, context)).join("/");
 }
 
 export type { Keybinding, KeybindingsConfig, KeyId };

package/src/config/model-profile-activation.ts

@@ -2,12 +2,15 @@ import { ThinkingLevel } from "@gajae-code/agent-core";
 import type { Api, Model } from "@gajae-code/ai";
 import type { AgentSession } from "../session/agent-session";
 import { formatClampedModelSelector } from "../thinking";
+import { validateModelProfileName } from "./model-profile-contract";
 import {
 	aggregateModelProfileRequiredProviders,
-	formatAvailableProfileNames,
 	formatModelProfileDisplayLabel,
 	resolveProfileBindings,
 } from "./model-profiles";
+
+export { resolveModelProfileName } from "./model-profile-contract";
+
 import {
 	GJC_MODEL_ASSIGNMENT_TARGETS,
 	type GjcModelAssignmentTargetId,
@@ -24,8 +27,6 @@ import {
 import { type ModelSelectorValue, normalizeModelSelectorValue } from "./model-selector-value";
 import type { Settings } from "./settings";
 
-const LEGACY_MODEL_PROFILE_ALIASES: ReadonlyMap<string, string> = new Map([["codex-standard", "codex-medium"]]);
-
 type ModelProfileActivationSession = Pick<
 	AgentSession,
 	"model" | "thinkingLevel" | "sessionId" | "getConfiguredModelChain" | "setConfiguredModelChain"
@@ -50,7 +51,7 @@ export interface PrepareModelProfileActivationOptions {
 		| "resolveCanonicalModel"
 		| "getCanonicalVariants"
 		| "getCanonicalId"
-	>;
+	> & { getError?: ModelRegistry["getError"] };
 	settings: Pick<Settings, "get">;
 	profileName: string;
 }
@@ -236,14 +237,6 @@ export function formatModelProfileCredentialError(profileLabel: string, provider
 	return `Model profile "${profileLabel}" requires credentials for: ${providers.join(", ")}. Run /login and configure the missing provider(s), then retry.`;
 }
 
-export function resolveModelProfileName(profileName: string, profiles: ReadonlyMap<string, unknown>): string {
-	// A retired-name alias is fallback-only: never shadow a profile that actually
-	// exists under the requested name (e.g. a user-defined `codex-standard`).
-	if (profiles.has(profileName)) return profileName;
-	const replacement = LEGACY_MODEL_PROFILE_ALIASES.get(profileName);
-	return replacement && profiles.has(replacement) ? replacement : profileName;
-}
-
 /**
  * Rewrite a selector only within the selector provider's own alternative group.
  * Strict providers are never rewritten, and authenticated alternative providers
@@ -348,12 +341,8 @@ export async function prepareModelProfileActivation(
 	options: PrepareModelProfileActivationOptions,
 ): Promise<PreparedModelProfileActivation> {
 	const profiles = options.modelRegistry.getModelProfiles();
-	const profileName = resolveModelProfileName(options.profileName, profiles);
-	const profile = profiles.get(profileName) ?? options.modelRegistry.getModelProfile(profileName);
-	if (!profile) {
-		const available = formatAvailableProfileNames(profiles);
-		throw new Error(`Unknown model profile "${options.profileName}". Available profiles: ${available}`);
-	}
+	const profileName = validateModelProfileName(options.profileName, profiles, options.modelRegistry.getError?.());
+	const profile = profiles.get(profileName) ?? options.modelRegistry.getModelProfile(profileName)!;
 	const profileLabel = formatModelProfileDisplayLabel(profile);
 
 	const requiredProviders = aggregateModelProfileRequiredProviders(profile.requiredProviders, profile);

package/src/config/model-profile-contract.ts

@@ -0,0 +1,161 @@
+import { formatModelProfileDisplayLabel, type ModelProfileDefinition } from "./model-profiles";
+
+export const MODEL_PROFILE_DISCOVERY_QUERY = "models.profiles.list";
+export const MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES = 2048;
+const REQUESTED_PROFILE_MAX_BYTES = 256;
+
+const LEGACY_MODEL_PROFILE_ALIASES: ReadonlyMap<string, string> = new Map([["codex-standard", "codex-medium"]]);
+
+export interface ModelProfileCatalogItem {
+	id: string;
+	displayName: string;
+	source: "builtin" | "configured";
+}
+
+export interface UnknownModelProfileDetails {
+	requestedProfile: string;
+	availableProfiles: string[];
+	discoveryQuery: typeof MODEL_PROFILE_DISCOVERY_QUERY;
+}
+
+export interface ModelProfileRegistryErrorDetails {
+	requestedProfile?: string;
+	availableProfiles: [];
+	discoveryQuery: typeof MODEL_PROFILE_DISCOVERY_QUERY;
+}
+
+export type ModelProfileErrorDetails = UnknownModelProfileDetails | ModelProfileRegistryErrorDetails;
+export type ModelProfileErrorCode = "unknown_model_profile" | "model_profile_registry_error";
+
+function truncateUtf8(value: string, maxBytes: number): string {
+	if (Buffer.byteLength(value) <= maxBytes) return value;
+	let end = value.length;
+	while (end > 0 && Buffer.byteLength(value.slice(0, end)) > maxBytes) end--;
+	return value.slice(0, end);
+}
+
+function diagnosticProfileEcho(value: string): string {
+	return truncateUtf8(value.normalize("NFKC").replace(/[\p{Cc}\p{Cf}]+/gu, " "), REQUESTED_PROFILE_MAX_BYTES);
+}
+
+function boundedAvailableProfiles(requestedProfile: string, profiles: ReadonlyMap<string, unknown>): string[] {
+	const availableProfiles: string[] = [];
+	for (const id of [...new Set(profiles.keys())].sort((left, right) => left.localeCompare(right))) {
+		const candidate: UnknownModelProfileDetails = {
+			requestedProfile,
+			availableProfiles: [...availableProfiles, id],
+			discoveryQuery: MODEL_PROFILE_DISCOVERY_QUERY,
+		};
+		if (Buffer.byteLength(JSON.stringify(candidate)) > MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES) continue;
+		availableProfiles.push(id);
+	}
+	return availableProfiles;
+}
+
+export class UnknownModelProfileError extends Error {
+	readonly code = "unknown_model_profile" as const;
+	readonly details: UnknownModelProfileDetails;
+
+	constructor(requestedProfile: string, profiles: ReadonlyMap<string, unknown>) {
+		const echoed = diagnosticProfileEcho(requestedProfile);
+		const availableProfiles = boundedAvailableProfiles(echoed, profiles);
+		const available = availableProfiles.length > 0 ? availableProfiles.join(", ") : "none";
+		super(
+			truncateUtf8(
+				`Unknown model profile ${JSON.stringify(echoed)}. Available profiles: ${available}. Query ${MODEL_PROFILE_DISCOVERY_QUERY} for the complete catalog.`,
+				512,
+			),
+		);
+		this.name = "UnknownModelProfileError";
+		this.details = {
+			requestedProfile: echoed,
+			availableProfiles,
+			discoveryQuery: MODEL_PROFILE_DISCOVERY_QUERY,
+		};
+	}
+}
+
+export class ModelProfileRegistryError extends Error {
+	readonly code = "model_profile_registry_error" as const;
+	readonly details: ModelProfileRegistryErrorDetails;
+
+	constructor(requestedProfile?: string) {
+		super(
+			`The model profile registry is unavailable. Query ${MODEL_PROFILE_DISCOVERY_QUERY} after fixing models.yml.`,
+		);
+		this.name = "ModelProfileRegistryError";
+		const echoed = requestedProfile === undefined ? undefined : diagnosticProfileEcho(requestedProfile);
+		this.details = {
+			...(echoed ? { requestedProfile: echoed } : {}),
+			availableProfiles: [],
+			discoveryQuery: MODEL_PROFILE_DISCOVERY_QUERY,
+		};
+	}
+}
+
+export function resolveModelProfileName(profileName: string, profiles: ReadonlyMap<string, unknown>): string {
+	if (profiles.has(profileName)) return profileName;
+	const replacement = LEGACY_MODEL_PROFILE_ALIASES.get(profileName);
+	return replacement && profiles.has(replacement) ? replacement : profileName;
+}
+
+export function validateModelProfileName(
+	profileName: string,
+	profiles: ReadonlyMap<string, unknown>,
+	registryError?: unknown,
+): string {
+	if (registryError !== undefined) throw new ModelProfileRegistryError(profileName);
+	const resolved = resolveModelProfileName(profileName, profiles);
+	if (!profiles.has(resolved)) throw new UnknownModelProfileError(profileName, profiles);
+	return resolved;
+}
+
+export function projectModelProfileCatalog(
+	profiles: ReadonlyMap<string, ModelProfileDefinition>,
+	registryError?: unknown,
+): ModelProfileCatalogItem[] {
+	if (registryError !== undefined) throw new ModelProfileRegistryError();
+	return [...profiles.entries()]
+		.map(([id, definition]) => ({
+			id,
+			displayName: formatModelProfileDisplayLabel(definition),
+			source: definition.source === "user" ? ("configured" as const) : ("builtin" as const),
+		}))
+		.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+export function isModelProfileError(value: unknown): value is {
+	code: ModelProfileErrorCode;
+	message: string;
+	details: ModelProfileErrorDetails;
+} {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const error = value as Record<string, unknown>;
+	if (
+		(error.code !== "unknown_model_profile" && error.code !== "model_profile_registry_error") ||
+		typeof error.message !== "string" ||
+		!error.details ||
+		typeof error.details !== "object" ||
+		Array.isArray(error.details)
+	)
+		return false;
+	const details = error.details as Record<string, unknown>;
+	const detailKeys = Object.keys(details);
+	if (
+		!detailKeys.every(key => key === "requestedProfile" || key === "availableProfiles" || key === "discoveryQuery") ||
+		details.discoveryQuery !== MODEL_PROFILE_DISCOVERY_QUERY ||
+		!Array.isArray(details.availableProfiles) ||
+		!details.availableProfiles.every(id => typeof id === "string") ||
+		Buffer.byteLength(JSON.stringify(details)) > MODEL_PROFILE_ERROR_DETAIL_MAX_BYTES ||
+		(typeof details.requestedProfile === "string" &&
+			Buffer.byteLength(details.requestedProfile) > REQUESTED_PROFILE_MAX_BYTES)
+	)
+		return false;
+	if (error.code === "unknown_model_profile")
+		return detailKeys.length === 3 && typeof details.requestedProfile === "string";
+	return (
+		detailKeys.length === (details.requestedProfile === undefined ? 2 : 3) &&
+		details.availableProfiles.length === 0 &&
+		(details.requestedProfile === undefined || typeof details.requestedProfile === "string")
+	);
+}

package/src/config/model-profiles.ts

@@ -1,9 +1,8 @@
 import { sanitizeText } from "@gajae-code/utils";
-import type { GjcModelAssignmentTargetId } from "./model-registry";
 import { type ModelSelectorValue, normalizeModelSelectorValue } from "./model-selector-value";
-import type { ModelsConfig } from "./models-config-schema";
+import type { GJC_MODEL_ASSIGNMENT_TARGET_IDS, ModelsConfig } from "./models-config-schema";
 
-export type ModelProfileRole = GjcModelAssignmentTargetId;
+export type ModelProfileRole = (typeof GJC_MODEL_ASSIGNMENT_TARGET_IDS)[number];
 
 export interface ModelProfileDefinition {
 	name: string;

package/src/config/model-registry.ts

@@ -2049,7 +2049,10 @@ export class ModelRegistry {
 		const modelsUrl = `${baseUrl}/models`;
 
 		const headers: Record<string, string> = { ...(providerConfig.headers ?? {}) };
-		const apiKey = await this.authStorage.getApiKey(providerConfig.provider);
+		// Resolve with the same baseUrl context completion requests use so an
+		// endpoint-scoped (or config-pinned) credential wins here exactly as it
+		// does for chat completions.
+		const apiKey = await this.authStorage.getApiKey(providerConfig.provider, undefined, { baseUrl });
 		if (apiKey && apiKey !== DEFAULT_LOCAL_TOKEN && apiKey !== kNoAuth) {
 			headers.Authorization = `Bearer ${apiKey}`;
 		}
@@ -2059,6 +2062,13 @@ export class ModelRegistry {
 			signal: AbortSignal.timeout(250),
 		});
 		if (!response.ok) {
+			if (response.status === 401 || response.status === 403) {
+				// Redacted by construction: name the provider, endpoint, and the
+				// config surface to fix — never the resolved key.
+				throw new Error(
+					`HTTP ${response.status} from ${modelsUrl}: provider "${providerConfig.provider}" credential was rejected for OpenAI models-list discovery; check providers.${providerConfig.provider}.apiKey/apiKeyEnv.`,
+				);
+			}
 			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
 		}
 		const payload = (await response.json()) as { data?: Array<{ id: string }> };

package/src/config/settings-schema.ts

@@ -1343,6 +1343,16 @@ export const SETTINGS_SCHEMA = {
 			description: "Suggest emojis from `:name:` shortcodes and expand text emoticons like `:D` or `:-)`",
 		},
 	},
+	promptSuggestions: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "interaction",
+			label: "Prompt Suggestions",
+			description:
+				"Predict your likely next prompt after each turn (smol-model call) and show it as ghost text; Tab accepts",
+		},
+	},
 
 	"startup.quiet": {
 		type: "boolean",
@@ -3299,7 +3309,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"providers.image": {
 		type: "enum",
-		values: ["auto", "openai", "gemini", "openrouter", "antigravity", "custom"] as const,
+		values: ["auto", "openai", "gemini", "openrouter", "antigravity", "alibaba", "custom"] as const,
 		default: "auto",
 		ui: {
 			tab: "providers",
@@ -3309,12 +3319,17 @@ export const SETTINGS_SCHEMA = {
 				{
 					value: "auto",
 					label: "Auto",
-					description: "Priority: GPT model image tool > Antigravity > OpenRouter > Gemini",
+					description: "Priority: GPT model image tool > Antigravity > OpenRouter > Gemini > Alibaba",
 				},
 				{ value: "openai", label: "OpenAI", description: "Uses gpt-image-2 via OpenAI Responses/Codex" },
 				{ value: "gemini", label: "Gemini", description: "Requires GEMINI_API_KEY" },
 				{ value: "openrouter", label: "OpenRouter", description: "Requires OPENROUTER_API_KEY" },
 				{ value: "antigravity", label: "Antigravity", description: "Requires login with google-antigravity" },
+				{
+					value: "alibaba",
+					label: "Alibaba Bailian",
+					description: "Requires ALIBABA_TOKEN_PLAN_API_KEY (wan2.7-image via Token Plan)",
+				},
 				{
 					value: "custom",
 					label: "Custom",