sapiens-mcp 1.0.0

package/dist/tools/helen.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { convexAction, getSessionToken } from "../convexClient.js";
+/**
+ * Helen Voice — Text-to-Speech via ElevenLabs ou Google Gemini.
+ *
+ * Sub-actions:
+ *   - speak: sintetiza fala. Retorna audioBase64 + mimeType + sizeBytes.
+ *   - list_presets: catálogo de voiceIds/voiceNames recomendados pra cada
+ *     provider, com sugestões de uso.
+ *
+ * Speak retorna áudio inline base64. Pra arquivos grandes (>10s), salve em
+ * disco no caller (skill /sapiens:voice faz isso em apps/sapiens/.tmp/).
+ */
+export const helenSchema = z.object({
+    action: z.enum(["speak", "list_presets"]),
+    text: z
+        .string()
+        .optional()
+        .describe("Texto a falar (action=speak). Max 5000 chars."),
+    provider: z
+        .enum(["elevenlabs", "google"])
+        .optional()
+        .describe("elevenlabs (melhor natural, mais caro) ou google (Gemini TTS, mais barato). Default elevenlabs."),
+    modelId: z
+        .string()
+        .optional()
+        .describe("ElevenLabs: 'eleven_v3' (default) ou 'eleven_multilingual_v2'. Google: 'gemini-2.5-flash-preview-tts'."),
+    voiceId: z
+        .string()
+        .optional()
+        .describe("ElevenLabs voice_id (obrigatório se provider=elevenlabs). Use list_presets pra ver opções."),
+    googleVoiceName: z
+        .string()
+        .optional()
+        .describe("Google prebuilt voice (default Kore). Use list_presets pra ver opções."),
+    languageCode: z
+        .string()
+        .optional()
+        .describe("ElevenLabs: ex 'pt' pra PT-BR otimizado."),
+    stylePreamble: z
+        .string()
+        .optional()
+        .describe("Google: prefixo de instrução de mood ('Read this in a thoughtful tone:'). Não suportado em ElevenLabs."),
+    voiceSettings: z
+        .object({
+        stability: z.number().min(0).max(1).optional(),
+        similarity_boost: z.number().min(0).max(1).optional(),
+        style: z.number().min(0).max(1).optional(),
+        use_speaker_boost: z.boolean().optional(),
+        speed: z.number().optional(),
+    })
+        .optional()
+        .describe("ElevenLabs voice_settings. Default razoável: stability=0.45, similarity_boost=0.75, style=0.30."),
+    outputFormat: z
+        .string()
+        .optional()
+        .describe("ElevenLabs ex 'mp3_44100_128'. Default da provider."),
+    clientApiKey: z
+        .string()
+        .optional()
+        .describe("BYOK: chave do user. Se vazia, usa env default do deploy (ELEVENLABS_API_KEY ou GEMINI_API_KEY)."),
+});
+const PRESETS = {
+    elevenlabs: {
+        note: "ElevenLabs presets. modelId default 'eleven_v3'. Custa ~$0.30 USD pra 500 chars.",
+        voices: [
+            { voiceId: "pNInz6obpgDQGcFmaJgB", name: "Adam", use: "narração masculina pro/editorial, médio-grave" },
+            { voiceId: "EXAVITQu4vr4xnSDxMAC", name: "Sarah", use: "narração feminina, calorosa" },
+            { voiceId: "IKne3meq5aSn9XLyUdCD", name: "Charlie", use: "masculina jovem, articulada" },
+            { voiceId: "XB0fDUnXU5powFXDhCwa", name: "Charlotte", use: "feminina contemplativa" },
+        ],
+    },
+    google: {
+        note: "Google Gemini TTS. modelId 'gemini-2.5-flash-preview-tts'. Custa ~$0.01 USD pra 500 chars (mais barato).",
+        voices: [
+            { voiceName: "Kore", use: "feminina, neutra (default)" },
+            { voiceName: "Aoede", use: "feminina, melódica" },
+            { voiceName: "Charon", use: "masculina, profunda" },
+            { voiceName: "Fenrir", use: "masculina, mais áspera" },
+        ],
+        stylePreambles: [
+            "Read this in a thoughtful, almost-whispered tone:",
+            "Read this with skeptical curiosity:",
+            "Read this fast, like reciting a manifesto:",
+            "Read this slow and contemplative, with pauses:",
+        ],
+    },
+};
+export async function helen(args) {
+    if (args.action === "list_presets") {
+        return PRESETS;
+    }
+    if (args.action === "speak") {
+        if (!args.text || !args.text.trim()) {
+            throw new Error("action=speak exige text (não vazio).");
+        }
+        const provider = args.provider ?? "elevenlabs";
+        const modelId = args.modelId ??
+            (provider === "elevenlabs"
+                ? "eleven_v3"
+                : "gemini-2.5-flash-preview-tts");
+        if (provider === "elevenlabs" && !args.voiceId) {
+            throw new Error("provider=elevenlabs exige voiceId. Use action=list_presets pra ver opções.");
+        }
+        const sessionToken = getSessionToken();
+        return await convexAction("mcpExtrasActions:mcpHelenSpeak", {
+            sessionToken,
+            text: args.text,
+            provider,
+            modelId,
+            voiceId: args.voiceId,
+            googleVoiceName: args.googleVoiceName,
+            languageCode: args.languageCode,
+            stylePreamble: args.stylePreamble,
+            voiceSettings: args.voiceSettings,
+            outputFormat: args.outputFormat,
+            clientApiKey: args.clientApiKey,
+        });
+    }
+}

