@dotdrelle/wiki-manager 0.15.32 → 0.15.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.32",
+  "version": "0.15.34",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardPlaceholders.test.js src/runtime/store.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/donna-contract.test.js src/runtime/auth.test.js",
+    "test": "node --test src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/runtime/store.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/donna-contract.test.js src/runtime/auth.test.js",
     "check-versions": "node scripts/check-versions.js",
     "prepack": "node scripts/check-versions.js",
     "prepublishOnly": "node scripts/check-versions.js",

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.32",
+  "version": "0.15.34",
   "commit": "8b6b1aa"
 }

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.15.32';
+const WIKI_MANAGER_VERSION = '0.15.34';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/modelFetch.js

@@ -1,56 +1,160 @@
+/**
+ * Découverte des modèles disponibles, pour alimenter le wizard.
+ *
+ * Deux chemins, correspondant aux deux valeurs de `llm.provider` :
+ *
+ * - `openai-compatible` : un serveur unique. L'endpoint et les en-têtes
+ *   dépendent du moteur (`engine`), d'où les tables ci-dessous.
+ * - `ai-gateway` : un seul chemin, `GET /v1/models`, plus `GET /model/info`
+ *   quand il est disponible — c'est lui qui porte le type de chaque modèle
+ *   (chat, embedding, rerank) et permet de filtrer les listes du wizard.
+ */
+
 const FALLBACK_MODELS = {
   openai: ['gpt-5.4', 'gpt-5.4-mini', 'gpt-4.1', 'gpt-4.1-mini'],
   anthropic: ['claude-sonnet-4-5', 'claude-opus-4-1', 'claude-3-7-sonnet-latest'],
   ollama: ['llama3.2', 'qwen2.5', 'mistral', 'nomic-embed-text'],
-  'openai-compatible': ['gpt-4.1-mini', 'llama3.2'],
-  other: ['gpt-4.1-mini', 'llama3.2'],
+  vllm: ['Qwen/Qwen2.5-7B-Instruct', 'meta-llama/Llama-3.1-8B-Instruct'],
+  mlx: ['mlx-community/Qwen2.5-7B-Instruct-4bit'],
+  albert: ['albert-large', 'albert-small'],
+  generic: ['gpt-4.1-mini', 'llama3.2'],
 };
 
 const FALLBACK_EMBEDDINGS = {
   openai: ['text-embedding-3-small', 'text-embedding-3-large'],
   anthropic: ['text-embedding-3-small'],
   ollama: ['nomic-embed-text', 'mxbai-embed-large'],
-  'openai-compatible': ['BAAI/bge-m3', 'text-embedding-3-small', 'nomic-embed-text'],
-  other: ['text-embedding-3-small', 'nomic-embed-text'],
+  vllm: ['BAAI/bge-m3'],
+  mlx: ['BAAI/bge-m3'],
+  albert: ['BAAI/bge-m3'],
+  generic: ['BAAI/bge-m3', 'text-embedding-3-small', 'nomic-embed-text'],
 };
 
+export const PROVIDERS = ['openai-compatible', 'ai-gateway'];
+
+export const ENGINES = [
+  'ollama',
+  'vllm',
+  'mlx',
+  'albert',
+  'openai',
+  'anthropic',
+  'generic',
+];
+
+/** Moteurs qui exigent une baseUrl explicite — il n'existe pas de défaut sensé. */
+const ENGINES_REQUIRING_BASE_URL = new Set(['ollama', 'vllm', 'mlx', 'generic']);
+
+const ENGINE_DEFAULT_BASE_URL = {
+  openai: 'https://api.openai.com/v1',
+  anthropic: 'https://api.anthropic.com/v1',
+  albert: 'https://albert.api.etalab.gouv.fr/v1',
+  ollama: 'http://127.0.0.1:11434/v1',
+  vllm: 'http://127.0.0.1:8000/v1',
+  mlx: 'http://127.0.0.1:8080/v1',
+};
+
+export function requiresBaseUrl(provider, engine) {
+  if (normalizeProvider(provider) === 'ai-gateway') return true;
+  return ENGINES_REQUIRING_BASE_URL.has(normalizeEngine(engine));
+}
+
+export function defaultBaseUrl(provider, engine) {
+  if (normalizeProvider(provider) === 'ai-gateway') return '';
+  return ENGINE_DEFAULT_BASE_URL[normalizeEngine(engine)] ?? '';
+}
+
+/** Routage. Tolérant aux libellés du wizard. */
 export function normalizeProvider(provider) {
   const value = String(provider ?? '').toLowerCase();
-  if (value.includes('compatible') || value.includes('other')) return 'openai-compatible';
-  if (value.includes('anthropic')) return 'anthropic';
-  if (value.includes('ollama')) return 'ollama';
-  if (value.includes('openai')) return 'openai';
+  if (value.includes('gateway')) return 'ai-gateway';
   return 'openai-compatible';
 }
 
