@ararahq/mcp 5.0.0 → 6.0.0

package/build/tools/campaigns.js

@@ -0,0 +1,215 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { MAX_PAGE_SIZE } from "../config.js";
+import { apiRequest } from "../lib/api.js";
+import { AraraError } from "../lib/errors.js";
+import { resolveRecipient } from "../lib/recipients.js";
+import { campaignDetailSchema, campaignEstimateSchema, campaignListSchema, campaignSchema, pagedTemplatesSchema, } from "../lib/schemas.js";
+import { templateButtonLabels } from "../lib/templates.js";
+import { renderTemplateBody } from "../ui/model/format.js";
+import { uiResourceUri } from "../ui/resources.js";
+import { execute } from "../mcp/result.js";
+import { readOnly, register, write } from "./register.js";
+import { e164Schema, recipientInputSchema, variablesSchema } from "./send.js";
+const MAX_BROADCAST_RECIPIENTS = 1000;
+const MAX_UNRESOLVED_LISTED = 10;
+const DEFAULT_CAMPAIGN_PAGE_SIZE = 20;
+const AB_DEFAULT_SAMPLE_PCT = 20;
+const AB_DEFAULT_SPLIT_PCT = 50;
+const AB_DEFAULT_DECISION_MINUTES = 240;
+const AB_DEFAULT_METRIC = "CLICKED";
+const idSchema = z.string().uuid();
+const recipientEntrySchema = z.union([
+    recipientInputSchema,
+    z.object({ to: recipientInputSchema, variables: variablesSchema }),
+]);
+const recipientsSchema = z.array(recipientEntrySchema).min(1).max(MAX_BROADCAST_RECIPIENTS);
+const abTestSchema = z.object({
+    variantBTemplateName: z.string().trim().min(1),
+    metric: z.enum(["DELIVERED", "READ", "CLICKED", "CONVERTED"]).default(AB_DEFAULT_METRIC),
+    samplePct: z.number().int().min(1).max(99).default(AB_DEFAULT_SAMPLE_PCT),
+    decisionWindowMinutes: z.number().int().min(1).default(AB_DEFAULT_DECISION_MINUTES),
+    autopilot: z.boolean().default(true),
+});
+export const resolveCampaignContacts = async (entries, sharedVariables) => {
+    const settled = await Promise.all(entries.map(async (entry) => {
+        const to = typeof entry === "string" ? entry : entry.to;
+        const variables = typeof entry === "string" ? sharedVariables : entry.variables;
+        try {
+            const recipient = await resolveRecipient(to);
+            return { to: recipient.phone, variables };
+        }
+        catch {
+            return { unresolved: to };
+        }
+    }));
+    const contacts = settled.filter((item) => "to" in item);
+    const unresolved = settled
+        .filter((item) => "unresolved" in item)
+        .map((item) => item.unresolved);
+    return { contacts, unresolved };
+};
+const defaultCampaignName = () => `Broadcast ${new Date().toISOString().slice(0, 16).replace("T", " ")}`;
+const buildAbTest = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    const parsed = abTestSchema.parse(raw);
+    return { ...parsed, splitPct: AB_DEFAULT_SPLIT_PCT };
+};
+const planBroadcast = async (input) => {
+    const entries = recipientsSchema.parse(input.to);
+    const shared = variablesSchema.parse(input.variables);
+    const { contacts, unresolved } = await resolveCampaignContacts(entries, shared);
+    if (contacts.length === 0) {
+        throw new AraraError("NO_VALID_RECIPIENTS", `No recipient could be resolved: ${unresolved.join(", ")}.`, 400, false);
+    }
+    return {
+        name: typeof input.name === "string" ? input.name : defaultCampaignName(),
+        templateName: z.string().trim().min(1).parse(input.templateName),
+        contacts,
+        unresolved,
+        sender: typeof input.from === "string" ? input.from : undefined,
+        scheduledAt: typeof input.scheduledAt === "string" ? input.scheduledAt : undefined,
+        abTest: buildAbTest(input.abTest),
+    };
+};
+/** Template body and buttons rendered with the first contact's variables. Never blocks a send. */
+const loadTemplatePreview = async (plan) => {
+    const fallback = { renderedBody: "", buttons: [], category: "" };
+    const params = new URLSearchParams({ name: plan.templateName, size: "1" });
+    const templates = await apiRequest(`/v1/templates?${params.toString()}`, {
+        schema: pagedTemplatesSchema,
+    }).catch(() => []);
+    const [template] = templates;
+    if (template === undefined)
+        return fallback;
+    const body = typeof template.bodyPreview === "string" ? template.bodyPreview : "";
+    const variables = plan.contacts[0]?.variables ?? [];
+    return {
+        renderedBody: renderTemplateBody(body, variables),
+        buttons: templateButtonLabels(template.structureJson),
+        category: template.category,
+    };
+};
+const previewRequest = (input) => Object.fromEntries(Object.entries(input).filter(([key, value]) => key !== "dryRun" && value !== undefined));
+const previewBroadcast = async (input) => {
+    const plan = await planBroadcast(input);
+    const [template, estimate] = await Promise.all([
+        loadTemplatePreview(plan),
+        apiRequest("/v1/campaigns/estimate", {
+            method: "POST",
+            body: { templateName: plan.templateName, phones: plan.contacts.map((contact) => contact.to) },
+            schema: campaignEstimateSchema,
+            retry: false,
+        }),
+    ]);
+    const data = {
+        preview: true,
+        templateName: plan.templateName,
+        renderedBody: template.renderedBody,
+        buttons: template.buttons,
+        category: template.category || estimate.templateCategory,
+        recipients: plan.contacts.length,
+        unresolved: plan.unresolved,
+        totalCost: estimate.totalCost,
+        unitPrice: estimate.unitPrice,
+        abTest: plan.abTest,
+        scheduledAt: plan.scheduledAt,
+        request: previewRequest(input),
+    };
+    return {
+        data,
+        message: `Preview only, nothing sent. '${plan.templateName}' would reach ${plan.contacts.length} recipient(s) for ${estimate.totalCost.toFixed(2)}. Call broadcast again with dryRun=false to send.`,
+    };
+};
+const sendBroadcast = async (input) => {
+    const plan = await planBroadcast(input);
+    const idempotencyKey = typeof input.idempotencyKey === "string" ? input.idempotencyKey : randomUUID();
+    const [data, template] = await Promise.all([
+        apiRequest("/v1/campaigns", {
+            method: "POST",
+            body: {
+                name: plan.name,
+                templateName: plan.templateName,
+                contacts: plan.contacts,
+                ...(plan.sender === undefined ? {} : { sender: plan.sender }),
+                ...(plan.scheduledAt === undefined ? {} : { scheduledAt: plan.scheduledAt }),
+                ...(plan.abTest === undefined ? {} : { abTest: plan.abTest }),
+            },
+            schema: campaignSchema,
+            idempotencyKey,
+        }),
+        loadTemplatePreview(plan),
+    ]);
+    const unresolvedNote = plan.unresolved.length === 0
+        ? ""
+        : ` ${plan.unresolved.length} recipient(s) not resolved: ${plan.unresolved.slice(0, MAX_UNRESOLVED_LISTED).join(", ")}.`;
+    return {
+        data: {
+            ...data,
+            unresolved: plan.unresolved,
+            idempotencyKey,
+            renderedBody: template.renderedBody,
+            buttons: template.buttons,
+        },
+        message: `Campaign '${data.name}' accepted for ${data.totalMessages} recipient(s), total cost ${data.totalCost.toFixed(2)}.${unresolvedNote} Follow it with campaign_report.`,
+    };
+};
+const registerBroadcast = (server) => {
+    register(server, "broadcast", "Send an approved template to many people at once (up to 1000) as a campaign. By default it is a dry run: it resolves the audience, renders the message and estimates the cost without sending, so the user can approve. Call again with dryRun=false to send. Each entry in 'to' is a phone or contact name (uses the shared 'variables') or an object {to, variables} for per-person values. Optional 'abTest' runs an A/B test; optional 'scheduledAt' (ISO-8601) schedules instead of sending now. Unresolved recipients are listed, not silently dropped.", {
+        templateName: z.string().trim().min(1),
+        to: recipientsSchema,
+        variables: variablesSchema.default([]),
+        name: z.string().trim().min(1).max(255).optional(),
+        from: e164Schema.optional(),
+        scheduledAt: z.string().datetime().optional(),
+        abTest: abTestSchema.optional(),
+        dryRun: z.boolean().default(true),
+        idempotencyKey: z.string().uuid().optional(),
+    }, write, async (input) => execute(async () => input.dryRun === false ? sendBroadcast(input) : previewBroadcast(input)), { ui: uiResourceUri("broadcast") });
+};
+const listCampaigns = async (input) => {
+    const page = z.number().int().nonnegative().default(0).parse(input.page);
+    const size = z
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_PAGE_SIZE)
+        .default(DEFAULT_CAMPAIGN_PAGE_SIZE)
+        .parse(input.size);
+    const params = new URLSearchParams({ page: String(page), size: String(size) });
+    if (typeof input.status === "string" && input.status.length > 0) {
+        params.set("status", input.status);
+    }
+    const data = await apiRequest(`/v1/campaigns?${params.toString()}`, {
+        schema: campaignListSchema,
+    });
+    return {
+        data: { ...data, pagination: { ...data.pagination, page, size } },
+        message: `${data.data.length} campaign(s) loaded. Pass campaignId for the full report.`,
+    };
+};
+const getCampaign = async (campaignId) => {
+    const data = await apiRequest(`/v1/campaigns/${campaignId}`, { schema: campaignDetailSchema });
+    const pct = (count) => data.totalMessages > 0 ? ` (${Math.round((count / data.totalMessages) * 100)}%)` : "";
+    const message = [
+        `Campaign '${data.name}' [${data.status}] with template ${data.templateName}.`,
+        `Sent ${data.sentCount}${pct(data.sentCount)}, delivered ${data.deliveredCount}${pct(data.deliveredCount)}, read ${data.readCount}${pct(data.readCount)}, clicked ${data.clickedCount}${pct(data.clickedCount)}, replied ${data.replyCount}${pct(data.replyCount)}.`,
+        `Converted ${data.convertedCount} worth ${data.convertedValue.toFixed(2)}. Cost ${data.totalCost.toFixed(2)}.`,
+    ].join(" ");
+    return { data, message };
+};
+const registerCampaignReport = (server) => {
+    register(server, "campaign_report", "See what came back. Without 'campaignId' it lists recent campaigns (newest first, optional 'status' filter such as COMPLETED, AB_TESTING, SCHEDULED, CANCELED). With 'campaignId' it returns the full report: sent, delivered, read, clicked, replied, converted with value, blocked with reasons, refunds and cost.", {
+        campaignId: idSchema.optional(),
+        status: z.string().trim().max(40).optional(),
+        page: z.number().int().nonnegative().default(0),
+        size: z.number().int().min(1).max(MAX_PAGE_SIZE).default(DEFAULT_CAMPAIGN_PAGE_SIZE),
+    }, readOnly, async (input) => execute(async () => typeof input.campaignId === "string"
+        ? getCampaign(idSchema.parse(input.campaignId))
+        : listCampaigns(input)), { ui: uiResourceUri("campaign") });
+};
+export const registerCampaignTools = (server) => {
+    registerBroadcast(server);
+    registerCampaignReport(server);
+};

