okengine 0.9.0 → 0.10.0

package/src/cli/ai-setup/prompts.ts

@@ -1,43 +1,44 @@
 /**
- * Interactive Clack prompts for `oke ai setup`.
+ * Interactive Clack prompts for `oke ai setup` / create-oke AI wizard.
  */
 
-import { isCancel, note, select, text } from "@clack/prompts";
+import { isCancel, note, password, select, text } from "@clack/prompts";
 import {
-  CHAT_MODELS,
   CLOUD_PROVIDERS,
-  EMBED_MODELS,
-  VISION_MODELS,
+  MODEL_TIERS,
   cloudChatModels,
+  llamaCppModelsForTier,
+  modelsForTier,
   recommendCloudChat,
   recommendForRole,
+  recommendForTier,
+  recommendLlamaCppForTier,
   type CatalogModel,
-  type CloudModel,
+  type ModelTier,
 } from "./catalog.ts";
 import type { AiSetupApplyInput } from "./apply.ts";
+import { LLAMA_CPP_IMAGE } from "../../docker/recipes/llama-cpp.ts";
 import {
+  detectMachineInfo,
   detectOllama,
   detectTotalRamGb,
   isInstalled,
   type OllamaDetectResult,
 } from "./detect-ollama.ts";
 import {
-  OS_HEADROOM_GB,
-  fittingChatModels,
-  formatMachineSummary,
-  isTightFit,
-  modelFitsComfortably,
-  modelFitsOnMachine,
-  recommendChatForNeeds,
-  recommendVisionForNeeds,
-  type AiNeeds,
-  type AiPriority,
-  type AiUseCase,
+  formatLlamaCppBanner,
+  formatModelRow,
+  formatModelTableHeader,
+  formatOllamaBanner,
+  suggestTierForRam,
 } from "./recommend.ts";
 
 /** Provider menu value. */
 export type AiSetupProvider =
+  | "llama-cpp"
   | "ollama"
+  | "vllm"
+  | "sglang"
   | "openai"
   | "anthropic"
   | "gemini"
@@ -45,7 +46,7 @@ export type AiSetupProvider =
   | "openrouter"
   | "custom";
 
-/** Sentinel for ← Back in AI setup selects. */
+/** Sentinel for Back in AI setup selects. */
 const BACK = "__back__" as const;
 type Back = typeof BACK;
 
@@ -62,7 +63,6 @@ export async function askAiSetup(
     readonly ramGb?: number | null;
   } = {},
 ): Promise<AiSetupApplyInput | null> {
-  // Treat mock as "ask again" — create-oke may pass mock when only docker is Ollama.
   const rawProvider = options.provider?.trim() ?? "";
   let provider: AiSetupProvider | undefined =
     rawProvider === "" || rawProvider === "mock" ? undefined : (rawProvider as AiSetupProvider);
@@ -71,369 +71,347 @@ export async function askAiSetup(
     const value = await select({
       message: "AI Provider",
       options: [
+        {
+          value: "llama-cpp",
+          label: "llama.cpp (Local)",
+          hint: "default · Docker Hub ai/ · recommend for your RAM",
+        },
         {
           value: "ollama",
-          label: "◎  Ollama (Local)",
+          label: "Ollama (Local)",
           hint: "detect models · recommend for your RAM",
         },
-        { value: "openai", label: "◈  OpenAI" },
-        { value: "anthropic", label: "◉  Anthropic" },
-        { value: "gemini", label: "◇  Gemini", hint: "OpenAI-compatible proxy URL" },
-        { value: "lmstudio", label: "▣  LM Studio" },
-        { value: "openrouter", label: "⇄  OpenRouter" },
-        { value: "custom", label: "⋯  Custom OpenAI Compatible" },
+        {
+          value: "vllm",
+          label: "vLLM (self-hosted GPU)",
+          hint: "multi-user / production concurrency",
+        },
+        {
+          value: "sglang",
+          label: "SGLang (self-hosted GPU)",
+          hint: "structured / agent workloads",
+        },
+        { value: "openai", label: "OpenAI" },
+        { value: "anthropic", label: "Anthropic" },
+        { value: "gemini", label: "Gemini", hint: "OpenAI-compatible proxy URL" },
+        { value: "lmstudio", label: "LM Studio" },
+        { value: "openrouter", label: "OpenRouter" },
+        { value: "custom", label: "Custom OpenAI Compatible" },
       ],
     });
     if (isCancel(value)) return null;
     provider = String(value) as AiSetupProvider;
   }
 
+  if (provider === "llama-cpp") {
+    return askLlamaCppPath({
+      ramGb: options.ramGb === undefined ? detectTotalRamGb() : options.ramGb,
+    });
+  }
   if (provider === "ollama") {
     return askOllamaPath({
       detect: options.detect ?? detectOllama,
       ramGb: options.ramGb === undefined ? detectTotalRamGb() : options.ramGb,
     });
   }
+  if (provider === "vllm" || provider === "sglang") {
+    return askSelfHostedGpuPath(provider);
+  }
 
   return askCloudPath(provider);
 }
 
 /**
- * Ollama path — needs quiz → detect panel → pick mode (with ← Back).
+ * llama.cpp path — banner → Select model (tier) / Manual (Docker Hub `ai/`).
  *
- * @param options - Detect / RAM
+ * @param options - RAM override
  */
