@dotdrelle/wiki-manager 0.15.32 → 0.15.35

package/src/core/modelFetch.test.js

@@ -1,6 +1,16 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { fallbackModels, fetchModels } from './modelFetch.js';
+import {
+  DISCOVERY_TIMEOUT_MS,
+  classifyModelEntry,
+  describeFetchError,
+  fetchServerCatalog,
+  fallbackModels,
+  fetchGatewayCatalog,
+  fetchModels,
+  requiresBaseUrl,
+  transportSummary,
+} from './modelFetch.js';
 
 test('fetchModels returns remote OpenAI-compatible model ids', async () => {
   const originalFetch = globalThis.fetch;
@@ -34,5 +44,283 @@ 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('fetchGatewayCatalog queries /model/info and /v1/models in parallel', async () => {
+  const originalFetch = globalThis.fetch;
+  const started = [];
+  let releaseModelInfo;
+  const modelInfoGate = new Promise((resolve) => { releaseModelInfo = resolve; });
+  globalThis.fetch = async (url) => {
+    started.push(url);
+    if (url.endsWith('/model/info')) {
+      await modelInfoGate;
+      return { ok: false, status: 404 };
+    }
+    return { ok: true, json: async () => ({ data: [{ id: 'a' }] }) };
+  };
+  try {
+    const pending = fetchGatewayCatalog('http://gw:4000/v1', 'key', { timeoutMs: 100 });
+    // Le repli ne doit pas attendre la fin du chemin typé : les deux requêtes
+    // sont déjà parties quand /model/info est encore en vol.
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(started.length, 2);
+    releaseModelInfo();
+    const result = await pending;
+    assert.equal(result.ok, true);
+    assert.equal(result.typed, false);
+    assert.deepEqual(result.chat, ['a']);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('HTTP failures name the likely cause instead of a bare status', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({ ok: false, status: 401 });
+  try {
+    const result = await fetchModels('openai', 'https://api.openai.com/v1', 'bad', {
+      timeoutMs: 50,
+    });
+    assert.equal(result.ok, false);
+    assert.match(result.error, /HTTP 401/);
+    assert.match(result.error, /API key rejected/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('describeFetchError turns transport codes into an actionable sentence', () => {
+  const tls = Object.assign(new Error('fetch failed'), {
+    cause: { code: 'SELF_SIGNED_CERT_IN_CHAIN' },
+  });
+  assert.match(describeFetchError(tls, { url: 'https://gw:4000/v1/models' }), /--cacert/);
+
+  const refused = Object.assign(new Error('fetch failed'), {
+    cause: { code: 'ECONNREFUSED' },
+  });
+  assert.match(describeFetchError(refused, { url: 'http://gw:4000/v1' }), /gw:4000/);
+
+  const dns = Object.assign(new Error('fetch failed'), { cause: { code: 'ENOTFOUND' } });
+  assert.match(describeFetchError(dns, { url: 'http://nope.local/v1' }), /host not found/);
+
+  // Le délai en millisecondes est un détail d'implémentation : le message
+  // nomme l'hôte muet et les causes probables, pas la valeur du timeout.
+  const aborted = Object.assign(new Error('aborted'), { name: 'AbortError' });
+  const timedOut = describeFetchError(aborted, { url: 'http://gw:4000/v1', timeoutMs: 8000 });
+  assert.match(timedOut, /gw:4000 did not answer in time/);
+  assert.match(timedOut, /proxy or firewall/);
+  assert.doesNotMatch(timedOut, /\d+ ms/);
+});
+
+test('transportSummary warns when a declared proxy is not actually used', () => {
+  assert.match(
+    transportSummary({ HTTPS_PROXY: 'http://proxy:3128' }),
+    /NODE_USE_ENV_PROXY not set/,
+  );
+  assert.match(
+    transportSummary({ HTTPS_PROXY: 'http://proxy:3128', NODE_USE_ENV_PROXY: '1' }),
+    /proxy http:\/\/proxy:3128/,
+  );
+  assert.match(transportSummary({}), /direct connection/);
+  assert.match(transportSummary({ WIKI_MANAGER_CACERT_PATH: '/ca.pem' }), /CA \/ca\.pem/);
+});
+
+test('the discovery timeout only bounds silent failures, never a healthy endpoint', () => {
+  // Assez long pour un endpoint distant lent, assez court pour qu'un proxy qui
+  // avale la connexion finisse par se dénoncer. Il n'est jamais attendu par
+  // une étape du wizard : la découverte tourne en tâche de fond.
+  assert.ok(DISCOVERY_TIMEOUT_MS >= 5000 && DISCOVERY_TIMEOUT_MS <= 15000);
+});
+
+test('the gateway hands over the flat list before /model/info completes', async () => {
+  const originalFetch = globalThis.fetch;
+  let releaseModelInfo;
+  const modelInfoGate = new Promise((resolve) => { releaseModelInfo = resolve; });
+  globalThis.fetch = async (url) => {
+    if (url.endsWith('/model/info')) {
+      await modelInfoGate;
+      return {
+        ok: true,
+        json: async () => ({
+          data: [{ model_name: 'chat-a', model_info: { mode: 'chat' } }],
+        }),
+      };
+    }
+    return { ok: true, json: async () => ({ data: [{ id: 'chat-a' }, { id: 'embed-b' }] }) };
+  };
+  try {
+    const partials = [];
+    const pending = fetchGatewayCatalog('http://gw:4000/v1', 'key', {
+      timeoutMs: 100,
+      onPartial: (partial) => partials.push(partial),
+    });
+    // La liste plate doit être livrée pendant que /model/info est encore en vol.
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    assert.equal(partials.length, 1);
+    assert.equal(partials[0].typed, false);
+    assert.deepEqual(partials[0].chat, ['chat-a', 'embed-b']);
+
+    releaseModelInfo();
+    const result = await pending;
+    assert.equal(result.typed, true);
+    assert.deepEqual(result.chat, ['chat-a']);
+    // Le typage arrivé, plus aucune livraison partielle ne doit suivre.
+    assert.equal(partials.length, 1);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('classifyModelEntry reads the type hints real servers actually send', () => {
+  // Albert.
+  assert.equal(classifyModelEntry({ type: 'text-generation' }), 'chat');
+  assert.equal(classifyModelEntry({ type: 'text-embeddings-inference' }), 'embedding');
+  assert.equal(classifyModelEntry({ type: 'text-classification' }), 'rerank');
+  // Hors périmètre : absent des trois listes plutôt que mal classé.
+  assert.equal(classifyModelEntry({ type: 'automatic-speech-recognition' }), null);
+  // LiteLLM.
+  assert.equal(classifyModelEntry({ model_info: { mode: 'embedding' } }), 'embedding');
+  // OpenAI ne type rien : `object: "model"` ne doit pas être pris pour un type.
+  assert.equal(classifyModelEntry({ id: 'gpt-4.1', object: 'model' }), null);
+});
+
+test('fetchServerCatalog splits a direct server catalog by model type', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: true,
+    json: async () => ({
+      data: [
+        { id: 'openai/gpt-oss-120b', type: 'text-generation' },
+        { id: 'bge-m3', type: 'text-embeddings-inference' },
+        { id: 'bge-reranker-v2-m3', type: 'text-classification' },
+        { id: 'whisper-large-v3', type: 'automatic-speech-recognition' },
+      ],
+    }),
+  });
+  try {
+    const result = await fetchServerCatalog('openai-compatible', 'https://albert.example/v1', 'key', {
+      engine: 'albert',
+      timeoutMs: 100,
+    });
+    assert.equal(result.ok, true);
+    assert.equal(result.typed, true);
+    assert.deepEqual(result.chat, ['openai/gpt-oss-120b']);
+    assert.deepEqual(result.embedding, ['bge-m3']);
+    assert.deepEqual(result.rerank, ['bge-reranker-v2-m3']);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('fetchServerCatalog stays untyped when the server types nothing', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: true,
+    json: async () => ({ data: [{ id: 'b', object: 'model' }, { id: 'a', object: 'model' }] }),
+  });
+  try {
+    const result = await fetchServerCatalog('openai-compatible', 'https://api.openai.com/v1', 'key', {
+      engine: 'openai',
+      timeoutMs: 100,
+    });
+    assert.equal(result.typed, false);
+    assert.deepEqual(result.chat, ['a', 'b']);
+    assert.deepEqual(result.embedding, ['a', 'b']);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('a partially typed catalog falls back to the full list, never to an empty one', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: true,
+    json: async () => ({
+      data: [{ id: 'embed-only', type: 'text-embeddings-inference' }, { id: 'mystery' }],
+    }),
+  });
+  try {
+    const result = await fetchServerCatalog('openai-compatible', 'https://x/v1', 'key', {
+      timeoutMs: 100,
+    });
+    assert.equal(result.typed, true);
+    assert.deepEqual(result.embedding, ['embed-only']);
+    // Aucun modèle annoncé comme chat : proposer toute la liste vaut mieux
+    // qu'une étape sans aucune suggestion.
+    assert.deepEqual(result.chat, ['embed-only', 'mystery']);
+  } 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/profileServiceStatus.test.js

@@ -0,0 +1,146 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { PROFILE_FLAGS, profileServiceStatus } from './agentsCompose.js';
+
+test('a disabled service says which flag, in which file, and what to do', () => {
+  const status = profileServiceStatus('connectors', { env: {} });
+  assert.equal(status.enabled, false);
+  assert.equal(status.flag, 'CONNECTORS_ENABLED');
+  // Le message d'origine — « unavailable or disabled » — ne disait ni lequel
+  // des deux, ni où regarder : Donna, faute de fait à citer, inventait un
+  // `cme.yaml` et un « manifeste des services actifs ».
+  assert.match(status.message, /CONNECTORS_ENABLED is not set/);
+  assert.match(status.message, /set CONNECTORS_ENABLED=true/);
+  assert.match(status.message, /\/start agents/);
+  assert.match(status.message, /\.env/);
+  // Le piège du profil Compose : le conteneur n'existe pas du tout, ce qui
+  // ressemble à un service planté.
+  assert.match(status.message, /does not exist at all/);
+});
+
+test('a disabled service quotes the value actually found', () => {
+  const status = profileServiceStatus('connectors', { env: { CONNECTORS_ENABLED: 'false' } });
+  assert.equal(status.enabled, false);
+  assert.match(status.message, /CONNECTORS_ENABLED is "false"/);
+});
+
+test('an enabled but unreachable service is a different diagnosis', () => {
+  const status = profileServiceStatus('connectors', { env: { CONNECTORS_ENABLED: 'true' } });
+  assert.equal(status.enabled, true);
+  assert.match(status.message, /enabled .* but not reachable/);
+  assert.doesNotMatch(status.message, /set CONNECTORS_ENABLED=true/);
+});
+
+test('an unknown service is not described as disabled', () => {
+  const status = profileServiceStatus('nope', { env: {} });
+  assert.equal(status.flag, null);
+  assert.match(status.message, /no "nope" service/);
+});
+
+test('/connector reports the reason instead of a bare "unavailable or disabled"', () => {
+  const source = readFileSync(
+    fileURLToPath(new URL('../commands/slash.js', import.meta.url)),
+    'utf8',
+  );
+  assert.match(source, /profileServiceStatus\('connectors'\)\.message/);
+  assert.doesNotMatch(source, /The connectors service is unavailable or disabled\./);
+});
+
+test('every profile flag is documented where the operator will look', () => {
+  const doc = readFileSync(
+    fileURLToPath(new URL('../../../llm-wiki/help-doc/06-troubleshooting.md', import.meta.url)),
+    'utf8',
+  );
+  // Donna répond aux questions produit depuis cette documentation : un drapeau
+  // absent d'ici est un drapeau qu'elle ne peut que deviner.
+  for (const flag of Object.values(PROFILE_FLAGS)) {
+    assert.ok(doc.includes(flag), `${flag} must be documented in help-doc/06-troubleshooting.md`);
+  }
+});
+
+test('stopping the agents resolves the same manager files as starting them', () => {
+  const source = readFileSync(
+    fileURLToPath(new URL('./wikiSetup.js', import.meta.url)),
+    'utf8',
+  );
+  // `stopAgents` n'épinglait pas WIKI_MANAGER_ENV_FILE : le script résolvait
+  // `.env` contre le répertoire du paquet, `connectors_enabled` y lisait un
+  // profil inactif, et `docker compose down` partait sans
+  // `--profile connectors`. Un service à profil inactif étant invisible à
+  // Compose, le conteneur restait debout — `/stop agents` annonçait un succès
+  // en laissant tourner ce qu'il prétendait arrêter.
+  const stopBlock = source.slice(source.indexOf('export async function stopAgents'));
+  for (const key of ['WIKI_MANAGER_ENV_FILE: managerEnvFile()', 'WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile()']) {
+    assert.ok(stopBlock.includes(key), `stopAgents must pin ${key}`);
+  }
+});
+
+test('"all" means the same thing to start and to stop', () => {
+  const slash = readFileSync(fileURLToPath(new URL('../commands/slash.js', import.meta.url)), 'utf8');
+  // `/start all` démarrait les agents, `/stop all` ne les arrêtait pas : la
+  // séquence start/stop ne revenait donc pas à l'état de départ.
+  assert.match(slash, /const startsAgents = service === 'all';/);
+  assert.match(slash, /const stopsAgents = service === 'all';/);
+  assert.match(slash, /if \(stopsAgents\) \{\s*\n\s*const agentsResult = await runAgentCommand\(stopAgents, 'stop'\);/);
+});
+
+test('the addressable agents are read from the compose file, never hard-coded', async () => {
+  const { agentServiceNames, togglableAgentNames } = await import('./agentsCompose.js');
+  const declared = agentServiceNames();
+
+  // Une liste figée annonçait `mailer`, qui ne vit que dans l'exemple
+  // d'override : proposer un service absent, c'est promettre un
+  // « no such service ».
+  assert.ok(declared.includes('connectors'));
+  assert.ok(declared.includes('cme'));
+  assert.ok(!declared.includes('mailer'), 'mailer is not declared until the operator uncomments it');
+
+  // Et seuls les agents à drapeau se proposent un par un dans l'interface.
+  assert.deepEqual(togglableAgentNames(), ['connectors']);
+  for (const name of togglableAgentNames()) {
+    assert.ok(declared.includes(name), `${name} must actually exist in the agents stack`);
+  }
+});
+
+test('an agent can be started and stopped on its own', () => {
+  const setup = readFileSync(fileURLToPath(new URL('./wikiSetup.js', import.meta.url)), 'utf8');
+  const slash = readFileSync(fileURLToPath(new URL('../commands/slash.js', import.meta.url)), 'utf8');
+  const script = readFileSync(fileURLToPath(new URL('../../wiki-workspace', import.meta.url)), 'utf8');
+
+  assert.match(setup, /'agents', 'up', \.\.\.\(options\.services \?\? \[\]\)/);
+  assert.match(setup, /'agents', 'down', \.\.\.\(options\.services \?\? \[\]\)/);
+  // La pile agents est un projet Compose distinct : sans ce routage, `/start
+  // connectors` allait chercher un service inexistant côté workspace.
+  assert.match(slash, /agentServiceNames\(\)\.includes\(service\)/);
+  // `down <service>` supprimerait le réseau commun : Compose impose stop + rm.
+  assert.match(script, /_agents_dc stop "\$@"/);
+  assert.match(script, /_agents_dc rm -f "\$@"/);
+});
+
+test('a connector read tool is not mistaken for the limit of its agent', () => {
+  const graph = readFileSync(fileURLToPath(new URL('../agent/graph.js', import.meta.url)), 'utf8');
+  // « récupère ce mail » et « envoie un mail » ont été refusés comme
+  // impossibles, alors que l'agent connectors déclare `external-source.collect`
+  // et `communication.send-email`. Donna raisonnait sur les outils de lecture
+  // exposés au chat — qui ne rendent que des métadonnées — au lieu de déléguer.
+  assert.match(graph, /direct read tools of a connector are a preview/);
+  assert.match(graph, /delegated through runtime__delegate, not answered from a read tool/);
+  // Et un droit manquant doit être nommé comme tel, pas présenté comme une
+  // fonctionnalité absente.
+  assert.match(graph, /lack of an authorization grant or scope/);
+});
+
+test('the system prompt points product questions at the documentation tools', () => {
+  const graph = readFileSync(
+    fileURLToPath(new URL('../agent/graph.js', import.meta.url)),
+    'utf8',
+  );
+  // Les outils help_* sont exposés (allow-list du mode chat) mais le prompt ne
+  // disait nulle part qu'ils sont LA source des questions produit : Donna
+  // répondait de mémoire, et inventait.
+  assert.match(graph, /bundled product documentation is your source/);
+  assert.match(graph, /call the documentation search\/read tools FIRST/);
+  assert.match(graph, /Configuration facts are never answered from memory/);
+});

package/src/core/wikiSetup.js

@@ -72,7 +72,7 @@ export async function startAgents(options = {}) {
       : await missingAgentImages(composeContext);
     if (absentImages.length > 0) options.onImagesMissing?.(absentImages);
     const exec = options.exec ?? execFileAsync;
-    const { stdout, stderr } = await exec(join(managerRoot(), 'wiki-workspace'), ['agents', 'up'], {
+    const { stdout, stderr } = await exec(join(managerRoot(), 'wiki-workspace'), ['agents', 'up', ...(options.services ?? [])], {
       cwd: managerRoot(),
       env: {
         ...process.env,
@@ -148,11 +148,20 @@ function agentsStartFailure({ downServices = [], missingServices = [], profiles
 
 export async function stopAgents(options = {}) {
   try {
-    const { stdout, stderr } = await execFileAsync(join(managerRoot(), 'wiki-workspace'), ['agents', 'down'], {
+    const { stdout, stderr } = await execFileAsync(join(managerRoot(), 'wiki-workspace'), ['agents', 'down', ...(options.services ?? [])], {
       cwd: managerRoot(),
       env: {
         ...process.env,
         WIKI_WORKSPACES_DIR: workspacesDir(),
+        // Même épinglage que startAgents, et pour la même raison : cwd est la
+        // racine du paquet, donc sans ces variables le script résout `.env`
+        // contre $PWD. `connectors_enabled` lisait alors le .env du PAQUET,
+        // concluait que le profil était inactif, et `docker compose down`
+        // partait sans `--profile connectors` — un service à profil inactif est
+        // invisible à Compose, donc le conteneur restait debout. `/stop agents`
+        // annonçait un succès en laissant tourner ce qu'il prétendait arrêter.
+        WIKI_MANAGER_ENV_FILE: managerEnvFile(),
+        WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
         AGENTS_DATA_DIR: resolveAgentsDataDir(),
       },
       timeout: options.timeout ?? 120_000,
@@ -261,11 +270,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 +313,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

@@ -66,11 +66,17 @@ 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 () => {
+test('the manager never builds an image, it only runs published ones', 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/);
+  // Ce script est livré dans le paquet npm, où le dépôt agent-connectors
+  // n'existe pas : il ne peut ni construire l'image, ni lire le
+  // .env.build.local qui porte l'application OAuth. La construction appartient
+  // à build-and-push.sh. Pour utiliser sa propre application Google,
+  // l'opérateur surcharge GOOGLE_OAUTH_CLIENT_ID / _SECRET dans le .env.
+  assert.doesNotMatch(script, /--build\b/);
+  assert.doesNotMatch(script, /\.env\.build\.local/);
+  assert.doesNotMatch(script, /require_connectors_build_credentials/);
 });
 
 test('workspace creation keeps mutable manager files outside the installed package', async () => {

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);
+});