strapi-plugin-mcp-chat 0.3.1 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-mcp-chat",
-  "version": "0.3.1",
+  "version": "0.6.0",
   "description": "AI chat inside the Strapi 5 admin that reads and edits your content (incl. components & dynamic zones) via MCP, with voice and a side-by-side live preview.",
   "keywords": [
     "strapi",

package/server/src/content-tools.ts

@@ -45,20 +45,24 @@ export function createContentTools(strapi: any) {
 
   // Populate profundo: components (simples/repetíveis), dynamic zones (com `on`
   // por componente) e mídia/relações. `seen` evita recursão infinita.
-  const buildPopulate = (attributes: Record<string, any>, seen = new Set<string>()): any => {
+  // `seen` evita ciclos (componente que se referencia) e `depth` é um teto rígido
+  // contra schemas patológicos (recursão profunda → stack/memória).
+  const MAX_DEPTH = 8;
+  const buildPopulate = (attributes: Record<string, any>, seen = new Set<string>(), depth = 0): any => {
+    if (depth >= MAX_DEPTH) return {};
     const populate: any = {};
     for (const [name, a] of Object.entries(attributes) as any[]) {
       if (a.type === 'component' && a.component) {
         const sub = seen.has(a.component)
           ? {}
-          : buildPopulate(attrsOf(a.component), new Set(seen).add(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: any = {};
         for (const comp of a.components || []) {
           const sub = seen.has(comp)
             ? {}
-            : buildPopulate(attrsOf(comp), new Set(seen).add(comp));
+            : buildPopulate(attrsOf(comp), new Set(seen).add(comp), depth + 1);
           on[comp] = Object.keys(sub).length ? { populate: sub } : true;
         }
         populate[name] = { on };
@@ -77,6 +81,7 @@ export function createContentTools(strapi: any) {
     collect: (path: (string | number)[], campo: string, valor: string) => void
   ) => {
     if (!node || typeof node !== 'object') return;
+    if (basePath.length > 24) return; // teto rígido contra recursão patológica
     for (const [name, a] of Object.entries(attributes) as any[]) {
       const v = node[name];
       if (v == null) continue;
@@ -102,18 +107,22 @@ export function createContentTools(strapi: any) {
     }
   };
 
-  const buscarTexto = async (termo: string) => {
+  const MAX_MATCHES = 100;
+  const buscarTexto = async (termo: string, status: 'draft' | 'published' = 'draft') => {
     const needle = String(termo || '').toLowerCase().trim();
     if (!needle) return { erro: 'termo vazio' };
+    // segue o modo do preview: 'draft' busca rascunhos, 'published' busca o que está no ar.
+    const st: 'draft' | 'published' = status === 'published' ? 'published' : 'draft';
     const matches: any[] = [];
     for (const ct of apiContentTypes() as any[]) {
+      if (matches.length >= MAX_MATCHES) break; // teto: não varre além do necessário
       const attributes = ct.attributes || {};
       const populate = buildPopulate(attributes);
       let entries: any[] = [];
       try {
         const res = await strapi
           .documents(ct.uid)
-          .findMany({ status: 'draft', populate, limit: 200 });
+          .findMany({ status: st, populate, limit: 200 });
         entries = Array.isArray(res) ? res : res ? [res] : [];
       } catch {
         continue;
@@ -135,7 +144,12 @@ export function createContentTools(strapi: any) {
         });
       }
     }
-    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` } : {}),
+    };
   };
 
   // Converte um nó populado de volta a forma gravável: preserva `id` (p/ Strapi

package/server/src/controllers/chat.ts

@@ -4,7 +4,7 @@
 
 export default ({ strapi }: { strapi: any }) => ({
   async message(ctx: any) {
-    const { messages, image, lang, previewUrl, autoPublish } = ctx.request.body || {};
+    const { messages, image, lang, previewUrl, previewStatus, autoPublish } = ctx.request.body || {};
     if (!Array.isArray(messages) || messages.length === 0) {
       return ctx.badRequest('Campo "messages" (array) é obrigatório.');
     }
@@ -12,7 +12,7 @@ export default ({ strapi }: { strapi: any }) => ({
       const result = await strapi
         .plugin('mcp-chat')
         .service('chat')
-        .chat({ messages, image, lang, previewUrl, autoPublish });
+        .chat({ messages, image, lang, previewUrl, previewStatus, autoPublish });
       ctx.body = result;
     } catch (e: any) {
       strapi.log.error(`[mcp-chat] ${e?.message || e}`);

package/server/src/controllers/frontend.ts

@@ -26,8 +26,13 @@ import type { LinkContext } from '../provision/adapters';
 const MANIFEST_NAME = 'strapi.manifest.json';
 
 function ensureInside(base: string, target: string): boolean {
-  const n = path.normalize(target);
-  return n === base || n.startsWith(base + path.sep);
+  // Resolve ambos para absoluto e compara via path.relative — robusto contra
+  // "..", separadores mistos e zip-slip (entrada do zip não pode escapar da pasta).
+  const b = path.resolve(base);
+  const t = path.resolve(target);
+  if (t === b) return true;
+  const rel = path.relative(b, t);
+  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
 }
 
 /** normaliza um nome livre para o formato kebab exigido pelo manifest. */

package/server/src/index.ts

@@ -10,11 +10,18 @@ import audioService from './services/audio';
 import routes from './routes';
 import register from './register';
 import { runPendingProvision } from './provision/orchestrate';
-import { stopFrontend } from './provision/runner';
+import { stopFrontend, cleanupStaleFrontend } from './provision/runner';
 
 export default {
   register,
   async bootstrap({ strapi }: { strapi: any }) {
+    // Limpa qualquer dev server do front que tenha sobrado de uma execução
+    // anterior (crash/SIGKILL não roda o destroy). Garante "limpar ao desligar"
+    // mesmo em shutdown sujo e evita o EADDRINUSE no próximo Preview.
+    try {
+      cleanupStaleFrontend(strapi.dirs.app.root);
+    } catch { /* best-effort */ }
+
     // Após um restart causado por um upload de frontend, conclui a provisão:
     // semeia o conteúdo e liga o preview. Idempotente (no-op se não há pendência).
     try {
@@ -31,7 +38,12 @@ export default {
   },
   destroy() {
     // encerra o dev server do frontend (se foi iniciado pelo preview).
-    stopFrontend();
+    // Nunca deixa o shutdown do Strapi falhar por causa disto.
+    try {
+      stopFrontend();
+    } catch {
+      /* shutdown best-effort */
+    }
   },
   config: {
     default: {},

package/server/src/mcp/define.ts

@@ -0,0 +1,72 @@
+/**
+ * Identity functions para DEFINIR capacidades MCP (tools/resources/prompts) com
+ * inferência de tipos, desacopladas do registro — espelhando a direção do PR
+ * #26603 do Strapi (`ai.mcp.defineTool` / `defineResource` / `definePrompt` +
+ * o namespace `import { ai } from "@strapi/strapi"`).
+ *
+ * Hoje o MCP nativo (Strapi >= 5.47) expõe `strapi.ai.mcp.registerTool`. Estes
+ * wrappers locais dão a inferência dos `args` do handler a partir do schema de
+ * input AGORA (acaba com o `any`), e mantêm cada tool como uma DEFINIÇÃO pura,
+ * registrada a partir de um array (sem side-effects na definição). Quando o
+ * `ai.mcp.defineTool` estável sair, migrar é trocar o import destes helpers por
+ * `import { ai } from "@strapi/strapi"` — as definições não mudam.
+ *
+ * Nota (decisão consciente): NÃO dependemos do build experimental do PR (a API
+ * ainda está em debate — namespace global vs DI, `@strapi/ai` como pacote
+ * próprio, etc.). Ficamos prontos-pra-migrar em vez de acoplados ao instável.
+ */
+import type { z } from '@strapi/utils';
+
+/** Resultado padrão de um handler de tool MCP. */
+export type McpToolResult = {
+  content: Array<{ type: string; text?: string; [k: string]: any }>;
+  structuredContent?: any;
+};
+
+/** Autorização declarativa (mesma forma aceita pelo MCP nativo). */
+export type McpAuth = { policies?: Array<{ action: string; [k: string]: any }> };
+
+/** Definição de uma tool MCP, com `args` do handler inferidos do input schema. */
+export type McpToolDef<S extends z.ZodTypeAny = z.ZodTypeAny> = {
+  name: string;
+  title?: string;
+  description?: string;
+  resolveInputSchema: () => S;
+  resolveOutputSchema?: () => z.ZodTypeAny;
+  auth?: McpAuth;
+  createHandler: (
+    strapi: any
+  ) => (ctx: { args: z.infer<S> }) => Promise<McpToolResult> | McpToolResult;
+};
+
+/**
+ * Identity function: devolve a definição inalterada, mas infere o genérico `S`
+ * do `resolveInputSchema`, tipando `ctx.args` no handler (sem `any`).
+ */
+export const defineTool = <S extends z.ZodTypeAny>(def: McpToolDef<S>): McpToolDef<S> => def;
+
+// ── Resources / Prompts (alinhamento completo com o PR; ainda não usados) ──────
+export type McpResourceDef = {
+  name: string;
+  uri: string;
+  title?: string;
+  description?: string;
+  mimeType?: string;
+  devModeOnly?: boolean;
+  auth?: McpAuth;
+  createHandler: (strapi: any) => (ctx: any) => Promise<any> | any;
+};
+export const defineResource = (def: McpResourceDef): McpResourceDef => def;
+
+export type McpPromptDef<S extends z.ZodTypeAny = z.ZodTypeAny> = {
+  name: string;
+  title?: string;
+  description?: string;
+  resolveArgsSchema?: () => S;
+  devModeOnly?: boolean;
+  createHandler: (strapi: any) => (ctx: { args: z.infer<S> }) => Promise<any> | any;
+};
+export const definePrompt = <S extends z.ZodTypeAny>(def: McpPromptDef<S>): McpPromptDef<S> => def;
+
+/** Assinatura do `registerTool` do MCP nativo (aceita uma McpToolDef). */
+export type RegisterTool = (def: McpToolDef<any>) => void;

package/server/src/mcp/index.ts

@@ -1,8 +1,12 @@
 /**
  * Registra as tools de conteúdo do plugin no MCP server NATIVO da Strapi
- * (>= 5.47.0). Estrutura modular inspirada no padrão do exemplo do Paul
- * Bratslavsky: cada tool é um módulo em ./tools/*, agregado em ./tools/index.ts,
- * e aqui passamos por um loop chamando `tool.register(registerTool, strapi)`.
+ * (>= 5.47.0). Cada tool é uma DEFINIÇÃO pura (`defineTool`, em ./tools/*),
+ * agregada em ./tools/index.ts; aqui só percorremos o array chamando
+ * `mcp.registerTool(def)` (padrão "define + register-from-array").
+ *
+ * Alinhado à direção do PR #26603 (`ai.mcp.defineTool`): quando o helper
+ * estável sair, troca-se o import de `./define` por `import { ai } from
+ * "@strapi/strapi"` — as definições não mudam. Ver server/src/mcp/define.ts.
  *
  * Deve rodar no `register()` do plugin, ANTES de o MCP server iniciar.
  */
@@ -18,7 +22,16 @@ export const registerMcpTools = (strapi: any) => {
     );
     return;
   }
-  const { registerTool } = mcp;
-  for (const tool of tools) tool.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) {
+    // Isola cada tool: uma definição com problema NUNCA aborta o registro das
+    // demais nem o boot do Strapi.
+    try {
+      mcp.registerTool(tool);
+      registered += 1;
+    } catch (e: any) {
+      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_*).`);
 };

package/server/src/mcp/tools/buscar-texto.ts

@@ -1,28 +1,22 @@
 import { z } from '@strapi/utils';
-import type { StrapiMcpToolModule } from '../types';
+import { defineTool } from '../define';
 import { createContentTools } from '../../content-tools';
 
-const tool: StrapiMcpToolModule = {
-  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: () => z.object({ termo: z.string() }),
-      resolveOutputSchema: () =>
-        z.object({
-          total: z.number().optional(),
-          resultados: z.array(z.any()).optional(),
-          erro: z.string().optional(),
-        }),
-      auth: { policies: [{ action: 'plugin::content-manager.explorer.read' }] },
-      createHandler: (strapi: any) => async ({ args }: any) => {
-        const r = await createContentTools(strapi).buscarTexto(args?.termo);
-        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
-      },
-    });
+export 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: () => z.object({ termo: z.string() }),
+  resolveOutputSchema: () =>
+    z.object({
+      total: z.number().optional(),
+      resultados: z.array(z.any()).optional(),
+      erro: z.string().optional(),
+    }),
+  auth: { policies: [{ action: 'plugin::content-manager.explorer.read' }] },
+  createHandler: (strapi: any) => async ({ args }) => {
+    const r = await createContentTools(strapi).buscarTexto(args.termo);
+    return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
   },
-};
-
-export default tool;
+});

package/server/src/mcp/tools/criar-locale.ts

@@ -1,30 +1,24 @@
 import { z } from '@strapi/utils';
-import type { StrapiMcpToolModule } from '../types';
+import { defineTool } from '../define';
 import { createContentTools } from '../../content-tools';
 
-const tool: StrapiMcpToolModule = {
-  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: () => z.object({ code: z.string(), name: z.string().optional() }),
-      resolveOutputSchema: () =>
-        z.object({
-          ok: z.boolean().optional(),
-          code: z.string().optional(),
-          name: z.string().optional(),
-          existed: z.boolean().optional(),
-          erro: z.string().optional(),
-        }),
-      auth: { policies: [{ action: 'plugin::i18n.locale.create' }] },
-      createHandler: (strapi: any) => async ({ args }: any) => {
-        const r = await createContentTools(strapi).criarLocale(args);
-        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
-      },
-    });
+export 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: () => z.object({ code: z.string(), name: z.string().optional() }),
+  resolveOutputSchema: () =>
+    z.object({
+      ok: z.boolean().optional(),
+      code: z.string().optional(),
+      name: z.string().optional(),
+      existed: z.boolean().optional(),
+      erro: z.string().optional(),
+    }),
+  auth: { policies: [{ action: 'plugin::i18n.locale.create' }] },
+  createHandler: (strapi: any) => async ({ args }) => {
+    const r = await createContentTools(strapi).criarLocale(args);
+    return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
   },
-};
-
-export default tool;
+});