package/build/tools/contacts.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { apiRequest } from "../lib/api.js";
+import { recipientLabel, resolveRecipient } from "../lib/recipients.js";
+import { contactsBatchSchema, conversationSchema, jsonValueSchema, mutationSchema, } from "../lib/schemas.js";
+import { execute } from "../mcp/result.js";
+import { uiResourceUri } from "../ui/resources.js";
+import { destructive, idempotentWrite, readOnly, register } from "./register.js";
+import { e164Schema, recipientInputSchema } from "./send.js";
+const MAX_CONTACTS_PER_BATCH = 1000;
+const MAX_CONTACT_NAME = 255;
+const MAX_EMAIL = 255;
+const MAX_ERRORS_LISTED = 10;
+const MAX_OPT_OUT_REASON = 80;
+const DEFAULT_CONVERSATION_LIMIT = 30;
+const MAX_CONVERSATION_LIMIT = 100;
+const INBOUND_DIRECTION = "INBOUND";
+const contactSchema = z.object({
+    name: z.string().trim().min(1).max(MAX_CONTACT_NAME),
+    phone: e164Schema,
+    email: z.string().email().max(MAX_EMAIL).optional(),
+    attributes: z.record(jsonValueSchema).optional(),
+});
+const contactsSchema = z.array(contactSchema).min(1).max(MAX_CONTACTS_PER_BATCH);
+const registerSaveContacts = (server) => {
+    register(server, "save_contacts", "Create or update up to 1000 contacts in one call so you can message people by name. Phone must be E.164 (+5511999998888). Returns created, updated and skipped counts plus per-row errors.", { contacts: contactsSchema }, idempotentWrite, async (input) => execute(async () => {
+        const contacts = contactsSchema.parse(input.contacts);
+        const data = await apiRequest("/v1/contacts/batch", {
+            method: "POST",
+            body: contacts,
+            schema: contactsBatchSchema,
+            retry: false,
+        });
+        const errors = data.errors.length === 0
+            ? ""
+            : ` ${data.errors.length} error(s): ${data.errors
+                .slice(0, MAX_ERRORS_LISTED)
+                .map((item) => `#${item.index} ${item.phone ?? "?"} ${item.reason}`)
+                .join("; ")}.`;
+        return {
+            data,
+            message: `Contacts saved: ${data.created} created, ${data.updated} updated, ${data.skipped} skipped.${errors}`,
+        };
+    }));
+};
+const registerOptOut = (server) => {
+    register(server, "opt_out", "Record that a person no longer wants messages from this organization. Idempotent. Use whenever someone replies STOP/PARAR or asks to leave; the backend then blocks every send to them.", { phone: e164Schema, reason: z.string().trim().min(1).max(MAX_OPT_OUT_REASON).optional() }, destructive, async (input) => execute(async () => ({
+        data: await apiRequest("/v1/opt-outs", {
+            method: "POST",
+            body: {
+                phone: input.phone,
+                ...(typeof input.reason === "string" ? { reason: input.reason } : {}),
+            },
+            schema: mutationSchema,
+            retry: false,
+        }),
+        message: `Opt-out recorded for ${String(input.phone)}.`,
+    })));
+};
+const registerReadConversation = (server) => {
+    register(server, "read_conversation", "Read what a person actually wrote: the raw message timeline with one contact, newest first, each line marked as customer or you. Use it to judge a reply before answering with send_whatsapp.", {
+        to: recipientInputSchema,
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(MAX_CONVERSATION_LIMIT)
+            .default(DEFAULT_CONVERSATION_LIMIT),
+    }, readOnly, async (input) => execute(async () => {
+        const recipient = await resolveRecipient(recipientInputSchema.parse(input.to));
+        const limit = z.number().int().min(1).max(MAX_CONVERSATION_LIMIT).parse(input.limit);
+        const params = new URLSearchParams({ limit: String(limit) });
+        const data = await apiRequest(`/v1/contacts/${recipient.phone}/messages?${params.toString()}`, { schema: conversationSchema });
+        const inbound = data.messages.filter((item) => item.direction.toUpperCase() === INBOUND_DIRECTION).length;
+        return {
+            data: { ...data, recipient },
+            message: `${data.total} message(s) with ${recipientLabel(recipient)}, ${inbound} from the customer in this page.`,
+        };
+    }), { ui: uiResourceUri("conversation") });
+};
+export const registerContactTools = (server) => {
+    registerSaveContacts(server);
+    registerOptOut(server);
+    registerReadConversation(server);
+};

package/build/tools/index.js

@@ -1,284 +1,41 @@
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { MAX_PAGE_SIZE } from "../config.js";
 import { apiRequest } from "../lib/api.js";
-import { AraraError } from "../lib/errors.js";
-import { automationSchema, automationsSchema, campaignSchema, coverageSchema, identitySchema, jsonValueSchema, messageSchema, mutationSchema, pagedInboxSchema, pagedMessagesSchema, planSchema, routineSchema, templateSchema, templatesSchema, todaySchema, } from "../lib/schemas.js";
-import { execute, toolOutputSchema } from "../mcp/result.js";
-const readOnly = {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: true,
-};
-const write = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: true,
-};
-const idempotentWrite = { ...write, idempotentHint: true };
-const destructive = {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: true,
-    openWorldHint: true,
-};
-const idSchema = z.string().uuid();
-const e164Schema = z.string().regex(/^\+[1-9]\d{6,14}$/, "Use E.164, for example +5511999999999.");
-const routineKeySchema = z.enum(["support", "billing", "scheduling"]);
-const routinesResponseSchema = z.object({ data: z.array(routineSchema) });
-const register = (server, name, description, inputSchema, annotations, handler) => {
-    server.registerTool(name, { description, inputSchema, outputSchema: toolOutputSchema, annotations }, handler);
-};
+import { balanceSchema, identitySchema, planSchema } from "../lib/schemas.js";
+import { execute } from "../mcp/result.js";
+import { registerCampaignTools } from "./campaigns.js";
+import { registerContactTools } from "./contacts.js";
+import { readOnly, register } from "./register.js";
+import { registerSendTools } from "./send.js";
+import { registerTemplateTools } from "./templates.js";
+export { destructive, idempotentWrite, readOnly, register, write } from "./register.js";
 export const TOOL_NAMES = [
     "whoami",
-    "get_today",
-    "find_conversations",
-    "get_conversation",
-    "reply_to_conversation",
-    "claim_conversation",
-    "close_conversation",
-    "list_automations",
-    "get_automation",
-    "prepare_campaign",
-    "publish_campaign",
     "send_whatsapp",
-    "check_message",
-    "save_contacts",
+    "broadcast",
+    "campaign_report",
+    "check_status",
     "create_template",
-    "get_template_status",
+    "save_contacts",
     "opt_out",
+    "read_conversation",
 ];
-export const registerAllTools = (server) => {
-    register(server, "whoami", "Return the authenticated AraraHQ identity and organization plan.", {}, readOnly, async () => execute(async () => {
-        const [identity, plan] = await Promise.all([
+const registerWhoami = (server) => {
+    register(server, "whoami", "Confirm who is authenticated, which organization will send, the current plan and the wallet balance. Call it before the first broadcast of a session.", {}, readOnly, async () => execute(async () => {
+        const [identity, plan, balance] = await Promise.all([
             apiRequest("/auth/me", { schema: identitySchema }),
             apiRequest("/v1/organizations/me/plan", { schema: planSchema }),
+            apiRequest("/dashboard/wallet/balance", { schema: balanceSchema }),
         ]);
+        const planName = typeof plan.current === "string" ? plan.current : "unknown";
         return {
-            data: { identity, plan },
-            message: `Authenticated as ${identity.name} (${identity.email}).`,
-        };
-    }));
-    register(server, "get_today", "Return today's Atendimento queue across support, billing and scheduling.", {}, readOnly, async () => execute(async () => ({
-        data: await apiRequest("/v1/operation/today", { schema: todaySchema }),
-        message: "Today's operation loaded.",
-    })));
-    register(server, "find_conversations", "Find Atendimento conversations with stable pagination. Use this before selecting a conversation.", {
-        filter: z.string().max(100).optional(),
-        page: z.number().int().nonnegative().default(0),
-        size: z.number().int().min(1).max(MAX_PAGE_SIZE).default(50),
-    }, readOnly, async (input) => execute(async () => {
-        const params = new URLSearchParams({ page: String(input.page), size: String(input.size) });
-        if (typeof input.filter === "string" && input.filter.length > 0)
-            params.set("filter", input.filter);
-        const data = await apiRequest(`/v1/operation/inbox?${params.toString()}`, {
-            schema: pagedInboxSchema,
-        });
-        return { data, message: `${data.data.length} conversation(s) loaded.` };
-    }));
-    register(server, "get_conversation", "Load a paginated message timeline. Conversation metadata comes from find_conversations.", {
-        conversationId: idSchema,
-        page: z.number().int().nonnegative().default(0),
-        size: z.number().int().min(1).max(MAX_PAGE_SIZE).default(50),
-    }, readOnly, async (input) => execute(async () => {
-        const conversationId = idSchema.parse(input.conversationId);
-        const page = z.number().int().nonnegative().parse(input.page);
-        const size = z.number().int().min(1).max(MAX_PAGE_SIZE).parse(input.size);
-        const data = await apiRequest(`/v1/conversations/${conversationId}/messages?page=${page}&size=${size}`, { schema: pagedMessagesSchema });
-        return {
-            data: { conversationId, ...data },
-            message: `${data.data.length} message(s) loaded.`,
-        };
-    }));
-    register(server, "reply_to_conversation", "Reply inside an Atendimento conversation. Accepted means queued, not delivered.", {
-        conversationId: idSchema,
-        body: z.string().trim().min(1).max(4096),
-    }, write, async (input) => execute(async () => ({
-        data: await apiRequest("/v1/conversations/reply", {
-            method: "POST",
-            body: input,
-            schema: mutationSchema,
-            retry: false,
-        }),
-        message: "Reply accepted and queued for delivery.",
-    })));
-    register(server, "claim_conversation", "Assign an unowned conversation to the authenticated operator.", { conversationId: idSchema }, idempotentWrite, async (input) => execute(async () => {
-        const conversationId = idSchema.parse(input.conversationId);
-        return {
-            data: await apiRequest(`/v1/operation/inbox/${conversationId}/claim`, {
-                method: "POST",
-                body: {},
-                schema: mutationSchema,
-                retry: false,
-            }),
-            message: "Conversation claimed.",
-        };
-    }));
-    register(server, "close_conversation", "Close a conversation after its outcome and next step are resolved.", { conversationId: idSchema }, destructive, async (input) => execute(async () => {
-        const conversationId = idSchema.parse(input.conversationId);
-        return {
-            data: await apiRequest(`/v1/conversations/${conversationId}/status`, {
-                method: "PATCH",
-                body: { status: "CLOSED" },
-                schema: mutationSchema,
-            }),
-            message: "Conversation closed.",
-        };
-    }));
-    register(server, "list_automations", "List configured automations.", {}, readOnly, async () => execute(async () => {
-        const data = await apiRequest("/v1/automations", { schema: automationsSchema });
-        return { data, message: `${data.length} automation(s) loaded.` };
-    }));
-    register(server, "get_automation", "Inspect an automation's trigger, steps, cost and status.", { automationId: idSchema }, readOnly, async (input) => execute(async () => {
-        const automationId = idSchema.parse(input.automationId);
-        const data = await apiRequest(`/v1/automations/${automationId}`, {
-            schema: automationSchema,
-        });
-        return { data, message: `Automation ${data.name} loaded.` };
-    }));
-    register(server, "prepare_campaign", "Load campaign preflight: guidance, published Atendimento routines, approved templates and coverage.", {}, readOnly, async () => execute(async () => {
-        const [copilot, routines, templates, coverage] = await Promise.all([
-            apiRequest("/v1/operation/copilot/campaign", { schema: z.record(jsonValueSchema) }),
-            apiRequest("/v1/operation/routines", { schema: routinesResponseSchema }),
-            apiRequest("/v1/templates", { schema: templatesSchema }),
-            apiRequest("/v1/operation/coverage", { schema: coverageSchema }),
-        ]);
-        return {
-            data: {
-                copilot,
-                coverage,
-                publishedRoutines: routines.data.filter((routine) => routine.published),
-                approvedTemplates: templates.filter((template) => template.providerStatus === "APPROVED" && template.availableForSending),
-            },
-            message: "Campaign preflight loaded. Review it before publishing.",
-        };
-    }));
-    const campaignContactSchema = z.object({
-        to: e164Schema,
-        variables: z.array(z.string().max(1024)).max(20).default([]),
-    });
-    register(server, "publish_campaign", "Publish a template campaign after validating its template and Atendimento destination routine.", {
-        name: z.string().trim().min(1).max(255),
-        templateName: z.string().trim().min(1),
-        routineKey: routineKeySchema,
-        contacts: z.array(campaignContactSchema).min(1).max(1000),
-        sender: e164Schema.optional(),
-        scheduledAt: z.string().datetime().optional(),
-        idempotencyKey: z.string().uuid().optional(),
-    }, write, async (input) => execute(async () => {
-        const [routines, templates] = await Promise.all([
-            apiRequest("/v1/operation/routines", { schema: routinesResponseSchema }),
-            apiRequest("/v1/templates", { schema: templatesSchema }),
-        ]);
-        const routineKey = routineKeySchema.parse(input.routineKey);
-        if (!routines.data.some((routine) => routine.key === routineKey && routine.published)) {
-            throw new AraraError("ROUTINE_NOT_PUBLISHED", `Atendimento routine '${routineKey}' is not published.`, 409, false);
-        }
-        if (!templates.some((template) => template.name === input.templateName &&
-            template.providerStatus === "APPROVED" &&
-            template.availableForSending)) {
-            throw new AraraError("TEMPLATE_NOT_AVAILABLE", `Template '${String(input.templateName)}' is not approved and available.`, 409, false);
-        }
-        const idempotencyKey = typeof input.idempotencyKey === "string" ? input.idempotencyKey : randomUUID();
-        const data = await apiRequest("/v1/campaigns", {
-            method: "POST",
-            body: {
-                name: input.name,
-                templateName: input.templateName,
-                routineKey,
-                contacts: input.contacts,
-                ...(input.sender === undefined ? {} : { sender: input.sender }),
-                ...(input.scheduledAt === undefined ? {} : { scheduledAt: input.scheduledAt }),
-            },
-            schema: campaignSchema,
-            idempotencyKey,
-        });
-        return {
-            data: { ...data, idempotencyKey },
-            message: `Campaign '${data.name}' accepted with ${data.totalMessages} message(s).`,
+            data: { identity, plan, balance },
+            message: `Authenticated as ${identity.name} (${identity.email}) on plan ${planName}.`,
         };
     }));
-    register(server, "send_whatsapp", "Send one WhatsApp text message to an E.164 number. Accepted means queued, not delivered.", {
-        to: e164Schema,
-        message: z.string().trim().min(1).max(4096),
-        from: e164Schema.optional(),
-        idempotencyKey: z.string().uuid().optional(),
-    }, write, async (input) => execute(async () => {
-        const idempotencyKey = typeof input.idempotencyKey === "string" ? input.idempotencyKey : randomUUID();
-        const data = await apiRequest("/v1/messages", {
-            method: "POST",
-            body: {
-                receiver: input.to,
-                body: input.message,
-                type: "text",
-                ...(input.from === undefined ? {} : { sender: input.from }),
-            },
-            schema: messageSchema,
-            idempotencyKey,
-        });
-        return {
-            data: { ...data, idempotencyKey },
-            message: `Message ${data.id ?? "accepted"} queued. Use check_message to verify delivery.`,
-        };
-    }));
-    register(server, "check_message", "Check the provider delivery state for a message.", { messageId: idSchema }, readOnly, async (input) => execute(async () => {
-        const messageId = idSchema.parse(input.messageId);
-        return {
-            data: await apiRequest(`/v1/messages/${messageId}`, { schema: mutationSchema }),
-            message: "Message status loaded.",
-        };
-    }));
-    const contactSchema = z.object({
-        name: z.string().trim().min(1).max(255),
-        phone: e164Schema,
-        email: z.string().email().max(255).optional(),
-        attributes: z.record(jsonValueSchema).optional(),
-    });
-    register(server, "save_contacts", "Create or update contacts in one batch.", { contacts: z.array(contactSchema).min(1).max(1000) }, idempotentWrite, async (input) => execute(async () => ({
-        data: await apiRequest("/v1/contacts/batch", {
-            method: "POST",
-            body: input.contacts,
-            schema: mutationSchema,
-            retry: false,
-        }),
-        message: "Contact batch processed.",
-    })));
-    register(server, "create_template", "Submit a WhatsApp template for Meta approval.", {
-        name: z
-            .string()
-            .regex(/^[a-z0-9_]+$/)
-            .max(512),
-        category: z.enum(["MARKETING", "UTILITY", "AUTHENTICATION"]),
-        body: z.string().trim().min(1).max(4096),
-        language: z.string().default("pt_BR"),
-        footer: z.string().max(60).optional(),
-    }, write, async (input) => execute(async () => ({
-        data: await apiRequest("/v1/templates", {
-            method: "POST",
-            body: input,
-            schema: templateSchema,
-            retry: false,
-        }),
-        message: "Template submitted for approval.",
-    })));
-    register(server, "get_template_status", "Check the Meta approval status for a template.", { templateId: idSchema }, readOnly, async (input) => execute(async () => {
-        const templateId = idSchema.parse(input.templateId);
-        return {
-            data: await apiRequest(`/v1/templates/${templateId}/status`, {
-                schema: mutationSchema,
-            }),
-            message: "Template status loaded.",
-        };
-    }));
-    register(server, "opt_out", "Record a WhatsApp opt-out and suppress future sends.", { phone: e164Schema, reason: z.string().trim().min(1).max(80).optional() }, destructive, async (input) => execute(async () => ({
-        data: await apiRequest("/v1/opt-outs", {
-            method: "POST",
-            body: input,
-            schema: mutationSchema,
-            retry: false,
-        }),
-        message: "Opt-out recorded.",
-    })));
+};
+export const registerAllTools = (server) => {
+    registerWhoami(server);
+    registerSendTools(server);
+    registerCampaignTools(server);
+    registerTemplateTools(server);
+    registerContactTools(server);
 };