pi-usereq 0.7.0 → 0.10.0

package/pi.dev-src/pi-mono/pods/src/commands/models.ts

@@ -0,0 +1,753 @@
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { getActivePod, loadConfig, saveConfig } from "../config.js";
+import { getModelConfig, getModelName, isKnownModel } from "../model-configs.js";
+import { sshExec } from "../ssh.js";
+import type { Pod } from "../types.js";
+
+/**
+ * Get the pod to use (active or override)
+ */
+const getPod = (podOverride?: string): { name: string; pod: Pod } => {
+	if (podOverride) {
+		const config = loadConfig();
+		const pod = config.pods[podOverride];
+		if (!pod) {
+			console.error(chalk.red(`Pod '${podOverride}' not found`));
+			process.exit(1);
+		}
+		return { name: podOverride, pod };
+	}
+
+	const active = getActivePod();
+	if (!active) {
+		console.error(chalk.red("No active pod. Use 'pi pods active <name>' to set one."));
+		process.exit(1);
+	}
+	return active;
+};
+
+/**
+ * Find next available port starting from 8001
+ */
+const getNextPort = (pod: Pod): number => {
+	const usedPorts = Object.values(pod.models).map((m) => m.port);
+	let port = 8001;
+	while (usedPorts.includes(port)) {
+		port++;
+	}
+	return port;
+};
+
+/**
+ * Select GPUs for model deployment (round-robin)
+ */
+const selectGPUs = (pod: Pod, count: number = 1): number[] => {
+	if (count === pod.gpus.length) {
+		// Use all GPUs
+		return pod.gpus.map((g) => g.id);
+	}
+
+	// Count GPU usage across all models
+	const gpuUsage = new Map<number, number>();
+	for (const gpu of pod.gpus) {
+		gpuUsage.set(gpu.id, 0);
+	}
+
+	for (const model of Object.values(pod.models)) {
+		for (const gpuId of model.gpu) {
+			gpuUsage.set(gpuId, (gpuUsage.get(gpuId) || 0) + 1);
+		}
+	}
+
+	// Sort GPUs by usage (least used first)
+	const sortedGPUs = Array.from(gpuUsage.entries())
+		.sort((a, b) => a[1] - b[1])
+		.map((entry) => entry[0]);
+
+	// Return the least used GPUs
+	return sortedGPUs.slice(0, count);
+};
+
+/**
+ * Start a model
+ */
+export const startModel = async (
+	modelId: string,
+	name: string,
+	options: {
+		pod?: string;
+		vllmArgs?: string[];
+		memory?: string;
+		context?: string;
+		gpus?: number;
+	},
+) => {
+	const { name: podName, pod } = getPod(options.pod);
+
+	// Validation
+	if (!pod.modelsPath) {
+		console.error(chalk.red("Pod does not have a models path configured"));
+		process.exit(1);
+	}
+	if (pod.models[name]) {
+		console.error(chalk.red(`Model '${name}' already exists on pod '${podName}'`));
+		process.exit(1);
+	}
+
+	const port = getNextPort(pod);
+
+	// Determine GPU allocation and vLLM args
+	let gpus: number[] = [];
+	let vllmArgs: string[] = [];
+	let modelConfig = null;
+
+	if (options.vllmArgs?.length) {
+		// Custom args override everything
+		vllmArgs = options.vllmArgs;
+		console.log(chalk.gray("Using custom vLLM args, GPU allocation managed by vLLM"));
+	} else if (isKnownModel(modelId)) {
+		// Handle --gpus parameter for known models
+		if (options.gpus) {
+			// Validate GPU count
+			if (options.gpus > pod.gpus.length) {
+				console.error(chalk.red(`Error: Requested ${options.gpus} GPUs but pod only has ${pod.gpus.length}`));
+				process.exit(1);
+			}
+
+			// Try to find config for requested GPU count
+			modelConfig = getModelConfig(modelId, pod.gpus, options.gpus);
+			if (modelConfig) {
+				gpus = selectGPUs(pod, options.gpus);
+				vllmArgs = [...(modelConfig.args || [])];
+			} else {
+				console.error(
+					chalk.red(`Model '${getModelName(modelId)}' does not have a configuration for ${options.gpus} GPU(s)`),
+				);
+				console.error(chalk.yellow("Available configurations:"));
+
+				// Show available configurations
+				for (let gpuCount = 1; gpuCount <= pod.gpus.length; gpuCount++) {
+					const config = getModelConfig(modelId, pod.gpus, gpuCount);
+					if (config) {
+						console.error(chalk.gray(`  - ${gpuCount} GPU(s)`));
+					}
+				}
+				process.exit(1);
+			}
+		} else {
+			// Find best config for this hardware (original behavior)
+			for (let gpuCount = pod.gpus.length; gpuCount >= 1; gpuCount--) {
+				modelConfig = getModelConfig(modelId, pod.gpus, gpuCount);
+				if (modelConfig) {
+					gpus = selectGPUs(pod, gpuCount);
+					vllmArgs = [...(modelConfig.args || [])];
+					break;
+				}
+			}
+			if (!modelConfig) {
+				console.error(chalk.red(`Model '${getModelName(modelId)}' not compatible with this pod's GPUs`));
+				process.exit(1);
+			}
+		}
+	} else {
+		// Unknown model
+		if (options.gpus) {
+			console.error(chalk.red("Error: --gpus can only be used with predefined models"));
+			console.error(chalk.yellow("For custom models, use --vllm with tensor-parallel-size or similar arguments"));
+			process.exit(1);
+		}
+		// Single GPU default
+		gpus = selectGPUs(pod, 1);
+		console.log(chalk.gray("Unknown model, defaulting to single GPU"));
+	}
+
+	// Apply memory/context overrides
+	if (!options.vllmArgs?.length) {
+		if (options.memory) {
+			const fraction = parseFloat(options.memory.replace("%", "")) / 100;
+			vllmArgs = vllmArgs.filter((arg) => !arg.includes("gpu-memory-utilization"));
+			vllmArgs.push("--gpu-memory-utilization", String(fraction));
+		}
+		if (options.context) {
+			const contextSizes: Record<string, number> = {
+				"4k": 4096,
+				"8k": 8192,
+				"16k": 16384,
+				"32k": 32768,
+				"64k": 65536,
+				"128k": 131072,
+			};
+			const maxTokens = contextSizes[options.context.toLowerCase()] || parseInt(options.context, 10);
+			vllmArgs = vllmArgs.filter((arg) => !arg.includes("max-model-len"));
+			vllmArgs.push("--max-model-len", String(maxTokens));
+		}
+	}
+
+	// Show what we're doing
+	console.log(chalk.green(`Starting model '${name}' on pod '${podName}'...`));
+	console.log(`Model: ${modelId}`);
+	console.log(`Port: ${port}`);
+	console.log(`GPU(s): ${gpus.length ? gpus.join(", ") : "Managed by vLLM"}`);
+	if (modelConfig?.notes) console.log(chalk.yellow(`Note: ${modelConfig.notes}`));
+	console.log("");
+
+	// Read and customize model_run.sh script with our values
+	const scriptPath = join(dirname(fileURLToPath(import.meta.url)), "../../scripts/model_run.sh");
+	let scriptContent = readFileSync(scriptPath, "utf-8");
+
+	// Replace placeholders - no escaping needed, heredoc with 'EOF' is literal
+	scriptContent = scriptContent
+		.replace("{{MODEL_ID}}", modelId)
+		.replace("{{NAME}}", name)
+		.replace("{{PORT}}", String(port))
+		.replace("{{VLLM_ARGS}}", vllmArgs.join(" "));
+
+	// Upload customized script
+	await sshExec(
+		pod.ssh,
+		`cat > /tmp/model_run_${name}.sh << 'EOF'
+${scriptContent}
+EOF
+chmod +x /tmp/model_run_${name}.sh`,
+	);
+
+	// Prepare environment
+	const env = [
+		`HF_TOKEN='${process.env.HF_TOKEN}'`,
+		`PI_API_KEY='${process.env.PI_API_KEY}'`,
+		`HF_HUB_ENABLE_HF_TRANSFER=1`,
+		`VLLM_NO_USAGE_STATS=1`,
+		`PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True`,
+		`FORCE_COLOR=1`,
+		`TERM=xterm-256color`,
+		...(gpus.length === 1 ? [`CUDA_VISIBLE_DEVICES=${gpus[0]}`] : []),
+		...Object.entries(modelConfig?.env || {}).map(([k, v]) => `${k}='${v}'`),
+	]
+		.map((e) => `export ${e}`)
+		.join("\n");
+
+	// Start the model runner with script command for pseudo-TTY (preserves colors)
+	// Note: We use script to preserve colors and create a log file
+	// setsid creates a new session so it survives SSH disconnection
+	const startCmd = `
+		${env}
+		mkdir -p ~/.vllm_logs
+		# Create a wrapper that monitors the script command
+		cat > /tmp/model_wrapper_${name}.sh << 'WRAPPER'
+#!/bin/bash
+script -q -f -c "/tmp/model_run_${name}.sh" ~/.vllm_logs/${name}.log
+exit_code=$?
+echo "Script exited with code $exit_code" >> ~/.vllm_logs/${name}.log
+exit $exit_code
+WRAPPER
+		chmod +x /tmp/model_wrapper_${name}.sh
+		setsid /tmp/model_wrapper_${name}.sh </dev/null >/dev/null 2>&1 &
+		echo $!
+		exit 0
+	`;
+
+	const pidResult = await sshExec(pod.ssh, startCmd);
+	const pid = parseInt(pidResult.stdout.trim(), 10);
+	if (!pid) {
+		console.error(chalk.red("Failed to start model runner"));
+		process.exit(1);
+	}
+
+	// Save to config
+	const config = loadConfig();
+	config.pods[podName].models[name] = { model: modelId, port, gpu: gpus, pid };
+	saveConfig(config);
+
+	console.log(`Model runner started with PID: ${pid}`);
+	console.log("Streaming logs... (waiting for startup)\n");
+
+	// Small delay to ensure log file is created
+	await new Promise((resolve) => setTimeout(resolve, 500));
+
+	// Stream logs with color support, watching for startup complete
+	const sshParts = pod.ssh.split(" ");
+	const sshCommand = sshParts[0]; // "ssh"
+	const sshArgs = sshParts.slice(1); // ["root@86.38.238.55"]
+	const host = sshArgs[0].split("@")[1] || "localhost";
+	const tailCmd = `tail -f ~/.vllm_logs/${name}.log`;
+
+	// Build the full args array for spawn
+	const fullArgs = [...sshArgs, tailCmd];
+
+	const logProcess = spawn(sshCommand, fullArgs, {
+		stdio: ["inherit", "pipe", "pipe"], // capture stdout and stderr
+		env: { ...process.env, FORCE_COLOR: "1" },
+	});
+
+	let interrupted = false;
+	let startupComplete = false;
+	let startupFailed = false;
+	let failureReason = "";
+
+	// Handle Ctrl+C
+	const sigintHandler = () => {
+		interrupted = true;
+		logProcess.kill();
+	};
+	process.on("SIGINT", sigintHandler);
+
+	// Process log output line by line
+	const processOutput = (data: Buffer) => {
+		const lines = data.toString().split("\n");
+		for (const line of lines) {
+			if (line) {
+				console.log(line); // Echo the line to console
+
+				// Check for startup complete message
+				if (line.includes("Application startup complete")) {
+					startupComplete = true;
+					logProcess.kill(); // Stop tailing logs
+				}
+
+				// Check for failure indicators
+				if (line.includes("Model runner exiting with code") && !line.includes("code 0")) {
+					startupFailed = true;
+					failureReason = "Model runner failed to start";
+					logProcess.kill();
+				}
+				if (line.includes("Script exited with code") && !line.includes("code 0")) {
+					startupFailed = true;
+					failureReason = "Script failed to execute";
+					logProcess.kill();
+				}
+				if (line.includes("torch.OutOfMemoryError") || line.includes("CUDA out of memory")) {
+					startupFailed = true;
+					failureReason = "Out of GPU memory (OOM)";
+					// Don't kill immediately - let it show more error context
+				}
+				if (line.includes("RuntimeError: Engine core initialization failed")) {
+					startupFailed = true;
+					failureReason = "vLLM engine initialization failed";
+					logProcess.kill();
+				}
+			}
+		}
+	};
+
+	logProcess.stdout?.on("data", processOutput);
+	logProcess.stderr?.on("data", processOutput);
+
+	await new Promise<void>((resolve) => logProcess.on("exit", resolve));
+	process.removeListener("SIGINT", sigintHandler);
+
+	if (startupFailed) {
+		// Model failed to start - clean up and report error
+		console.log(`\n${chalk.red(`✗ Model failed to start: ${failureReason}`)}`);
+
+		// Remove the failed model from config
+		const config = loadConfig();
+		delete config.pods[podName].models[name];
+		saveConfig(config);
+
+		console.log(chalk.yellow("\nModel has been removed from configuration."));
+
+		// Provide helpful suggestions based on failure reason
+		if (failureReason.includes("OOM") || failureReason.includes("memory")) {
+			console.log(`\n${chalk.bold("Suggestions:")}`);
+			console.log("  • Try reducing GPU memory utilization: --memory 50%");
+			console.log("  • Use a smaller context window: --context 4k");
+			console.log("  • Use a quantized version of the model (e.g., FP8)");
+			console.log("  • Use more GPUs with tensor parallelism");
+			console.log("  • Try a smaller model variant");
+		}
+
+		console.log(`\n${chalk.cyan(`Check full logs: pi ssh "tail -100 ~/.vllm_logs/${name}.log"`)}`);
+		process.exit(1);
+	} else if (startupComplete) {
+		// Model started successfully - output connection details
+		console.log(`\n${chalk.green("✓ Model started successfully!")}`);
+		console.log(`\n${chalk.bold("Connection Details:")}`);
+		console.log(chalk.cyan("─".repeat(50)));
+		console.log(chalk.white("Base URL:    ") + chalk.yellow(`http://${host}:${port}/v1`));
+		console.log(chalk.white("Model:       ") + chalk.yellow(modelId));
+		console.log(chalk.white("API Key:     ") + chalk.yellow(process.env.PI_API_KEY || "(not set)"));
+		console.log(chalk.cyan("─".repeat(50)));
+
+		console.log(`\n${chalk.bold("Export for shell:")}`);
+		console.log(chalk.gray(`export OPENAI_BASE_URL="http://${host}:${port}/v1"`));
+		console.log(chalk.gray(`export OPENAI_API_KEY="${process.env.PI_API_KEY || "your-api-key"}"`));
+		console.log(chalk.gray(`export OPENAI_MODEL="${modelId}"`));
+
+		console.log(`\n${chalk.bold("Example usage:")}`);
+		console.log(
+			chalk.gray(`
+  # Python
+  from openai import OpenAI
+  client = OpenAI()  # Uses env vars
+  response = client.chat.completions.create(
+      model="${modelId}",
+      messages=[{"role": "user", "content": "Hello!"}]
+  )
+
+  # CLI
+  curl $OPENAI_BASE_URL/chat/completions \\
+    -H "Authorization: Bearer $OPENAI_API_KEY" \\
+    -H "Content-Type: application/json" \\
+    -d '{"model":"${modelId}","messages":[{"role":"user","content":"Hi"}]}'`),
+		);
+		console.log("");
+		console.log(chalk.cyan(`Chat with model:  pi agent ${name} "Your message"`));
+		console.log(chalk.cyan(`Interactive mode: pi agent ${name} -i`));
+		console.log(chalk.cyan(`Monitor logs:     pi logs ${name}`));
+		console.log(chalk.cyan(`Stop model:       pi stop ${name}`));
+	} else if (interrupted) {
+		console.log(chalk.yellow("\n\nStopped monitoring. Model deployment continues in background."));
+		console.log(chalk.cyan(`Chat with model: pi agent ${name} "Your message"`));
+		console.log(chalk.cyan(`Check status: pi logs ${name}`));
+		console.log(chalk.cyan(`Stop model: pi stop ${name}`));
+	} else {
+		console.log(chalk.yellow("\n\nLog stream ended. Model may still be running."));
+		console.log(chalk.cyan(`Chat with model: pi agent ${name} "Your message"`));
+		console.log(chalk.cyan(`Check status: pi logs ${name}`));
+		console.log(chalk.cyan(`Stop model: pi stop ${name}`));
+	}
+};
+
+/**
+ * Stop a model
+ */
+export const stopModel = async (name: string, options: { pod?: string }) => {
+	const { name: podName, pod } = getPod(options.pod);
+
+	const model = pod.models[name];
+	if (!model) {
+		console.error(chalk.red(`Model '${name}' not found on pod '${podName}'`));
+		process.exit(1);
+	}
+
+	console.log(chalk.yellow(`Stopping model '${name}' on pod '${podName}'...`));
+
+	// Kill the script process and all its children
+	// Using pkill to kill the process and all children
+	const killCmd = `
+		# Kill the script process and all its children
+		pkill -TERM -P ${model.pid} 2>/dev/null || true
+		kill ${model.pid} 2>/dev/null || true
+	`;
+	await sshExec(pod.ssh, killCmd);
+
+	// Remove from config
+	const config = loadConfig();
+	delete config.pods[podName].models[name];
+	saveConfig(config);
+
+	console.log(chalk.green(`✓ Model '${name}' stopped`));
+};
+
+/**
+ * Stop all models on a pod
+ */
+export const stopAllModels = async (options: { pod?: string }) => {
+	const { name: podName, pod } = getPod(options.pod);
+
+	const modelNames = Object.keys(pod.models);
+	if (modelNames.length === 0) {
+		console.log(`No models running on pod '${podName}'`);
+		return;
+	}
+
+	console.log(chalk.yellow(`Stopping ${modelNames.length} model(s) on pod '${podName}'...`));
+
+	// Kill all script processes and their children
+	const pids = Object.values(pod.models).map((m) => m.pid);
+	const killCmd = `
+		for PID in ${pids.join(" ")}; do
+			pkill -TERM -P $PID 2>/dev/null || true
+			kill $PID 2>/dev/null || true
+		done
+	`;
+	await sshExec(pod.ssh, killCmd);
+
+	// Clear all models from config
+	const config = loadConfig();
+	config.pods[podName].models = {};
+	saveConfig(config);
+
+	console.log(chalk.green(`✓ Stopped all models: ${modelNames.join(", ")}`));
+};
+
+/**
+ * List all models
+ */
+export const listModels = async (options: { pod?: string }) => {
+	const { name: podName, pod } = getPod(options.pod);
+
+	const modelNames = Object.keys(pod.models);
+	if (modelNames.length === 0) {
+		console.log(`No models running on pod '${podName}'`);
+		return;
+	}
+
+	// Get pod SSH host for URL display
+	const sshParts = pod.ssh.split(" ");
+	const host = sshParts.find((p) => p.includes("@"))?.split("@")[1] || "unknown";
+
+	console.log(`Models on pod '${chalk.bold(podName)}':`);
+	for (const name of modelNames) {
+		const model = pod.models[name];
+		const gpuStr =
+			model.gpu.length > 1
+				? `GPUs ${model.gpu.join(",")}`
+				: model.gpu.length === 1
+					? `GPU ${model.gpu[0]}`
+					: "GPU unknown";
+		console.log(`  ${chalk.green(name)} - Port ${model.port} - ${gpuStr} - PID ${model.pid}`);
+		console.log(`    Model: ${chalk.gray(model.model)}`);
+		console.log(`    URL: ${chalk.cyan(`http://${host}:${model.port}/v1`)}`);
+	}
+
+	// Optionally verify processes are still running
+	console.log("");
+	console.log("Verifying processes...");
+	let anyDead = false;
+	for (const name of modelNames) {
+		const model = pod.models[name];
+		// Check both the wrapper process and if vLLM is responding
+		const checkCmd = `
+			# Check if wrapper process exists
+			if ps -p ${model.pid} > /dev/null 2>&1; then
+				# Process exists, now check if vLLM is responding
+				if curl -s -f http://localhost:${model.port}/health > /dev/null 2>&1; then
+					echo "running"
+				else
+					# Check if it's still starting up
+					if tail -n 20 ~/.vllm_logs/${name}.log 2>/dev/null | grep -q "ERROR\\|Failed\\|Cuda error\\|died"; then
+						echo "crashed"
+					else
+						echo "starting"
+					fi
+				fi
+			else
+				echo "dead"
+			fi
+		`;
+		const result = await sshExec(pod.ssh, checkCmd);
+		const status = result.stdout.trim();
+		if (status === "dead") {
+			console.log(chalk.red(`  ${name}: Process ${model.pid} is not running`));
+			anyDead = true;
+		} else if (status === "crashed") {
+			console.log(chalk.red(`  ${name}: vLLM crashed (check logs with 'pi logs ${name}')`));
+			anyDead = true;
+		} else if (status === "starting") {
+			console.log(chalk.yellow(`  ${name}: Still starting up...`));
+		}
+	}
+
+	if (anyDead) {
+		console.log("");
+		console.log(chalk.yellow("Some models are not running. Clean up with:"));
+		console.log(chalk.cyan("  pi stop <name>"));
+	} else {
+		console.log(chalk.green("✓ All processes verified"));
+	}
+};
+
+/**
+ * View model logs
+ */
+export const viewLogs = async (name: string, options: { pod?: string }) => {
+	const { name: podName, pod } = getPod(options.pod);
+
+	const model = pod.models[name];
+	if (!model) {
+		console.error(chalk.red(`Model '${name}' not found on pod '${podName}'`));
+		process.exit(1);
+	}
+
+	console.log(chalk.green(`Streaming logs for '${name}' on pod '${podName}'...`));
+	console.log(chalk.gray("Press Ctrl+C to stop"));
+	console.log("");
+
+	// Stream logs with color preservation
+	const sshParts = pod.ssh.split(" ");
+	const sshCommand = sshParts[0]; // "ssh"
+	const sshArgs = sshParts.slice(1); // ["root@86.38.238.55"]
+	const tailCmd = `tail -f ~/.vllm_logs/${name}.log`;
+
+	const logProcess = spawn(sshCommand, [...sshArgs, tailCmd], {
+		stdio: "inherit",
+		env: {
+			...process.env,
+			FORCE_COLOR: "1",
+		},
+	});
+
+	// Wait for process to exit
+	await new Promise<void>((resolve) => {
+		logProcess.on("exit", () => resolve());
+	});
+};
+
+/**
+ * Show known models and their hardware requirements
+ */
+export const showKnownModels = async () => {
+	const __filename = fileURLToPath(import.meta.url);
+	const __dirname = dirname(__filename);
+	const modelsJsonPath = join(__dirname, "..", "models.json");
+	const modelsJson = JSON.parse(readFileSync(modelsJsonPath, "utf-8"));
+	const models = modelsJson.models;
+
+	// Get active pod info if available
+	const activePod = getActivePod();
+	let podGpuCount = 0;
+	let podGpuType = "";
+
+	if (activePod) {
+		podGpuCount = activePod.pod.gpus.length;
+		// Extract GPU type from name (e.g., "NVIDIA H200" -> "H200")
+		podGpuType = activePod.pod.gpus[0]?.name?.replace("NVIDIA", "")?.trim()?.split(" ")[0] || "";
+
+		console.log(chalk.bold(`Known Models for ${activePod.name} (${podGpuCount}x ${podGpuType || "GPU"}):\n`));
+	} else {
+		console.log(chalk.bold("Known Models:\n"));
+		console.log(chalk.yellow("No active pod. Use 'pi pods active <name>' to filter compatible models.\n"));
+	}
+
+	console.log("Usage: pi start <model> --name <name> [options]\n");
+
+	// Group models by compatibility and family
+	const compatible: Record<string, Array<{ id: string; name: string; config: string; notes?: string }>> = {};
+	const incompatible: Record<string, Array<{ id: string; name: string; minGpu: string; notes?: string }>> = {};
+
+	for (const [modelId, info] of Object.entries(models)) {
+		const modelInfo = info as any;
+		const family = modelInfo.name.split("-")[0] || "Other";
+
+		let isCompatible = false;
+		let compatibleConfig = "";
+		let minGpu = "Unknown";
+		let minNotes: string | undefined;
+
+		if (modelInfo.configs && modelInfo.configs.length > 0) {
+			// Sort configs by GPU count to find minimum
+			const sortedConfigs = [...modelInfo.configs].sort((a: any, b: any) => (a.gpuCount || 1) - (b.gpuCount || 1));
+
+			// Find minimum requirements
+			const minConfig = sortedConfigs[0];
+			const minGpuCount = minConfig.gpuCount || 1;
+			const gpuTypes = minConfig.gpuTypes?.join("/") || "H100/H200";
+
+			if (minGpuCount === 1) {
+				minGpu = `1x ${gpuTypes}`;
+			} else {
+				minGpu = `${minGpuCount}x ${gpuTypes}`;
+			}
+
+			minNotes = minConfig.notes || modelInfo.notes;
+
+			// Check compatibility with active pod
+			if (activePod && podGpuCount > 0) {
+				// Find best matching config for this pod
+				for (const config of sortedConfigs) {
+					const configGpuCount = config.gpuCount || 1;
+					const configGpuTypes = config.gpuTypes || [];
+
+					// Check if we have enough GPUs
+					if (configGpuCount <= podGpuCount) {
+						// Check if GPU type matches (if specified)
+						if (
+							configGpuTypes.length === 0 ||
+							configGpuTypes.some((type: string) => podGpuType.includes(type) || type.includes(podGpuType))
+						) {
+							isCompatible = true;
+							if (configGpuCount === 1) {
+								compatibleConfig = `1x ${podGpuType}`;
+							} else {
+								compatibleConfig = `${configGpuCount}x ${podGpuType}`;
+							}
+							minNotes = config.notes || modelInfo.notes;
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		const modelEntry = {
+			id: modelId,
+			name: modelInfo.name,
+			notes: minNotes,
+		};
+
+		if (activePod && isCompatible) {
+			if (!compatible[family]) {
+				compatible[family] = [];
+			}
+			compatible[family].push({ ...modelEntry, config: compatibleConfig });
+		} else {
+			if (!incompatible[family]) {
+				incompatible[family] = [];
+			}
+			incompatible[family].push({ ...modelEntry, minGpu });
+		}
+	}
+
+	// Display compatible models first
+	if (activePod && Object.keys(compatible).length > 0) {
+		console.log(chalk.green.bold("✓ Compatible Models:\n"));
+
+		const sortedFamilies = Object.keys(compatible).sort();
+		for (const family of sortedFamilies) {
+			console.log(chalk.cyan(`${family} Models:`));
+
+			const modelList = compatible[family].sort((a, b) => a.name.localeCompare(b.name));
+
+			for (const model of modelList) {
+				console.log(`  ${chalk.green(model.id)}`);
+				console.log(`    Name: ${model.name}`);
+				console.log(`    Config: ${model.config}`);
+				if (model.notes) {
+					console.log(chalk.gray(`    Note: ${model.notes}`));
+				}
+				console.log("");
+			}
+		}
+	}
+
+	// Display incompatible models
+	if (Object.keys(incompatible).length > 0) {
+		if (activePod && Object.keys(compatible).length > 0) {
+			console.log(chalk.red.bold("✗ Incompatible Models (need more/different GPUs):\n"));
+		}
+
+		const sortedFamilies = Object.keys(incompatible).sort();
+		for (const family of sortedFamilies) {
+			if (!activePod) {
+				console.log(chalk.cyan(`${family} Models:`));
+			} else {
+				console.log(chalk.gray(`${family} Models:`));
+			}
+
+			const modelList = incompatible[family].sort((a, b) => a.name.localeCompare(b.name));
+
+			for (const model of modelList) {
+				const color = activePod ? chalk.gray : chalk.green;
+				console.log(`  ${color(model.id)}`);
+				console.log(chalk.gray(`    Name: ${model.name}`));
+				console.log(chalk.gray(`    Min Hardware: ${model.minGpu}`));
+				if (model.notes && !activePod) {
+					console.log(chalk.gray(`    Note: ${model.notes}`));
+				}
+				if (activePod) {
+					console.log(""); // Less verbose for incompatible models when filtered
+				} else {
+					console.log("");
+				}
+			}
+		}
+	}
+
+	console.log(chalk.gray("\nFor unknown models, defaults to single GPU deployment."));
+	console.log(chalk.gray("Use --vllm to pass custom arguments to vLLM."));
+};