package/server/src/mcp/tools/editar-campo.ts

@@ -1,39 +1,33 @@
 import { z } from '@strapi/utils';
-import type { StrapiMcpToolModule } from '../types';
+import { defineTool } from '../define';
 import { createContentTools } from '../../content-tools';
 
-const tool: StrapiMcpToolModule = {
-  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: () =>
-        z.object({
-          uid: z.string(),
-          documentId: z.string(),
-          path: z.array(z.union([z.string(), z.number()])).optional(),
-          campo: z.string().optional(),
-          novo_valor: z.string(),
-          locale: z.string().optional(),
-        }),
-      resolveOutputSchema: () =>
-        z.object({
-          ok: z.boolean().optional(),
-          uid: z.string().optional(),
-          documentId: z.string().optional(),
-          path: z.array(z.any()).optional(),
-          novo_valor: z.string().optional(),
-          erro: z.string().optional(),
-        }),
-      auth: { policies: [{ action: 'plugin::content-manager.explorer.update' }] },
-      createHandler: (strapi: any) => async ({ args }: any) => {
-        const r = await createContentTools(strapi).editarCampo(args);
-        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
-      },
-    });
+export 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: () =>
+    z.object({
+      uid: z.string(),
+      documentId: z.string(),
+      path: z.array(z.union([z.string(), z.number()])).optional(),
+      campo: z.string().optional(),
+      novo_valor: z.string(),
+      locale: z.string().optional(),
+    }),
+  resolveOutputSchema: () =>
+    z.object({
+      ok: z.boolean().optional(),
+      uid: z.string().optional(),
+      documentId: z.string().optional(),
+      path: z.array(z.any()).optional(),
+      novo_valor: z.string().optional(),
+      erro: z.string().optional(),
+    }),
+  auth: { policies: [{ action: 'plugin::content-manager.explorer.update' }] },
+  createHandler: (strapi: any) => async ({ args }) => {
+    const r = await createContentTools(strapi).editarCampo(args);
+    return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
   },
