@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/cli/models-cli.ts

@@ -0,0 +1,429 @@
+/**
+ * `prometheus models` — list, search, and refresh available models.
+ *
+ * Subcommands:
+ * - `ls` (default): list every available model with a canonical + provider view.
+ * - `find <substring>`: list models whose provider, id, or name contains the substring.
+ * - `refresh`: force an online catalog re-fetch (ignoring the model cache TTL),
+ *   then list. This is the supported replacement for `rm -rf ~/.prometheus/models.db`
+ *   when a provider ships a new model that the 24h cache has not picked up yet.
+ *
+ * `ls`/`find` use the cache when fresh (`online-if-uncached`); only `refresh`
+ * forces the network (`online`).
+ */
+import type { Api, Effort, Model } from "@prometheus-ai/ai";
+import { getSupportedEfforts } from "@prometheus-ai/catalog/model-thinking";
+import { formatNumber, getProjectDir } from "@prometheus-ai/utils";
+import chalk from "chalk";
+import { ModelRegistry } from "../config/model-registry";
+import { Settings } from "../config/settings";
+import { discoverAndLoadExtensions, loadExtensions } from "../extensibility/extensions";
+import { discoverAuthStorage } from "../sdk";
+import { EventBus } from "../utils/event-bus";
+
+export type ModelsAction = "ls" | "find" | "refresh" | "canonical";
+
+export interface ModelsCommandArgs {
+	action: ModelsAction;
+	/** Search substring for `find`, or optional filter for `ls`. */
+	pattern?: string;
+	flags: {
+		json?: boolean;
+		/** CLI `-e <path>` extension paths to load before listing (issue #905). */
+		extensions?: string[];
+		/** Skip extension discovery; only load explicit `extensions`. */
+		noExtensions?: boolean;
+		/** Extra `config.yml` overlays to apply for this invocation. */
+		config?: string[];
+	};
+}
+
+/**
+ * Known action keywords. Any other first token (e.g. `openai-codex`) is treated
+ * as a provider/substring filter for the default `ls` view, so every provider
+ * name doubles as an `prometheus models <provider>` shortcut.
+ */
+const KNOWN_ACTIONS: Record<string, ModelsAction> = {
+	ls: "ls",
+	list: "ls",
+	find: "find",
+	refresh: "refresh",
+	canonical: "canonical",
+};
+
+/** Resolve the two positional args into an action + filter (provider names fall through to `ls`). */
+export function resolveModelsArgs(
+	first: string | undefined,
+	second: string | undefined,
+): { action: ModelsAction; pattern: string | undefined } {
+	const known = first === undefined ? undefined : KNOWN_ACTIONS[first];
+	if (known) {
+		return { action: known, pattern: second };
+	}
+	return { action: "ls", pattern: first };
+}
+
+interface ModelJson {
+	provider: string;
+	id: string;
+	selector: string;
+	name: string;
+	contextWindow: number | null;
+	maxTokens: number | null;
+	reasoning: boolean;
+	/** Supported thinking efforts when the model thinks, otherwise null. */
+	thinking: readonly Effort[] | null;
+	input: ("text" | "image")[];
+	cost: Model<Api>["cost"];
+}
+
+interface CanonicalJson {
+	id: string;
+	selected: string;
+	variants: number;
+	contextWindow: number | null;
+	maxTokens: number | null;
+}
+
+interface ModelsJson {
+	models: ModelJson[];
+}
+
+interface CanonicalModelsJson {
+	canonical: CanonicalJson[];
+}
+
+function writeLine(line = ""): void {
+	process.stdout.write(`${line}\n`);
+}
+
+function formatLimit(n: number | null): string {
+	return n === null ? "-" : formatNumber(n);
+}
+
+function byProviderThenId(left: Model<Api>, right: Model<Api>): number {
+	const providerCmp = left.provider.localeCompare(right.provider);
+	if (providerCmp !== 0) return providerCmp;
+	return left.id.localeCompare(right.id);
+}
+
+function toModelJson(model: Model<Api>): ModelJson {
+	return {
+		provider: model.provider,
+		id: model.id,
+		selector: `${model.provider}/${model.id}`,
+		name: model.name,
+		contextWindow: model.contextWindow,
+		maxTokens: model.maxTokens,
+		reasoning: model.reasoning,
+		thinking: model.thinking ? getSupportedEfforts(model) : null,
+		input: model.input,
+		cost: model.cost,
+	};
+}
+
+type ColumnAlign = "left" | "right";
+
+interface BoxColumn {
+	header: string;
+	align?: ColumnAlign;
+}
+
+/** Right- or left-pad a plain (ANSI-free) cell to `width` display columns. */
+function padCell(text: string, width: number, align: ColumnAlign = "left"): string {
+	const space = width - Bun.stringWidth(text);
+	if (space <= 0) return text;
+	const fill = " ".repeat(space);
+	return align === "right" ? fill + text : text + fill;
+}
+
+/**
+ * Render `rows` as a box-drawing table. Cells must be plain text (no ANSI); the
+ * header row is bolded and the borders dimmed (both no-ops on non-TTY output).
+ */
+function boxTable(columns: BoxColumn[], rows: string[][]): string[] {
+	const widths = columns.map((column, index) =>
+		Math.max(Bun.stringWidth(column.header), ...rows.map(row => Bun.stringWidth(row[index] ?? ""))),
+	);
+	const bar = chalk.dim("│");
+	const segments = widths.map(width => "─".repeat(width + 2));
+	const renderRow = (cells: string[], bold: boolean): string => {
+		const padded = columns.map((column, index) => {
+			const cell = padCell(cells[index] ?? "", widths[index]!, column.align);
+			return bold ? chalk.bold(cell) : cell;
+		});
+		return `${bar} ${padded.join(` ${bar} `)} ${bar}`;
+	};
+	const lines = [chalk.dim(`┌${segments.join("┬")}┐`)];
+	lines.push(
+		renderRow(
+			columns.map(column => column.header),
+			true,
+		),
+	);
+	lines.push(chalk.dim(`├${segments.join("┼")}┤`));
+	for (const row of rows) {
+		lines.push(renderRow(row, false));
+	}
+	lines.push(chalk.dim(`└${segments.join("┴")}┘`));
+	return lines;
+}
+
+/** `prometheus models ls`/`find`: provider-grouped listing (one box table per provider). */
+function renderProviderModels(
+	modelRegistry: ModelRegistry,
+	action: ModelsAction,
+	pattern: string | undefined,
+	json: boolean,
+): void {
+	const available = modelRegistry.getAvailable();
+	const needle = pattern?.toLowerCase();
+	let filtered = available;
+
+	if (needle) {
+		let exactFound = false;
+		if (action !== "find") {
+			const exact = available.filter(m => m.provider.toLowerCase() === needle);
+			if (exact.length > 0) {
+				filtered = exact;
+				exactFound = true;
+			}
+		}
+		if (!exactFound) {
+			filtered = available.filter(
+				model =>
+					model.id.toLowerCase().includes(needle) ||
+					model.provider.toLowerCase().includes(needle) ||
+					`${model.provider}/${model.id}`.toLowerCase().includes(needle) ||
+					model.name.toLowerCase().includes(needle),
+			);
+		}
+	}
+
+	if (json) {
+		const output: ModelsJson = { models: filtered.slice().sort(byProviderThenId).map(toModelJson) };
+		writeLine(JSON.stringify(output));
+		return;
+	}
+
+	if (available.length === 0) {
+		writeLine("No models available. Set API keys in environment variables.");
+		return;
+	}
+	if (filtered.length === 0) {
+		writeLine(`No models matching "${pattern}"`);
+		return;
+	}
+
+	// One section per provider: bold heading + a box table of that provider's models.
+	const byProvider = new Map<string, Model<Api>[]>();
+	for (const model of filtered.slice().sort(byProviderThenId)) {
+		let group = byProvider.get(model.provider);
+		if (!group) {
+			group = [];
+			byProvider.set(model.provider, group);
+		}
+		group.push(model);
+	}
+
+	let firstProvider = true;
+	for (const [provider, models] of byProvider) {
+		if (!firstProvider) writeLine();
+		firstProvider = false;
+		writeLine(`${chalk.bold.cyan(provider)} ${chalk.dim(`(${models.length})`)}`);
+		const rows = models.map(model => [
+			model.id,
+			formatLimit(model.contextWindow),
+			formatLimit(model.maxTokens),
+			model.thinking ? getSupportedEfforts(model).join(",") : model.reasoning ? "yes" : "-",
+			model.input.includes("image") ? "yes" : "no",
+		]);
+		for (const line of boxTable(
+			[
+				{ header: "model" },
+				{ header: "context", align: "right" },
+				{ header: "max-out", align: "right" },
+				{ header: "thinking" },
+				{ header: "images" },
+			],
+			rows,
+		)) {
+			writeLine(line);
+		}
+	}
+}
+
+/** `prometheus models canonical`: the coalesced canonical view (one row per canonical id). */
+function renderCanonicalModels(modelRegistry: ModelRegistry, pattern: string | undefined, json: boolean): void {
+	const selections = modelRegistry.getCanonicalModelSelections({ availableOnly: true });
+	const needle = pattern?.toLowerCase();
+	const filtered = needle
+		? selections.filter(
+				({ record, model }) =>
+					record.id.toLowerCase().includes(needle) ||
+					`${model.provider}/${model.id}`.toLowerCase().includes(needle),
+			)
+		: selections;
+
+	if (json) {
+		const output: CanonicalModelsJson = {
+			canonical: filtered
+				.map(({ record, model }) => ({
+					id: record.id,
+					selected: `${model.provider}/${model.id}`,
+					variants: record.variants.length,
+					contextWindow: model.contextWindow,
+					maxTokens: model.maxTokens,
+				}))
+				.sort((left, right) => left.id.localeCompare(right.id)),
+		};
+		writeLine(JSON.stringify(output));
+		return;
+	}
+
+	if (selections.length === 0) {
+		writeLine("No models available. Set API keys in environment variables.");
+		return;
+	}
+	if (filtered.length === 0) {
+		writeLine(`No canonical models matching "${pattern}"`);
+		return;
+	}
+
+	const rows = filtered
+		.slice()
+		.sort((left, right) => left.record.id.localeCompare(right.record.id))
+		.map(({ record, model }) => [
+			record.id,
+			`${model.provider}/${model.id}`,
+			String(record.variants.length),
+			formatLimit(model.contextWindow),
+			formatLimit(model.maxTokens),
+		]);
+	for (const line of boxTable(
+		[
+			{ header: "canonical" },
+			{ header: "selected" },
+			{ header: "variants", align: "right" },
+			{ header: "context", align: "right" },
+			{ header: "max-out", align: "right" },
+		],
+		rows,
+	)) {
+		writeLine(line);
+	}
+}
+
+/**
+ * Options for {@link runModelsListing}: render the catalog from a caller-supplied
+ * registry. Loads extensions (CLI `-e` paths and configured `settings.extensions`)
+ * and discovers their providers before rendering so extension-contributed models
+ * appear (issue #905). The caller is responsible for refreshing built-in providers.
+ */
+export interface RunModelsListingOptions {
+	modelRegistry: ModelRegistry;
+	cwd: string;
+	action?: ModelsAction;
+	pattern?: string;
+	json?: boolean;
+	/** CLI-supplied extension paths (e.g. from `-e <path>`). */
+	additionalExtensionPaths?: string[];
+	/** Extension paths configured under `extensions:` in user settings. */
+	settingsExtensions?: string[];
+	/** Disabled extension ids from settings (`disabledExtensions`). */
+	disabledExtensionIds?: string[];
+	/** When true, skip discovery and only load `additionalExtensionPaths`. */
+	disableExtensionDiscovery?: boolean;
+}
+
+export async function runModelsListing(options: RunModelsListingOptions): Promise<void> {
+	const {
+		modelRegistry,
+		cwd,
+		action = "ls",
+		pattern,
+		json = false,
+		additionalExtensionPaths = [],
+		settingsExtensions = [],
+		disabledExtensionIds = [],
+		disableExtensionDiscovery = false,
+	} = options;
+
+	const eventBus = new EventBus();
+	const extensionsResult = disableExtensionDiscovery
+		? await loadExtensions(additionalExtensionPaths, cwd, eventBus)
+		: await discoverAndLoadExtensions(
+				[...additionalExtensionPaths, ...settingsExtensions],
+				cwd,
+				eventBus,
+				disabledExtensionIds,
+			);
+
+	for (const { path: extPath, error } of extensionsResult.errors) {
+		process.stderr.write(`Failed to load extension: ${extPath}: ${error}\n`);
+	}
+
+	// Mirror sdk.ts: drain pending provider registrations into the registry.
+	const activeSources = extensionsResult.extensions.map(extension => extension.path);
+	modelRegistry.syncExtensionSources(activeSources);
+	for (const sourceId of new Set(activeSources)) {
+		modelRegistry.clearSourceRegistrations(sourceId);
+	}
+	for (const { name, config, sourceId } of extensionsResult.runtime.pendingProviderRegistrations) {
+		modelRegistry.registerProvider(name, config, sourceId);
+	}
+	extensionsResult.runtime.pendingProviderRegistrations = [];
+	// Discover runtime (extension) provider catalogs now that they are registered.
+	await modelRegistry.refreshRuntimeProviders(action === "refresh" ? "online" : "online-if-uncached");
+
+	if (action === "canonical") {
+		renderCanonicalModels(modelRegistry, pattern, json);
+	} else {
+		renderProviderModels(modelRegistry, action, pattern, json);
+	}
+}
+
+/**
+ * Entry point for the standalone `prometheus models` command: bootstraps auth storage,
+ * settings, and the model registry, force/cache-refreshes built-in providers per
+ * the chosen action, then delegates to {@link runModelsListing}.
+ */
+export async function runModelsCommand(command: ModelsCommandArgs): Promise<void> {
+	const { action, pattern } = command;
+	const json = command.flags.json ?? false;
+
+	if (action === "find" && (!pattern || pattern.trim().length === 0)) {
+		process.stderr.write(
+			"`prometheus models find` requires a search substring, e.g. `prometheus models find minimax`\n",
+		);
+		process.exitCode = 1;
+		return;
+	}
+
+	const cwd = getProjectDir();
+	const authStorage = await discoverAuthStorage();
+	try {
+		const settings = await Settings.init({ cwd, configFiles: command.flags.config });
+		const modelRegistry = new ModelRegistry(authStorage);
+
+		if (action === "refresh" && !json && process.stderr.isTTY) {
+			process.stderr.write("Refreshing models from all providers…\n");
+		}
+		await modelRegistry.refresh(action === "refresh" ? "online" : "online-if-uncached");
+
+		const cliExtensionPaths = command.flags.noExtensions ? [] : (command.flags.extensions ?? []);
+		await runModelsListing({
+			modelRegistry,
+			cwd,
+			action,
+			pattern,
+			json,
+			additionalExtensionPaths: cliExtensionPaths,
+			settingsExtensions: settings.get("extensions") ?? [],
+			disabledExtensionIds: settings.get("disabledExtensions") ?? [],
+			disableExtensionDiscovery: Boolean(command.flags.noExtensions),
+		});
+	} finally {
+		authStorage.close();
+	}
+}