-async function askOllamaPath(options: {
-  readonly detect: () => Promise<OllamaDetectResult>;
+async function askLlamaCppPath(options: {
   readonly ramGb: number | null;
 }): Promise<AiSetupApplyInput | null> {
-  const detected = await options.detect();
-  const embedRec = recommendForRole("embed");
-
-  // Quiz → panel → mode; ← Back from mode re-asks the quiz (same detect).
-  for (;;) {
-    const needs = await askAiNeedsQuiz();
-    if (needs === null) return null;
-
-    const recommended = recommendChatForNeeds(options.ramGb, needs);
-    const visionRec = recommendVisionForNeeds(options.ramGb, needs.wantVision);
-    const fitting = fittingChatModels(options.ramGb);
-    const tooLarge = CHAT_MODELS.filter((m) => !fitting.some((f) => f.id === m.id));
-    const comfortable = fitting.filter((m) => modelFitsComfortably(m, options.ramGb));
-    const tight = fitting.filter((m) => isTightFit(m, options.ramGb));
-
-    const panel = [
-      formatMachineSummary(options.ramGb, recommended),
-      "",
-      "Detected local models",
-      ...(detected.curatedInstalled.length > 0
-        ? detected.curatedInstalled.map((m) => `✓ ${m.id}`)
-        : ["(none from the curated list)"]),
-      "",
-      "Fits comfortably (leaves RAM for OS/IDE)",
-      ...(comfortable.length > 0
-        ? comfortable.map((m) => {
-            const star = m.id === recommended.id ? " ⭐ for you" : "";
-            const have = isInstalled(m.id, detected.installed) ? " · installed" : "";
-            return `• ${m.id} — ≈${m.ramGb}GB-class${star}${have}`;
-          })
-        : ["(none — see tight fits below)"]),
-    ];
-    if (tight.length > 0) {
-      panel.push(
-        "",
-        "Fits the tier but tight (little headroom)",
-        ...tight.map((m) => {
-          const star = m.id === recommended.id ? " ⭐ for you" : "";
-          return `• ${m.id} — ≈${m.ramGb}GB-class${star}`;
-        }),
-      );
-    }
-    if (tooLarge.length > 0) {
-      panel.push(
-        "",
-        `Too large for ~${options.ramGb ?? "?"}GB (needs a bigger machine tier)`,
-        ...tooLarge.map((m) => `• ${m.id} — ≈${m.ramGb}GB-class`),
-      );
-    }
-    panel.push(
-      "",
-      `Tip: Ollama download size ≪ machine RAM · keep ~${OS_HEADROOM_GB}GB free while running.`,
+  const machine = detectMachineInfo();
+  const ramGb = options.ramGb ?? machine.ramGb;
+  note(formatLlamaCppBanner({ ...machine, ramGb }), "llama.cpp");
+
+  mode: for (;;) {
+    const mode = await selectWithBack(
+      "How do you want to pick models?",
+      [
+        {
+          value: "select",
+          label: "Select model",
+          hint: "Ultra Fast  ·  Fast  ·  Balanced  ·  Smart",
+        },
+        {
+          value: "manual",
+          label: "Manual model",
+          hint: "type any Docker Hub ai/ model id",
+        },
+      ],
+      "select",
+      false,
     );
-    if (!detected.available) {
-      panel.push("", "Ollama CLI/server not detected — https://ollama.com");
+    if (mode === null) return null;
+
+    if (mode === "manual") {
+      const id = await askOtherModelId("smollm2");
+      if (id === null) return null;
+      return finishLlamaCpp(id);
     }
-    note(panel.join("\n"), "Ollama");
-
-    // Inner mode loop — ← Back here returns to the quiz; Back from confirm stays here.
-    for (;;) {
-      const mode = await selectWithBack(
-        "How do you want to pick models?",
-        [
-          {
-            value: "recommended",
-            label: "⭐  Use recommended for my answers",
-            hint: `${recommended.label} · ≈${recommended.ramGb}GB-class (not your full ${options.ramGb ?? "?"}GB RAM)`,
-          },
-          {
-            value: "installed",
-            label: "✓  Use installed models",
-            hint: detected.curatedInstalled.length === 0 ? "none detected" : "no download",
-          },
-          {
-            value: "manual",
-            label: "◆  Select manually",
-            hint: "curated list · fit / tight labeled",
-          },
-        ],
-        detected.curatedInstalled.some((m) => m.id === recommended.id)
-          ? "installed"
-          : "recommended",
+
+    tier: for (;;) {
+      const tierPick = await selectWithBack(
+        "Select model",
+        MODEL_TIERS.map((t) => ({
+          value: t.value,
+          label: t.label,
+          hint: t.hint,
+        })),
+        suggestTierForRam(ramGb),
         true,
       );
-      if (mode === null) return null;
-      if (mode === BACK) break; // outer loop → re-ask quiz
-
-      if (mode === "recommended") {
-        const pull = [recommended.id, ...(visionRec ? [visionRec.id] : []), embedRec.id].filter(
-          (id) => detected.available && !isInstalled(id, detected.installed),
+      if (tierPick === null) return null;
+      if (tierPick === BACK) continue mode;
+
+      const tier = tierPick as ModelTier;
+      const recommended = recommendLlamaCppForTier(tier, ramGb);
+
+      how: for (;;) {
+        const how = await selectWithBack(
+          MODEL_TIERS.find((t) => t.value === tier)?.label ?? tier,
+          [
+            {
+              value: "recommended",
+              label: "Use recommended",
+              hint: formatModelRow(recommended),
+            },
+            {
+              value: "manual",
+              label: "Select manually",
+              hint: "up to 20 models in this tier",
+            },
+          ],
+          "recommended",
+          true,
         );
-        if (pull.length > 0 && detected.available) {
-          const doPull = await selectWithBack(
-            `Download ${pull.join(", ")}?`,
-            [
-              {
-                value: "yes",
-                label: "✓  Yes, download",
-                hint: `${recommended.label} · ≈${recommended.ramGb}GB-class machine (pull ≪ RAM)`,
-              },
-              { value: "no", label: "✗  No, write ids only", hint: "pull later yourself" },
-            ],
-            "yes",
-            true,
-          );
-          if (doPull === null) return null;
-          if (doPull === BACK) continue;
-          if (doPull === "yes") await pullModels(pull);
-        }
-        return {
-          driver: "ollama",
-          baseUrl: detected.baseUrl,
-          chatModel: recommended.id,
-          visionModel: visionRec?.id ?? null,
-          embedModel: embedRec.id,
-        };
-      }
+        if (how === null) return null;
+        if (how === BACK) continue tier;
 
-      if (mode === "installed") {
-        if (detected.curatedInstalled.length === 0) {
-          note("No curated models installed — try recommended or manual.", "Ollama");
-          continue;
+        if (how === "recommended") {
+          return finishLlamaCpp(recommended.id, recommended);
         }
-        const chat =
-          detected.curatedInstalled.find(
-            (m) => m.role === "chat" && modelFitsComfortably(m, options.ramGb),
-          ) ??
-          detected.curatedInstalled.find(
-            (m) => m.role === "chat" && modelFitsOnMachine(m, options.ramGb),
-          ) ??
-          detected.curatedInstalled.find((m) => m.role === "chat") ??
-          detected.curatedInstalled[0]!;
-        const vision = needs.wantVision
-          ? (detected.curatedInstalled.find((m) => m.role === "vision" && m.id !== chat.id) ??
-            visionRec)
-          : null;
-        const embed = detected.curatedInstalled.find((m) => m.role === "embed") ?? embedRec;
-        return {
-          driver: "ollama",
-          baseUrl: detected.baseUrl,
-          chatModel: chat.id,
-          visionModel: vision?.id ?? null,
-          embedModel: embed.id,
-        };
-      }
 
-      const manual = await askManualOllama(detected, recommended, needs, options.ramGb, true);
-      if (manual === null) return null;
-      if (manual === BACK) continue;
-      return manual;
+        const list = llamaCppModelsForTier(tier);
+        note(formatModelTableHeader(), "Select model");
+        const picked = await selectWithBack(
+          "Pick a model",
+          list.map((m) => ({
+            value: m.id,
+            label: formatModelRow(m),
+            hint: m.hint,
+          })),
+          recommended.id,
+          true,
+        );
+        if (picked === null) return null;
+        if (picked === BACK) continue how;
+        const model = list.find((m) => m.id === picked);
+        return finishLlamaCpp(picked, model);
+      }
     }
   }
 }
 
 /**
- * Short quiz — use case + priority + vision.
+ * Build apply input for llama.cpp — OpenAI-compatible + curated image pin.
  *
- * @returns Needs or null on cancel
+ * @param chatId - Docker Hub `ai/` model id (org prefix optional)
+ * @param catalog - Optional catalog row (modalities)
  */
-async function askAiNeedsQuiz(): Promise<AiNeeds | null> {
-  const use = await selectWithBack(
-    "What will you use local AI for most?",
-    [
-      { value: "coding", label: "◆  Coding & agents", hint: "Qwen-family tends to win" },
-      { value: "general", label: "◎  General chat", hint: "Gemma / Llama" },
-      { value: "reasoning", label: "◉  Reasoning", hint: "DeepSeek R1-class" },
-      { value: "balanced", label: "★  Not sure — balanced", hint: "safe default for most devs" },
-    ],
-    "balanced",
-    false,
-  );
-  if (use === null || use === BACK) return null;
-
-  const priority = await selectWithBack(
-    "Speed or quality?",
-    [
-      { value: "speed", label: "⚡  Speed", hint: "smaller model · 8GB-class" },
-      { value: "balanced", label: "★  Balanced", hint: "best fit for 8–16GB machines" },
-      { value: "quality", label: "◆  Quality", hint: "largest that still leaves RAM free" },
-    ],
-    "balanced",
-    true,
-  );
-  if (priority === null) return null;
-  if (priority === BACK) return askAiNeedsQuiz();
-
-  const vision = await selectWithBack(
-    "Need a vision model (images)?",
-    [
-      { value: "yes", label: "✓  Yes", hint: "adds a small VL model if RAM allows" },
-      { value: "no", label: "✗  No", hint: "chat + embed only" },
-    ],
-    "no",
-    true,
-  );
-  if (vision === null) return null;
-  if (vision === BACK) return askAiNeedsQuiz();
-
+function finishLlamaCpp(chatId: string, catalog?: CatalogModel): AiSetupApplyInput {
+  const id = chatId.replace(/^ai\//, "");
   return {
-    useCase: use as AiUseCase,
-    priority: priority as AiPriority,
-    wantVision: vision === "yes",
+    driver: "openai-compatible",
+    baseUrl: process.env.OKE_AI_URL ?? "http://127.0.0.1:8080/v1",
+    chatModel: id,
+    visionModel: catalog?.modalities.includes("vision") ? id : null,
+    embedModel: null,
+    image: LLAMA_CPP_IMAGE,
   };
 }
 
 /**
- * Manual chat → vision → embed (models that fit listed first).
+ * vLLM / SGLang — Hugging Face model path for self-hosted GPU inference.
  *
- * @param detected - Detect result
- * @param recommended - Recommended chat
- * @param needs - Quiz answers (vision optional)
- * @param ramGb - Machine RAM
- * @param allowBack - Offer ← Back to mode menu
+ * @param provider - vllm | sglang
  */
-async function askManualOllama(
-  detected: OllamaDetectResult,
-  recommended: CatalogModel,
-  needs: AiNeeds,
-  ramGb: number | null,
-  allowBack: boolean,
-): Promise<AiSetupApplyInput | Back | null> {
-  const ordered = [
-    ...fittingChatModels(ramGb),
-    ...CHAT_MODELS.filter((m) => !modelFitsOnMachine(m, ramGb)),
-  ];
-  const seen = new Set<string>();
-  const chatList = ordered.filter((m) => {
-    if (seen.has(m.id)) return false;
-    seen.add(m.id);
-    return true;
+async function askSelfHostedGpuPath(
+  provider: "vllm" | "sglang",
+): Promise<AiSetupApplyInput | null> {
+  const port = provider === "vllm" ? 8000 : 30000;
+  const image =
+    provider === "vllm" ? "vllm/vllm-openai:v0.26.0" : "lmsysorg/sglang:v0.5.16-runtime";
+  const model = await text({
+    message: "Hugging Face model id",
+    placeholder: "Qwen/Qwen3-0.6B",
+    initialValue: "Qwen/Qwen3-0.6B",
+    validate: (v) => {
+      if (!v?.trim()) return "Model id required";
+      return undefined;
+    },
   });
+  if (isCancel(model)) return null;
+  return {
+    driver: "openai-compatible",
+    baseUrl: process.env.OKE_AI_URL ?? `http://127.0.0.1:${port}/v1`,
+    chatModel: String(model).trim(),
+    visionModel: null,
+    embedModel: null,
+    image,
+  };
+}
 
-  let chat = recommended.id;
-  let vision: string | null | undefined = needs.wantVision
-    ? (recommendVisionForNeeds(ramGb, true)?.id ?? recommendForRole("vision").id)
-    : null;
-
-  while (true) {
-    const chatPick = await pickModel(
-      "Select Chat Model",
-      chatList,
-      chat,
-      false,
+/**
+ * Ollama path — banner → Select model (tier) / Manual model.
+ *
+ * @param options - Detect / RAM
+ */
+async function askOllamaPath(options: {
+  readonly detect: () => Promise<OllamaDetectResult>;
+  readonly ramGb: number | null;
+}): Promise<AiSetupApplyInput | null> {
+  const detected = await options.detect();
+  const machine = detectMachineInfo();
+  const ramGb = options.ramGb ?? machine.ramGb;
+  const detectedIds =
+    detected.installed.length > 0
+      ? detected.installed.slice(0, 12)
+      : detected.curatedInstalled.map((m) => m.id);
+
+  note(formatOllamaBanner({ ...machine, ramGb }, detectedIds), "Ollama");
+
+  mode: for (;;) {
+    const mode = await selectWithBack(
+      "How do you want to pick models?",
+      [
+        {
+          value: "select",
+          label: "Select model",
+          hint: "Ultra Fast  ·  Fast  ·  Balanced  ·  Smart",
+        },
+        {
+          value: "manual",
+          label: "Manual model",
+          hint: "type any Ollama model id",
+        },
+      ],
+      "select",
       false,
-      allowBack,
-      ramGb,
     );
-    if (chatPick === null) return null;
-    if (chatPick === BACK) return BACK;
-    if (typeof chatPick !== "string") continue;
-    chat = chatPick;
-
-    if (needs.wantVision) {
-      const visionPick = await pickModel(
-        "Vision Model",
-        VISION_MODELS,
-        vision ?? recommendForRole("vision").id,
-        false,
-        true,
-        true,
-        ramGb,
-      );
-      if (visionPick === null) return null;
-      if (visionPick === BACK) continue;
-      vision = visionPick === undefined ? null : visionPick;
-    }
+    if (mode === null) return null;
 
-    const embedPick = await pickModel(
-      "Embedding Model",
-      EMBED_MODELS,
-      recommendForRole("embed").id,
-      false,
-      false,
-      true,
-      ramGb,
-    );
-    if (embedPick === null) return null;
-    if (embedPick === BACK) continue;
-    if (typeof embedPick !== "string") continue;
+    if (mode === "manual") {
+      const id = await askOtherModelId("gemma4:e4b");
+      if (id === null) return null;
+      return finishOllama(id, detected);
+    }
 
-    const needed = [chat, ...(typeof vision === "string" ? [vision] : []), embedPick].filter(
-      (id) => detected.available && !isInstalled(id, detected.installed),
-    );
-    if (needed.length > 0 && detected.available) {
-      const doPull = await selectWithBack(
-        `Download missing (${needed.join(", ")})?`,
-        [
-          { value: "yes", label: "✓  Yes", hint: "pull size ≪ machine RAM" },
-          { value: "no", label: "✗  No" },
-        ],
-        "yes",
+    tier: for (;;) {
+      const tierPick = await selectWithBack(
+        "Select model",
+        MODEL_TIERS.map((t) => ({
+          value: t.value,
+          label: t.label,
+          hint: t.hint,
+        })),
+        suggestTierForRam(ramGb),
         true,
       );
-      if (doPull === null) return null;
-      if (doPull === BACK) continue;
-      if (doPull === "yes") await pullModels(needed);
-    }
+      if (tierPick === null) return null;
+      if (tierPick === BACK) continue mode;
+
+      const tier = tierPick as ModelTier;
+      const recommended = recommendForTier(tier, ramGb);
+
+      how: for (;;) {
+        const how = await selectWithBack(
+          MODEL_TIERS.find((t) => t.value === tier)?.label ?? tier,
+          [
+            {
+              value: "recommended",
+              label: "Use recommended",
+              hint: formatModelRow(recommended),
+            },
+            {
+              value: "manual",
+              label: "Select manually",
+              hint: "up to 10 models in this tier",
+            },
+          ],
+          "recommended",
+          true,
+        );
+        if (how === null) return null;
+        if (how === BACK) continue tier;
 
-    return {
-      driver: "ollama",
-      baseUrl: detected.baseUrl,
-      chatModel: chat,
-      visionModel: typeof vision === "string" ? vision : null,
-      embedModel: embedPick,
-    };
+        if (how === "recommended") {
+          return finishOllama(recommended.id, detected, recommended);
+        }
+
+        const list = modelsForTier(tier);
+        note(formatModelTableHeader(), "Select model");
+        const picked = await selectWithBack(
+          "Pick a model",
+          list.map((m) => ({
+            value: m.id,
+            label: formatModelRow(m),
+            hint: isInstalled(m.id, detected.installed) ? "installed" : m.hint,
+          })),
+          recommended.id,
+          true,
+        );
+        if (picked === null) return null;
+        if (picked === BACK) continue how;
+        const model = list.find((m) => m.id === picked);
+        return finishOllama(picked, detected, model);
+      }
+    }
   }
 }
 
 /**
- * Select with optional trailing ← Back.
+ * Build apply input for Ollama — embed default, optional silent pull.
+ *
+ * @param chatId - Chat model id
+ * @param detected - Detect result
+ * @param catalog - Optional catalog row (modalities)
  */
-async function selectWithBack(
-  message: string,
-  options: readonly { value: string; label: string; hint?: string }[],
-  initialValue: string,
-  allowBack: boolean,
-): Promise<string | Back | null> {
-  const list = [...options, ...(allowBack ? [{ value: BACK, label: "←  Back" }] : [])];
-  const value = await select({ message, options: list, initialValue });
-  if (isCancel(value)) return null;
-  const picked = String(value);
-  if (picked === BACK) return BACK;
-  return picked;
+async function finishOllama(
+  chatId: string,
+  detected: OllamaDetectResult,
+  catalog?: CatalogModel,
+): Promise<AiSetupApplyInput> {
+  const embed = recommendForRole("embed");
+  const visionModel = catalog?.modalities.includes("vision") ? chatId : null;
+
+  const needed = [chatId, embed.id].filter(
+    (id) => detected.available && !isInstalled(id, detected.installed),
+  );
+  if (needed.length > 0 && detected.available) {
+    await pullModels(needed, detected.baseUrl);
+  }
+
+  return {
+    driver: "ollama",
+    baseUrl: detected.baseUrl,
+    chatModel: chatId,
+    visionModel,
+    embedModel: embed.id,
+  };
 }
 
 /**
- * Cloud / openai-compatible path — curated models + Other (type id).
+ * Cloud / openai-compatible path — API token → Select model / Manual.
  *
  * @param provider - Menu provider
  */
@@ -443,83 +421,136 @@ async function askCloudPath(provider: AiSetupProvider): Promise<AiSetupApplyInpu
 
   let baseUrl: string | undefined = meta?.baseUrl;
   if (provider === "custom" || provider === "gemini" || !baseUrl) {
-    const urlValue = await text({
-      message:
-        provider === "gemini"
-          ? "OpenAI-compatible base URL for Gemini"
-          : "OpenAI-compatible base URL",
-      placeholder: baseUrl ?? "https://api.example.com/v1",
-      initialValue: baseUrl ?? "",
+    if (provider !== "anthropic") {
+      const urlValue = await text({
+        message:
+          provider === "gemini"
+            ? "OpenAI-compatible base URL for Gemini"
+            : "OpenAI-compatible base URL",
+        placeholder: baseUrl ?? "https://api.example.com/v1",
+        initialValue: baseUrl ?? "",
+      });
+      if (isCancel(urlValue)) return null;
+      const trimmed = String(urlValue).trim();
+      baseUrl = trimmed.length > 0 ? trimmed : undefined;
+    }
+  }
+
+  const apiKeyEnv = meta?.apiKeyEnv;
+  let apiKey: string | undefined;
+  if (apiKeyEnv) {
+    const token = await password({
+      message: `API token (${apiKeyEnv})`,
+      validate: (v) => {
+        if (!v?.trim()) return "API token is required";
+        return undefined;
+      },
     });
-    if (isCancel(urlValue)) return null;
-    const trimmed = String(urlValue).trim();
-    baseUrl = trimmed.length > 0 ? trimmed : undefined;
+    if (isCancel(token)) return null;
+    apiKey = String(token).trim();
   }
 
-  const models = cloudChatModels(provider);
-  const chat = await pickCloudModel("Select Chat Model", models, recommendCloudChat(provider));
-  if (chat === null) return null;
+  for (;;) {
+    const mode = await selectWithBack(
+      "How do you want to pick models?",
+      [
+        {
+          value: "select",
+          label: "Select model",
+          hint: "up to 10 latest curated models",
+        },
+        {
+          value: "manual",
+          label: "Manual model",
+          hint: "type any model id",
+        },
+      ],
+      "select",
+      false,
+    );
+    if (mode === null) return null;
+
+    if (mode === "manual") {
+      const id = await askOtherModelId(recommendCloudChat(provider));
+      if (id === null) return null;
+      return {
+        driver,
+        ...(baseUrl !== undefined ? { baseUrl } : {}),
+        chatModel: id,
+        visionModel: null,
+        embedModel: null,
+        ...(apiKeyEnv ? { apiKeyEnv, ...(apiKey ? { apiKey } : {}) } : {}),
+      };
+    }
 
-  const apiKeyEnv = driver === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+    const models = cloudChatModels(provider);
+    if (models.length === 0) {
+      const id = await askOtherModelId(recommendCloudChat(provider));
+      if (id === null) return null;
+      return {
+        driver,
+        ...(baseUrl !== undefined ? { baseUrl } : {}),
+        chatModel: id,
+        visionModel: null,
+        embedModel: null,
+        ...(apiKeyEnv ? { apiKeyEnv, ...(apiKey ? { apiKey } : {}) } : {}),
+      };
+    }
 
-  return {
-    driver,
-    ...(baseUrl !== undefined ? { baseUrl } : {}),
-    chatModel: chat,
-    visionModel: null,
-    embedModel: null,
-    apiKeyEnv,
-  };
-}
+    const initial = recommendCloudChat(provider);
+    const chat = await selectWithBack(
+      "Select model",
+      models.map((m) => ({
+        value: m.id,
+        label: m.label,
+        hint: m.hint,
+      })),
+      models.some((m) => m.id === initial) ? initial : models[0]!.id,
+      true,
+    );
+    if (chat === null) return null;
+    if (chat === BACK) continue;
 
-/**
- * Format a catalog row — for Ollama, annotate fit vs too-large.
- *
- * @param m - Catalog / cloud model
- * @param ramGb - Machine RAM (ollama only)
- * @param recommendedId - Id marked "for you"
- */
-function catalogOption(
-  m: CatalogModel | CloudModel,
-  ramGb: number | null = null,
-  recommendedId?: string,
-): { value: string; label: string; hint: string } {
-  const isRec = m.recommended || m.id === recommendedId;
-  if ("ramGb" in m && typeof m.ramGb === "number") {
-    const onMachine = modelFitsOnMachine(m, ramGb);
-    const comfortable = modelFitsComfortably(m, ramGb);
-    const fitLabel = !onMachine
-      ? "too large for this machine"
-      : comfortable
-        ? "fits comfortably"
-        : "tight fit";
     return {
-      value: m.id,
-      label: isRec ? `⭐  ${m.label} (for you)` : `   ${m.label}`,
-      hint: `${m.hint} · ${fitLabel}`,
+      driver,
+      ...(baseUrl !== undefined ? { baseUrl } : {}),
+      chatModel: chat,
+      visionModel: null,
+      embedModel: null,
+      ...(apiKeyEnv ? { apiKeyEnv, ...(apiKey ? { apiKey } : {}) } : {}),
     };
   }
-  return {
-    value: m.id,
-    label: isRec ? `⭐  ${m.label} (Recommended)` : `   ${m.label}`,
-    hint: m.hint,
-  };
 }
 
-const OTHER_MODEL = "__other__";
+/**
+ * Select with optional trailing Back.
+ */
+async function selectWithBack(
+  message: string,
+  options: readonly { value: string; label: string; hint?: string }[],
+  initialValue: string,
+  allowBack: boolean,
+): Promise<string | Back | null> {
+  const list = [...options, ...(allowBack ? [{ value: BACK, label: "Back" }] : [])];
+  const value = await select({ message, options: list, initialValue });
+  if (isCancel(value)) return null;
+  const picked = String(value);
+  if (picked === BACK) return BACK;
+  return picked;
+}
 
 /**
- * Ask for a custom model id when the user picks Other.
+ * Ask for a custom model id.
  *
  * @param placeholder - Example id
  */
 async function askOtherModelId(placeholder: string): Promise<string | null> {
   const value = await text({
-    message: "Model id",
+    message: "Model name",
     placeholder,
     initialValue: "",
     validate: (v) => {
-      if (!v?.trim()) return "Model id is required";
+      if (!v?.trim()) return "Model name is required";
       return undefined;
     },
   });
@@ -528,122 +559,35 @@ async function askOtherModelId(placeholder: string): Promise<string | null> {
 }
 
 /**
- * Pick from a curated cloud list + Other (type any id).
- *
- * @param message - Prompt
- * @param models - Curated list
- * @param initial - Default id
- */
-async function pickCloudModel(
-  message: string,
-  models: readonly CloudModel[],
-  initial: string,
-): Promise<string | null> {
-  const options: { value: string; label: string; hint?: string }[] = [
-    ...models.map((m) => catalogOption(m)),
-    {
-      value: OTHER_MODEL,
-      label: "⋯  Other…",
-      hint: "type any model id",
-    },
-  ];
-  const initialValue = models.some((m) => m.id === initial) ? initial : OTHER_MODEL;
-  const value = await select({
-    message,
-    options,
-    initialValue,
-  });
-  if (isCancel(value)) return null;
-  const picked = String(value);
-  if (picked === OTHER_MODEL) {
-    return askOtherModelId(initial || "model-id");
-  }
-  return picked;
-}
-
-/**
- * Pick from a curated list, with optional Show all + Skip + Other + Back.
- *
- * @returns model id, null cancel, undefined skip, BACK
- */
-async function pickModel(
-  message: string,
-  models: readonly CatalogModel[],
-  initial: string,
-  showAllHint: boolean,
-  allowSkip = false,
-  allowBack = false,
-  ramGb: number | null = null,
-): Promise<string | Back | null | undefined> {
-  const short = models.slice(0, 5);
-  const options: { value: string; label: string; hint?: string }[] = short.map((m) =>
-    catalogOption(m, ramGb, initial),
-  );
-  if (showAllHint && models.length > short.length) {
-    options.push({ value: "__all__", label: "⋯  Show all models", hint: "full curated catalog" });
-  }
-  options.push({
-    value: OTHER_MODEL,
-    label: "⋯  Other…",
-    hint: "type any model id",
-  });
-  if (allowSkip) {
-    options.push({ value: "__skip__", label: "⊘  Skip", hint: "no vision model" });
-  }
-  if (allowBack) {
-    options.push({ value: BACK, label: "←  Back" });
-  }
-
-  const value = await select({
-    message,
-    options,
-    initialValue: models.some((m) => m.id === initial) ? initial : short[0]?.id,
-  });
-  if (isCancel(value)) return null;
-  const picked = String(value);
-  if (picked === BACK) return BACK;
-  if (picked === "__skip__") return undefined;
-  if (picked === OTHER_MODEL) {
-    return askOtherModelId(initial);
-  }
-  if (picked === "__all__") {
-    const allOptions = [
-      ...models.map((m) => catalogOption(m, ramGb, initial)),
-      { value: OTHER_MODEL, label: "⋯  Other…", hint: "type any model id" },
-      ...(allowSkip ? [{ value: "__skip__", label: "⊘  Skip", hint: "no vision model" }] : []),
-      ...(allowBack ? [{ value: BACK, label: "←  Back" }] : []),
-    ];
-    const allValue = await select({
-      message,
-      options: allOptions,
-      initialValue: initial,
-    });
-    if (isCancel(allValue)) return null;
-    const allPicked = String(allValue);
-    if (allPicked === BACK) return BACK;
-    if (allPicked === "__skip__") return undefined;
-    if (allPicked === OTHER_MODEL) return askOtherModelId(initial);
-    return allPicked;
-  }
-  return picked;
-}
-
-/**
- * Run `ollama pull` for each model with a spinner-friendly console log.
+ * Pull each model via the Ollama HTTP API (`POST /api/pull`).
  *
  * @param models - Model ids
+ * @param baseUrl - Ollama server base URL
  */
-async function pullModels(models: readonly string[]): Promise<void> {
+async function pullModels(models: readonly string[], baseUrl: string): Promise<void> {
+  const base = baseUrl.replace(/\/+$/, "");
   for (const id of models) {
-    console.log(`ollama pull ${id}…`);
-    const proc = Bun.spawn(["ollama", "pull", id], {
-      stdout: "inherit",
-      stderr: "inherit",
-      stdin: "inherit",
-    });
-    const code = await proc.exited;
-    if (code !== 0) {
-      console.error(`oke ai setup: ollama pull ${id} failed (continuing)`);
+    console.log(`ollama: pulling ${id} via ${base}/api/pull…`);
+    try {
+      const tags = await fetch(`${base}/api/tags`);
+      if (!tags.ok) {
+        throw new Error(`GET ${base}/api/tags → ${tags.status}`);
+      }
+      const res = await fetch(`${base}/api/pull`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ model: id, stream: false }),
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(
+          `POST ${base}/api/pull → ${res.status}${body ? ` ${body.slice(0, 120)}` : ""}`,
+        );
+      }
+      await res.arrayBuffer();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`oke ai setup: pull ${id} failed (continuing) — ${msg}`);
     }
   }
 }