package/dist/tools/image.js

@@ -0,0 +1,145 @@
+import { z } from "zod";
+import { convexAction, getSessionToken } from "../convexClient.js";
+// IDs canônicos do catálogo (apps/sapiens/convex/shared/imageModels.ts).
+// IDs fora dessa lista caem no fallback e o pricing vira 999. Sempre usar os
+// IDs canônicos.
+const MODELS = [
+    "nano-banana-max", // gemini-3-pro-image-preview · 450 + adder
+    "nano-banana-2", // gemini-3.1-flash-image-preview (V2, Flash 3.1) · 450 + adder · COM refs · DEFAULT
+    "gpt-image-2-low", // Azure gpt-image-2 quality=low · 250
+    "gpt-image-2-high", // Azure gpt-image-2 quality=high · 800
+];
+export const imageSchema = z.object({
+    action: z.enum(["generate", "request_generation", "compose"]),
+    prompt: z.string().describe("Prompt da imagem. Full-bleed, sujeito oversized."),
+    model: z
+        .enum(MODELS)
+        .optional()
+        .describe("Default 'nano-banana-2' (Flash 3.1 com referenceImageUrls). Use 'nano-banana-max' (Pro 3) pra qualidade alta. 'gpt-image-2-low/high' = Azure OpenAI."),
+    aspectRatio: z
+        .enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"])
+        .optional()
+        .describe("Default '1:1'. 9:16 = vertical pra story/short, 16:9 = landscape."),
+    size: z
+        .enum(["1K", "2K", "4K"])
+        .optional()
+        .describe("Default '1K'. 2K/4K só funcionam em modelos com hasResolutionAdder (nano-banana-max e nano-banana-2), adicionam 100/300 sinapses."),
+    styleId: z
+        .string()
+        .optional()
+        .describe("Default 'none'. IDs de estilo no convex/shared/imageStyles.ts."),
+    negativePrompt: z.string().optional(),
+    referenceImageUrls: z
+        .array(z.string())
+        .optional()
+        .describe("URLs públicas (Convex storage / Bunny CDN / Wikimedia) usadas como reference images. Trava character/style entre múltiplas gerações. Requer model com supportsReferences=true (nano-banana-2 ou gpt-image-2-*)."),
+    mode: z
+        .enum(["create", "edit", "variation"])
+        .optional()
+        .describe("Default 'create' (gera do zero). 'edit' aplica prompt como mudança sobre sourceImageId. 'variation' gera similar mantendo estilo. Edit/variation exigem sourceImageId e enviam a imagem como referência inline pro modelo."),
+    sourceImageId: z
+        .string()
+        .optional()
+        .describe("ID de imagem do gallery do próprio user (`generatedImages:_id`). Obrigatório pra mode=edit ou mode=variation. Use sapiens_gallery action=list pra descobrir IDs."),
+    // v1.8 — compose frame (persona + screen via Gemini)
+    personaBase64: z
+        .string()
+        .optional()
+        .describe("Pra action=compose: base64 da imagem persona (start ref). 1 dos {personaBase64, screenImage*} obrigatório."),
+    personaMimeType: z.string().optional(),
+    screenImageBase64: z
+        .string()
+        .optional()
+        .describe("Pra action=compose: base64 da tela. Alt: screenImageUrl."),
+    screenImageMimeType: z.string().optional(),
+    screenImageUrl: z
+        .string()
+        .optional()
+        .describe("Pra action=compose: URL da tela (Bunny CDN). Convex baixa server-side."),
+    instruction: z
+        .string()
+        .optional()
+        .describe("Pra action=compose: instrução em EN pro Gemini. Ex: 'Compose a vertical 9:16 photo: persona holding a smartphone facing the camera, the phone screen displaying the provided second image (clearly visible, sharp). Mobile photography aesthetic.'"),
+});
+export async function image(args) {
+    const sessionToken = getSessionToken();
+    // v1.8: compose tem args próprios, validação separada
+    if (args.action === "compose") {
+        if (!args.instruction || args.instruction.trim().length < 5) {
+            throw new Error("action=compose exige 'instruction' (mínimo 5 chars).");
+        }
+        if (!args.personaBase64 && !args.screenImageBase64 && !args.screenImageUrl) {
+            throw new Error("compose exige pelo menos um de: personaBase64, screenImageBase64, screenImageUrl.");
+        }
+        return await convexAction("mcpExtrasActions:mcpComposeFrame", {
+            sessionToken,
+            personaBase64: args.personaBase64,
+            personaMimeType: args.personaMimeType,
+            screenImageBase64: args.screenImageBase64,
+            screenImageMimeType: args.screenImageMimeType,
+            screenImageUrl: args.screenImageUrl,
+            instruction: args.instruction,
+        });
+    }
+    if (!args.prompt || args.prompt.trim().length < 5) {
+        throw new Error("Faltando 'prompt' (mínimo 5 chars).");
+    }
+    // v1.7: request_generation cria row pendente em generatedImages e debita
+    // créditos. Necessário antes de chamar sapiens_shorts/sapiens_video (que
+    // exigem imageId pré-existente). Pra modelos de imagem (nano-banana-*,
+    // gpt-image-2-*), prefira action="generate" que já faz tudo num call.
+    if (args.action === "request_generation") {
+        return await import("../convexClient.js").then(({ convexMutation }) => convexMutation("mcpExtras:mcpRequestGeneration", {
+            sessionToken,
+            model: args.model ?? "nano-banana-2",
+            styleId: args.styleId,
+            prompt: args.prompt,
+            negativePrompt: args.negativePrompt,
+            aspectRatio: args.aspectRatio ?? "16:9",
+            size: args.size ?? "1K",
+        }));
+    }
+    // Edit/variation usam desktopMcp.generateImageOnline (suporta sourceImageId
+    // inline como reference). Create sem sourceImageId pode usar a rota mais
+    // direta do pipelineMcpImage (catálogo legacy). Pra simplificar, usamos
+    // sempre desktopMcp.generateImageOnline a partir da v1 do plugin, porque
+    // ele cobre os 3 modos uniformemente e tem a coreografia completa (auth,
+    // créditos, upload Bunny, patch row).
+    if ((args.mode === "edit" || args.mode === "variation") && !args.sourceImageId) {
+        throw new Error(`mode='${args.mode}' exige sourceImageId. Use sapiens_gallery action=list pra descobrir.`);
+    }
+    // Quando há referenceImageUrls (URLs externas) e mode=create, ainda usamos
+    // o pipelineMcpImage (que aceita URLs). Pra modos edit/variation usamos
+    // desktopMcp (que aceita sourceImageId interno).
+    if (args.sourceImageId) {
+        const result = await convexAction("desktopMcp:generateImageOnline", {
+            sessionToken,
+            prompt: args.prompt,
+            aspectRatio: args.aspectRatio,
+            size: args.size,
+            model: args.model ?? "nano-banana-2",
+            negativePrompt: args.negativePrompt,
+            mode: args.mode ?? "edit",
+            sourceImageId: args.sourceImageId,
+        });
+        return {
+            imageId: result?.imageId,
+            url: result?.url,
+            mimeType: result?.mimeType,
+            // Não incluir base64 no retorno (polui contexto). Quem quiser bytes
+            // chama sapiens_gallery action=get com includeBase64=true.
+        };
+    }
+    // Fluxo legacy: pipelineMcpImage com referenceImageUrls (externas) ou puro.
+    const result = await convexAction("pipelineMcpImage:mcpGenerateImage", {
+        sessionToken,
+        prompt: args.prompt,
+        model: args.model ?? "nano-banana-2",
+        aspectRatio: args.aspectRatio,
+        size: args.size,
+        styleId: args.styleId,
+        negativePrompt: args.negativePrompt,
+        referenceImageUrls: args.referenceImageUrls,
+    });
+    return result;
+}

