beplus-mcp 0.8.0

package/dist/index.js

@@ -0,0 +1,1238 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.beplus.academy";
+function loadConfig() {
+  const token = process.env.BEPLUS_API_TOKEN?.trim();
+  if (!token) {
+    throw new Error(
+      "BEPLUS_API_TOKEN is required. Generate a Personal Access Token in your BePlus account settings (Tokens de acesso) and set it as BEPLUS_API_TOKEN in the MCP config."
+    );
+  }
+  const baseUrl = (process.env.BEPLUS_API_URL?.trim() || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const inlineImages = process.env.BEPLUS_INLINE_IMAGES !== "0";
+  const verifyOnStart = process.env.BEPLUS_VERIFY_ON_START === "1";
+  const rawThreshold = process.env.BEPLUS_COST_WARN_THRESHOLD;
+  const threshold = rawThreshold ? Number(rawThreshold) : NaN;
+  const activeProject = process.env.BEPLUS_ACTIVE_PROJECT?.trim() || null;
+  return {
+    baseUrl,
+    apiBase: `${baseUrl}/api/v1/mcp`,
+    token,
+    inlineImages,
+    inlineImageMax: 4,
+    inlineImageMaxBytes: 5 * 1024 * 1024,
+    verifyOnStart,
+    costWarnThreshold: Number.isFinite(threshold) && threshold > 0 ? threshold : null,
+    activeProject
+  };
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/api/errors.ts
+var ApiError = class extends Error {
+  httpStatus;
+  body;
+  constructor(httpStatus, message, body) {
+    super(message);
+    this.name = "ApiError";
+    this.httpStatus = httpStatus;
+    this.body = body;
+  }
+};
+function apiErrorToUserMessage(err) {
+  if (err instanceof ApiError) {
+    const detail = err.message || "";
+    switch (err.httpStatus) {
+      case 401:
+        return "Token inv\xE1lido ou expirado. Gere um novo Personal Access Token no painel BePlus e atualize BEPLUS_API_TOKEN no config do MCP.";
+      case 402:
+        return `Diamantes insuficientes. ${detail} Recarregue ou escolha um modelo/resolu\xE7\xE3o mais barato (use estimate_cost / list_models).`;
+      case 403:
+        return `Sem permiss\xE3o para esta a\xE7\xE3o. ${detail}`;
+      case 404:
+        return `N\xE3o encontrado. ${detail}`;
+      case 408:
+        return detail || "Tempo esgotado ao falar com a API BePlus.";
+      case 409:
+        return detail;
+      case 429:
+        return `Limite atingido. ${detail} Aguarde alguns segundos e tente novamente (reduza gera\xE7\xF5es em paralelo).`;
+      case 400:
+      case 422:
+        return `Par\xE2metros inv\xE1lidos: ${detail}. Use list_models para ver modelos/params v\xE1lidos.`;
+      case 0:
+        return detail || "Falha de rede ao falar com a API BePlus. Confira BEPLUS_API_URL.";
+      default:
+        if (err.httpStatus >= 500) return `Erro no servidor BePlus: ${detail}`;
+        return detail || `Erro HTTP ${err.httpStatus}`;
+    }
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+// src/api/client.ts
+var BeplusClient = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  cfg;
+  async request(method, path, opts = {}) {
+    const url = new URL(`${this.cfg.apiBase}${path}`);
+    if (opts.query) {
+      for (const [k, v] of Object.entries(opts.query)) {
+        if (v !== void 0 && v !== null && v !== "") url.searchParams.set(k, String(v));
+      }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 3e4);
+    let res;
+    try {
+      res = await fetch(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.cfg.token}`,
+          ...opts.body ? { "Content-Type": "application/json" } : {}
+        },
+        body: opts.body ? JSON.stringify(opts.body) : void 0,
+        signal: controller.signal
+      });
+    } catch (e) {
+      if (e?.name === "AbortError") {
+        throw new ApiError(408, `Tempo esgotado ao falar com a API BePlus (${path}).`);
+      }
+      throw new ApiError(0, `Falha de rede ao falar com a API BePlus (${path}). Confira BEPLUS_API_URL.`);
+    } finally {
+      clearTimeout(timer);
+    }
+    const text = await res.text();
+    let json;
+    if (text) {
+      try {
+        json = JSON.parse(text);
+      } catch {
+      }
+    }
+    if (!res.ok) {
+      const message = json?.message || (Array.isArray(json?.error?.formatted) ? json.error.formatted.join(", ") : void 0) || res.statusText || `HTTP ${res.status}`;
+      throw new ApiError(res.status, message, json);
+    }
+    return json && typeof json === "object" && "result" in json ? json.result : json;
+  }
+  startGeneration(body) {
+    return this.request("POST", "/generations", { body });
+  }
+  listProjects() {
+    return this.request("GET", "/projects");
+  }
+  createProject(body) {
+    return this.request("POST", "/projects", { body });
+  }
+  getActiveProject() {
+    return this.request("GET", "/projects/active");
+  }
+  setActiveProject(project) {
+    return this.request("PUT", "/projects/active", { body: { project } });
+  }
+  // ---------------------------- clients ----------------------------
+  listClients() {
+    return this.request("GET", "/clients");
+  }
+  createClient(body) {
+    return this.request("POST", "/clients", { body });
+  }
+  setActiveClient(client) {
+    return this.request("PUT", "/clients/active", { body: { client } });
+  }
+  getStatus(id) {
+    return this.request("GET", `/generations/${id}`, { timeoutMs: 15e3 });
+  }
+  cancel(id) {
+    return this.request("DELETE", `/generations/${id}`);
+  }
+  listGenerations(query) {
+    return this.request("GET", "/generations", { query });
+  }
+  tts(body) {
+    return this.request("POST", "/tts", { body, timeoutMs: 9e4 });
+  }
+  models() {
+    return this.request("GET", "/models");
+  }
+  calculateCost(query) {
+    return this.request("GET", "/calculate-cost", { query });
+  }
+  balance() {
+    return this.request("GET", "/balance");
+  }
+  me() {
+    return this.request("GET", "/me");
+  }
+  readProvenance(body) {
+    return this.request("POST", "/read-provenance", { body, timeoutMs: 3e4 });
+  }
+  analyzeMedia(body) {
+    return this.request("POST", "/analyze-media", { body, timeoutMs: 3e5 });
+  }
+  searchCalls(query) {
+    return this.request("GET", "/calls", { query });
+  }
+  getCall(id) {
+    return this.request("GET", `/calls/${id}`);
+  }
+};
+
+// src/tools/generation.ts
+import { z } from "zod";
+
+// src/tools/team-gating.ts
+var TEAM_GATING_NOTE = " \u26A0\uFE0F DESTINO DA GERA\xC7\xC3O: toda imagem/v\xEDdeo vai para o CLIENTE + PROJETO ATIVOS. ANTES de gerar, SEMPRE confirme com o usu\xE1rio em qual cliente e projeto trabalhar \u2014 MESMO que j\xE1 exista um projeto ativo, ele pode ter ficado de uma sess\xE3o anterior (N\xC3O confie no ativo herdado). Fluxo: chame list_clients e list_projects, mostre o ativo atual + as op\xE7\xF5es, e pe\xE7a pro usu\xE1rio escolher/confirmar (set_active_client + set_active_project, ou passe `project` na tool). Pode criar novos com create_client / create_project. S\xF3 gere depois que o usu\xE1rio confirmar o cliente+projeto de destino \u2014 nunca gere no ativo herdado sem confirmar.";
+function isTeamGatingError(msg) {
+  return !!msg && /cliente e um projeto|selecione um cliente|sem cliente vinculado|antes de gerar/i.test(msg);
+}
+async function buildPickProjectMessage(client) {
+  let clientsTxt = "  (n\xE3o foi poss\xEDvel listar clientes)";
+  let projectsTxt = "  (n\xE3o foi poss\xEDvel listar projetos)";
+  try {
+    const { clients } = await client.listClients();
+    clientsTxt = clients.length ? clients.map((c) => `  \u2022 ${c.code} \u2014 ${c.name}`).join("\n") : "  (nenhum cliente ainda \u2014 crie com create_client)";
+  } catch {
+  }
+  try {
+    const { projects } = await client.listProjects();
+    projectsTxt = projects.length ? projects.map(
+      (p) => `  \u2022 ${p.code} \u2014 ${p.name}` + (p.client_name ? ` (cliente: ${p.client_name})` : " (\u26A0\uFE0F sem cliente \u2014 vincule um antes)")
+    ).join("\n") : "  (nenhum projeto ainda \u2014 crie com create_project)";
+  } catch {
+  }
+  return `\u26A0\uFE0F Esta conta \xE9 de EQUIPE: gerar exige um CLIENTE e um PROJETO ativos. Nada foi gerado ainda.
+Pergunte ao usu\xE1rio em qual cliente/projeto vincular ANTES de gerar.
+
+Clientes dispon\xEDveis:
+${clientsTxt}
+
+Projetos dispon\xEDveis:
+${projectsTxt}
+
+Para prosseguir: set_active_client + set_active_project (ou passe \`project=<code>\` no generate). Se o projeto escolhido estiver sem cliente, vincule um primeiro (no admin/IA Lab).`;
+}
+
+// src/poll.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function pollUntilDone(client, generationId, budgetMs, jitterSeed = 0) {
+  const start = Date.now();
+  let interval = 1500;
+  let last;
+  let tick = 0;
+  while (Date.now() - start < budgetMs) {
+    const status = await client.getStatus(generationId);
+    last = status;
+    if (status.status === "completed" || status.status === "failed") {
+      return { settled: true, status };
+    }
+    const jitter = (jitterSeed + tick) % 5 * 100 - 250;
+    await sleep(Math.max(500, interval + jitter));
+    interval = Math.min(Math.round(interval * 1.4), 5e3);
+    tick += 1;
+  }
+  if (!last) last = await client.getStatus(generationId);
+  return { settled: last.status === "completed" || last.status === "failed", status: last };
+}
+
+// src/log.ts
+function fmt(a) {
+  return typeof a === "string" ? a : JSON.stringify(a);
+}
+function logInfo(...args) {
+  process.stderr.write(`[beplus] ${args.map(fmt).join(" ")}
+`);
+}
+function logError(...args) {
+  process.stderr.write(`[beplus][error] ${args.map(fmt).join(" ")}
+`);
+}
+
+// src/format.ts
+function textResult(s) {
+  return { content: [{ type: "text", text: s }] };
+}
+function errorResult(s) {
+  return { content: [{ type: "text", text: s }], isError: true };
+}
+function compact(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0 && v !== null) out[k] = v;
+  }
+  return out;
+}
+function costFooter(start, cfg) {
+  const parts = [];
+  if (typeof start.diamond_cost === "number") parts.push(`Custo: ${start.diamond_cost} \u{1F48E}`);
+  if (typeof start.new_balance === "number") parts.push(`Saldo: ${start.new_balance} \u{1F48E}`);
+  let footer = parts.join(" \xB7 ");
+  if (cfg.costWarnThreshold && typeof start.diamond_cost === "number" && start.diamond_cost > cfg.costWarnThreshold) {
+    footer = `\u26A0 Custo alto (${start.diamond_cost} \u{1F48E})
+${footer}`;
+  }
+  if (start.project_code) {
+    const proj = `\u{1F4C1} Projeto: ${start.project_code}${start.project_name ? ` \u2014 ${start.project_name}` : ""}`;
+    footer = footer ? `${proj}
+${footer}` : proj;
+  }
+  return footer;
+}
+function outputUrls(status) {
+  return (status.output?.urls ?? []).filter((u) => typeof u === "string" && u.length > 0);
+}
+function mimeFromUrl(url) {
+  const u = url.toLowerCase();
+  if (u.includes(".webp")) return "image/webp";
+  if (u.includes(".jpg") || u.includes(".jpeg")) return "image/jpeg";
+  return "image/png";
+}
+async function buildImageBlocks(urls, cfg) {
+  if (!cfg.inlineImages) return [];
+  const blocks = [];
+  for (const url of urls.slice(0, cfg.inlineImageMax)) {
+    try {
+      const res = await fetch(url);
+      if (!res.ok) continue;
+      const mimeType = res.headers.get("content-type") || mimeFromUrl(url);
+      if (!mimeType.startsWith("image/")) continue;
+      const buf = Buffer.from(await res.arrayBuffer());
+      if (buf.byteLength > cfg.inlineImageMaxBytes) continue;
+      blocks.push({ type: "image", data: buf.toString("base64"), mimeType });
+    } catch (e) {
+      logError("failed to inline image", url, e?.message ?? "unknown");
+    }
+  }
+  return blocks;
+}
+
+// src/schemas/enums.ts
+var IMAGE_MODELS = [
+  "google/nano-banana-2",
+  "google/nano-banana-pro",
+  "openai/gpt-image-2"
+];
+var VIDEO_MODELS = [
+  "bytedance/seedance-2.0",
+  "bytedance/seedance-2.0-fast",
+  "kwaivgi/kling-v2.5-turbo-pro",
+  "kwaivgi/kling-v2.6",
+  "kwaivgi/kling-v2.6-motion-control",
+  "kwaivgi/kling-v3-video",
+  "kwaivgi/kling-v3-omni-video"
+];
+var MUSIC_MODELS = [
+  "suno/v5-5",
+  "suno/v4-5"
+];
+var VOCAL_GENDERS = ["f", "m"];
+var TTS_MODELS = [
+  "gemini-3.1-flash-tts-preview",
+  "gemini-2.5-pro-preview-tts"
+];
+var VOICES = [
+  "Zephyr",
+  "Puck",
+  "Charon",
+  "Kore",
+  "Fenrir",
+  "Leda",
+  "Orus",
+  "Aoede",
+  "Callirrhoe",
+  "Autonoe",
+  "Enceladus",
+  "Iapetus",
+  "Umbriel",
+  "Algieba",
+  "Despina",
+  "Erinome",
+  "Algenib",
+  "Rasalgethi",
+  "Laomedeia",
+  "Achernar",
+  "Alnilam",
+  "Schedar",
+  "Gacrux",
+  "Pulcherrima",
+  "Achird",
+  "Zubenelgenubi",
+  "Vindemiatrix",
+  "Sadachbia",
+  "Sadaltager",
+  "Sulafat"
+];
+var ASPECT_RATIOS = ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "4:5", "5:4", "21:9"];
+var IMAGE_RESOLUTIONS = ["1K", "2K", "4K"];
+var VIDEO_RESOLUTIONS = ["480p", "720p", "1080p", "2K"];
+var DEFAULTS = {
+  imageModel: "google/nano-banana-2",
+  imageAspect: "1:1",
+  imageResolution: "1K",
+  videoModel: "bytedance/seedance-2.0-fast",
+  videoAspect: "16:9",
+  videoResolution: "720p",
+  videoDuration: 5,
+  ttsModel: "gemini-3.1-flash-tts-preview",
+  voice: "Kore",
+  musicModel: "suno/v5-5"
+};
+
+// src/tools/generation.ts
+var IMAGE_BUDGET_MS = 9e4;
+var VIDEO_BUDGET_MS = 12e4;
+function registerGenerationTools(server, client, cfg) {
+  server.registerTool(
+    "generate_image",
+    {
+      title: "Gerar imagem",
+      description: "Gera uma imagem a partir de um prompt usando o IA Lab da BePlus. R\xE1pido (~10-30s). Consome diamantes da conta vinculada. Apenas `prompt` \xE9 obrigat\xF3rio; passe `reference_images` (URLs p\xFAblicas) para image-to-image. Veja custos com estimate_cost / list_models." + TEAM_GATING_NOTE,
+      inputSchema: {
+        prompt: z.string().min(1).max(4e3).describe("Descri\xE7\xE3o da imagem desejada."),
+        model: z.enum(IMAGE_MODELS).default(DEFAULTS.imageModel).describe("nano-banana-2 = barato/r\xE1pido; nano-banana-pro = melhor qualidade; gpt-image-2 = OpenAI."),
+        aspect_ratio: z.enum(ASPECT_RATIOS).optional().describe("Propor\xE7\xE3o (nano-banana). Padr\xE3o 1:1."),
+        resolution: z.enum(IMAGE_RESOLUTIONS).optional().describe("Resolu\xE7\xE3o (nano-banana): 1K/2K/4K. Padr\xE3o 1K."),
+        reference_images: z.array(z.string().url()).max(16).optional().describe("URLs p\xFAblicas de imagens de refer\xEAncia (image-to-image). At\xE9 14 (nano-banana) / 16 (gpt-image-2)."),
+        google_search: z.boolean().optional().describe("nano-banana-2: aterra a imagem em busca web do Google (fatos atuais). Padr\xE3o false."),
+        image_search: z.boolean().optional().describe("nano-banana-2: usa busca de imagens do Google como refer\xEAncia visual. Padr\xE3o false."),
+        size: z.enum(["1024x1024", "1536x1024", "1024x1536", "auto"]).optional().describe("Tamanho (gpt-image-2)."),
+        quality: z.enum(["low", "medium", "high", "auto"]).optional().describe("Qualidade (gpt-image-2)."),
+        background: z.enum(["opaque", "transparent", "auto"]).optional().describe("Fundo (gpt-image-2). transparent s\xF3 com output_format png/webp. Padr\xE3o opaque."),
+        moderation: z.enum(["low", "auto"]).optional().describe("Modera\xE7\xE3o (gpt-image-2). Padr\xE3o low."),
+        output_format: z.enum(["png", "jpeg", "webp"]).optional().describe("Formato de sa\xEDda (gpt-image-2). Padr\xE3o png."),
+        output_compression: z.number().int().min(0).max(100).optional().describe("Compress\xE3o 0-100 (gpt-image-2, s\xF3 jpeg/webp). Padr\xE3o 90."),
+        seed: z.number().int().optional(),
+        project: z.string().max(64).optional().describe('Projeto (uuid OU code curto, ex.: "VRAO-26"). S\xF3 omita se o usu\xE1rio J\xC1 confirmou o projeto ativo nesta sess\xE3o.')
+      }
+    },
+    async (args) => {
+      try {
+        const isGoogle = args.model.startsWith("google/");
+        const input = compact({
+          prompt: args.prompt,
+          aspect_ratio: args.aspect_ratio ?? (isGoogle ? DEFAULTS.imageAspect : void 0),
+          resolution: args.resolution ?? (isGoogle ? DEFAULTS.imageResolution : void 0),
+          reference_images: args.reference_images,
+          google_search: args.google_search,
+          image_search: args.image_search,
+          size: args.size,
+          quality: args.quality,
+          background: args.background,
+          moderation: args.moderation,
+          output_format: args.output_format,
+          output_compression: args.output_compression,
+          seed: args.seed
+        });
+        const start = await client.startGeneration(
+          compact({ model: args.model, input, project: args.project ?? cfg.activeProject ?? void 0 })
+        );
+        if (!start.success || !start.generation_id) {
+          if (isTeamGatingError(start.message)) return errorResult(await buildPickProjectMessage(client));
+          return errorResult(start.message || "Falha ao iniciar a gera\xE7\xE3o.");
+        }
+        const footer = costFooter(start, cfg);
+        const { settled, status } = await pollUntilDone(client, start.generation_id, IMAGE_BUDGET_MS);
+        if (!settled) {
+          return textResult(
+            `\u23F3 Imagem ainda em processamento (id: ${start.generation_id}, ${status.progress ?? 0}%). Use check_generation com esse id.
+${footer}`
+          );
+        }
+        if (status.status === "failed") {
+          return errorResult(`Gera\xE7\xE3o falhou: ${status.error_message || "erro desconhecido"}.
+${footer}`);
+        }
+        const urls = outputUrls(status);
+        const blocks = await buildImageBlocks(urls, cfg);
+        const list = urls.map((u, i) => `${i + 1}. ${u}`).join("\n") || "(sem URLs)";
+        return {
+          content: [{ type: "text", text: `\u2705 Imagem gerada (${args.model}).
+${list}
+${footer}` }, ...blocks]
+        };
+      } catch (e) {
+        const msg = e instanceof ApiError ? e.message : e instanceof Error ? e.message : "";
+        if (isTeamGatingError(msg)) return errorResult(await buildPickProjectMessage(client));
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "generate_video",
+    {
+      title: "Gerar v\xEDdeo",
+      description: "Gera um v\xEDdeo curto usando o IA Lab da BePlus. LENTO (geralmente 1-5+ min). Aguarda at\xE9 ~2 min; se n\xE3o terminar, retorna o generation_id e o status \u2014 ent\xE3o use check_generation. Consome diamantes (mais caro para dura\xE7\xF5es/resolu\xE7\xF5es maiores). Suporta image-to-video (`first_frame_image`), \xFAltimo frame (`last_frame_image`), refer\xEAncias de imagem/v\xEDdeo/\xE1udio, prompt negativo, \xE1udio gerado e mais \u2014 os campos aceitos variam por modelo (consulte list_models). `kling-v2.6-motion-control` usa `first_frame_image` + `motion_video`. Imagens com rosto de pessoa REAL s\xE3o bloqueadas pela modera\xE7\xE3o do provedor (use ilustra\xE7\xF5es/personagens)." + TEAM_GATING_NOTE,
+      inputSchema: {
+        prompt: z.string().min(1).max(4e3).describe("Descri\xE7\xE3o do v\xEDdeo desejado."),
+        model: z.enum(VIDEO_MODELS).default(DEFAULTS.videoModel).describe("seedance-2.0-fast = barato/r\xE1pido; seedance-2.0 = melhor; kling-v3-video = alternativa."),
+        aspect_ratio: z.enum(ASPECT_RATIOS).optional().describe("Propor\xE7\xE3o. Padr\xE3o 16:9."),
+        resolution: z.enum(VIDEO_RESOLUTIONS).optional().describe("480p/720p/1080p/2K. Padr\xE3o 720p."),
+        duration: z.number().int().min(3).max(60).optional().describe(
+          "Dura\xE7\xE3o em segundos. Seedance 2.0/2.0-fast: 4\u201315 (granular). Kling: 5 ou 10. O backend valida por modelo \u2014 consulte list_models p/ os valores aceitos. Padr\xE3o 5."
+        ),
+        negative_prompt: z.string().max(2500).optional().describe("O que evitar no v\xEDdeo (Kling)."),
+        mode: z.enum(["standard", "pro"]).optional().describe("Qualidade de gera\xE7\xE3o (Kling): standard ou pro."),
+        generate_audio: z.boolean().optional().describe("Gerar trilha de \xE1udio junto com o v\xEDdeo (Seedance/Kling). Na web fica ligado por padr\xE3o."),
+        first_frame_image: z.string().url().optional().describe("URL da imagem inicial (image-to-video / primeiro frame)."),
+        last_frame_image: z.string().url().optional().describe("URL da imagem do \xFAltimo frame (Seedance/Kling)."),
+        reference_images: z.array(z.string().url()).max(9).optional().describe("URLs de imagens de refer\xEAncia (personagem/estilo) \u2014 modelos omni/Seedance. At\xE9 9."),
+        reference_videos: z.array(z.string().url()).max(4).optional().describe("URLs de v\xEDdeos de refer\xEAncia (Seedance reference_videos / Kling reference_video)."),
+        reference_audios: z.array(z.string().url()).max(4).optional().describe("URLs de \xE1udios de refer\xEAncia (Seedance)."),
+        motion_video: z.string().url().optional().describe("URL do v\xEDdeo de movimento/m\xE1scara din\xE2mica (kling-v2.6-motion-control)."),
+        character_orientation: z.string().optional().describe("Orienta\xE7\xE3o do personagem (alguns modelos Kling via Replicate)."),
+        keep_original_sound: z.boolean().optional().describe("Manter o som original do v\xEDdeo de refer\xEAncia (alguns modelos Kling)."),
+        reference_image: z.string().url().optional().describe("[Obsoleto \u2014 use first_frame_image] URL de imagem de refer\xEAncia (image-to-video)."),
+        seed: z.number().int().optional(),
+        project: z.string().max(64).optional().describe('Projeto (uuid OU code curto, ex.: "VRAO-26"). S\xF3 omita se o usu\xE1rio J\xC1 confirmou o projeto ativo nesta sess\xE3o.')
+      }
+    },
+    async (args) => {
+      try {
+        const firstFrame = args.first_frame_image ?? args.reference_image;
+        const refVideos = args.reference_videos;
+        const input = compact({
+          prompt: args.prompt,
+          aspect_ratio: args.aspect_ratio ?? DEFAULTS.videoAspect,
+          resolution: args.resolution ?? DEFAULTS.videoResolution,
+          duration: args.duration ?? DEFAULTS.videoDuration,
+          negative_prompt: args.negative_prompt,
+          mode: args.mode,
+          generate_audio: args.generate_audio,
+          image: firstFrame,
+          end_image: args.last_frame_image,
+          reference_images: args.reference_images,
+          reference_videos: refVideos,
+          reference_video: refVideos && refVideos.length > 0 ? refVideos[0] : void 0,
+          reference_audios: args.reference_audios,
+          motion_video: args.motion_video,
+          character_orientation: args.character_orientation,
+          keep_original_sound: args.keep_original_sound,
+          seed: args.seed
+        });
+        const start = await client.startGeneration(
+          compact({ model: args.model, input, project: args.project ?? cfg.activeProject ?? void 0 })
+        );
+        if (!start.success || !start.generation_id) {
+          if (isTeamGatingError(start.message)) return errorResult(await buildPickProjectMessage(client));
+          return errorResult(start.message || "Falha ao iniciar a gera\xE7\xE3o.");
+        }
+        const footer = costFooter(start, cfg);
+        const { settled, status } = await pollUntilDone(client, start.generation_id, VIDEO_BUDGET_MS);
+        if (!settled) {
+          return textResult(
+            `\u23F3 V\xEDdeo ainda em processamento (id: ${start.generation_id}, ${status.progress ?? 0}%). V\xEDdeos costumam levar alguns minutos \u2014 use check_generation com esse id.
+${footer}`
+          );
+        }
+        if (status.status === "failed") {
+          return errorResult(`Gera\xE7\xE3o falhou: ${status.error_message || "erro desconhecido"}.
+${footer}`);
+        }
+        const urls = outputUrls(status);
+        const list = urls.map((u, i) => `${i + 1}. ${u}`).join("\n") || "(sem URLs)";
+        return textResult(`\u2705 V\xEDdeo gerado (${args.model}).
+${list}
+${footer}`);
+      } catch (e) {
+        const msg = e instanceof ApiError ? e.message : e instanceof Error ? e.message : "";
+        if (isTeamGatingError(msg)) return errorResult(await buildPickProjectMessage(client));
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "check_generation",
+    {
+      title: "Checar gera\xE7\xE3o",
+      description: "Consulta o status de uma gera\xE7\xE3o ass\xEDncrona (imagem/v\xEDdeo) pelo id. Use depois de generate_video ou de um generate_image que estourou o tempo. Retorna status, progresso e (quando pronto) as URLs.",
+      inputSchema: {
+        generation_id: z.string().min(1).describe("O id retornado por generate_image / generate_video.")
+      }
+    },
+    async ({ generation_id }) => {
+      try {
+        const status = await client.getStatus(generation_id);
+        if (status.status === "completed") {
+          const urls = outputUrls(status);
+          const blocks = await buildImageBlocks(urls, cfg);
+          const list = urls.map((u, i) => `${i + 1}. ${u}`).join("\n") || "(sem URLs)";
+          return { content: [{ type: "text", text: `\u2705 Pronto.
+${list}` }, ...blocks] };
+        }
+        if (status.status === "failed") {
+          return errorResult(`Gera\xE7\xE3o falhou: ${status.error_message || "erro desconhecido"}.`);
+        }
+        return textResult(
+          `\u23F3 ${status.status} \u2014 ${status.progress ?? 0}%${status.stage ? ` (${status.stage})` : ""}. Tente novamente em alguns segundos.`
+        );
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "cancel_generation",
+    {
+      title: "Cancelar gera\xE7\xE3o",
+      description: "Cancela uma gera\xE7\xE3o em fila/processamento pelo id. Pode estornar diamantes.",
+      inputSchema: {
+        generation_id: z.string().min(1).describe("O id da gera\xE7\xE3o a cancelar.")
+      }
+    },
+    async ({ generation_id }) => {
+      try {
+        await client.cancel(generation_id);
+        return textResult(`\u2705 Gera\xE7\xE3o ${generation_id} cancelada (diamantes estornados quando aplic\xE1vel).`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  const readMetadataSchema = {
+    url: z.string().url().optional().describe("URL p\xFAblica do arquivo gerado \u2014 imagem, v\xEDdeo, \xE1udio ou m\xFAsica (ex.: link do storage da BePlus)."),
+    image_base64: z.string().optional().describe("Conte\xFAdo do arquivo em base64 \u2014 use quando a m\xEDdia estiver na m\xE1quina do usu\xE1rio (leia o arquivo do disco e converta para base64). Alternativa \xE0 url.")
+  };
+  const readMetadataHandler = async ({ url, image_base64 }) => {
+    if (!url && !image_base64) return errorResult("Forne\xE7a url ou image_base64.");
+    try {
+      const r = await client.readProvenance(compact({ url, image_base64 }));
+      if (!r.found) {
+        return textResult(
+          "Nenhum dado de gera\xE7\xE3o encontrado nesse arquivo (sem metadata embutida ou formato n\xE3o suportado)."
+        );
+      }
+      const p = r.provenance;
+      const g = r.generation ?? void 0;
+      const model = g?.model ?? p?.model ?? "(modelo desconhecido)";
+      const prompt = g?.prompt ?? p?.prompt ?? "(sem prompt)";
+      const configs = g?.input_params ?? p?.configs ?? {};
+      const inputs = p?.input_image_urls ?? [];
+      const lines = [
+        `\u{1F9EC} Dados da gera\xE7\xE3o (${r.source === "db" ? "registro da conta" : "metadata do arquivo"}):`,
+        `\u2022 Modelo: ${model}`,
+        `\u2022 Prompt: ${prompt}`,
+        `\u2022 Configs: ${JSON.stringify(configs)}`
+      ];
+      if (inputs.length) lines.push(`\u2022 Inputs: ${inputs.join(", ")}`);
+      if (p?.generation_id) lines.push(`\u2022 generation_id: ${p.generation_id}`);
+      return textResult(lines.join("\n"));
+    } catch (e) {
+      return errorResult(apiErrorToUserMessage(e));
+    }
+  };
+  server.registerTool(
+    "read_media_metadata",
+    {
+      title: "Ler dados de gera\xE7\xE3o de uma m\xEDdia",
+      description: "L\xEA os dados de gera\xE7\xE3o embutidos em QUALQUER m\xEDdia gerada na plataforma BePlus \u2014 imagem, v\xEDdeo, \xE1udio ou m\xFAsica (prompt, modelo, configs, inputs). \xDAtil para recriar/ajustar uma gera\xE7\xE3o a partir do resultado. Passe o arquivo de UMA destas formas: (a) `url` p\xFAblica (ex.: link do storage da BePlus); ou (b) `image_base64` \u2014 se o arquivo estiver NA M\xC1QUINA DO USU\xC1RIO, leia-o do disco voc\xEA mesmo e envie o conte\xFAdo em base64 neste campo. O servidor NUNCA acessa o filesystem do usu\xE1rio; ler o arquivo local e convert\xEA-lo em base64 \xE9 responsabilidade do cliente (voc\xEA).",
+      inputSchema: readMetadataSchema
+    },
+    readMetadataHandler
+  );
+  server.registerTool(
+    "read_image_metadata",
+    {
+      title: "Ler dados de gera\xE7\xE3o de uma m\xEDdia (alias)",
+      description: "[Obsoleto \u2014 use read_media_metadata] L\xEA os dados de gera\xE7\xE3o embutidos em qualquer m\xEDdia gerada na BePlus (imagem, v\xEDdeo, \xE1udio ou m\xFAsica). Passe `url` p\xFAblica OU `image_base64` (se o arquivo estiver na m\xE1quina do usu\xE1rio, leia-o do disco e envie em base64).",
+      inputSchema: readMetadataSchema
+    },
+    readMetadataHandler
+  );
+}
+
+// src/tools/audio.ts
+import { z as z2 } from "zod";
+function registerAudioTools(server, client, cfg) {
+  server.registerTool(
+    "generate_audio",
+    {
+      title: "Gerar \xE1udio (TTS)",
+      description: 'Sintetiza fala a partir de texto (s\xEDncrono \u2014 retorna a URL na hora) usando o IA Lab da BePlus. ~30 vozes. Opcional `style_instruction` (notas de dire\xE7\xE3o, ex.: "fale animado e pausado") e di\xE1logo com 2 locutores via `multi_speaker`. Consome diamantes por segundo de \xE1udio.' + TEAM_GATING_NOTE,
+      inputSchema: {
+        text: z2.string().min(1).max(1e4).describe("Texto a ser falado."),
+        voice: z2.enum(VOICES).default(DEFAULTS.voice).describe("Voz (ex.: Kore, Puck, Charon)."),
+        model: z2.enum(TTS_MODELS).default(DEFAULTS.ttsModel).describe("Modelo TTS."),
+        style_instruction: z2.string().max(2e3).optional().describe("Instru\xE7\xE3o de estilo/tom aplicada \xE0 fala."),
+        multi_speaker: z2.object({
+          speaker1: z2.object({ name: z2.string().min(1).max(50), voice: z2.enum(VOICES) }),
+          speaker2: z2.object({ name: z2.string().min(1).max(50), voice: z2.enum(VOICES) })
+        }).optional().describe('Di\xE1logo de 2 locutores. Marque as falas no texto como "Nome: ...".'),
+        project: z2.string().max(64).optional().describe('Projeto (uuid OU code curto, ex.: "VRAO-26"). Omita para usar o projeto ativo da conta.')
+      }
+    },
+    async (args) => {
+      try {
+        const body = compact({
+          text: args.text,
+          voice: args.voice,
+          model: args.model,
+          styleInstruction: args.style_instruction,
+          multiSpeaker: args.multi_speaker,
+          project: args.project ?? cfg.activeProject ?? void 0
+        });
+        const res = await client.tts(body);
+        const parts = [`Custo: ${res.diamond_cost} \u{1F48E}`];
+        if (res.diamonds_refunded) parts.push(`Estorno: ${res.diamonds_refunded} \u{1F48E}`);
+        const projLine = res.project_code ? `
+\u{1F4C1} Projeto: ${res.project_code}${res.project_name ? ` \u2014 ${res.project_name}` : ""}` : "";
+        return textResult(
+          `\u2705 \xC1udio gerado (${res.model}, voz ${res.voice}, ${res.duration_sec.toFixed(1)}s).
+${res.url}
+${parts.join(" \xB7 ")}${projLine}`
+        );
+      } catch (e) {
+        const msg = e instanceof ApiError ? e.message : e instanceof Error ? e.message : "";
+        if (isTeamGatingError(msg)) return errorResult(await buildPickProjectMessage(client));
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+}
+
+// src/tools/music.ts
+import { z as z3 } from "zod";
+var MUSIC_BUDGET_MS = 15e4;
+function registerMusicTools(server, client, cfg) {
+  server.registerTool(
+    "generate_music",
+    {
+      title: "Gerar m\xFAsica",
+      description: 'Gera uma m\xFAsica completa (com vocais ou instrumental) usando o Suno no IA Lab da BePlus. ASS\xCDNCRONO e LENTO (geralmente 30s\u20132+ min). Aguarda at\xE9 ~2,5 min; se n\xE3o terminar, retorna o generation_id e o status \u2014 ent\xE3o use check_generation. Consome diamantes. DOIS modos: (a) DESCRI\xC7\xC3O (custom_mode=false, padr\xE3o) \u2192 passe `description` ("uma balada triste de piano"); (b) LETRA PR\xD3PRIA (custom_mode=true) \u2192 passe `lyrics` (a letra) e opcionalmente `title`. Use `tags` para g\xEAnero/estilo em ambos os modos (ex.: "sertanejo, animado, vocal feminino"). `vocal_gender` (f/m) s\xF3 \xE9 aceito pelo Suno v4.5 e \xE9 ignorado quando `make_instrumental=true`.' + TEAM_GATING_NOTE,
+      inputSchema: {
+        model: z3.enum(MUSIC_MODELS).default(DEFAULTS.musicModel).describe("suno/v5-5 = mais novo; suno/v4-5 = r\xE1pido/consistente (\xFAnico que aceita vocal_gender)."),
+        custom_mode: z3.boolean().optional().describe("false (padr\xE3o) = gera a partir de `description`; true = usa sua `lyrics` pr\xF3pria."),
+        description: z3.string().max(2500).optional().describe("Modo descri\xE7\xE3o (custom_mode=false): descreva a m\xFAsica desejada. Obrigat\xF3rio nesse modo."),
+        lyrics: z3.string().max(5e3).optional().describe("Modo letra (custom_mode=true): a letra completa da m\xFAsica. Obrigat\xF3rio nesse modo."),
+        title: z3.string().max(120).optional().describe("T\xEDtulo da m\xFAsica (modo letra)."),
+        tags: z3.string().max(1e3).optional().describe('G\xEAnero/estilo, separados por v\xEDrgula (ex.: "pop, energ\xE9tico, vocal masculino").'),
+        make_instrumental: z3.boolean().optional().describe("true = sem vocais (apenas instrumental). Padr\xE3o false."),
+        vocal_gender: z3.enum(VOCAL_GENDERS).optional().describe("G\xEAnero do vocal: f (feminino) ou m (masculino). S\xF3 Suno v4.5; ignorado se instrumental."),
+        negative_tags: z3.string().max(1e3).optional().describe("Estilos/elementos a evitar."),
+        style_weight: z3.number().min(0).max(1).optional().describe("Peso do estilo (0\u20131). Maior = segue mais as tags. Omita para o modelo decidir."),
+        weirdness_constraint: z3.number().min(0).max(1).optional().describe("Criatividade/imprevisibilidade (0\u20131). Omita para o modelo decidir."),
+        project: z3.string().max(64).optional().describe('Projeto (uuid OU code curto, ex.: "VRAO-26"). S\xF3 omita se o usu\xE1rio J\xC1 confirmou o projeto ativo nesta sess\xE3o.')
+      }
+    },
+    async (args) => {
+      try {
+        const customMode = args.custom_mode ?? false;
+        if (customMode && !args.lyrics?.trim()) {
+          return errorResult("Modo letra (custom_mode=true) exige `lyrics`.");
+        }
+        if (!customMode && !args.description?.trim()) {
+          return errorResult("Modo descri\xE7\xE3o (custom_mode=false) exige `description`.");
+        }
+        const input = {
+          custom_mode: customMode,
+          make_instrumental: args.make_instrumental ?? false
+        };
+        if (args.vocal_gender) input.vocal_gender = args.vocal_gender;
+        if (args.negative_tags?.trim()) input.negative_tags = args.negative_tags.trim();
+        if (args.style_weight != null) input.style_weight = args.style_weight;
+        if (args.weirdness_constraint != null) input.weirdness_constraint = args.weirdness_constraint;
+        if (args.tags?.trim()) input.tags = args.tags.trim();
+        if (customMode) {
+          input.prompt = args.lyrics.trim();
+          if (args.title?.trim()) input.title = args.title.trim();
+        } else {
+          const desc = args.description.trim();
+          input.gpt_description_prompt = desc;
+          input.prompt = desc;
+        }
+        const start = await client.startGeneration(
+          compact({ model: args.model, input, project: args.project ?? cfg.activeProject ?? void 0 })
+        );
+        if (!start.success || !start.generation_id) {
+          if (isTeamGatingError(start.message)) return errorResult(await buildPickProjectMessage(client));
+          return errorResult(start.message || "Falha ao iniciar a gera\xE7\xE3o.");
+        }
+        const footer = costFooter(start, cfg);
+        const { settled, status } = await pollUntilDone(client, start.generation_id, MUSIC_BUDGET_MS);
+        if (!settled) {
+          return textResult(
+            `\u23F3 M\xFAsica ainda em produ\xE7\xE3o (id: ${start.generation_id}, ${status.progress ?? 0}%). Suno costuma levar alguns minutos \u2014 use check_generation com esse id.
+${footer}`
+          );
+        }
+        if (status.status === "failed") {
+          return errorResult(`Gera\xE7\xE3o falhou: ${status.error_message || "erro desconhecido"}.
+${footer}`);
+        }
+        const urls = outputUrls(status);
+        const list = urls.map((u, i) => `${i + 1}. ${u}`).join("\n") || "(sem URLs)";
+        return textResult(`\u2705 M\xFAsica gerada (${args.model}).
+${list}
+${footer}`);
+      } catch (e) {
+        const msg = e instanceof ApiError ? e.message : e instanceof Error ? e.message : "";
+        if (isTeamGatingError(msg)) return errorResult(await buildPickProjectMessage(client));
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+}
+
+// src/tools/account.ts
+import { z as z4 } from "zod";
+function registerAccountTools(server, client, _cfg) {
+  server.registerTool(
+    "whoami",
+    {
+      title: "Conta vinculada",
+      description: "Verifica o token (PAT) e mostra a conta BePlus vinculada (nome, email, saldo). Use para confirmar o v\xEDnculo.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const me = await client.me();
+        return textResult(
+          `\u{1F464} ${me.name ?? "(sem nome)"} <${me.email ?? "sem email"}>
+Saldo: ${me.diamonds} \u{1F48E} \xB7 auth: ${me.authType}`
+        );
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "get_balance",
+    {
+      title: "Saldo de diamantes",
+      description: "Mostra o saldo atual de diamantes da conta vinculada.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const b = await client.balance();
+        return textResult(`Saldo: ${b.diamonds} \u{1F48E}`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "list_models",
+    {
+      title: "Listar modelos",
+      description: "Lista os modelos dispon\xEDveis com pre\xE7o-base e limites por usu\xE1rio. Use quando estiver em d\xFAvida sobre qual modelo/params usar ou quanto custa. \xC9 a fonte de verdade em runtime.",
+      inputSchema: {
+        kind: z4.enum(["image", "video", "audio", "all"]).default("all").optional().describe("Filtrar por tipo.")
+      }
+    },
+    async () => {
+      try {
+        const m = await client.models();
+        const lines = m.models.map((x) => {
+          const price = typeof x.pricing === "number" ? `$${x.pricing}` : JSON.stringify(x.pricing);
+          return `\u2022 ${x.model} \u2014 ${price} (base USD)`;
+        });
+        const analyzeLines = (m.analyze ?? []).map(
+          (a) => `\u2022 ${a.model} (${a.label}) \u2014 $${a.inputCostPerMillion}/$${a.outputCostPerMillion} por 1M tok in/out \xB7 aceita img=${a.accepts.images} vid=${a.accepts.videos} \xE1udio=${a.accepts.audios} pdf=${a.accepts.pdfs}`
+        );
+        const analyzeBlock = analyzeLines.length ? `
+
+Modelos de an\xE1lise multimodal (tool analyze_media \u2014 prompt + m\xEDdia \u2192 texto):
+${analyzeLines.join("\n")}` : "";
+        const txt = `Modelos de gera\xE7\xE3o:
+${lines.join("\n") || "(nenhum)"}` + analyzeBlock + `
+
+Limites simult\xE2neos por usu\xE1rio: imagem=${m.limits.perUserMaxImage}, v\xEDdeo=${m.limits.perUserMaxVideo}, \xE1udio=${m.limits.perUserMaxAudio}.
+1 \u{1F48E} \u2248 $${m.pricing.diamondValueUsd} (margem ${m.pricing.diamondMargin}x, m\xEDn ${m.pricing.minDiamonds} \u{1F48E}). Use estimate_cost para o custo exato em diamantes (gera\xE7\xE3o).`;
+        return textResult(txt);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "estimate_cost",
+    {
+      title: "Estimar custo",
+      description: "Retorna o custo autoritativo em diamantes ANTES de gerar. Para \xE1udio (TTS) o custo \xE9 por segundo e s\xF3 \xE9 conhecido ap\xF3s a s\xEDntese.",
+      inputSchema: {
+        model: z4.string().min(1).describe("Id do modelo (ex.: google/nano-banana-pro, bytedance/seedance-2.0)."),
+        resolution: z4.string().optional(),
+        duration: z4.number().int().optional(),
+        mode: z4.string().optional(),
+        size: z4.string().optional(),
+        quality: z4.string().optional()
+      }
+    },
+    async (args) => {
+      try {
+        const c = await client.calculateCost(
+          compact({
+            model: args.model,
+            resolution: args.resolution,
+            duration: args.duration,
+            mode: args.mode,
+            size: args.size,
+            quality: args.quality
+          })
+        );
+        const note = c.fallback ? " [modelo desconhecido \u2014 custo m\xEDnimo]" : "";
+        return textResult(`Custo estimado: ${c.cost} \u{1F48E} (${c.model})${note}`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+}
+
+// src/tools/analyze.ts
+import { z as z5 } from "zod";
+function registerAnalyzeTools(server, client, _cfg) {
+  server.registerTool(
+    "analyze_media",
+    {
+      title: "Analisar m\xEDdia (Gemini)",
+      description: "Envia um prompt + m\xEDdia (imagem, v\xEDdeo, \xE1udio ou PDF) para o Gemini e devolve uma resposta em texto. Use para descrever/analisar/transcrever/resumir/extrair informa\xE7\xE3o de m\xEDdia, ou perguntar algo sobre ela. A m\xEDdia entra como `media_urls` (URLs p\xFAblicas \u2014 tudo que o Google aceita: imagens, v\xEDdeos, \xE1udios, PDFs). V\xEDdeo/\xE1udio grandes funcionam (v\xE3o pela Files API do Google). Consome diamantes (reembolsados se falhar). Veja custo/limites com list_models.",
+      inputSchema: {
+        prompt: z5.string().min(1).max(5e4).describe('O que voc\xEA quer do modelo sobre a m\xEDdia (ex.: "descreva este v\xEDdeo", "transcreva este \xE1udio").'),
+        media_urls: z5.array(z5.string().url()).max(50).optional().describe("URLs p\xFAblicas da m\xEDdia (imagem/v\xEDdeo/\xE1udio/PDF). Pode misturar tipos. Opcional (prompt s\xF3-texto tamb\xE9m funciona)."),
+        model: z5.enum(["gemini-flash", "gemini-pro"]).default("gemini-flash").optional().describe("gemini-flash = r\xE1pido/barato (Gemini 3.5 Flash); gemini-pro = mais capaz (Gemini 3.1 Pro).")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.analyzeMedia(
+          compact({
+            prompt: args.prompt,
+            media_urls: args.media_urls,
+            model: args.model
+          })
+        );
+        const footer = `
+
+\u2014 ${res.diamondsUsed} \u{1F48E} (saldo: ${res.newBalance}) \xB7 ${res.model} \xB7 ${res.inputTokens}\u2192${res.outputTokens} tok`;
+        return textResult(`${res.text}${footer}`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+}
+
+// src/tools/projects.ts
+import { z as z6 } from "zod";
+function projectLine(p, active) {
+  const marker = active ? "\u25CF " : "\u25CB ";
+  const counts = `${p.generation_count ?? 0} gera\xE7\xF5es`;
+  const owner = p.client_name ? ` \xB7 cliente: ${p.client_name}` : "";
+  return `${marker}${p.code} \u2014 ${p.name} (${counts}${owner})`;
+}
+function registerProjectTools(server, client, _cfg) {
+  server.registerTool(
+    "list_projects",
+    {
+      title: "Listar projetos",
+      description: "Lista os projetos do IA Lab em que a conta vinculada \xE9 membro, marcando qual est\xE1 ativo (\u25CF). Toda gera\xE7\xE3o feita sem `project` expl\xEDcito \xE9 vinculada ao projeto ativo. Use set_active_project para trocar.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const { projects } = await client.listProjects();
+        if (!projects.length) {
+          return textResult(
+            "Voc\xEA ainda n\xE3o \xE9 membro de nenhum projeto. Crie um com create_project, ou pe\xE7a a um admin para te adicionar."
+          );
+        }
+        const lines = projects.map((p) => projectLine(p, !!p.is_active_for_user));
+        const active = projects.find((p) => p.is_active_for_user);
+        const header = active ? `Projeto ativo: ${active.code} \u2014 ${active.name}` : "Nenhum projeto ativo (gera\xE7\xF5es ficam sem projeto).";
+        return textResult(`${header}
+
+${lines.join("\n")}`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "create_project",
+    {
+      title: "Criar projeto",
+      description: "Cria um projeto novo no IA Lab (workspace compartilhado), SEMPRE dentro de um cliente/marca, e por padr\xE3o j\xE1 o deixa ativo \u2014 gera\xE7\xF5es seguintes entram nele. S\xF3 membros da equipe podem criar. O campo `client` \xE9 obrigat\xF3rio: passe o code/uuid de um cliente existente (veja list_clients) OU o NOME de um cliente novo (ele \xE9 criado automaticamente). Projetos s\xE3o globais: todos da equipe usam.",
+      inputSchema: {
+        name: z6.string().min(1).max(256).describe('Nome do projeto (ex.: "Ladeira Abaixo").'),
+        client: z6.string().min(1).max(256).describe('Cliente/marca dono: code/uuid existente (ex.: "RDBL") OU nome novo (ex.: "Red Bull"). Obrigat\xF3rio.'),
+        description: z6.string().max(4e3).optional().describe("Descri\xE7\xE3o do projeto (opcional)."),
+        color: z6.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("Cor em hex #RRGGBB para o badge (opcional)."),
+        set_active: z6.boolean().optional().describe("Deixar o novo projeto como ativo (padr\xE3o true).")
+      }
+    },
+    async (args) => {
+      try {
+        const { project, is_active } = await client.createProject({
+          name: args.name,
+          client: args.client,
+          description: args.description,
+          color: args.color,
+          set_active: args.set_active
+        });
+        const activeNote = is_active ? " (definido como ativo)" : "";
+        return textResult(`\u2705 Projeto criado: ${project.code} \u2014 ${project.name}${activeNote}.`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "set_active_project",
+    {
+      title: "Definir projeto ativo",
+      description: 'Define o projeto ativo da conta (por uuid OU code curto, ex.: "VRAO-26"). A partir da\xED, gera\xE7\xF5es sem `project` expl\xEDcito s\xE3o vinculadas a ele \u2014 espelha o seletor de projeto da web. Passe project=null para limpar.',
+      inputSchema: {
+        project: z6.string().max(64).nullable().describe("uuid OU code curto do projeto. null para nenhum projeto.")
+      }
+    },
+    async ({ project }) => {
+      try {
+        const { project: active } = await client.setActiveProject(project ?? null);
+        if (!active) return textResult("\u2705 Projeto ativo removido \u2014 novas gera\xE7\xF5es ficar\xE3o sem projeto.");
+        return textResult(`\u2705 Projeto ativo: ${active.code} \u2014 ${active.name}.`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+}
+
+// src/tools/clients.ts
+import { z as z7 } from "zod";
+function clientLine(c, active) {
+  const marker = active ? "\u25CF " : "\u25CB ";
+  const counts = `${c.project_count ?? 0} projetos`;
+  return `${marker}${c.code} \u2014 ${c.name} (${counts})`;
+}
+function registerClientTools(server, client, _cfg) {
+  server.registerTool(
+    "list_clients",
+    {
+      title: "Listar clientes",
+      description: "Lista os clientes/marcas do IA Lab (globais para a equipe), marcando qual est\xE1 ativo (\u25CF). Cliente \xE9 o container ACIMA do projeto (Cliente \u2192 Projeto \u2192 gera\xE7\xE3o). Use antes de criar/escolher um projeto: primeiro o cliente, depois o projeto dele.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const { clients } = await client.listClients();
+        if (!clients.length) {
+          return textResult(
+            'Nenhum cliente ainda. Crie um com create_client (ex.: "Red Bull"), ou crie um projeto passando o nome do cliente em create_project \u2014 ele \xE9 criado junto.'
+          );
+        }
+        const lines = clients.map((c) => clientLine(c, !!c.is_active_for_user));
+        const active = clients.find((c) => c.is_active_for_user);
+        const header = active ? `Cliente ativo: ${active.code} \u2014 ${active.name}` : "Nenhum cliente ativo.";
+        return textResult(`${header}
+
+${lines.join("\n")}`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "create_client",
+    {
+      title: "Criar cliente",
+      description: 'Cria um cliente/marca novo (ex.: "Red Bull"). S\xF3 membros da equipe. Clientes s\xE3o globais: qualquer colega passa a v\xEA-lo e us\xE1-lo. Depois crie projetos dentro dele com create_project.',
+      inputSchema: {
+        name: z7.string().min(1).max(256).describe('Nome do cliente/marca (ex.: "Red Bull").')
+      }
+    },
+    async (args) => {
+      try {
+        const { client: created } = await client.createClient({ name: args.name });
+        return textResult(`\u2705 Cliente criado: ${created.code} \u2014 ${created.name}.`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "set_active_client",
+    {
+      title: "Definir cliente ativo",
+      description: 'Define o cliente ativo da conta (por uuid OU code curto, ex.: "RDBL"). Trocar de cliente limpa o projeto ativo se ele pertencia a outro cliente. Passe client=null para limpar.',
+      inputSchema: {
+        client: z7.string().max(64).nullable().describe("uuid OU code curto do cliente. null para nenhum.")
+      }
+    },
+    async ({ client: ref }) => {
+      try {
+        const { client: active } = await client.setActiveClient(ref ?? null);
+        if (!active) return textResult("\u2705 Cliente ativo removido.");
+        return textResult(`\u2705 Cliente ativo: ${active.code} \u2014 ${active.name}.`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+}
+
+// src/tools/calls.ts
+import { z as z8 } from "zod";
+var VIS_LABEL = {
+  team: "equipe",
+  private: "privada",
+  workspace: "projeto",
+  link: "link p\xFAblico"
+};
+function fmtDuration(sec) {
+  if (!sec || sec <= 0) return "\u2014";
+  const m = Math.floor(sec / 60);
+  const s = Math.floor(sec % 60);
+  return `${m}:${String(s).padStart(2, "0")}`;
+}
+function fmtDate(iso) {
+  return iso ? iso.slice(0, 10) : "";
+}
+function callLine(c) {
+  const proj = c.project_name ? ` \xB7 ${c.client_name ? c.client_name + " / " : ""}${c.project_name}` : "";
+  const who = c.speakers.length ? ` \xB7 ${c.speakers.join(", ")}` : c.participant_count ? ` \xB7 ${c.participant_count} falantes` : "";
+  const vis = VIS_LABEL[c.visibility] ?? c.visibility;
+  const flag = c.status !== "ready" ? ` [${c.status}]` : "";
+  return `\u2022 ${c.title ?? "(sem t\xEDtulo)"}${flag}
+  ${fmtDate(c.date)} \xB7 ${fmtDuration(c.duration_sec)} \xB7 ${vis}${proj}${who}
+  id: ${c.id}`;
+}
+function renderCall(c) {
+  const lines = [`# ${c.title ?? "(sem t\xEDtulo)"}`];
+  if (c.subtitle) lines.push(c.subtitle);
+  const meta = [];
+  if (c.date) meta.push(fmtDate(c.date));
+  meta.push(fmtDuration(c.duration_sec));
+  meta.push(VIS_LABEL[c.visibility] ?? c.visibility);
+  if (c.project_name) meta.push(`${c.client_name ? c.client_name + " / " : ""}${c.project_name}`);
+  if (c.status !== "ready") meta.push(`status: ${c.status}`);
+  lines.push(meta.join(" \xB7 "));
+  if (c.participants.length) lines.push(`Falantes: ${c.participants.join(", ")}`);
+  if (c.recording_url) lines.push(`Grava\xE7\xE3o: ${c.recording_url}`);
+  else if (c.audio_url) lines.push(`\xC1udio: ${c.audio_url}`);
+  if (c.summary) lines.push(`
+## Resumo
+${c.summary}`);
+  if (c.transcript.length) {
+    lines.push("\n## Transcri\xE7\xE3o");
+    let lastSpeaker = "";
+    for (const t of c.transcript) {
+      if (t.speaker !== lastSpeaker) {
+        lines.push(`
+${t.speaker}:`);
+        lastSpeaker = t.speaker;
+      }
+      lines.push(t.text);
+    }
+  } else {
+    lines.push("\n(transcri\xE7\xE3o ainda n\xE3o dispon\xEDvel)");
+  }
+  return lines.join("\n");
+}
+function registerCallTools(server, client, _cfg) {
+  server.registerTool(
+    "search_calls",
+    {
+      title: "Buscar calls",
+      description: "Busca nas calls (reuni\xF5es gravadas e transcritas) vis\xEDveis pra conta \u2014 suas, da equipe e compartilhadas. Todos os filtros s\xE3o opcionais e combin\xE1veis: `query` (texto no t\xEDtulo/projeto/cliente/falante), `project` (code/uuid/nome), `client` (code/nome), `visibility` (team|private|workspace|link), `speaker` (nome do falante). Retorna uma lista resumida \u2014 use get_call com o id pra ler a transcri\xE7\xE3o completa.",
+      inputSchema: {
+        query: z8.string().max(200).optional().describe("Texto livre \u2014 casa t\xEDtulo, projeto, cliente ou falante."),
+        project: z8.string().max(64).optional().describe('Projeto: code (ex.: "CONTEUDO-INS"), uuid ou parte do nome.'),
+        client: z8.string().max(128).optional().describe("Cliente: code ou parte do nome."),
+        visibility: z8.enum(["team", "private", "workspace", "link"]).optional().describe("Privacidade: team (equipe), private (privada), workspace (projeto) ou link."),
+        speaker: z8.string().max(128).optional().describe("Nome do falante."),
+        limit: z8.number().int().min(1).max(50).optional().describe("M\xE1ximo de resultados (padr\xE3o 20).")
+      }
+    },
+    async (args) => {
+      try {
+        const { calls, total } = await client.searchCalls(args);
+        if (!calls.length) return textResult("Nenhuma call encontrada com esses filtros.");
+        const header = total > calls.length ? `${calls.length} de ${total} calls:` : `${calls.length} call(s):`;
+        return textResult(`${header}
+
+${calls.map(callLine).join("\n\n")}`);
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+  server.registerTool(
+    "get_call",
+    {
+      title: "Ler call",
+      description: "Retorna o conte\xFAdo completo de uma call pelo id (use search_calls pra achar): t\xEDtulo, resumo, falantes, projeto/cliente, links da grava\xE7\xE3o e a TRANSCRI\xC7\xC3O inteira por falante. Respeita a visibilidade \u2014 s\xF3 retorna o que a conta pode ver.",
+      inputSchema: {
+        id: z8.string().min(1).max(64).describe("id (uuid) da call, obtido via search_calls.")
+      }
+    },
+    async ({ id }) => {
+      try {
+        const { call } = await client.getCall(id);
+        return textResult(renderCall(call));
+      } catch (e) {
+        return errorResult(apiErrorToUserMessage(e));
+      }
+    }
+  );
+}
+
+// src/server.ts
+function buildServer(cfg) {
+  const server = new McpServer({ name: "beplus", version: "0.8.0" });
+  const client = new BeplusClient(cfg);
+  registerGenerationTools(server, client, cfg);
+  registerAudioTools(server, client, cfg);
+  registerMusicTools(server, client, cfg);
+  registerAccountTools(server, client, cfg);
+  registerAnalyzeTools(server, client, cfg);
+  registerProjectTools(server, client, cfg);
+  registerClientTools(server, client, cfg);
+  registerCallTools(server, client, cfg);
+  return { server, client };
+}
+
+// src/index.ts
+async function main() {
+  let cfg;
+  try {
+    cfg = loadConfig();
+  } catch (e) {
+    logError(e.message);
+    process.exit(1);
+  }
+  const { server, client } = buildServer(cfg);
+  if (cfg.verifyOnStart) {
+    try {
+      const me = await client.me();
+      logInfo(`linked as ${me.name ?? me.email ?? me.userId} (${me.diamonds} \u{1F48E})`);
+    } catch (e) {
+      logError("startup verify failed:", e?.message ?? "unknown");
+    }
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logInfo(`ready \u2014 api=${cfg.baseUrl}`);
+}
+process.on("uncaughtException", (e) => {
+  logError("uncaughtException", e?.message ?? String(e));
+  process.exit(1);
+});
+process.on("unhandledRejection", (e) => {
+  logError("unhandledRejection", String(e));
+  process.exit(1);
+});
+main().catch((e) => {
+  logError("fatal", e?.message ?? String(e));
+  process.exit(1);
+});