-function fallbackFor(provider, kind) {
-  const normalized = normalizeProvider(provider);
+/**
+ * Libellés du wizard vers moteur. Correspondance **exacte**, pas par sous-chaîne.
+ *
+ * Une recherche par sous-chaîne était fausse : « Other (generic
+ * OpenAI-compatible) » contient « openai », qui était testé avant « generic »
+ * — l'option « serveur générique » persistait donc `engine: openai`, avec les
+ * contournements inversés. Et aucun libellé ne pouvait plus résoudre vers
+ * `generic`, ce qui cassait la présélection à la réouverture du wizard.
+ */
+const ENGINE_LABELS = new Map([
+  ['openai', 'openai'],
+  ['anthropic', 'anthropic'],
+  ['ollama (local)', 'ollama'],
+  ['vllm (local)', 'vllm'],
+  ['mlx (local)', 'mlx'],
+  ['albert', 'albert'],
+  ['other (generic openai-compatible)', 'generic'],
+]);
+
+/**
+ * Moteur. Accepte les libellés du wizard, les valeurs canoniques, et les
+ * anciennes valeurs de `provider` (`openai`, `ollama`, `anthropic`) devenues
+ * des moteurs.
+ */
+export function normalizeEngine(engine) {
+  const value = String(engine ?? '').trim().toLowerCase();
+  const fromLabel = ENGINE_LABELS.get(value);
+  if (fromLabel) return fromLabel;
+  if (ENGINES.includes(value)) return value;
+  // Repli tolérant, utile pour les valeurs libres ; l'ordre importe donc les
+  // moteurs les plus spécifiques passent avant les plus génériques.
+  for (const candidate of ENGINES) {
+    if (candidate !== 'generic' && value.includes(candidate)) return candidate;
+  }
+  return 'generic';
+}
+
+function fallbackFor(engine, kind) {
+  const normalized = normalizeEngine(engine);
   const source = kind === 'embedding' ? FALLBACK_EMBEDDINGS : FALLBACK_MODELS;
-  return source[normalized] ?? source.other;
+  return source[normalized] ?? source.generic;
 }
 
-function endpointFor(provider, baseUrl) {
-  const normalized = normalizeProvider(provider);
+function trimUrl(url) {
+  return String(url ?? '').replace(/\/+$/g, '');
+}
+
+/**
+ * `baseUrl` est écrite avec son suffixe `/v1` dans le wikirc. Les endpoints de
+ * listing vivent tantôt sous `/v1` (OpenAI), tantôt à la racine (Ollama,
+ * `/model/info` de LiteLLM) — d'où cette racine sans suffixe.
+ */
+function rootOf(baseUrl) {
+  return trimUrl(baseUrl).replace(/\/v1$/, '');
+}
+
+function endpointFor(provider, engine, baseUrl) {
+  if (normalizeProvider(provider) === 'ai-gateway') {
+    return `${rootOf(baseUrl)}/v1/models`;
+  }
+  const normalized = normalizeEngine(engine);
   if (normalized === 'anthropic') return 'https://api.anthropic.com/v1/models';
-  const root = String(baseUrl || (normalized === 'ollama' ? 'http://localhost:11434' : 'https://api.openai.com')).replace(/\/+$/g, '');
+  const root = rootOf(baseUrl) || 'https://api.openai.com';
   return normalized === 'ollama' ? `${root}/api/tags` : `${root}/v1/models`;
 }
 
-function headersFor(provider, apiKey) {
-  const normalized = normalizeProvider(provider);
+function headersFor(provider, engine, apiKey) {
+  if (normalizeProvider(provider) === 'ai-gateway') {
+    return { Authorization: `Bearer ${apiKey}` };
+  }
+  const normalized = normalizeEngine(engine);
   if (normalized === 'ollama') return {};
   if (normalized === 'anthropic') {
-    return {
-      'x-api-key': apiKey,
-      'anthropic-version': '2023-06-01',
-    };
+    return { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' };
   }
   return { Authorization: `Bearer ${apiKey}` };
 }
 
-function parseModelNames(provider, payload) {
-  const normalized = normalizeProvider(provider);
-  const items = normalized === 'ollama' ? payload?.models : payload?.data;
+function parseModelNames(provider, engine, payload) {
+  const items =
+    normalizeProvider(provider) === 'openai-compatible' &&
+    normalizeEngine(engine) === 'ollama'
+      ? payload?.models
+      : payload?.data;
   if (!Array.isArray(items)) return [];
   return items
     .map((item) => item?.id ?? item?.name ?? item?.model)
@@ -59,39 +163,123 @@ function parseModelNames(provider, payload) {
     .sort((a, b) => a.localeCompare(b));
 }
 
+async function getJson(url, headers, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { headers, signal: controller.signal });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Liste plate des modèles.
+ *
+ * `options.engine` porte le moteur ; à défaut, le premier argument est
+ * réinterprété comme tel, ce qui garde les appels historiques valides.
+ */
 export async function fetchModels(provider, baseUrl, apiKey, options = {}) {
-  const normalized = normalizeProvider(provider);
-  if (normalized === 'anthropic') {
-    return { ok: false, models: fallbackFor(normalized, options.kind), source: 'fallback', error: 'Anthropic model listing is not supported' };
+  const routing = normalizeProvider(provider);
+  const normalizedEngine = normalizeEngine(options.engine ?? provider);
+
+  if (routing === 'openai-compatible' && normalizedEngine === 'anthropic') {
+    return {
+      ok: false,
+      models: fallbackFor(normalizedEngine, options.kind),
+      source: 'fallback',
+      error: 'Anthropic model listing is not supported',
+    };
   }
+
   const timeoutMs = options.timeoutMs ?? 10000;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    if (normalized !== 'ollama' && !apiKey) {
+    const needsKey = !(routing === 'openai-compatible' && normalizedEngine === 'ollama');
+    if (needsKey && !apiKey) {
       throw new Error('API key is required to fetch remote models');
     }
-    const response = await fetch(endpointFor(normalized, baseUrl), {
-      headers: headersFor(normalized, apiKey),
-      signal: controller.signal,
-    });
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    const payload = await response.json();
-    const models = parseModelNames(normalized, payload);
+    const payload = await getJson(
+      endpointFor(provider, normalizedEngine, baseUrl),
+      headersFor(provider, normalizedEngine, apiKey),
+      timeoutMs,
+    );
+    const models = parseModelNames(provider, normalizedEngine, payload);
     if (models.length === 0) throw new Error('No models returned');
     return { ok: true, models, source: 'remote' };
   } catch (err) {
     return {
       ok: false,
-      models: fallbackFor(normalized, options.kind),
+      models: fallbackFor(normalizedEngine, options.kind),
       source: 'fallback',
       error: err instanceof Error ? err.message : String(err),
     };
-  } finally {
-    clearTimeout(timer);
   }
 }
 
-export function fallbackModels(provider, kind) {
-  return fallbackFor(provider, kind);
+/**
+ * Catalogue typé d'une gateway.
+ *
+ * Dégradation gracieuse en trois temps — jamais un catch silencieux vers un
+ * défaut :
+ *
+ *   1. `GET /model/info` porte `model_info.mode` : on sait quel modèle est un
+ *      chat, un embedding ou un reranker, et le wizard filtre ses listes.
+ *   2. `GET /v1/models` ne renvoie qu'une liste plate : les trois listes
+ *      reçoivent la même chose, et `typed: false` permet à l'appelant de le
+ *      dire à l'utilisateur.
+ *   3. Injoignable : listes vides, `error` renseignée. Le wizard garde sa
+ *      saisie libre, qui fait foi de toute façon.
+ */
+export async function fetchGatewayCatalog(baseUrl, apiKey, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 10000;
+  const headers = { Authorization: `Bearer ${apiKey}` };
+
+  try {
+    const payload = await getJson(`${rootOf(baseUrl)}/model/info`, headers, timeoutMs);
+    const items = Array.isArray(payload?.data) ? payload.data : [];
+    const typed = { chat: [], embedding: [], rerank: [] };
+    for (const item of items) {
+      const name = item?.model_name ?? item?.id ?? item?.model_info?.id;
+      const mode = item?.model_info?.mode;
+      if (!name || !mode || !(mode in typed)) continue;
+      typed[mode].push(String(name));
+    }
+    const total = typed.chat.length + typed.embedding.length + typed.rerank.length;
+    if (total === 0) throw new Error('No typed models returned by /model/info');
+    for (const key of Object.keys(typed)) {
+      typed[key] = [...new Set(typed[key])].sort((a, b) => a.localeCompare(b));
+    }
+    return { ok: true, typed: true, source: 'model-info', ...typed };
+  } catch (modelInfoError) {
+    const flat = await fetchModels('ai-gateway', baseUrl, apiKey, { timeoutMs });
+    if (!flat.ok) {
+      return {
+        ok: false,
+        typed: false,
+        source: 'unreachable',
+        chat: [],
+        embedding: [],
+        rerank: [],
+        error: flat.error,
+      };
+    }
+    return {
+      ok: true,
+      typed: false,
+      source: 'models',
+      chat: flat.models,
+      embedding: flat.models,
+      rerank: flat.models,
+      // Conservée pour l'affichage : elle explique pourquoi les listes ne sont
+      // pas filtrées.
+      error:
+        modelInfoError instanceof Error ? modelInfoError.message : String(modelInfoError),
+    };
+  }
+}
+
+export function fallbackModels(engine, kind) {
+  return fallbackFor(engine, kind);
 }

package/src/core/modelFetch.test.js

@@ -1,6 +1,11 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { fallbackModels, fetchModels } from './modelFetch.js';
+import {
+  fallbackModels,
+  fetchGatewayCatalog,
+  fetchModels,
+  requiresBaseUrl,
+} from './modelFetch.js';
 
 test('fetchModels returns remote OpenAI-compatible model ids', async () => {
   const originalFetch = globalThis.fetch;
@@ -34,5 +39,75 @@ test('fetchModels falls back on invalid remote response', async () => {
 });
 
 test('fallbackModels leaves custom-model to the wizard append action', () => {
-  assert.deepEqual(fallbackModels('openai-compatible'), ['gpt-4.1-mini', 'llama3.2']);
+  assert.deepEqual(fallbackModels('generic'), ['gpt-4.1-mini', 'llama3.2']);
+});
+
+test('fetchGatewayCatalog types models from /model/info', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url) => {
+    assert.equal(url, 'http://gw:4000/model/info');
+    return {
+      ok: true,
+      json: async () => ({
+        data: [
+          { model_name: 'anthropic/claude-sonnet-4-5', model_info: { mode: 'chat' } },
+          { model_name: 'infinity/bge-m3', model_info: { mode: 'embedding' } },
+          { model_name: 'infinity/bge-reranker', model_info: { mode: 'rerank' } },
+          { model_name: 'dalle', model_info: { mode: 'image_generation' } },
+        ],
+      }),
+    };
+  };
+  try {
+    const result = await fetchGatewayCatalog('http://gw:4000/v1', 'key', { timeoutMs: 100 });
+    assert.equal(result.ok, true);
+    assert.equal(result.typed, true);
+    assert.deepEqual(result.chat, ['anthropic/claude-sonnet-4-5']);
+    assert.deepEqual(result.embedding, ['infinity/bge-m3']);
+    assert.deepEqual(result.rerank, ['infinity/bge-reranker']);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('fetchGatewayCatalog degrades to an untyped /v1/models list', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url) => {
+    if (url.endsWith('/model/info')) return { ok: false, status: 404 };
+    return { ok: true, json: async () => ({ data: [{ id: 'b' }, { id: 'a' }] }) };
+  };
+  try {
+    const result = await fetchGatewayCatalog('http://gw:4000/v1', 'key', { timeoutMs: 100 });
+    assert.equal(result.ok, true);
+    assert.equal(result.typed, false);
+    // Non typé : les trois listes reçoivent la même chose, à charge du wizard
+    // de le signaler.
+    assert.deepEqual(result.chat, ['a', 'b']);
+    assert.deepEqual(result.embedding, ['a', 'b']);
+    assert.deepEqual(result.rerank, ['a', 'b']);
+    assert.match(result.error, /HTTP 404/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('fetchGatewayCatalog reports an unreachable gateway without inventing models', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => { throw new Error('ECONNREFUSED'); };
+  try {
+    const result = await fetchGatewayCatalog('http://gw:4000/v1', 'key', { timeoutMs: 100 });
+    assert.equal(result.ok, false);
+    assert.equal(result.source, 'unreachable');
+    assert.deepEqual(result.chat, []);
+    assert.match(result.error, /ECONNREFUSED/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('requiresBaseUrl follows the engine, and the gateway always needs one', () => {
+  assert.equal(requiresBaseUrl('openai-compatible', 'ollama'), true);
+  assert.equal(requiresBaseUrl('openai-compatible', 'openai'), false);
+  assert.equal(requiresBaseUrl('openai-compatible', 'anthropic'), false);
+  assert.equal(requiresBaseUrl('ai-gateway', 'openai'), true);
 });

package/src/core/wikiSetup.js

@@ -261,11 +261,37 @@ export function writeLanguageConfig(workspacePath, profileName, language) {
   return patchWikircProfile(workspacePath, profileName || 'default', { language });
 }
 
+/**
+ * Le wizard tourne sur l'hôte, les services dans Docker : une baseUrl saisie
+ * en `localhost` répond au wizard et échoue dans le container. On la réécrit
+ * vers `host.docker.internal`, que les services déclarent déjà en
+ * `extra_hosts`. Jamais sur un hostname réel — seulement sur les trois formes
+ * de boucle locale. L'appelant affiche la réécriture : la faire en silence
+ * rend le diagnostic impossible quand elle se trompe.
+ */
+export function containerReachableUrl(baseUrl) {
+  if (!baseUrl) return { url: baseUrl, rewritten: false };
+  try {
+    const parsed = new URL(baseUrl);
+    if (!['localhost', '127.0.0.1', '::1', '[::1]'].includes(parsed.hostname)) {
+      return { url: baseUrl, rewritten: false };
+    }
+    const original = parsed.hostname;
+    parsed.hostname = 'host.docker.internal';
+    return { url: parsed.toString().replace(/\/$/, ''), rewritten: true, from: original };
+  } catch {
+    return { url: baseUrl, rewritten: false };
+  }
+}
+
 export function writeLlmConfig(workspacePath, profileName, config) {
   const patches = {
     llm: {
       provider: config.provider,
-      ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+      // Absent derrière une gateway : l'endpoint est opaque, il n'y a pas un
+      // moteur mais un par modèle.
+      ...(config.engine ? { engine: config.engine } : {}),
+      ...(config.baseUrl ? { baseUrl: containerReachableUrl(config.baseUrl).url } : {}),
       ...(config.apiKey ? { apiKey: config.apiKey } : {}),
       model: config.model,
     },
@@ -278,7 +304,11 @@ export function writeVectorConfig(workspacePath, profileName, config) {
     retrieval: {
       vector: {
         enabled: true,
-        ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+        // baseUrl et apiKey absents = hérités du bloc llm par resolveConfig.
+        // Le wizard ne les transmet que lorsqu'ils divergent réellement, pour
+        // que le wikirc reste lisible et que la clé du LLM ne soit pas
+        // recopiée vers un autre hôte.
+        ...(config.baseUrl ? { baseUrl: containerReachableUrl(config.baseUrl).url } : {}),
         ...(config.apiKey ? { apiKey: config.apiKey } : {}),
         timeoutMs: config.timeoutMs ?? 600_000,
         embeddingModel: config.embeddingModel,

package/src/core/wikirc.test.js

@@ -5,7 +5,12 @@ import { join } from 'node:path';
 import test from 'node:test';
 import YAML from 'yaml';
 import { loadWikircProfile, normalizeCapabilityRouting, patchWikircProfile } from './wikirc.js';
-import { finalizeCreatedWorkspace, writeVectorConfig } from './wikiSetup.js';
+import {
+  containerReachableUrl,
+  finalizeCreatedWorkspace,
+  writeLlmConfig,
+  writeVectorConfig,
+} from './wikiSetup.js';
 
 test('patchWikircProfile merges keys and preserves existing values', () => {
   const root = mkdtempSync(join(tmpdir(), 'wikirc-patch-'));
@@ -106,7 +111,7 @@ test('writeVectorConfig writes llm-wiki vector and rerank keys', () => {
   ].join('\n'), 'utf8');
 
   writeVectorConfig(root, 'default', {
-    baseUrl: 'http://localhost:7997/v1',
+    baseUrl: 'http://host.docker.internal:7997/v1',
     apiKey: 'vector-key',
     embeddingModel: 'BAAI/bge-m3',
     rerankEnabled: true,
@@ -115,7 +120,7 @@ test('writeVectorConfig writes llm-wiki vector and rerank keys', () => {
 
   const parsed = YAML.parse(readFileSync(join(root, '.wikirc.yaml'), 'utf8'));
   assert.equal(parsed.retrieval.vector.enabled, true);
-  assert.equal(parsed.retrieval.vector.baseUrl, 'http://localhost:7997/v1');
+  assert.equal(parsed.retrieval.vector.baseUrl, 'http://host.docker.internal:7997/v1');
   assert.equal(parsed.retrieval.vector.apiKey, 'vector-key');
   assert.equal(parsed.retrieval.vector.embeddingModel, 'BAAI/bge-m3');
   assert.equal(parsed.retrieval.vector.rerankEnabled, true);
@@ -143,7 +148,7 @@ test('writeVectorConfig removes commented vector placeholders it replaces', () =
   ].join('\n'), 'utf8');
 
   writeVectorConfig(root, 'default', {
-    baseUrl: 'http://localhost:7997/v1',
+    baseUrl: 'http://host.docker.internal:7997/v1',
     apiKey: 'vector-key',
     embeddingModel: 'BAAI/bge-m3',
     rerankEnabled: true,
@@ -154,7 +159,7 @@ test('writeVectorConfig removes commented vector placeholders it replaces', () =
   const parsed = YAML.parse(raw);
   assert.doesNotMatch(raw, /^\s*#\s*baseUrl:/m);
   assert.doesNotMatch(raw, /^\s*#\s*apiKey:/m);
-  assert.equal(parsed.retrieval.vector.baseUrl, 'http://localhost:7997/v1');
+  assert.equal(parsed.retrieval.vector.baseUrl, 'http://host.docker.internal:7997/v1');
   assert.equal(parsed.retrieval.vector.apiKey, 'vector-key');
 });
 
@@ -195,3 +200,52 @@ test('finalizeCreatedWorkspace copies generated wiki token into default wikirc',
     else process.env.WIKI_WORKSPACES_DIR = previousDir;
   }
 });
+
+test('writeLlmConfig writes provider + engine and rewrites loopback hosts for containers', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wikirc-llm-'));
+  writeFileSync(join(root, '.wikirc.yaml'), ['language: en', ''].join('\n'), 'utf8');
+
+  writeLlmConfig(root, 'default', {
+    provider: 'openai-compatible',
+    engine: 'ollama',
+    baseUrl: 'http://localhost:11434/v1',
+    apiKey: 'ollama',
+    model: 'qwen2.5',
+  });
+
+  const parsed = YAML.parse(readFileSync(join(root, '.wikirc.yaml'), 'utf8'));
+  assert.equal(parsed.llm.provider, 'openai-compatible');
+  assert.equal(parsed.llm.engine, 'ollama');
+  // Le wizard tourne sur l'hôte, serve dans Docker : localhost y désigne le
+  // container lui-meme.
+  assert.equal(parsed.llm.baseUrl, 'http://host.docker.internal:11434/v1');
+});
+
+test('writeLlmConfig omits engine behind a gateway and leaves real hostnames alone', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wikirc-llm-gw-'));
+  writeFileSync(join(root, '.wikirc.yaml'), ['language: en', ''].join('\n'), 'utf8');
+
+  writeLlmConfig(root, 'default', {
+    provider: 'ai-gateway',
+    engine: null,
+    baseUrl: 'https://gateway.internal.example/v1',
+    apiKey: 'sk-virtual',
+    model: 'anthropic/claude-sonnet-4-5',
+  });
+
+  const parsed = YAML.parse(readFileSync(join(root, '.wikirc.yaml'), 'utf8'));
+  assert.equal(parsed.llm.provider, 'ai-gateway');
+  assert.equal(parsed.llm.engine, undefined);
+  assert.equal(parsed.llm.baseUrl, 'https://gateway.internal.example/v1');
+});
+
+test('containerReachableUrl only touches loopback hosts', () => {
+  assert.deepEqual(containerReachableUrl('http://127.0.0.1:8000/v1'), {
+    url: 'http://host.docker.internal:8000/v1',
+    rewritten: true,
+    from: '127.0.0.1',
+  });
+  assert.equal(containerReachableUrl('https://api.openai.com/v1').rewritten, false);
+  assert.equal(containerReachableUrl('http://gateway:4000/v1').rewritten, false);
+  assert.equal(containerReachableUrl(undefined).rewritten, false);
+});

package/src/shell/SetupWizard.tsx

@@ -3,7 +3,15 @@ import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
 import { useKeyboard, usePaste } from '@opentui/solid';
 import { createEffect, createMemo, createSignal, For, Show } from 'solid-js';
-import { fallbackModels, normalizeProvider } from '../core/modelFetch.js';
+import {
+  defaultBaseUrl,
+  fallbackModels,
+  fetchGatewayCatalog,
+  fetchModels,
+  normalizeEngine,
+  normalizeProvider,
+  requiresBaseUrl,
+} from '../core/modelFetch.js';
 import { checkInternetConnectivity } from '../core/startupCheck.js';
 import {
   createNewWorkspace,
@@ -24,11 +32,40 @@ type Step =
   | { kind: 'menu'; title: string; items: Array<{ label: string; value: string; muted?: boolean }> }
   | { kind: 'confirm'; title: string; message: string; yesLabel: string; noLabel: string }
   | { kind: 'select'; title: string; label: string; options: string[]; note?: string }
-  | { kind: 'text'; title: string; label: string; note?: string; placeholder?: string; prefill?: string; secret?: boolean }
+  | {
+      kind: 'text';
+      title: string;
+      label: string;
+      note?: string;
+      placeholder?: string;
+      prefill?: string;
+      secret?: boolean;
+      /**
+       * Catalogue découvert. Purement indicatif : le champ texte fait foi, ce
+       * qui garde l'étape utilisable quand l'endpoint est injoignable ou quand
+       * le modèle voulu n'y figure pas.
+       */
+      suggestions?: string[];
+    }
   | { kind: 'done' };
 type LogEntry = { icon: string; label: string; detail?: string };
 
-const PROVIDERS = ['OpenAI', 'Anthropic', 'Ollama (local)', 'Other (OpenAI-compatible)'];
+// Deux axes, deux questions. `provider` dit où l'on tape, `engine` dit
+// comment se comporte le serveur en face. Les fusionner était précisément ce
+// qui empêchait de décrire une gateway.
+const PROVIDERS = [
+  'Direct server (OpenAI-compatible)',
+  'AI gateway (LiteLLM, Bifrost, Portkey…)',
+];
+const ENGINE_OPTIONS = [
+  'OpenAI',
+  'Anthropic',
+  'Ollama (local)',
+  'vLLM (local)',
+  'MLX (local)',
+  'Albert',
+  'Other (generic OpenAI-compatible)',
+];
 // The scaffolded .wikirc.yaml ships fake endpoints and secrets so the file
 // documents its own shape (`https://mon-provider.example.com/v1`,
 // `http://infinity.local:7997/v1`, `YOUR_LLM_API_KEY`…). Preloading them into
@@ -43,12 +80,10 @@ function configuredValue(value: unknown) {
 }
 const MAIN_MENU = ['Agents', 'Workspaces', 'LLM configuration', 'Vector search', '---', 'Close'];
 
-function defaultBaseUrl(provider: string) {
-  if (provider === 'ollama') return 'http://localhost:11434';
-  if (provider === 'anthropic') return 'https://api.anthropic.com';
-  if (provider === 'openai') return 'https://api.openai.com';
-  if (provider === 'openai-compatible') return 'http://localhost:8000';
-  return '';
+// Les défauts et la question « faut-il demander une baseUrl ? » vivent dans
+// core/modelFetch.js, source unique partagée avec la découverte.
+function exampleBaseUrl(provider: string, engine: string) {
+  return defaultBaseUrl(provider, engine);
 }
 
 function currentWorkspaceContext(session: any, fallback?: any) {
@@ -239,17 +274,30 @@ export function SetupWizard(props: {
         kind: 'select',
         title: 'LLM configuration',
         label: context?.configError
-          ? `${context.configError} Select a provider after creating or fixing the config:`
-          : `No LLM configured${context?.workspaceName ? ` for ${context.workspaceName}` : ''}. Select a provider:`,
+          ? `${context.configError} Select how requests are routed after creating or fixing the config:`
+          : `No LLM configured${context?.workspaceName ? ` for ${context.workspaceName}` : ''}. How are requests routed?`,
         options: PROVIDERS,
+        note: 'A gateway is external infrastructure you deploy yourself; llm-wiki only reads its model catalog.',
+      };
+    }
+    if (currentRoute === 'llm-engine') {
+      return {
+        kind: 'select',
+        title: 'LLM configuration',
+        label: 'Which server is answering?',
+        options: ENGINE_OPTIONS,
+        note: 'Drives request-shaping workarounds and the `wiki doctor` calibration.',
       };
     }
     if (currentRoute === 'llm-baseurl') {
-      const example = defaultBaseUrl(llm().provider);
+      const isGateway = llm().provider === 'ai-gateway';
+      const example = exampleBaseUrl(llm().provider, llm().engine);
       return {
         kind: 'text',
         title: 'LLM configuration',
-        label: `Base URL${example ? ` (example: ${example})` : ''}`,
+        label: isGateway
+          ? 'Gateway base URL (example: http://gateway:4000/v1)'
+          : `Base URL${example ? ` (example: ${example})` : ''}`,
         prefill: llm().baseUrl || '',
       };
     }
@@ -257,13 +305,15 @@ export function SetupWizard(props: {
       return { kind: 'text', title: 'LLM configuration', label: 'API key (required)', secret: true };
     }
     if (currentRoute === 'llm-model') {
-      const example = fallbackModels(llm().provider)[0] || 'provider-agentic-model';
+      const discovered = catalog()?.chat ?? [];
+      const example = discovered[0] || fallbackModels(llm().engine)[0] || 'provider-agentic-model';
       return {
         kind: 'text',
         title: 'LLM configuration',
         label: `Model (example: ${example})`,
-        note: 'Required: an agentic model with tool/function calling support.',
-        prefill: llm().model || '',
+        note: catalogNote('Required: an agentic model with tool/function calling support.'),
+        prefill: llm().model || example,
+        suggestions: discovered,
       };
     }
     if (currentRoute === 'vector-confirm') {
@@ -274,19 +324,50 @@ export function SetupWizard(props: {
       return { kind: 'text', title: 'Vector search', label: 'Embeddings/rerank base URL', prefill: baseUrl, placeholder: baseUrl };
     }
     if (currentRoute === 'vector-apikey') {
-      const hint = llm().apiKey ? '(leave empty to reuse LLM key)' : undefined;
-      return { kind: 'text', title: 'Vector search', label: 'Vector API key', placeholder: hint, secret: true };
+      // L'héritage n'est proposé que tant que l'URL n'a pas divergé : sinon la
+      // clé du LLM — celle de la gateway, qui ouvre tous les providers —
+      // partirait vers un autre hôte.
+      const diverged = vectorBaseUrlDiverged();
+      const hint = !diverged && llm().apiKey ? '(leave empty to reuse LLM key)' : undefined;
+      return {
+        kind: 'text',
+        title: 'Vector search',
+        label: diverged ? 'Vector API key (required: different host)' : 'Vector API key',
+        placeholder: hint,
+        secret: true,
+      };
     }
     if (currentRoute === 'vector-model') {
-      const defaultEmbedding = vector().embeddingModel || fallbackModels(vector().provider || llm().provider, 'embedding')[0] || '';
-      return { kind: 'text', title: 'Vector search', label: 'Embedding model', prefill: defaultEmbedding };
+      const discovered = catalog()?.embedding ?? [];
+      const defaultEmbedding =
+        vector().embeddingModel ||
+        discovered[0] ||
+        fallbackModels(llm().engine, 'embedding')[0] ||
+        '';
+      return {
+        kind: 'text',
+        title: 'Vector search',
+        label: 'Embedding model',
+        note: catalogNote('Embeddings endpoint model.'),
+        prefill: defaultEmbedding,
+        suggestions: discovered,
+      };
     }
     if (currentRoute === 'vector-rerank') {
       return { kind: 'confirm', title: 'Vector search', message: 'Enable reranking?', yesLabel: 'Enable', noLabel: 'Skip' };
     }
     if (currentRoute === 'vector-rerank-model') {
-      const defaultReranker = vector().rerankerModel || 'BAAI/bge-reranker-v2-m3';
-      return { kind: 'text', title: 'Vector search', label: 'Rerank model', prefill: defaultReranker };
+      const discovered = catalog()?.rerank ?? [];
+      const defaultReranker =
+        vector().rerankerModel || discovered[0] || 'BAAI/bge-reranker-v2-m3';
+      return {
+        kind: 'text',
+        title: 'Vector search',
+        label: 'Rerank model',
+        note: catalogNote('Leave reranking disabled if no rerank model is available.'),
+        prefill: defaultReranker,
+        suggestions: discovered,
+      };
     }
     if (currentRoute === 'unregister-confirm') {
       const workspace = targetWorkspace();
@@ -315,12 +396,93 @@ export function SetupWizard(props: {
     setInput((s as any).prefill ?? '');
     const items = (s as any).items ?? (s as any).options?.map((label: string) => ({ label })) ?? [{ label: 'x' }];
     let preferred = -1;
+    // La question de routage est reposée à chaque passage — c'est plus simple
+    // et plus honnête que de la mémoriser dans un champ dédié. On se contente
+    // de présélectionner ce que le wikirc déclare déjà.
     if (route() === 'llm-provider' && llm().provider) {
-      preferred = PROVIDERS.findIndex((p) => normalizeProvider(p) === normalizeProvider(llm().provider));
+      preferred = PROVIDERS.findIndex(
+        (p) => normalizeProvider(p) === normalizeProvider(llm().provider),
+      );
+    }
+    if (route() === 'llm-engine' && llm().engine) {
+      preferred = ENGINE_OPTIONS.findIndex(
+        (e) => normalizeEngine(e) === normalizeEngine(llm().engine),
+      );
     }
     setSelected(preferred >= 0 ? preferred : firstSelectableIndex(items));
   });
 
+  /**
+   * Catalogue découvert auprès du serveur ou de la gateway. Il ne sert qu'à
+   * préremplir : le champ texte reste la vérité, ce qui garde le wizard
+   * utilisable quand l'endpoint est injoignable ou quand le modèle voulu n'y
+   * figure pas.
+   */
+  const [catalog, setCatalog] = createSignal<any>(null);
+  const [catalogError, setCatalogError] = createSignal<string | null>(null);
+
+  function catalogNote(base: string) {
+    const error = catalogError();
+    if (error) return `${base} (model discovery unavailable: ${error})`;
+    const found = catalog();
+    if (!found) return base;
+    if (!found.typed) {
+      return `${base} (gateway has no /model/info: the three lists are unfiltered)`;
+    }
+    return base;
+  }
+
+  async function discoverModels(target?: {
+    provider?: string;
+    engine?: string;
+    baseUrl?: string;
+    apiKey?: string;
+  }) {
+    setCatalog(null);
+    setCatalogError(null);
+    const source = target ?? llm();
+    const { provider, engine, baseUrl, apiKey } = source as any;
+    if (!baseUrl) return;
+    try {
+      if (normalizeProvider(provider) === 'ai-gateway') {
+        const found = await fetchGatewayCatalog(baseUrl, apiKey);
+        if (!found.ok) {
+          setCatalogError(found.error ?? 'gateway unreachable');
+          return;
+        }
+        setCatalog(found);
+        return;
+      }
+      const chat = await fetchModels(provider, baseUrl, apiKey, { engine });
+      const embedding = await fetchModels(provider, baseUrl, apiKey, {
+        engine,
+        kind: 'embedding',
+      });
+      if (!chat.ok && !embedding.ok) {
+        setCatalogError(chat.error ?? 'server unreachable');
+        return;
+      }
+      // Un serveur direct ne type pas ses modèles : les mêmes entrées
+      // alimentent les trois questions.
+      setCatalog({
+        typed: false,
+        chat: chat.models,
+        embedding: embedding.models,
+        rerank: embedding.models,
+      });
+    } catch (err) {
+      setCatalogError(err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  /** Vrai quand l'URL vecteur ne pointe plus le même hôte que le LLM. */
+  function vectorBaseUrlDiverged() {
+    const vectorUrl = vector().baseUrl;
+    const llmUrl = llm().baseUrl;
+    if (!vectorUrl || !llmUrl) return false;
+    return vectorUrl.replace(/\/+$/, '') !== llmUrl.replace(/\/+$/, '');
+  }
+
   function preloadWikirc(context: any) {
     const workspacePath = context?.workspacePath;
     if (!workspacePath) return;
@@ -330,6 +492,15 @@ export function SetupWizard(props: {
       if (config?.llm?.provider) {
         setLlm({
           provider: normalizeProvider(config.llm.provider),
+          // Un wikirc pré-0.16 porte le moteur dans `provider`
+          // (`ollama`, `anthropic`, `openai`). Sans cette déduction, l'étape
+          // moteur ne présélectionne rien et propose OpenAI en tête — au
+          // risque d'écraser une configuration qui marchait.
+          engine: config.llm.engine
+            ? normalizeEngine(config.llm.engine)
+            : normalizeProvider(config.llm.provider) === 'ai-gateway'
+              ? null
+              : normalizeEngine(config.llm.provider),
           baseUrl: configuredValue(config.llm.baseUrl),
           apiKey: configuredValue(config.llm.apiKey),
           model: configuredValue(config.llm.model),
@@ -500,14 +671,28 @@ export function SetupWizard(props: {
     }
     if (currentRoute === 'llm-provider') {
       const provider = normalizeProvider(value);
+      setLlm((old: any) => ({
+        ...old,
+        provider,
+        // Derrière une gateway il n'y a pas de moteur : l'endpoint est opaque
+        // et chaque modèle peut en avoir un différent.
+        engine: provider === 'ai-gateway' ? null : old.engine,
+        baseUrl: old.provider === provider ? old.baseUrl : '',
+      }));
+      // La gateway exige toujours une baseUrl, et n'a pas de moteur à choisir.
+      if (provider === 'ai-gateway') return navigate('llm-baseurl');
+      return navigate('llm-engine');
+    }
+    if (currentRoute === 'llm-engine') {
+      const engine = normalizeEngine(value);
       setLlm((old: any) => {
-        const asksForBaseUrl = provider === 'ollama' || provider === 'openai-compatible';
-        const baseUrl = (old.provider === provider && old.baseUrl)
+        const asksForBaseUrl = requiresBaseUrl(old.provider, engine);
+        const baseUrl = (old.engine === engine && old.baseUrl)
           ? old.baseUrl
-          : asksForBaseUrl ? '' : defaultBaseUrl(provider);
-        return { ...old, provider, baseUrl, ...(provider === 'ollama' && !old.apiKey ? { apiKey: 'ollama' } : {}) };
+          : asksForBaseUrl ? '' : defaultBaseUrl(old.provider, engine);
+        return { ...old, engine, baseUrl, ...(engine === 'ollama' && !old.apiKey ? { apiKey: 'ollama' } : {}) };
       });
-      if (provider === 'ollama' || provider === 'openai-compatible') return navigate('llm-baseurl');
+      if (requiresBaseUrl(llm().provider, engine)) return navigate('llm-baseurl');
       return navigate('llm-apikey');
     }
     if (currentRoute === 'unregister-confirm') {
@@ -569,7 +754,7 @@ export function SetupWizard(props: {
       setVector((old: any) => ({
         ...old,
         provider: old.provider || llm().provider,
-        baseUrl: old.baseUrl || llm().baseUrl || defaultBaseUrl(llm().provider),
+        baseUrl: old.baseUrl || llm().baseUrl || defaultBaseUrl(llm().provider, llm().engine),
       }));
       return navigate('vector-baseurl');
     }
@@ -612,24 +797,46 @@ export function SetupWizard(props: {
     if (currentRoute === 'llm-baseurl') {
       if (!value) return setError('Base URL is required.');
       setLlm((old: any) => ({ ...old, baseUrl: value }));
-      if (llm().provider === 'ollama') return navigate('llm-model');
+      // Ollama n'exige pas de clé : on peut découvrir tout de suite.
+      if (llm().engine === 'ollama') {
+        await discoverModels();
+        return navigate('llm-model');
+      }
       return navigate('llm-apikey');
     }
     if (currentRoute === 'llm-apikey') {
       if (!value) return setError('API key is required.');
       setLlm((old: any) => ({ ...old, apiKey: value }));
+      await discoverModels();
       return navigate('llm-model');
     }
     if (currentRoute === 'vector-baseurl') {
       const baseUrl = value || vector().baseUrl || llm().baseUrl;
       if (!baseUrl) return setError('Embeddings/rerank base URL is required.');
-      setVector((old: any) => ({ ...old, provider: llm().provider, baseUrl }));
+      setVector((old: any) => ({
+        ...old,
+        provider: llm().provider,
+        engine: llm().engine,
+        baseUrl,
+      }));
       return navigate('vector-apikey');
     }
     if (currentRoute === 'vector-apikey') {
+      if (vectorBaseUrlDiverged() && !value) {
+        return setError(
+          'API key is required: the vector base URL differs from the LLM one, so the LLM key is not reused.',
+        );
+      }
       const apiKey = value || llm().apiKey || undefined;
       if (!apiKey) return setError('API key is required (or set LLM key first).');
       setVector((old: any) => ({ ...old, apiKey }));
+      // Le catalogue affiché aux étapes embeddings et rerank doit venir de
+      // l'endpoint vecteur, pas du LLM : ce sont deux serveurs distincts dès
+      // que l'URL diverge, et proposer les modèles de chat de l'un pour les
+      // embeddings de l'autre n'a aucun sens.
+      if (vectorBaseUrlDiverged()) {
+        await discoverModels({ ...vector(), apiKey });
+      }
       return navigate('vector-model');
     }
     if (currentRoute === 'llm-model') {
@@ -754,6 +961,31 @@ export function SetupWizard(props: {
     return value || (s.secret ? (s.placeholder ?? '') : '');
   };
   const inputHasValue = () => step().kind === 'text' && input().length > 0;
+
+  /**
+   * Suggestions filtrées par ce qui est tapé.
+   *
+   * Une gateway correctement remplie expose plusieurs centaines de modèles :
+   * une liste brute est inutilisable, et un select classique interdirait de
+   * saisir un modèle absent du catalogue. On garde donc le champ texte comme
+   * seule vérité et on n'affiche qu'un rappel filtré — ce qui règle d'un coup
+   * les trois cas : liste énorme, modèle absent, endpoint injoignable.
+   */
+  const SUGGESTION_ROWS = 4;
+  const filteredSuggestions = createMemo(() => {
+    const current = step() as any;
+    const all: string[] = current?.suggestions ?? [];
+    if (all.length === 0) return { rows: [] as string[], total: 0, matched: 0 };
+    const needle = input().trim().toLowerCase();
+    const matches = needle
+      ? all.filter((item) => item.toLowerCase().includes(needle))
+      : all;
+    return {
+      rows: matches.slice(0, SUGGESTION_ROWS),
+      total: all.length,
+      matched: matches.length,
+    };
+  });
   const lineWidth = () => Math.max(10, dialogWidth() - 10);
   const displayLine1 = () => displayValue().slice(0, lineWidth());
   const displayLine2 = () => displayValue().slice(lineWidth(), lineWidth() * 2);
@@ -839,6 +1071,25 @@ export function SetupWizard(props: {
           </box>
         </box>
       </Show>
+      <Show when={step().kind === 'text' && filteredSuggestions().total > 0}>
+        <text height={1} fg="#7F8C8D">
+          {filteredSuggestions().matched === 0
+            ? `no match among ${filteredSuggestions().total} discovered model(s) — the typed value is used as-is`
+            : `${filteredSuggestions().matched}/${filteredSuggestions().total} discovered model(s) — type to filter, the typed value wins`}
+        </text>
+        <For each={filteredSuggestions().rows}>
+          {(suggestion) => (
+            <text height={1} fg={suggestion === input().trim() ? '#8BD5CA' : '#9CA3AF'}>
+              {`  ${suggestion === input().trim() ? '*' : '·'} ${suggestion}`}
+            </text>
+          )}
+        </For>
+        <Show when={filteredSuggestions().matched > SUGGESTION_ROWS}>
+          <text height={1} fg="#7F8C8D">
+            {`  … ${filteredSuggestions().matched - SUGGESTION_ROWS} more`}
+          </text>
+        </Show>
+      </Show>
       <Show when={step().kind !== 'text'}>
         <For each={currentItems()}>
           {(item, index) => (

package/src/shell/setupWizardPlaceholders.test.js

@@ -48,7 +48,7 @@ test('preloading a profile filters placeholders out of every prefilled field', (
   // With the vector URL filtered to null, this is what makes the embeddings
   // step offer the base URL the operator just typed.
   assert.match(source, /const baseUrl = vector\(\)\.baseUrl \|\| llm\(\)\.baseUrl;/);
-  assert.match(source, /baseUrl: old\.baseUrl \|\| llm\(\)\.baseUrl \|\| defaultBaseUrl\(llm\(\)\.provider\)/);
+  assert.match(source, /baseUrl: old\.baseUrl \|\| llm\(\)\.baseUrl \|\| defaultBaseUrl\(llm\(\)\.provider, llm\(\)\.engine\)/);
 });
 
 test('a real configuration is never mistaken for a placeholder', () => {

package/src/shell/setupWizardSuggestions.test.js

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+
+const source = readFileSync(new URL('./SetupWizard.tsx', import.meta.url), 'utf8');
+
+test('the model steps feed the discovered catalog into the filter', () => {
+  // Trois étapes doivent porter des suggestions : modèle LLM, embeddings,
+  // reranker. Sans elles, le filtre n'a rien a filtrer.
+  const occurrences = source.match(/suggestions: discovered/g) ?? [];
+  assert.equal(occurrences.length, 3);
+});
+
+test('the typed value always wins over the suggestion list', () => {
+  // Garde-fou : la liste ne doit jamais devenir un select. Si ce message
+  // disparait, c'est que la saisie libre a ete perdue.
+  assert.match(source, /the typed value wins/);
+  assert.match(source, /the typed value is used as-is/);
+});
+
+test('suggestions are filtered by the current input, not shown raw', () => {
+  assert.match(source, /all\.filter\(\(item\) => item\.toLowerCase\(\)\.includes\(needle\)\)/);
+  assert.match(source, /matches\.slice\(0, SUGGESTION_ROWS\)/);
+});

package/wiki-workspace

@@ -1074,6 +1074,7 @@ cacert_compose_args() {
 run_wiki() {
   local workspace="$1"
   shift
+  need_workspace_env "$workspace"
   local ws_path
   ws_path="$(normalize_path "$(workspace_value "$workspace" WIKI_WORKSPACE_PATH)")"
   ensure_workspace_dirs "$ws_path"