strapi-plugin-mcp-chat 0.1.0 → 0.5.0

package/dist/server/index.js

@@ -36,12 +36,12 @@ module.exports = __toCommonJS(index_exports);
 // server/src/controllers/chat.ts
 var chat_default = ({ strapi }) => ({
   async message(ctx) {
-    const { messages, image, lang, previewUrl } = ctx.request.body || {};
+    const { messages, image, lang, previewUrl, autoPublish } = ctx.request.body || {};
     if (!Array.isArray(messages) || messages.length === 0) {
       return ctx.badRequest('Campo "messages" (array) \xE9 obrigat\xF3rio.');
     }
     try {
-      const result = await strapi.plugin("mcp-chat").service("chat").chat({ messages, image, lang, previewUrl });
+      const result = await strapi.plugin("mcp-chat").service("chat").chat({ messages, image, lang, previewUrl, autoPublish });
       ctx.body = result;
     } catch (e) {
       strapi.log.error(`[mcp-chat] ${e?.message || e}`);
@@ -412,6 +412,68 @@ var import_node_path = __toESM(require("node:path"));
 function isDev() {
   return process.env.NODE_ENV === "development";
 }
+var KNOWN_ATTR_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "text",
+  "richtext",
+  "blocks",
+  "email",
+  "password",
+  "uid",
+  "enumeration",
+  "json",
+  "integer",
+  "biginteger",
+  "decimal",
+  "float",
+  "date",
+  "time",
+  "datetime",
+  "timestamp",
+  "boolean",
+  "media",
+  "relation",
+  "component",
+  "dynamiczone"
+]);
+function validateApi(api) {
+  const errs = [];
+  const rel = Object.keys(api.files).find((r) => r.endsWith("schema.json"));
+  if (!rel) {
+    errs.push(`${api.singularName}: schema.json ausente nos arquivos gerados`);
+    return errs;
+  }
+  let schema;
+  try {
+    schema = JSON.parse(api.files[rel]);
+  } catch (e) {
+    errs.push(`${api.singularName}: schema.json n\xE3o \xE9 JSON v\xE1lido (${e?.message ?? e})`);
+    return errs;
+  }
+  if (schema?.kind !== "collectionType" && schema?.kind !== "singleType") {
+    errs.push(`${api.singularName}: "kind" inv\xE1lido (${schema?.kind})`);
+  }
+  if (!schema?.info?.singularName || !schema?.info?.pluralName) {
+    errs.push(`${api.singularName}: info.singularName/pluralName obrigat\xF3rios`);
+  }
+  const attrs = schema?.attributes;
+  if (!attrs || typeof attrs !== "object") {
+    errs.push(`${api.singularName}: "attributes" ausente ou inv\xE1lido`);
+  } else {
+    for (const [name, a] of Object.entries(attrs)) {
+      if (!a || typeof a !== "object" || !a.type) {
+        errs.push(`${api.singularName}.${name}: atributo sem "type"`);
+      } else if (!KNOWN_ATTR_TYPES.has(a.type)) {
+        errs.push(`${api.singularName}.${name}: type desconhecido "${a.type}"`);
+      } else if (a.type === "relation" && !a.target) {
+        errs.push(`${api.singularName}.${name}: relation sem "target"`);
+      } else if (a.type === "component" && !a.component) {
+        errs.push(`${api.singularName}.${name}: component sem "component"`);
+      }
+    }
+  }
+  return errs;
+}
 function writeApis(apis, opts) {
   const result = {
     ok: false,
@@ -431,6 +493,37 @@ function writeApis(apis, opts) {
     result.errors.push(`apiRoot deve ser um caminho absoluto: ${opts.apiRoot}`);
     return result;
   }
+  const toWrite = apis.filter((api) => !import_node_fs.default.existsSync(import_node_path.default.join(opts.apiRoot, api.singularName)));
+  const knownSingulars = /* @__PURE__ */ new Set([
+    ...apis.map((a) => a.singularName),
+    ...import_node_fs.default.existsSync(opts.apiRoot) ? import_node_fs.default.readdirSync(opts.apiRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : []
+  ]);
+  const validationErrors = [];
+  for (const api of toWrite) {
+    validationErrors.push(...validateApi(api));
+    const rel = Object.keys(api.files).find((r) => r.endsWith("schema.json"));
+    if (rel) {
+      try {
+        const attrs = JSON.parse(api.files[rel])?.attributes || {};
+        for (const [name, a] of Object.entries(attrs)) {
+          if (a?.type === "relation" && typeof a.target === "string") {
+            const tgt = a.target.split("::")[1]?.split(".")[0];
+            if (tgt && !knownSingulars.has(tgt)) {
+              validationErrors.push(`${api.singularName}.${name}: relation aponta para "${a.target}" inexistente`);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (validationErrors.length) {
+    result.errors.push(
+      "Schema gerado inv\xE1lido \u2014 nada foi escrito (provis\xE3o abortada com seguran\xE7a):",
+      ...validationErrors
+    );
+    return result;
+  }
   for (const api of apis) {
     const apiDir = import_node_path.default.join(opts.apiRoot, api.singularName);
     if (import_node_fs.default.existsSync(apiDir)) {
@@ -1712,6 +1805,18 @@ export function __getLocale(): string {
   } catch {}
   return __defaultLocale;
 }
+/** Status ativo: ?preview=1 ou ?status=draft na URL \u2192 rascunho (preview do
+ *  mcp-chat em modo Draft). Caso contr\xE1rio, publicado. S\xF3 no cliente; no SSR
+ *  cai para "published" (ver a nota de draft preview no README). */
+export function __getStatus(): "draft" | "published" {
+  try {
+    if (typeof window !== "undefined") {
+      const sp = new URL(window.location.href).searchParams;
+      if (sp.get("preview") === "1" || sp.get("status") === "draft") return "draft";
+    }
+  } catch {}
+  return "published";
+}
 
 ${mapperCode}
 
@@ -1719,11 +1824,13 @@ const __store: Record<string, any> = {};
 export function hydrate(d: any) { if (d) for (const k of Object.keys(d)) __store[k] = d[k]; }
 
 export async function loadAllData(opts: { locale?: string; status?: "draft" | "published" } = {}) {
+  // Sem status expl\xEDcito, herda do flag de preview na URL (?preview=1 \u2192 draft).
+  const __opts = { locale: opts.locale, status: opts.status || __getStatus() };
   const raw: Record<string, any> = {};
   await Promise.all(
     __cts.map(async (c: any) => {
       try {
-        raw[c.s] = c.k === "singleType" ? await fetchSingle(c.s, opts) : await fetchCollection(c.p, opts);
+        raw[c.s] = c.k === "singleType" ? await fetchSingle(c.s, __opts) : await fetchCollection(c.p, __opts);
       } catch {
         raw[c.s] = c.k === "singleType" ? null : [];
       }
@@ -2074,8 +2181,11 @@ async function integrateFrontend(strapi, opts) {
 // server/src/controllers/frontend.ts
 var MANIFEST_NAME = "strapi.manifest.json";
 function ensureInside2(base, target) {
-  const n = import_node_path7.default.normalize(target);
-  return n === base || n.startsWith(base + import_node_path7.default.sep);
+  const b = import_node_path7.default.resolve(base);
+  const t = import_node_path7.default.resolve(target);
+  if (t === b) return true;
+  const rel = import_node_path7.default.relative(b, t);
+  return !!rel && !rel.startsWith("..") && !import_node_path7.default.isAbsolute(rel);
 }
 function toKebab(input) {
   const s = (input || "frontend").toLowerCase().replace(/\.zip$/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/^[^a-z]+/, "");
@@ -2297,6 +2407,15 @@ var baseHeaders = {
   "Content-Type": "application/json",
   Accept: "application/json, text/event-stream"
 };
+var fetchT = async (url, opts, timeoutMs = 8e3) => {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...opts, signal: ctrl.signal });
+  } finally {
+    clearTimeout(t);
+  }
+};
 var parseSse = (text) => {
   const dataLines = text.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).filter(Boolean);
   const last = dataLines[dataLines.length - 1];
@@ -2320,7 +2439,7 @@ var McpClient = class {
     return h;
   }
   async init() {
-    const res = await fetch(this.url, {
+    const res = await fetchT(this.url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify({
@@ -2336,14 +2455,14 @@ var McpClient = class {
     });
     this.sessionId = res.headers.get("mcp-session-id") || void 0;
     await res.text();
-    await fetch(this.url, {
+    await fetchT(this.url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })
     });
   }
   async rpc(method, params, id) {
-    const res = await fetch(this.url, {
+    const res = await fetchT(this.url, {
       method: "POST",
       headers: this.headers(),
       body: JSON.stringify({ jsonrpc: "2.0", id, method, params })
@@ -2458,16 +2577,19 @@ function createContentTools(strapi) {
     (ct) => ct.uid?.startsWith("api::")
   );
   const attrsOf = (uid) => strapi.contentTypes?.[uid]?.attributes || strapi.components?.[uid]?.attributes || {};
-  const buildPopulate = (attributes, seen = /* @__PURE__ */ new Set()) => {
+  const hasDraftAndPublish = (uid) => strapi.contentTypes?.[uid]?.options?.draftAndPublish === true;
+  const MAX_DEPTH = 8;
+  const buildPopulate = (attributes, seen = /* @__PURE__ */ new Set(), depth = 0) => {
+    if (depth >= MAX_DEPTH) return {};
     const populate = {};
     for (const [name, a] of Object.entries(attributes)) {
       if (a.type === "component" && a.component) {
-        const sub = seen.has(a.component) ? {} : buildPopulate(attrsOf(a.component), new Set(seen).add(a.component));
+        const sub = seen.has(a.component) ? {} : buildPopulate(attrsOf(a.component), new Set(seen).add(a.component), depth + 1);
         populate[name] = Object.keys(sub).length ? { populate: sub } : true;
       } else if (a.type === "dynamiczone") {
         const on = {};
         for (const comp of a.components || []) {
-          const sub = seen.has(comp) ? {} : buildPopulate(attrsOf(comp), new Set(seen).add(comp));
+          const sub = seen.has(comp) ? {} : buildPopulate(attrsOf(comp), new Set(seen).add(comp), depth + 1);
           on[comp] = Object.keys(sub).length ? { populate: sub } : true;
         }
         populate[name] = { on };
@@ -2479,6 +2601,7 @@ function createContentTools(strapi) {
   };
   const walkFind = (node, attributes, basePath, needle, collect) => {
     if (!node || typeof node !== "object") return;
+    if (basePath.length > 24) return;
     for (const [name, a] of Object.entries(attributes)) {
       const v = node[name];
       if (v == null) continue;
@@ -2503,11 +2626,13 @@ function createContentTools(strapi) {
       }
     }
   };
+  const MAX_MATCHES = 100;
   const buscarTexto = async (termo) => {
     const needle = String(termo || "").toLowerCase().trim();
     if (!needle) return { erro: "termo vazio" };
     const matches = [];
     for (const ct of apiContentTypes()) {
+      if (matches.length >= MAX_MATCHES) break;
       const attributes = ct.attributes || {};
       const populate = buildPopulate(attributes);
       let entries = [];
@@ -2517,6 +2642,7 @@ function createContentTools(strapi) {
       } catch {
         continue;
       }
+      const dp = hasDraftAndPublish(ct.uid);
       for (const e of entries) {
         walkFind(e, attributes, [], needle, (path9, campo, valor) => {
           matches.push({
@@ -2525,12 +2651,20 @@ function createContentTools(strapi) {
             documentId: e.documentId,
             path: path9,
             campo,
-            valor_atual: valor.length > 300 ? valor.slice(0, 300) + "\u2026" : valor
+            valor_atual: valor.length > 300 ? valor.slice(0, 300) + "\u2026" : valor,
+            // draftAndPublish=false → não há rascunho; a edição já é o conteúdo
+            // vivo e não há o que publicar (a IA deve avisar o usuário).
+            draftAndPublish: dp
           });
         });
       }
     }
-    return { total: matches.length, resultados: matches };
+    const truncated = matches.length > MAX_MATCHES;
+    return {
+      total: matches.length,
+      resultados: matches.slice(0, MAX_MATCHES),
+      ...truncated ? { truncado: true, nota: `mostrando ${MAX_MATCHES} de ${matches.length} resultados; refine o termo` } : {}
+    };
   };
   const sanitizeNode = (node, attributes) => {
     if (node == null) return node;
@@ -2572,7 +2706,7 @@ function createContentTools(strapi) {
     const loc = locale ? { locale } : {};
     if (p.length === 1 && ad && TEXTUAL.includes(ad.type)) {
       const updated2 = await strapi.documents(uid).update({ documentId, ...loc, data: { [topAttr]: novo_valor } });
-      return { ok: true, uid, documentId: updated2?.documentId || documentId, path: p, novo_valor, locale };
+      return { ok: true, uid, documentId: updated2?.documentId || documentId, path: p, novo_valor, locale, draftAndPublish: hasDraftAndPublish(uid) };
     }
     const populate = buildPopulate(attributes);
     const entry = await strapi.documents(uid).findOne({ documentId, status: "draft", ...loc, populate });
@@ -2586,13 +2720,22 @@ function createContentTools(strapi) {
     cur[p[p.length - 1]] = novo_valor;
     const data = { [topAttr]: sanitizeAttr(entry[topAttr], ad) };
     const updated = await strapi.documents(uid).update({ documentId, ...loc, data });
-    return { ok: true, uid, documentId: updated?.documentId || documentId, path: p, novo_valor, locale };
+    return { ok: true, uid, documentId: updated?.documentId || documentId, path: p, novo_valor, locale, draftAndPublish: hasDraftAndPublish(uid) };
   };
   const publicar = async ({
     uid,
     documentId,
     locale
   }) => {
+    if (!hasDraftAndPublish(uid)) {
+      return {
+        ok: true,
+        uid,
+        documentId,
+        status: "no-draft-publish",
+        nota: "Esta content-type n\xE3o tem Draft & Publish; n\xE3o h\xE1 rascunho a publicar \u2014 a altera\xE7\xE3o j\xE1 est\xE1 no ar."
+      };
+    }
     await strapi.documents(uid).publish({ documentId, ...locale ? { locale } : {} });
     return { ok: true, uid, documentId, status: "published", locale };
   };
@@ -2722,7 +2865,7 @@ function createContentTools(strapi) {
           if (!Object.keys(data).length) continue;
           await strapi.documents(ct.uid).update({ documentId: e.documentId, locale: tgt, data });
           documentos += 1;
-          if (publish) {
+          if (publish && hasDraftAndPublish(ct.uid)) {
             await strapi.documents(ct.uid).publish({ documentId: e.documentId, locale: tgt });
             publicados += 1;
           }
@@ -2779,7 +2922,7 @@ var openAiToolSpecs = [
     type: "function",
     function: {
       name: "publicar",
-      description: 'Publica a entrada (torna a altera\xE7\xE3o vis\xEDvel no site p\xFAblico). Passe "locale" para publicar um idioma espec\xEDfico, ou "*" para todos.',
+      description: 'Publica a entrada (torna a altera\xE7\xE3o vis\xEDvel no site p\xFAblico). Passe "locale" para publicar um idioma espec\xEDfico, ou "*" para todos. Se a content-type N\xC3O tiver Draft & Publish, n\xE3o h\xE1 o que publicar: retorna status "no-draft-publish" (a edi\xE7\xE3o j\xE1 est\xE1 no ar) \u2014 avise o usu\xE1rio em vez de tentar publicar de novo.',
       parameters: {
         type: "object",
         properties: {
@@ -2955,9 +3098,9 @@ Ferramentas de conte\xFAdo:
 Fluxo padr\xE3o quando o usu\xE1rio pede uma mudan\xE7a no site (por texto, voz ou mostrando a tela):
 1. Use buscar_texto com um trecho distintivo do texto a alterar (sem r\xF3tulos de status).
 2. Se houver mais de um resultado, escolha o mais prov\xE1vel pelo contexto (e diga qual escolheu); se amb\xEDguo de verdade, pergunte.
-3. editar_campo passando o mesmo uid, documentId e path do resultado, com o novo valor.
-4. publicar a entrada.
-5. Confirme em 1 frase o que foi alterado e publicado (content-type, campo, antes \u2192 depois).
+3. editar_campo passando o mesmo uid, documentId e path do resultado, com o novo valor. Isso salva como RASCUNHO (n\xE3o publica).
+4. Decida se publica ou n\xE3o conforme a POL\xCDTICA DE PUBLICA\xC7\xC3O indicada mais abaixo.
+5. Confirme em 1 frase o que foi alterado (content-type, campo, antes \u2192 depois) e se ficou como rascunho ou foi publicado.
 
 Ferramentas de tradu\xE7\xE3o / idiomas (i18n):
 - listar_locales(): mostra os idiomas configurados e o default.
@@ -2971,6 +3114,8 @@ Fluxo quando o usu\xE1rio pede tradu\xE7\xE3o (ex.: "quero o site todo em pt-BR"
 3. Ap\xF3s o restart, ao repetir, traduzir funciona e localiza tudo.
 4. Confirme em 1 frase: idiomas, quantos documentos e campos foram traduzidos/publicados (use o resumo retornado, n\xE3o despeje o conte\xFAdo).
 
+Draft & Publish: cada resultado de buscar_texto traz "draftAndPublish". Se for false, aquele tipo N\xC3O tem rascunho no Strapi \u2014 a edi\xE7\xE3o j\xE1 \xE9 o conte\xFAdo vivo e N\xC3O h\xE1 o que publicar; nesse caso, ao confirmar, avise que "esse conte\xFAdo n\xE3o tem rascunho, a altera\xE7\xE3o j\xE1 est\xE1 no ar" e N\xC3O chame publicar.
+
 Se o usu\xE1rio compartilhar a tela, uma imagem \xE9 anexada \xE0 \xFAltima mensagem \u2014 use-a para entender exatamente o que ele est\xE1 vendo e qual texto quer trocar.
 
 Seja objetivo e acion\xE1vel. Responda SEMPRE em portugu\xEAs.`,
@@ -2984,9 +3129,9 @@ Content tools:
 Default flow when the user asks for a site change (by text, voice or by showing their screen):
 1. Use buscar_texto with a distinctive snippet of the text to change (no status labels).
 2. If there is more than one result, pick the most likely from context (and say which); if truly ambiguous, ask.
-3. editar_campo passing the same uid, documentId and path from the result, with the new value.
-4. publicar the entry.
-5. Confirm in one sentence what was changed and published (content-type, field, before \u2192 after).
+3. editar_campo passing the same uid, documentId and path from the result, with the new value. This saves a DRAFT (does not publish).
+4. Decide whether to publish based on the PUBLISH POLICY stated below.
+5. Confirm in one sentence what was changed (content-type, field, before \u2192 after) and whether it stayed a draft or was published.
 
 Translation / language tools (i18n):
 - listar_locales(): shows configured languages and the default.
@@ -3000,12 +3145,14 @@ Flow when the user asks for translation (e.g. "I want the whole site in pt-BR"):
 3. After the restart, repeating the request makes traduzir localize everything.
 4. Confirm in one sentence: languages, how many documents and fields were translated/published (use the returned summary, don't dump the content).
 
+Draft & Publish: each buscar_texto result includes "draftAndPublish". If it is false, that type has NO draft in Strapi \u2014 the edit IS the live content and there is nothing to publish; in that case, when confirming, warn that "this content has no draft, the change is already live" and do NOT call publicar.
+
 If the user shares their screen, an image is attached to the last message \u2014 use it to understand exactly what they see and which text they want to change.
 
 Be concise and actionable. ALWAYS answer in English.`
 };
 var chat_default2 = ({ strapi }) => ({
-  async chat({ messages, image, lang = "pt", previewUrl }) {
+  async chat({ messages, image, lang = "pt", previewUrl, autoPublish = false }) {
     const apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) {
       throw new Error(
@@ -3029,7 +3176,10 @@ var chat_default2 = ({ strapi }) => ({
     if (process.env.PLAYWRIGHT_MCP_URL) {
       try {
         const client = new McpClient(process.env.PLAYWRIGHT_MCP_URL, "playwright");
-        await client.init();
+        await Promise.race([
+          client.init(),
+          new Promise((_, rej) => setTimeout(() => rej(new Error("timeout")), 4e3))
+        ]);
         const list = await client.listTools();
         for (const t of list) {
           if (mcpByTool[t.name]) continue;
@@ -3062,7 +3212,19 @@ Voc\xEA tamb\xE9m controla um navegador real via ferramentas browser_* (Playwrig
 
 You also control a real browser via browser_* tools (Playwright), pointed at the STRAPI ADMIN at ${adminBase} (the backend \u2014 this is where content actually changes, NOT the public site). You can navigate (browser_navigate), click, type, scroll, take your own screenshots (browser_take_screenshot) and inspect console/errors. Always prefer your direct tools (buscar_texto/editar_campo/publicar) to change content; use the browser to VERIFY in the admin that the edit/publish landed, or for admin UI flows the direct tools don't cover.`
     };
-    const systemContent = SYSTEM[language] + (hasBrowser ? BROWSER_NOTE[language] : "");
+    const PUBLISH_POLICY = {
+      pt: autoPublish ? `
+
+POL\xCDTICA DE PUBLICA\xC7\xC3O: AUTO-PUBLICAR est\xE1 LIGADO. Depois de editar_campo, chame publicar para deixar a mudan\xE7a no ar. Em traduzir, use publish:true (default).` : `
+
+POL\xCDTICA DE PUBLICA\xC7\xC3O: MODO RASCUNHO (auto-publicar DESLIGADO). N\xC3O chame publicar a menos que o usu\xE1rio pe\xE7a explicitamente ("publica", "p\xF5e no ar", "publish"). Depois de editar_campo, PARE e avise que a altera\xE7\xE3o foi salva como RASCUNHO para revis\xE3o (ela j\xE1 aparece no preview em modo rascunho, mas ainda n\xE3o no site p\xFAblico). Em traduzir, passe publish:false. Se o usu\xE1rio pedir para publicar, a\xED sim use publicar (ou traduzir com publish:true).`,
+      en: autoPublish ? `
+
+PUBLISH POLICY: AUTO-PUBLISH is ON. After editar_campo, call publicar to make the change live. For traduzir, use publish:true (default).` : `
+
+PUBLISH POLICY: DRAFT MODE (auto-publish OFF). Do NOT call publicar unless the user explicitly asks ("publish", "make it live", "publica"). After editar_campo, STOP and tell them the change was saved as a DRAFT for review (it already shows in the preview when in draft mode, but not on the public site yet). For traduzir, pass publish:false. If the user asks to publish, then use publicar (or traduzir with publish:true).`
+    };
+    const systemContent = SYSTEM[language] + (hasBrowser ? BROWSER_NOTE[language] : "") + PUBLISH_POLICY[language];
     const convo = [{ role: "system", content: systemContent }];
     const pageNote = previewUrl ? language === "en" ? `
 
@@ -3089,11 +3251,22 @@ You also control a real browser via browser_* tools (Playwright), pointed at the
       }
     });
     const callOpenAI = async (body) => {
-      const res = await fetch(OPENAI_URL4, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-      });
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), 6e4);
+      let res;
+      try {
+        res = await fetch(OPENAI_URL4, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: ctrl.signal
+        });
+      } catch (e) {
+        if (e?.name === "AbortError") throw new Error("OpenAI chat: tempo limite excedido (60s).");
+        throw e;
+      } finally {
+        clearTimeout(timer);
+      }
       if (!res.ok) throw new Error(`OpenAI chat: ${await res.text()}`);
       return res.json();
     };
@@ -3132,6 +3305,11 @@ You also control a real browser via browser_* tools (Playwright), pointed at the
           } catch (e) {
             content = `Erro ao chamar a tool ${name}: ${e?.message || e}`;
           }
+          const MAX_TOOL_CHARS = 12e3;
+          if (content.length > MAX_TOOL_CHARS) {
+            content = content.slice(0, MAX_TOOL_CHARS) + `
+\u2026[resultado truncado: ${content.length} chars]`;
+          }
           convo.push({ role: "tool", tool_call_id: call.id, content });
         }
         continue;
@@ -3255,196 +3433,166 @@ var routes_default = {
 
 // server/src/mcp/tools/buscar-texto.ts
 var import_utils2 = require("@strapi/utils");
-var tool = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_buscar_texto",
-      title: "Search text across content (deep)",
-      description: 'Search a phrase across ALL content-types, single types, components and dynamic zones (recursive, substring). Returns matches with a `path` (e.g. ["dynamic_zone",2,"heading"]) to pass to mcp_chat_editar_campo.',
-      resolveInputSchema: () => import_utils2.z.object({ termo: import_utils2.z.string() }),
-      resolveOutputSchema: () => import_utils2.z.object({
-        total: import_utils2.z.number().optional(),
-        resultados: import_utils2.z.array(import_utils2.z.any()).optional(),
-        erro: import_utils2.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).buscarTexto(args?.termo);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+
+// server/src/mcp/define.ts
+var defineTool = (def) => def;
+
+// server/src/mcp/tools/buscar-texto.ts
+var buscar_texto_default = defineTool({
+  name: "mcp_chat_buscar_texto",
+  title: "Search text across content (deep)",
+  description: 'Search a phrase across ALL content-types, single types, components and dynamic zones (recursive, substring). Returns matches with a `path` (e.g. ["dynamic_zone",2,"heading"]) to pass to mcp_chat_editar_campo.',
+  resolveInputSchema: () => import_utils2.z.object({ termo: import_utils2.z.string() }),
+  resolveOutputSchema: () => import_utils2.z.object({
+    total: import_utils2.z.number().optional(),
+    resultados: import_utils2.z.array(import_utils2.z.any()).optional(),
+    erro: import_utils2.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).buscarTexto(args.termo);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var buscar_texto_default = tool;
+});
 
 // server/src/mcp/tools/editar-campo.ts
 var import_utils3 = require("@strapi/utils");
-var tool2 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_editar_campo",
-      title: "Edit a (possibly nested) field",
-      description: "Edit a field value (saved as draft), including text nested in components/dynamic zones. Pass the `path` exactly as returned by mcp_chat_buscar_texto; for a simple top-level field you may use `campo`.",
-      resolveInputSchema: () => import_utils3.z.object({
-        uid: import_utils3.z.string(),
-        documentId: import_utils3.z.string(),
-        path: import_utils3.z.array(import_utils3.z.union([import_utils3.z.string(), import_utils3.z.number()])).optional(),
-        campo: import_utils3.z.string().optional(),
-        novo_valor: import_utils3.z.string(),
-        locale: import_utils3.z.string().optional()
-      }),
-      resolveOutputSchema: () => import_utils3.z.object({
-        ok: import_utils3.z.boolean().optional(),
-        uid: import_utils3.z.string().optional(),
-        documentId: import_utils3.z.string().optional(),
-        path: import_utils3.z.array(import_utils3.z.any()).optional(),
-        novo_valor: import_utils3.z.string().optional(),
-        erro: import_utils3.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).editarCampo(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var editar_campo_default = defineTool({
+  name: "mcp_chat_editar_campo",
+  title: "Edit a (possibly nested) field",
+  description: "Edit a field value (saved as draft), including text nested in components/dynamic zones. Pass the `path` exactly as returned by mcp_chat_buscar_texto; for a simple top-level field you may use `campo`.",
+  resolveInputSchema: () => import_utils3.z.object({
+    uid: import_utils3.z.string(),
+    documentId: import_utils3.z.string(),
+    path: import_utils3.z.array(import_utils3.z.union([import_utils3.z.string(), import_utils3.z.number()])).optional(),
+    campo: import_utils3.z.string().optional(),
+    novo_valor: import_utils3.z.string(),
+    locale: import_utils3.z.string().optional()
+  }),
+  resolveOutputSchema: () => import_utils3.z.object({
+    ok: import_utils3.z.boolean().optional(),
+    uid: import_utils3.z.string().optional(),
+    documentId: import_utils3.z.string().optional(),
+    path: import_utils3.z.array(import_utils3.z.any()).optional(),
+    novo_valor: import_utils3.z.string().optional(),
+    erro: import_utils3.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).editarCampo(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var editar_campo_default = tool2;
+});
 
 // server/src/mcp/tools/publicar.ts
 var import_utils4 = require("@strapi/utils");
-var tool3 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_publicar",
-      title: "Publish an entry",
-      description: 'Publish an entry by uid + documentId, making the change visible on the site. Pass `locale` to publish a specific language, or "*" for all.',
-      resolveInputSchema: () => import_utils4.z.object({ uid: import_utils4.z.string(), documentId: import_utils4.z.string(), locale: import_utils4.z.string().optional() }),
-      resolveOutputSchema: () => import_utils4.z.object({
-        ok: import_utils4.z.boolean().optional(),
-        uid: import_utils4.z.string().optional(),
-        documentId: import_utils4.z.string().optional(),
-        status: import_utils4.z.string().optional(),
-        locale: import_utils4.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.publish" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).publicar(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var publicar_default = defineTool({
+  name: "mcp_chat_publicar",
+  title: "Publish an entry",
+  description: 'Publish an entry by uid + documentId, making the change visible on the site. Pass `locale` to publish a specific language, or "*" for all. For content-types without Draft & Publish there is nothing to publish (returns status "no-draft-publish") \u2014 the edit is already live.',
+  resolveInputSchema: () => import_utils4.z.object({ uid: import_utils4.z.string(), documentId: import_utils4.z.string(), locale: import_utils4.z.string().optional() }),
+  resolveOutputSchema: () => import_utils4.z.object({
+    ok: import_utils4.z.boolean().optional(),
+    uid: import_utils4.z.string().optional(),
+    documentId: import_utils4.z.string().optional(),
+    status: import_utils4.z.string().optional(),
+    locale: import_utils4.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.publish" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).publicar(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var publicar_default = tool3;
+});
 
 // server/src/mcp/tools/listar-locales.ts
 var import_utils5 = require("@strapi/utils");
-var tool4 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_listar_locales",
-      title: "List i18n locales",
-      description: "List the configured locales (languages) and which one is the default.",
-      resolveInputSchema: () => import_utils5.z.object({}),
-      resolveOutputSchema: () => import_utils5.z.object({
-        default: import_utils5.z.string().optional(),
-        locales: import_utils5.z.array(import_utils5.z.any()).optional(),
-        erro: import_utils5.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
-      createHandler: (strapi) => async () => {
-        const r = await createContentTools(strapi).listarLocales();
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var listar_locales_default = defineTool({
+  name: "mcp_chat_listar_locales",
+  title: "List i18n locales",
+  description: "List the configured locales (languages) and which one is the default.",
+  resolveInputSchema: () => import_utils5.z.object({}),
+  resolveOutputSchema: () => import_utils5.z.object({
+    default: import_utils5.z.string().optional(),
+    locales: import_utils5.z.array(import_utils5.z.any()).optional(),
+    erro: import_utils5.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.read" }] },
+  createHandler: (strapi) => async () => {
+    const r = await createContentTools(strapi).listarLocales();
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var listar_locales_default = tool4;
+});
 
 // server/src/mcp/tools/criar-locale.ts
 var import_utils6 = require("@strapi/utils");
-var tool5 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_criar_locale",
-      title: "Create an i18n locale",
-      description: 'Create a locale (language). `code` must be a valid ISO code (e.g. "pt-BR", "es"). Idempotent: returns ok if it already exists.',
-      resolveInputSchema: () => import_utils6.z.object({ code: import_utils6.z.string(), name: import_utils6.z.string().optional() }),
-      resolveOutputSchema: () => import_utils6.z.object({
-        ok: import_utils6.z.boolean().optional(),
-        code: import_utils6.z.string().optional(),
-        name: import_utils6.z.string().optional(),
-        existed: import_utils6.z.boolean().optional(),
-        erro: import_utils6.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::i18n.locale.create" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).criarLocale(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var criar_locale_default = defineTool({
+  name: "mcp_chat_criar_locale",
+  title: "Create an i18n locale",
+  description: 'Create a locale (language). `code` must be a valid ISO code (e.g. "pt-BR", "es"). Idempotent: returns ok if it already exists.',
+  resolveInputSchema: () => import_utils6.z.object({ code: import_utils6.z.string(), name: import_utils6.z.string().optional() }),
+  resolveOutputSchema: () => import_utils6.z.object({
+    ok: import_utils6.z.boolean().optional(),
+    code: import_utils6.z.string().optional(),
+    name: import_utils6.z.string().optional(),
+    existed: import_utils6.z.boolean().optional(),
+    erro: import_utils6.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::i18n.locale.create" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).criarLocale(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var criar_locale_default = tool5;
+});
 
 // server/src/mcp/tools/traduzir.ts
 var import_utils7 = require("@strapi/utils");
-var tool6 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_traduzir",
-      title: "Translate localized content",
-      description: "Translate localized content into one or more languages. Creates missing locales, translates field by field (long text is split and reassembled, never overflows) and publishes. Without uid/documentId, translates ALL localized content-types. Handles many locales at once.",
-      resolveInputSchema: () => import_utils7.z.object({
-        target_locales: import_utils7.z.array(import_utils7.z.string()).min(1),
-        source_locale: import_utils7.z.string().optional(),
-        uid: import_utils7.z.string().optional(),
-        documentId: import_utils7.z.string().optional(),
-        publish: import_utils7.z.boolean().optional()
-      }),
-      resolveOutputSchema: () => import_utils7.z.object({
-        ok: import_utils7.z.boolean().optional(),
-        source: import_utils7.z.string().optional(),
-        por_locale: import_utils7.z.array(import_utils7.z.any()).optional(),
-        erro: import_utils7.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = await createContentTools(strapi).traduzir(args);
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var traduzir_default = defineTool({
+  name: "mcp_chat_traduzir",
+  title: "Translate localized content",
+  description: "Translate localized content into one or more languages. Creates missing locales, translates field by field (long text is split and reassembled, never overflows) and publishes (only on content-types with Draft & Publish). Without uid/documentId, translates ALL localized content-types. Handles many locales at once.",
+  resolveInputSchema: () => import_utils7.z.object({
+    target_locales: import_utils7.z.array(import_utils7.z.string()).min(1),
+    source_locale: import_utils7.z.string().optional(),
+    uid: import_utils7.z.string().optional(),
+    documentId: import_utils7.z.string().optional(),
+    publish: import_utils7.z.boolean().optional()
+  }),
+  resolveOutputSchema: () => import_utils7.z.object({
+    ok: import_utils7.z.boolean().optional(),
+    source: import_utils7.z.string().optional(),
+    por_locale: import_utils7.z.array(import_utils7.z.any()).optional(),
+    erro: import_utils7.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-manager.explorer.update" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = await createContentTools(strapi).traduzir(args);
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var traduzir_default = tool6;
+});
 
 // server/src/mcp/tools/habilitar-i18n.ts
 var import_utils8 = require("@strapi/utils");
-var tool7 = {
-  register(registerTool) {
-    registerTool({
-      name: "mcp_chat_habilitar_i18n",
-      title: "Enable i18n on a content-type",
-      description: 'Enable translation on content-types not localized yet: marks the content-type and its textual fields/components as localized. Required before translating content provisioned without i18n. Omit `uid` (or pass "*") to enable ALL content-types at once. Edits the schema (dev-only); Strapi restarts.',
-      resolveInputSchema: () => import_utils8.z.object({ uid: import_utils8.z.string().optional(), campos: import_utils8.z.array(import_utils8.z.string()).optional() }),
-      resolveOutputSchema: () => import_utils8.z.object({
-        ok: import_utils8.z.boolean().optional(),
-        uid: import_utils8.z.string().optional(),
-        campos: import_utils8.z.array(import_utils8.z.string()).optional(),
-        contentTypes: import_utils8.z.array(import_utils8.z.any()).optional(),
-        total: import_utils8.z.number().optional(),
-        restart: import_utils8.z.boolean().optional(),
-        erro: import_utils8.z.string().optional()
-      }),
-      auth: { policies: [{ action: "plugin::content-type-builder.read" }] },
-      createHandler: (strapi) => async ({ args }) => {
-        const r = enableI18n({ strapi, uid: args?.uid, campos: args?.campos });
-        return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
-      }
-    });
+var habilitar_i18n_default = defineTool({
+  name: "mcp_chat_habilitar_i18n",
+  title: "Enable i18n on a content-type",
+  description: 'Enable translation on content-types not localized yet: marks the content-type and its textual fields/components as localized. Required before translating content provisioned without i18n. Omit `uid` (or pass "*") to enable ALL content-types at once. Edits the schema (dev-only); Strapi restarts.',
+  resolveInputSchema: () => import_utils8.z.object({ uid: import_utils8.z.string().optional(), campos: import_utils8.z.array(import_utils8.z.string()).optional() }),
+  resolveOutputSchema: () => import_utils8.z.object({
+    ok: import_utils8.z.boolean().optional(),
+    uid: import_utils8.z.string().optional(),
+    campos: import_utils8.z.array(import_utils8.z.string()).optional(),
+    contentTypes: import_utils8.z.array(import_utils8.z.any()).optional(),
+    total: import_utils8.z.number().optional(),
+    restart: import_utils8.z.boolean().optional(),
+    erro: import_utils8.z.string().optional()
+  }),
+  auth: { policies: [{ action: "plugin::content-type-builder.read" }] },
+  createHandler: (strapi) => async ({ args }) => {
+    const r = enableI18n({ strapi, uid: args.uid, campos: args.campos });
+    return { content: [{ type: "text", text: JSON.stringify(r) }], structuredContent: r };
   }
-};
-var habilitar_i18n_default = tool7;
+});
 
 // server/src/mcp/tools/index.ts
 var tools = [
@@ -3467,9 +3615,16 @@ var registerMcpTools = (strapi) => {
     );
     return;
   }
-  const { registerTool } = mcp;
-  for (const tool8 of tools) tool8.register(registerTool, strapi);
-  strapi.log.info(`[mcp-chat] ${tools.length} tools registradas no MCP nativo (mcp_chat_*).`);
+  let registered = 0;
+  for (const tool of tools) {
+    try {
+      mcp.registerTool(tool);
+      registered += 1;
+    } catch (e) {
+      strapi.log.warn(`[mcp-chat] tool "${tool?.name}" falhou ao registrar: ${e?.message ?? e}`);
+    }
+  }
+  strapi.log.info(`[mcp-chat] ${registered}/${tools.length} tools registradas no MCP nativo (mcp_chat_*).`);
 };
 
 // server/src/register.ts
@@ -3498,7 +3653,10 @@ var index_default = {
     }
   },
   destroy() {
-    stopFrontend();
+    try {
+      stopFrontend();
+    } catch {
+    }
   },
   config: {
     default: {},