package/dist/tools/meta.js

@@ -0,0 +1,241 @@
+import { z } from "zod";
+import { convexQuery, convexMutation, convexAction, getSessionToken, saveSessionToken, clearSessionToken, } from "../convexClient.js";
+export const metaSchema = z.object({
+    action: z.enum([
+        "login",
+        "logout",
+        "whoami",
+        "formats",
+        "health",
+        "credits",
+        "app_url",
+        "subscription",
+    ]),
+    code: z
+        .string()
+        .optional()
+        .describe("Código XXXX-XXXX gerado (logado) em sapiensinteticos.com/conectar-claude. Só pra action=login."),
+});
+const APP_URL = "https://sapiensinteticos.com";
+const FORMAT_GUIDE = {
+    post_social: {
+        description: "Post de texto curto/médio pra rede social (genérico).",
+        payloadHint: {
+            text: "string PT principal",
+            textEn: "string EN (opcional)",
+            hashtags: ["string"],
+            cta: "string opcional",
+        },
+    },
+    carrossel_ig: {
+        description: "Carrossel Instagram com múltiplos slides texto + imagem.",
+        payloadHint: {
+            slides: [
+                {
+                    title: "string opcional",
+                    body: "string",
+                    imagePrompt: "string (pra gerador de imagem)",
+                    imageUrl: "string (preenche depois de gerar)",
+                },
+            ],
+            caption: "string",
+            hashtags: ["string"],
+        },
+    },
+    tirinha: {
+        description: "Tirinha em painéis (3-6) com diálogo curto.",
+        payloadHint: {
+            title: "string",
+            panels: [
+                {
+                    description: "string narrativo",
+                    dialogue: "string opcional",
+                    imagePrompt: "string",
+                    imageUrl: "string opcional",
+                },
+            ],
+        },
+    },
+    musica: {
+        description: "Faixa curta com letra + estilo + mood.",
+        payloadHint: {
+            style: "string ex 'lo-fi hip-hop'",
+            mood: "string",
+            lyrics: "string completa",
+            audioUrl: "string opcional",
+        },
+    },
+    shorts_yt: {
+        description: "Roteiro pra short vertical de 30-60s.",
+        payloadHint: {
+            title: "string",
+            script: "string roteiro completo",
+            scenes: [{ visual: "string", voiceover: "string", duration: "number" }],
+        },
+    },
+    cena_visual: {
+        description: "Cena visual única pra still ou abertura.",
+        payloadHint: {
+            prompt: "string",
+            composition: "string",
+            imageUrl: "string opcional",
+        },
+    },
+    video_yt: {
+        description: "Vídeo programático longer-form.",
+        payloadHint: {
+            title: "string",
+            script: "string roteiro completo",
+            scenes: [{ visual: "string", voiceover: "string", duration: "number" }],
+        },
+    },
+    post_linkedin: {
+        description: "Post LinkedIn (texto + opcional carrossel curto).",
+        payloadHint: { text: "string", hashtags: ["string"] },
+    },
+    post_twitter: {
+        description: "Post Twitter/X (single ou thread).",
+        payloadHint: {
+            tweets: ["string (max 280 chars)"],
+            threadStyle: "boolean",
+        },
+    },
+    post_threads: {
+        description: "Post Threads (parecido com Twitter mas mais longo).",
+        payloadHint: { posts: ["string"] },
+    },
+};
+export async function meta(args) {
+    if (args.action === "formats") {
+        return {
+            formats: FORMAT_GUIDE,
+            note: "Payload é livre (v.any() no schema). Use o hint como guia, mas pode estender.",
+        };
+    }
+    if (args.action === "app_url") {
+        return {
+            web: APP_URL,
+            conectarClaude: `${APP_URL}/conectar-claude`,
+            desktopLogin: `${APP_URL}/desktop-login`,
+            dashboard: `${APP_URL}/dashboard`,
+            adminCuration: `${APP_URL}/dashboard/admin/blog/sapiens-curation`,
+            adminPopArticles: `${APP_URL}/dashboard/admin/repertorio-articles`,
+            adminPipeline: `${APP_URL}/dashboard/admin/content`,
+        };
+    }
+    // Login: troca o código de uso único (gerado no site, logado) por um
+    // sessionToken de 30 dias e salva localmente. NÃO exige token prévio.
+    if (args.action === "login") {
+        const code = (args.code || "").trim();
+        if (!code) {
+            throw new Error("Passe o código: action=login com code=XXXX-XXXX. Gere em sapiensinteticos.com/conectar-claude (logado).");
+        }
+        const token = await convexMutation("desktopAuth:redeemDesktopCode", {
+            code,
+        });
+        if (typeof token !== "string" || token.length < 8) {
+            throw new Error("Não consegui validar o código. Ele expira em 5 min e é de uso único. Gere um novo em sapiensinteticos.com/conectar-claude.");
+        }
+        const saved = saveSessionToken(token);
+        let who = null;
+        try {
+            who = await convexQuery("mcpExtras:mcpGetMySubscription", {
+                sessionToken: token,
+            });
+        }
+        catch {
+            // best-effort: o token foi salvo mesmo que o whoami falhe
+        }
+        return {
+            ok: true,
+            message: "Conta Sapiens conectada. Já dá pra pedir pra gerar imagem, escrever artigo, etc. (gasta as suas Sinapses).",
+            email: who?.user?.email ?? null,
+            tier: who?.user?.isAdmin ? "admin" : "user",
+            balance: who?.balance?.total ?? null,
+            savedTo: saved.path,
+        };
+    }
+    if (args.action === "logout") {
+        const cleared = clearSessionToken();
+        return {
+            ok: true,
+            cleared,
+            message: cleared
+                ? "Sessão local removida. Rode action=login pra reconectar."
+                : "Nenhuma sessão local encontrada.",
+        };
+    }
+    const sessionToken = getSessionToken();
+    if (args.action === "whoami") {
+        // mcpGetMySubscription usa requireMcpUser (qualquer logado), então whoami
+        // funciona pra user E admin, e reporta o tier pro Claude saber o que pode.
+        const sub = await convexQuery("mcpExtras:mcpGetMySubscription", {
+            sessionToken,
+        });
+        const isAdmin = !!sub?.user?.isAdmin;
+        return {
+            userId: sub?.user?._id ?? null,
+            email: sub?.user?.email ?? null,
+            isAdmin,
+            tier: isAdmin ? "admin" : "user",
+            balance: sub?.balance ?? null,
+            warnings: sub?.warnings ?? null,
+            note: isAdmin
+                ? "Tier admin (dono): pipeline, blog editorial, Coluna Sapiens e shorts/video, além de tudo do tier user."
+                : "Tier user: gerar imagem, escrever artigo (sapiens_write), persona, Helen TTS, Musicator, repertório, comunidade. Cada geração cobra as tuas Sinapses. Pipeline, blog editorial e Coluna são owner-only.",
+        };
+    }
+    if (args.action === "credits") {
+        // desktopMcp.whoami já vem com totalCredits (subscription+grants+legacy+free).
+        // Usa essa fonte porque pipelineMcp:mcpWhoami só fala dos campos admin.
+        const me = await convexAction("desktopMcp:whoami", { sessionToken });
+        return {
+            email: me?.email ?? null,
+            name: me?.name ?? null,
+            credits: me?.credits ?? null,
+            role: me?.role ?? null,
+        };
+    }
+    if (args.action === "subscription") {
+        // v1.2: combinação plan + saldo detalhado por bucket (subscription/grants/free)
+        return await convexQuery("mcpExtras:mcpGetMySubscription", { sessionToken });
+    }
+    if (args.action === "health") {
+        try {
+            // Core: funciona pra qualquer logado (requireMcpUser).
+            const sub = await convexQuery("mcpExtras:mcpGetMySubscription", {
+                sessionToken,
+            });
+            const isAdmin = !!sub?.user?.isAdmin;
+            // Pipeline só pra admin (owner-only). Wrap pra nunca derrubar o health.
+            let pipeline = null;
+            if (isAdmin) {
+                try {
+                    const sources = await convexQuery("pipelineMcp:mcpListSources", {
+                        sessionToken,
+                    });
+                    pipeline = {
+                        sourcesTotal: Array.isArray(sources) ? sources.length : 0,
+                        sourcesPending: Array.isArray(sources)
+                            ? sources.filter((s) => !s.isDone).length
+                            : 0,
+                    };
+                }
+                catch {
+                    pipeline = null;
+                }
+            }
+            return {
+                ok: true,
+                tier: isAdmin ? "admin" : "user",
+                email: sub?.user?.email ?? null,
+                balance: sub?.balance ?? null,
+                pipeline,
+                appUrl: APP_URL,
+            };
+        }
+        catch (err) {
+            return { ok: false, error: err?.message ?? String(err) };
+        }
+    }
+}

