@nodefony/ai 0.0.0-stage → 10.0.0-beta.4

package/dist/nodefony/config/defineModuleConfig.js

@@ -0,0 +1,51 @@
+import { aiConfigSchema } from "./config.js";
+import { configJsonSchema } from "./configSchema.js";
+import { parseModuleConfig } from "nodefony";
+// nodefony/config/defineModuleConfig.ts
+/**
+* @nodefony/ai — LE COMMENT : builder PUR de la config.
+*
+* ⭐ TL;DR : ce fichier VALIDE et GÈLE. Il ne porte AUCUNE valeur — les défauts
+* vivent dans le schéma de `./config.ts` (règle d'or ADR-0006). Pour changer un
+* défaut, c'est là-bas ; ici, on ne fait que le faire respecter.
+*
+* Le nom du FICHIER est le même dans tous les modules Nodefony
+* (`defineModuleConfig.ts`) ; la FONCTION, elle, est préfixée par le module —
+* deux modules importés côte à côte ne se marchent pas dessus.
+*
+* L'environnement ne se lit JAMAIS ici. La surcharge générique
+* (`NF__AI__<CHEMIN>`) comme un nom court (`NF_AI_<RÉGLAGE>`) sont
+* posés par le Kernel avant cette validation. Un nom court se DÉCLARE sur son
+* champ, dans `./config.ts` : `.meta({ env: "NF_AI_<RÉGLAGE>" })`.
+*
+* 🔴 **La validation passe par `parseModuleConfig`, du cœur** — un seul endroit
+* pour une seule règle. Il lève une `BootConfigurationError`, et pas une `Error`
+* ordinaire : le kernel distingue les deux. Un hook de cycle de vie qui lève une
+* erreur QUELCONQUE est absorbé en développement (fail-soft — il protège la DX
+* d'un module optionnel cassé), tandis qu'une erreur de CONFIGURATION interrompt
+* le boot dans TOUS les environnements. Mesuré sur un module généré : avec une
+* `Error`, `use("@nodefony/ai", { gretting: "…" })` laissait l'application
+* démarrer, servir, et rendre 0 — la faute de frappe n'atteignait personne. Une
+* configuration explicite qu'on ne peut pas honorer ne se répare pas en
+* continuant.
+*
+* ⚠️ Ne PAS réécrire ce bloc à la main : les dix modules du framework portaient
+* chacun leur copie du `try`/`catch`, et elles avaient divergé sur les deux
+* points qui comptent — le type de l'erreur levée et la langue du message.
+*
+* @param config - config brute venue de `use("@nodefony/ai", { … })`.
+* @returns config validée et gelée.
+* @throws BootConfigurationError si un champ est invalide ou inconnu (toutes les
+*   erreurs Zod agrégées, par champ) — le boot s'interrompt, en dev comme en prod.
+*/
+function defineAiConfig(config = {}) {
+	return Object.freeze(parseModuleConfig(aiConfigSchema, config, "@nodefony/ai"));
+}
+/**
+* JSON Schema de la config — Studio en dérive son formulaire d'édition
+* (libellés, types, défauts, descriptions), sans une ligne d'UI écrite à la main.
+*/
+function aiConfigJsonSchema() {
+	return configJsonSchema();
+}
+export { aiConfigJsonSchema, defineAiConfig };

package/dist/nodefony/mcp/caller.js

@@ -0,0 +1,38 @@
+import { rolesFromScopes } from "nodefony";
+// nodefony/mcp/caller.ts
+const NO_ROLES = [];
+/**
+* Quels rôles porte l'appelant d'une porte MCP — **la règle, à un seul endroit**.
+*
+* ⭐ Toute porte MCP passe par ici, y compris celles qu'un module créera plus
+* tard (gestion d'agents, passerelles métier). C'est délibéré : la question
+* « que vaut un appelant sur ma porte » a exactement une bonne réponse, et
+* laisser chaque porte la réécrire garantit qu'une copie finira plus permissive
+* que les autres sans que rien ne le signale — c'est déjà ce qui s'est produit
+* quand la lecture d'administration fabriquait un administrateur.
+*
+* Les trois postures :
+*
+* | La porte | L'appelant | Ce qu'il porte |
+* | --- | --- | --- |
+* | non protégée | quiconque l'atteint | `operatorRoles` — AUCUN par défaut ; une porte dont le PÉRIMÈTRE protège l'élargit |
+* | protégée | jeton vérifié | ce que ses SCOPES ouvrent, rien de plus |
+* | protégée | anonyme toléré | **rien** — la déclaration d'autorisation serait vidée de son sens |
+*
+* Le premier cas n'accorde RIEN par défaut : une porte non protégée peut être
+* celle d'une application, ouverte en production. Seule une porte que son
+* PÉRIMÈTRE protège — la porte de développement de devkit, module
+* `policy: "dev"`, dont l'appelant lit déjà les sources — passe le rôle
+* d'opérateur, et l'écrit. Ce qui compte, c'est que ce soit un CHOIX écrit par
+* la porte — pas un administrateur fabriqué au fond d'une fonction de lecture.
+*
+* @param posture - ce que la porte sait d'elle-même et de cet appel.
+* @param operatorRoles - ce qu'accorde une porte NON protégée ; aucun rôle par
+*   défaut.
+* @returns les rôles à poser sur `IMcpCaller.roles`.
+*/
+function mcpCallerRoles(posture, operatorRoles = NO_ROLES) {
+	if (!posture.protected) return operatorRoles;
+	return posture.authenticated ? rolesFromScopes(posture.scopes) : [];
+}
+export { mcpCallerRoles };