-};
-
-export default tool;
+});

package/server/src/mcp/tools/habilitar-i18n.ts

@@ -1,33 +1,27 @@
 import { z } from '@strapi/utils';
-import type { StrapiMcpToolModule } from '../types';
+import { defineTool } from '../define';
 import { enableI18n } from '../../provision/enable-i18n';
 
-const tool: StrapiMcpToolModule = {
-  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: () =>
-        z.object({ uid: z.string().optional(), campos: z.array(z.string()).optional() }),
-      resolveOutputSchema: () =>
-        z.object({
-          ok: z.boolean().optional(),
-          uid: z.string().optional(),
-          campos: z.array(z.string()).optional(),
-          contentTypes: z.array(z.any()).optional(),
-          total: z.number().optional(),
-          restart: z.boolean().optional(),
-          erro: z.string().optional(),
-        }),
-      auth: { policies: [{ action: 'plugin::content-type-builder.read' }] },
-      createHandler: (strapi: any) => async ({ args }: any) => {
-        const r = enableI18n({ strapi, uid: args?.uid, campos: args?.campos });
-        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
-      },
-    });
+export 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: () =>
+    z.object({ uid: z.string().optional(), campos: z.array(z.string()).optional() }),
+  resolveOutputSchema: () =>
+    z.object({
+      ok: z.boolean().optional(),
+      uid: z.string().optional(),
+      campos: z.array(z.string()).optional(),
+      contentTypes: z.array(z.any()).optional(),
+      total: z.number().optional(),
+      restart: z.boolean().optional(),
+      erro: z.string().optional(),
+    }),
+  auth: { policies: [{ action: 'plugin::content-type-builder.read' }] },
+  createHandler: (strapi: any) => async ({ args }) => {
+    const r = enableI18n({ strapi, uid: args.uid, campos: args.campos });
+    return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
   },
