@dotdrelle/wiki-manager 0.15.29 → 0.15.34

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/wikiWorkspace.test.js

@@ -28,6 +28,15 @@ test('wiki-workspace checks runtime pid command before killing', async () => {
   assert.match(script, /kill "\$\(cat "\$pid_file"\)"/);
 });
 
+test('project refresh shuts down runtime and removes only compose-owned images', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  assert.match(script, /if \[\[ \$# -eq 1 && "\$1" == "refresh" \]\]; then\n    refresh_project/);
+  assert.match(script, /compose_for_workspace "\$workspace" down --rmi all --remove-orphans/);
+  assert.match(script, /_agents_dc down --rmi all --remove-orphans/);
+  assert.doesNotMatch(script, /docker (?:image )?prune/);
+});
+
 test('wiki-workspace regenerates CA compose overrides instead of retaining removed services', async () => {
   const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
 
@@ -57,6 +66,13 @@ test('wiki-workspace provisions connector secrets and persistent state', async (
   assert.match(script, /delete config\.chatAccess\.servers\.connectors/);
 });
 
+test('local connector builds require both public Desktop OAuth values', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  assert.match(script, /for build_key in WIKILLM_GOOGLE_OAUTH_CLIENT_ID WIKILLM_GOOGLE_OAUTH_CLIENT_SECRET/);
+  assert.match(script, /require_connectors_build_credentials/);
+});
+
 test('workspace creation keeps mutable manager files outside the installed package', async () => {
   const source = await readFile(new URL('./workspaces.js', import.meta.url), 'utf8');
 

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/orchestrator/agentRegistry.js

@@ -41,13 +41,20 @@ async function discoverServerAgent(session, serverName, endpoint = {}, { callToo
     return legacyAgent(serverName, endpoint, { health: UNAVAILABLE, lastSeenAt });
   }
 
-  const toolName = findAgentDescribeTool(serverName, endpoint.tools ?? []);
-  if (!toolName) {
+  const tool = findAgentDescribeTool(serverName, endpoint.tools ?? []);
+  if (!tool) {
     return legacyAgent(serverName, endpoint, { health: AVAILABLE, lastSeenAt });
   }
+  const toolName = tool.name;
 
   try {
-    const result = await callTool(session.mcp, serverName, toolName, {}, signal);
+    const result = await callTool(
+      session.mcp,
+      serverName,
+      toolName,
+      describeArguments(tool, session?.workspace),
+      signal,
+    );
     const description = assertContract('agentDescription', parseToolJsonResult(result));
     return {
       serverName,
@@ -108,13 +115,34 @@ function dispatchRegistryEvent(session, type, payload) {
 }
 
 function findAgentDescribeTool(serverName, tools) {
-  const names = tools.map((tool) => String(tool.name ?? '')).filter(Boolean);
-  return names.find((name) => name === 'agent_describe')
-    ?? names.find((name) => name === `${serverName}__agent_describe`)
-    ?? names.find((name) => name.endsWith('__agent_describe'))
+  const named = tools.filter((tool) => String(tool?.name ?? ''));
+  const byName = (predicate) => named.find((tool) => predicate(String(tool.name)));
+  return byName((name) => name === 'agent_describe')
+    ?? byName((name) => name === `${serverName}__agent_describe`)
+    ?? byName((name) => name.endsWith('__agent_describe'))
     ?? null;
 }
 
+// Parts of a contract are workspace-scoped — typically the closed vocabulary of
+// an argument (the sources declared in THIS workspace). Published as a bare
+// string, such a field is unverifiable and a planner fills it with any noun
+// from the objective, so it is worth telling the agent which workspace we are
+// asking about.
+//
+// But the orchestrator must not assume an agent accepts an argument it never
+// declared: an agent whose agent_describe schema is `additionalProperties:
+// false` REJECTS the call, drops out of the registry, and its capabilities
+// silently vanish — the objective then resolves to whatever agent is left.
+// Send the workspace only to agents whose own schema says they can take it.
+function describeArguments(tool, workspace) {
+  if (!workspace) return {};
+  const schema = tool?.inputSchema;
+  if (!schema || typeof schema !== 'object') return {};
+  const declaresWorkspace = Object.hasOwn(schema.properties ?? {}, 'workspace');
+  const acceptsExtra = schema.additionalProperties !== false;
+  return declaresWorkspace || acceptsExtra ? { workspace: String(workspace) } : {};
+}
+
 function parseToolJsonResult(result) {
   if (result && typeof result === 'object' && !Array.isArray(result) && !Array.isArray(result.content)) {
     return result;