package/src/cli/session-picker.ts

@@ -2,7 +2,8 @@ import { ProcessTerminal, TUI } from "@prometheus-ai/tui";
 import { logger } from "@prometheus-ai/utils";
 import { SessionSelectorComponent } from "../modes/components/session-selector";
 import { HistoryStorage } from "../session/history-storage";
-import { type SessionInfo, SessionManager } from "../session/session-manager";
+import type { SessionInfo } from "../session/session-listing";
+import { SessionManager } from "../session/session-manager";
 import { FileSessionStorage } from "../session/session-storage";
 
 /**

package/src/cli/setup-cli.ts

@@ -4,12 +4,18 @@
  * Handles `prometheus setup` for onboarding and `prometheus setup <component>` for optional dependencies.
  */
 import * as path from "node:path";
-import { $which, APP_NAME, getPythonEnvDir } from "@prometheus-ai/utils";
+import { $which, APP_NAME, getProjectDir, getPythonEnvDir } from "@prometheus-ai/utils";
 import { $ } from "bun";
 import chalk from "chalk";
+import { Settings, settings } from "../config/settings";
 import { theme } from "../modes/theme/theme";
+import { downloadSttModel, isSttModelCached } from "../stt/downloader";
+import { isSttModelKey, STT_MODEL_OPTIONS } from "../stt/models";
+import { detectRecorder, ensureRecorder } from "../stt/recorder";
+import { downloadTtsModel, isTtsLocalModelKey, isTtsModelCached, TTS_LOCAL_MODEL_OPTIONS } from "../tts";
+import { selectSetupModel } from "./setup-model-picker";
 