-};
-
-export default tool;
+});

package/server/src/mcp/tools/listar-locales.ts

@@ -1,27 +1,21 @@
 import { z } from '@strapi/utils';
-import type { StrapiMcpToolModule } from '../types';
+import { defineTool } from '../define';
 import { createContentTools } from '../../content-tools';
 
-const tool: StrapiMcpToolModule = {
-  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: () => z.object({}),
-      resolveOutputSchema: () =>
-        z.object({
-          default: z.string().optional(),
-          locales: z.array(z.any()).optional(),
-          erro: z.string().optional(),
-        }),
-      auth: { policies: [{ action: 'plugin::content-manager.explorer.read' }] },
-      createHandler: (strapi: any) => async () => {
-        const r = await createContentTools(strapi).listarLocales();
-        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
-      },
-    });
+export default defineTool({
+  name: 'mcp_chat_listar_locales',
+  title: 'List i18n locales',
+  description: 'List the configured locales (languages) and which one is the default.',
+  resolveInputSchema: () => z.object({}),
+  resolveOutputSchema: () =>
+    z.object({
+      default: z.string().optional(),
+      locales: z.array(z.any()).optional(),
+      erro: z.string().optional(),
+    }),
+  auth: { policies: [{ action: 'plugin::content-manager.explorer.read' }] },
+  createHandler: (strapi: any) => async () => {
+    const r = await createContentTools(strapi).listarLocales();
+    return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
   },
-};
-
-export default tool;
+});

