@imenam/mcp-http-gateway 2.0.8 → 2.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/mcp-http-gateway",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "type": "module",
   "description": "HTTP gateway that exposes MCP servers as REST routes — bridge between MCP and any HTTP-capable agent",
   "main": "server.js",
@@ -13,7 +13,8 @@
     "mcp-endpoint.js",
     "auth.js",
     "README.md",
-    "embeddings/"
+    "embeddings/",
+    "startup-exposition.js"
   ],
   "scripts": {
     "start": "node server.js",

package/startup-exposition.js

@@ -0,0 +1,89 @@
+// Pré-exposition des MCP au démarrage de l'agent (EXPOSE_AT_AGENT_STARTUP).
+//
+// Par défaut, un agent connecté au gateway ne reçoit que les trois outils de découverte
+// (list_mcps / list_tools / call_tool) et doit interroger le gateway pour découvrir les
+// MCP et leurs outils. Pour les MCP fréquemment utilisés, cette découverte coûte cher :
+// `list_tools` reverse l'intégralité des schémas dans la conversation, où ils restent
+// jusqu'à la fin de la session.
+//
+// Un MCP pré-exposé voit à la place ses outils publiés comme de VRAIS outils MCP dans la
+// réponse `tools/list`, nommés `<serveur>__<outil>`, avec description et inputSchema
+// complets. L'agent les appelle directement, sans passer par call_tool.
+//
+// L'option se déclare PAR MCP, dans le bloc `env` de config/mcp-servers.json — au même
+// endroit que MCP_SERVER_ROUTE, qui est également une directive lue par le gateway :
+//
+//   "documentor": {
+//     "command": "node",
+//     "args": ["…"],
+//     "description": "…",
+//     "env": {
+//       "MCP_SERVER_ROUTE": "/documentor",
+//       "EXPOSE_AT_AGENT_STARTUP": "true"
+//     }
+//   }
+//
+// Sans cette clé (ou à "false"), le MCP n'est pas pré-exposé et reste accessible via
+// list_mcps / list_tools / call_tool.
+//
+// Dans tous les cas le MCP enfant reste hébergé côté gateway : seules ses définitions
+// sont relayées, les appels sont proxifiés.
+
+const TRUTHY = new Set(['true', '1', 'yes', 'on']);
+const FALSY = new Set(['false', '0', 'no', 'off', '']);
+
+// Séparateur entre le nom du MCP et celui de l'outil dans les outils proxy.
+const PROXY_SEPARATOR = '__';
+
+// Le client ajoute son propre préfixe (ex. `mcp__<serveur>__`) et de nombreux clients
+// plafonnent les noms d'outils à 64 caractères : on garde notre part courte.
+const MAX_PROXY_NAME_LENGTH = 40;
+
+// Interprète la valeur déclarée. Retourne { value, valid } pour permettre à l'appelant
+// d'avertir sur une valeur non reconnue plutôt que de l'ignorer en silence.
+export function parseExposeFlag(raw) {
+  if (raw === undefined || raw === null) return { value: false, valid: true };
+  if (typeof raw === 'boolean') return { value: raw, valid: true };
+
+  const normalized = String(raw).trim().toLowerCase();
+  if (TRUTHY.has(normalized)) return { value: true, valid: true };
+  if (FALSY.has(normalized)) return { value: false, valid: true };
+  return { value: false, valid: false };
+}
+
+// Les noms d'outils MCP doivent rester dans [a-zA-Z0-9_-].
+function sanitizeSegment(value) {
+  return String(value).replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+// Construit les outils proxy à partir du registry. Chaque entrée porte `route` +
+// `toolName` pour le routage — à retirer avant publication via toolDefinition().
+export function buildProxyTools(registry) {
+  const proxyTools = [];
+
+  for (const entry of registry ?? []) {
+    if (!entry.exposeAtStartup) continue;
+
+    for (const tool of entry.tools ?? []) {
+      proxyTools.push({
+        name: `${sanitizeSegment(entry.name)}${PROXY_SEPARATOR}${sanitizeSegment(tool.name)}`,
+        description: tool.description ?? '',
+        inputSchema: tool.inputSchema ?? { type: 'object', properties: {} },
+        route: entry.route,
+        toolName: tool.name,
+      });
+    }
+  }
+
+  return proxyTools;
+}
+
+// Vue « définition MCP » d'un outil proxy : sans les champs de routage internes.
+export function toolDefinition({ name, description, inputSchema }) {
+  return { name, description, inputSchema };
+}
+
+// Noms proxy trop longs pour survivre au préfixe ajouté par le client.
+export function overlongProxyNames(proxyTools) {
+  return (proxyTools ?? []).filter(t => t.name.length > MAX_PROXY_NAME_LENGTH).map(t => t.name);
+}