-export type SetupComponent = "python" | "stt";
+export type SetupComponent = "python" | "speech";
 
 export interface SetupCommandArgs {
 	component: SetupComponent;
@@ -19,7 +25,7 @@ export interface SetupCommandArgs {
 	};
 }
 
-const VALID_COMPONENTS: SetupComponent[] = ["python", "stt"];
+const VALID_COMPONENTS: SetupComponent[] = ["python", "speech"];
 
 const MANAGED_PYTHON_ENV = getPythonEnvDir();
 
@@ -114,8 +120,8 @@ export async function runSetupCommand(cmd: SetupCommandArgs): Promise<void> {
 		case "python":
 			await handlePythonSetup(cmd.flags);
 			break;
-		case "stt":
-			await handleSttSetup(cmd.flags);
+		case "speech":
+			await handleSpeechSetup(cmd.flags);
 			break;
 	}
 }
@@ -149,58 +155,153 @@ async function handlePythonSetup(flags: { json?: boolean; check?: boolean }): Pr
 	process.exit(1);
 }
 
-async function handleSttSetup(flags: { json?: boolean; check?: boolean }): Promise<void> {
-	const { checkDependencies, formatDependencyStatus } = await import("../stt/setup");
-	const status = await checkDependencies();
+/**
+ * One installable speech dependency. `isReady`/`status` are read-only probes;
+ * `pick` (optional) lets an interactive user choose + persist a model; `ensure`
+ * performs the download, streaming a normalized progress event.
+ */
+interface SpeechComponent {
+	name: string;
+	isReady(): Promise<boolean>;
+	status(): Promise<string>;
+	pick?(): Promise<boolean>;
+	ensure(onProgress: (progress: { stage: string; percent?: number }) => void): Promise<void>;
+}
 
-	if (flags.json) {
-		console.log(JSON.stringify(status, null, 2));
-		if (!status.recorder.available || !status.python.available || !status.whisper.available) process.exit(1);
-		return;
-	}
+function buildSpeechComponents(): SpeechComponent[] {
+	return [
+		{
+			name: "Recorder",
+			isReady: async () => detectRecorder() !== null,
+			status: async () => {
+				const recorder = detectRecorder();
+				return recorder ? `${recorder.tool} (${recorder.bin})` : "none — ffmpeg will be downloaded";
+			},
+			ensure: async onProgress => {
+				await ensureRecorder(onProgress);
+			},
+		},
+		{
+			name: "Speech-to-Text model",
+			isReady: () => isSttModelCached(settings.get("stt.modelName")),
+			status: async () => {
+				const key = settings.get("stt.modelName");
+				return (await isSttModelCached(key)) ? key : `${key} — not downloaded`;
+			},
+			pick: async () => {
+				const chosen = await selectSetupModel(
+					"Speech-to-Text model",
+					[...STT_MODEL_OPTIONS],
+					settings.get("stt.modelName"),
+				);
+				if (chosen === null) return false;
+				if (isSttModelKey(chosen)) {
+					settings.set("stt.modelName", chosen);
+					await settings.flush();
+				}
+				return true;
+			},
+			ensure: onProgress =>
+				downloadSttModel(settings.get("stt.modelName"), progress =>
+					onProgress({ stage: `Downloading ${progress.label} model`, percent: progress.percent }),
+				),
+		},
+		{
+			name: "Text-to-Speech model",
+			isReady: () => isTtsModelCached(settings.get("tts.localModel")),
+			status: async () => {
+				const key = settings.get("tts.localModel");
+				return (await isTtsModelCached(key)) ? key : `${key} — model/runtime not installed`;
+			},
+			pick: async () => {
+				const chosen = await selectSetupModel(
+					"Text-to-Speech model",
+					[...TTS_LOCAL_MODEL_OPTIONS],
+					settings.get("tts.localModel"),
+				);
+				if (chosen === null) return false;
+				if (isTtsLocalModelKey(chosen)) {
+					settings.set("tts.localModel", chosen);
+					await settings.flush();
+				}
+				return true;
+			},
+			ensure: async onProgress => {
+				const ok = await downloadTtsModel(settings.get("tts.localModel"), progress =>
+					onProgress({ stage: progress.stage, percent: progress.percent }),
+				);
+				if (!ok) throw new Error("Failed to download the local text-to-speech model.");
+			},
+		},
+	];
+}
 
-	console.log(formatDependencyStatus(status));
+/**
+ * Unified `prometheus setup speech` flow. Drives every {@link SpeechComponent} through
+ * one path: report (`--json`/`--check`) or install (interactive pick + ensure
+ * with single-line progress; non-TTY skips pickers and installs configured
+ * values).
+ */
+async function handleSpeechSetup(flags: { json?: boolean; check?: boolean }): Promise<void> {
+	await Settings.init({ cwd: getProjectDir() });
+	const components = buildSpeechComponents();
 
-	if (status.recorder.available && status.python.available && status.whisper.available) {
-		console.log(chalk.green(`\n${theme.status.success} Speech-to-text is ready`));
+	if (flags.json) {
+		const report: Record<string, { ready: boolean; status: string }> = {};
+		let allReady = true;
+		for (const component of components) {
+			const ready = await component.isReady();
+			if (!ready) allReady = false;
+			report[component.name] = { ready, status: await component.status() };
+		}
+		console.log(JSON.stringify(report, null, 2));
+		if (!allReady) process.exit(1);
 		return;
 	}
 
 	if (flags.check) {
-		process.exit(1);
-	}
-
-	if (!status.python.available) {
-		console.error(chalk.red(`\n${theme.status.error} Python not found`));
-		console.error(chalk.dim("Install Python 3.8+ and ensure it's in your PATH"));
-		process.exit(1);
-	}
-
-	if (!status.recorder.available) {
-		console.error(chalk.yellow(`\n${theme.status.warning} No recording tool found`));
-		console.error(chalk.dim(status.recorder.installHint));
+		console.log(chalk.bold("Speech dependencies:"));
+		let allReady = true;
+		for (const component of components) {
+			const ready = await component.isReady();
+			if (!ready) allReady = false;
+			const mark = ready ? chalk.green("[ok]") : chalk.yellow("[missing]");
+			console.log(`  ${mark} ${component.name}: ${await component.status()}`);
+		}
+		if (!allReady) process.exit(1);
+		return;
 	}
 
-	if (!status.whisper.available) {
-		console.log(chalk.dim(`\nInstalling openai-whisper...`));
-		const { resolvePython } = await import("../stt/transcriber");
-		const pythonCmd = resolvePython()!;
-		const result = await $`${pythonCmd} -m pip install -q openai-whisper`.nothrow();
-		if (result.exitCode !== 0) {
-			console.error(chalk.red(`\n${theme.status.error} Failed to install openai-whisper`));
-			console.error(chalk.dim("Try manually: pip install openai-whisper"));
+	const interactive = Boolean(process.stdout.isTTY);
+	for (const component of components) {
+		if (interactive && component.pick) {
+			await component.pick();
+		}
+		if (await component.isReady()) {
+			console.log(chalk.green(`${theme.status.success} ${component.name} ready`));
+			continue;
+		}
+		console.log(chalk.dim(`Preparing ${component.name}...`));
+		try {
+			await component.ensure(progress => {
+				const percent = typeof progress.percent === "number" ? ` (${progress.percent}%)` : "";
+				process.stdout.write(`\r${chalk.dim(`${progress.stage}${percent}`)}\x1b[K`);
+			});
+			process.stdout.write("\n");
+		} catch (err) {
+			process.stdout.write("\n");
+			const msg = err instanceof Error ? err.message : `Failed to set up ${component.name}`;
+			console.error(chalk.red(`${theme.status.error} ${msg}`));
 			process.exit(1);
 		}
 	}
 
-	const recheck = await checkDependencies();
-	if (recheck.recorder.available && recheck.python.available && recheck.whisper.available) {
-		console.log(chalk.green(`\n${theme.status.success} Speech-to-text is ready`));
-	} else {
-		console.error(chalk.red(`\n${theme.status.error} Setup incomplete`));
-		console.log(formatDependencyStatus(recheck));
-		process.exit(1);
-	}
+	console.log(chalk.green(`\n${theme.status.success} Speech is ready`));
+	console.log(
+		chalk.dim(
+			"Enable speech-to-text via stt.enabled, then hold Space to talk (or bind app.stt.toggle); enable the speech-generation tool via speechgen.enabled; speak replies aloud via speech.enabled.",
+		),
+	);
 }
 
 /**
@@ -215,7 +316,7 @@ ${chalk.bold("Usage:")}
 
 ${chalk.bold("Components:")}
   python    Verify a Python 3 interpreter is reachable for code execution
-  stt       Install speech-to-text dependencies (openai-whisper, recording tools)
+  speech    Pick + download the speech-to-text and text-to-speech models and an audio recorder
 
 ${chalk.bold("Options:")}
   -c, --check   Check if dependencies are installed without installing
@@ -224,8 +325,8 @@ ${chalk.bold("Options:")}
 ${chalk.bold("Examples:")}
   ${APP_NAME} setup                  Run the onboarding wizard
   ${APP_NAME} setup python           Check Python execution dependencies
-  ${APP_NAME} setup stt              Install speech-to-text dependencies
-  ${APP_NAME} setup stt --check      Check if STT dependencies are available
+  ${APP_NAME} setup speech           Set up speech (pick STT + TTS models, install a recorder)
+  ${APP_NAME} setup speech --check   Check if speech dependencies are available
   ${APP_NAME} setup python --check   Check if Python execution is available
 `);
 }