package/server/src/mcp/tools/publicar.ts

@@ -1,31 +1,25 @@
 import { z } from '@strapi/utils';
-import type { StrapiMcpToolModule } from '../types';
+import { defineTool } from '../define';
 import { createContentTools } from '../../content-tools';
 
-const tool: StrapiMcpToolModule = {
-  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: () =>
-        z.object({ uid: z.string(), documentId: z.string(), locale: z.string().optional() }),
-      resolveOutputSchema: () =>
-        z.object({
-          ok: z.boolean().optional(),
-          uid: z.string().optional(),
-          documentId: z.string().optional(),
-          status: z.string().optional(),
-          locale: z.string().optional(),
-        }),
-      auth: { policies: [{ action: 'plugin::content-manager.explorer.publish' }] },
-      createHandler: (strapi: any) => async ({ args }: any) => {
-        const r = await createContentTools(strapi).publicar(args);
-        return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
-      },
-    });
+export 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") — the edit is already live.',
+  resolveInputSchema: () =>
+    z.object({ uid: z.string(), documentId: z.string(), locale: z.string().optional() }),
+  resolveOutputSchema: () =>
+    z.object({
+      ok: z.boolean().optional(),
+      uid: z.string().optional(),
+      documentId: z.string().optional(),
+      status: z.string().optional(),
+      locale: z.string().optional(),
+    }),
+  auth: { policies: [{ action: 'plugin::content-manager.explorer.publish' }] },
+  createHandler: (strapi: any) => async ({ args }) => {
+    const r = await createContentTools(strapi).publicar(args);
+    return { content: [{ type: 'text', text: JSON.stringify(r) }], structuredContent: r };
   },
-};
-
-export default tool;
+});