package/dist/tools/musicator.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { convexAction, getSessionToken } from "../convexClient.js";
+/**
+ * Musicator — gera letra + style prompt pra Musicator (sem criar track).
+ *
+ * Sub-action:
+ *   - lyrics: gera letra na voz Sapiens + stylePrompt EN curto pra synth.
+ *     Retorna texto inline. Caller (skill /sapiens:lyrics) decide se salva
+ *     em /tmp/ ou cola no studio pra renderizar áudio.
+ *
+ * Pra fluxo cheio com track + render Lyria/ACE/Suno, use studio na UI
+ * (link em sapiens_studios action=get studio=musicator).
+ */
+export const musicatorSchema = z.object({
+    action: z.enum(["lyrics", "render"]),
+    // lyrics args
+    title: z.string().optional().describe("Título da faixa (action=lyrics). Vai no metadata do synth."),
+    context: z
+        .string()
+        .optional()
+        .describe("Tema/argumento curto, 1-2 frases (action=lyrics). Mínimo 10 chars."),
+    direction: z
+        .string()
+        .optional()
+        .describe("Gênero/mood (ex: 'synthwave melancólico 1980s', 'lo-fi hip-hop 80 BPM', 'acoustic indie folk'). Default 'livre'."),
+    language: z
+        .string()
+        .optional()
+        .describe("Default 'pt-BR'. Pode ser 'en', 'es', etc."),
+    // render args (v1.9)
+    trackId: z
+        .string()
+        .optional()
+        .describe("musicator_tracks:_id (obrigatório pra action=render). Track precisa ter stylePrompt + lyrics preenchidos (gere via action=lyrics e cole no studio)."),
+    stylePromptOverride: z
+        .string()
+        .optional()
+        .describe("Pra action=render: sobrescreve stylePrompt antes do render (não muda track persistido)."),
+    negativePrompt: z
+        .string()
+        .optional()
+        .describe("Pra action=render: negative prompt do synth (provider-dependent)."),
+    seed: z
+        .number()
+        .optional()
+        .describe("Pra action=render: seed pra reprodutibilidade do synth."),
+});
+export async function musicator(args) {
+    const sessionToken = getSessionToken();
+    if (args.action === "lyrics") {
+        if (!args.title || !args.context) {
+            throw new Error("action=lyrics exige title + context.");
+        }
+        if (args.context.length < 10) {
+            throw new Error("context muito curto (mínimo 10 chars).");
+        }
+        return await convexAction("mcpExtrasActions:mcpMusicatorLyrics", {
+            sessionToken,
+            title: args.title,
+            context: args.context,
+            direction: args.direction,
+            language: args.language ?? "pt-BR",
+        });
+    }
+    if (args.action === "render") {
+        if (!args.trackId) {
+            throw new Error("action=render exige trackId. Crie track no studio Musicator primeiro (UI), depois cole o ID aqui.");
+        }
+        return await convexAction("mcpExtrasActions:mcpMusicatorRender", {
+            sessionToken,
+            trackId: args.trackId,
+            stylePromptOverride: args.stylePromptOverride,
+            negativePrompt: args.negativePrompt,
+            seed: args.seed,
+        });
+    }
+}

package/dist/tools/persona.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { convexAction, convexQuery, getSessionToken } from "../convexClient.js";
+/**
+ * Persona Atlas — gera 1 ilustração MBTI ou lista códigos.
+ *
+ * Sub-actions:
+ *   - list_codes: retorna os 16 MBTI codes + grupo (NT/NF/SJ/SP). Estático.
+ *   - generate: gera arte pra 1 code (admin-only via session token). Retorna
+ *     URL Bunny e tamanho do payload base64.
+ *
+ * Generate é admin-only e consome quota Gemini (~1 imagem). Não retorna
+ * base64 inline pra economizar contexto (use sapiens_gallery action=get pra
+ * baixar bytes se precisar).
+ */
+const MBTI_CODES = [
+    "ESFJ", "ISFJ", "ESTJ", "ISTJ",
+    "ESFP", "ISFP", "ESTP", "ISTP",
+    "ENFP", "INFP", "ENFJ", "INFJ",
+    "ENTP", "INTP", "ENTJ", "INTJ",
+];
+const MBTI_GROUPS = {
+    ESFJ: "SJ", ISFJ: "SJ", ESTJ: "SJ", ISTJ: "SJ",
+    ESFP: "SP", ISFP: "SP", ESTP: "SP", ISTP: "SP",
+    ENFP: "NF", INFP: "NF", ENFJ: "NF", INFJ: "NF",
+    ENTP: "NT", INTP: "NT", ENTJ: "NT", INTJ: "NT",
+};
+const MBTI_NAMES = {
+    INTJ: "O Estrategista", INTP: "O Lógico",
+    ENTJ: "O Comandante", ENTP: "O Inovador",
+    INFJ: "O Defensor", INFP: "O Mediador",
+    ENFJ: "O Protagonista", ENFP: "O Ativista",
+    ISTJ: "O Logístico", ISFJ: "O Defensor (concreto)",
+    ESTJ: "O Executivo", ESFJ: "O Cônsul",
+    ISTP: "O Virtuoso", ISFP: "O Aventureiro",
+    ESTP: "O Empreendedor", ESFP: "O Animador",
+};
+export const personaSchema = z.object({
+    action: z.enum(["list_codes", "list_generated", "generate"]),
+    code: z
+        .enum(MBTI_CODES)
+        .optional()
+        .describe("Pra action=generate: código MBTI a gerar. Case-insensitive (normaliza pra maiúscula)."),
+});
+export async function persona(args) {
+    if (args.action === "list_codes") {
+        return {
+            count: MBTI_CODES.length,
+            codes: MBTI_CODES.map((c) => ({
+                code: c,
+                name: MBTI_NAMES[c],
+                group: MBTI_GROUPS[c],
+            })),
+            groups: {
+                NT: "Analistas — pensa em sistemas",
+                NF: "Diplomatas — pensa em pessoas",
+                SJ: "Sentinelas — pensa em ordem",
+                SP: "Exploradores — pensa em sensação",
+            },
+        };
+    }
+    if (args.action === "list_generated") {
+        // personaArtData.getAll é query pública sem auth check explícito
+        // (read-only, tabela de 16 rows fixos). Sem session token necessário.
+        const rows = await convexQuery("personaArtData:getAll", {});
+        return {
+            count: Array.isArray(rows) ? rows.length : 0,
+            generated: (rows || []).map((r) => ({
+                code: r.code,
+                name: MBTI_NAMES[r.code],
+                group: MBTI_GROUPS[r.code],
+                bunnyUrl: r.bunnyUrl ?? null,
+                updatedAt: r.updatedAt ?? r._creationTime ?? null,
+            })),
+            note: "Apenas codes que já foram gerados. Pra ver os 16 possíveis (gerados ou não), use action=list_codes.",
+        };
+    }
+    if (args.action === "generate") {
+        if (!args.code) {
+            throw new Error("action=generate exige code MBTI (ex 'INTJ').");
+        }
+        const sessionToken = getSessionToken();
+        return await convexAction("mcpExtrasActions:mcpGeneratePersonaArt", {
+            sessionToken,
+            code: args.code,
+        });
+    }
+}