@affset/mcp 0.1.0

package/dist/lib/time.js

@@ -0,0 +1,234 @@
+/**
+ * Date-range resolution for stats queries.
+ *
+ * Every boundary here is computed in the TENANT's timezone, not the timezone of
+ * the machine running this server. The API buckets `group_by=date` by the tenant
+ * timezone, so resolving "today" against the operator's laptop clock would ask
+ * for a window that straddles two of the buckets it gets back — a single "today"
+ * arriving as two partial rows. Callers fetch the tenant timezone (see
+ * AffsetClient#getTenantTimezone) and pass it in.
+ */
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+const ISO_TIMESTAMP = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(Z|[+-]\d{2}:\d{2})$/i;
+const MAX_DATE_MS = 8_640_000_000_000_000;
+export const RANGE_PRESETS = [
+    "today",
+    "yesterday",
+    "last_7_days",
+    "last_30_days",
+    "this_month",
+];
+function parseCalendarDay(value) {
+    const [y, month, d] = value.split("-").map(Number);
+    const m = month - 1;
+    const check = new Date(Date.UTC(y, m, d));
+    if (check.getUTCFullYear() !== y || check.getUTCMonth() !== m || check.getUTCDate() !== d) {
+        throw new Error(`Invalid date "${value}". Use a real YYYY-MM-DD calendar date.`);
+    }
+    return { y, m, d };
+}
+/**
+ * UTC offset in ms of `timeZone` at a specific instant. Resolved per instant
+ * rather than per day because a zone's offset changes partway through a DST
+ * transition day.
+ */
+function offsetMsAt(utcMs, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+    }).formatToParts(new Date(utcMs));
+    const get = (name) => parseInt(parts.find((p) => p.type === name)?.value ?? "0", 10);
+    // en-CA with hour12:false renders midnight as "24"; normalise it.
+    const hour = get("hour") % 24;
+    const localAsUtcMs = Date.UTC(get("year"), get("month") - 1, get("day"), hour, get("minute"), get("second"));
+    return localAsUtcMs - Math.floor(utcMs / 1000) * 1000;
+}
+/** Which calendar day an instant falls on, in the given timezone. */
+function calendarDayIn(utcMs, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).formatToParts(new Date(utcMs));
+    const get = (name) => parseInt(parts.find((p) => p.type === name)?.value ?? "0", 10);
+    return { y: get("year"), m: get("month") - 1, d: get("day") };
+}
+/** Shift a calendar day by whole days. Zone-free arithmetic; handles rollover. */
+function addDays(day, n) {
+    const t = new Date(Date.UTC(day.y, day.m, day.d + n));
+    return { y: t.getUTCFullYear(), m: t.getUTCMonth(), d: t.getUTCDate() };
+}
+/**
+ * Epoch ms for 00:00:00.000 on a calendar day in a timezone.
+ *
+ * Two passes: the offset we need is the one in force at local midnight, and that
+ * is not knowable until the instant is. A fixed-hour guess is wrong on DST
+ * transition days.
+ */
+function startOfDayMs(day, timeZone) {
+    const wallClock = Date.UTC(day.y, day.m, day.d, 0, 0, 0, 0);
+    const firstGuess = wallClock - offsetMsAt(wallClock, timeZone);
+    return wallClock - offsetMsAt(firstGuess, timeZone);
+}
+/**
+ * Epoch ms for 23:59:59.999 on a calendar day in a timezone. Derived from the
+ * next day's start so 23h and 25h days end on the right instant.
+ */
+function endOfDayMs(day, timeZone) {
+    return startOfDayMs(addDays(day, 1), timeZone) - 1;
+}
+/** Format epoch ms as a YYYY-MM-DD calendar day in the tenant timezone. */
+function fmtDay(ms, timeZone) {
+    const { y, m, d } = calendarDayIn(ms, timeZone);
+    return `${y}-${String(m + 1).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+}
+/**
+ * Parse an explicit bound: epoch-ms string, YYYY-MM-DD calendar day, or ISO
+ * timestamp with an explicit offset. Date-only strings are read as calendar
+ * days in the tenant timezone — matching the presets and the API's date buckets
+ * — and for `to` mean end-of-day so a full calendar day is included.
+ */
+function parseBound(value, role, timeZone) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    if (/^\d+$/.test(trimmed))
+        return parseEpochMs(Number(trimmed), value);
+    if (DATE_ONLY.test(trimmed)) {
+        const day = parseCalendarDay(trimmed);
+        return role === "to" ? endOfDayMs(day, timeZone) : startOfDayMs(day, timeZone);
+    }
+    return parseIsoTimestamp(trimmed);
+}
+function parseEpochMs(value, original) {
+    if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_DATE_MS) {
+        throw new Error(`Invalid date "${original}". Epoch milliseconds must be a positive safe integer.`);
+    }
+    return value;
+}
+function parseIsoTimestamp(value) {
+    const match = ISO_TIMESTAMP.exec(value);
+    if (!match) {
+        throw new Error(`Invalid date "${value}". Use YYYY-MM-DD, epoch ms, or an ISO timestamp with Z/UTC offset.`);
+    }
+    parseCalendarDay(match[1]);
+    const hour = Number(match[2]);
+    const minute = Number(match[3]);
+    const second = Number(match[4] ?? 0);
+    const offset = match[6];
+    const offsetHour = offset === "Z" || offset === "z" ? 0 : Number(offset.slice(1, 3));
+    const offsetMinute = offset === "Z" || offset === "z" ? 0 : Number(offset.slice(4, 6));
+    if (hour > 23 || minute > 59 || second > 59 || offsetHour > 23 || offsetMinute > 59) {
+        throw new Error(`Invalid date "${value}". Timestamp contains an out-of-range time.`);
+    }
+    const parsed = Date.parse(value);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Invalid date "${value}". Use a valid ISO timestamp with Z/UTC offset.`);
+    }
+    return parsed;
+}
+/**
+ * Parse one campaign schedule boundary. Date-only values use the tenant's
+ * timezone; explicit ISO timestamps and epoch milliseconds remain exact.
+ */
+export function parseCampaignDateBound(value, role, timeZone) {
+    if (value === null)
+        return null;
+    if (typeof value === "number")
+        return parseEpochMs(value, value);
+    const trimmed = value.trim();
+    if (/^\d+$/.test(trimmed))
+        return parseEpochMs(Number(trimmed), value);
+    if (DATE_ONLY.test(trimmed)) {
+        const day = parseCalendarDay(trimmed);
+        return role === "end" ? endOfDayMs(day, timeZone) : startOfDayMs(day, timeZone);
+    }
+    return parseIsoTimestamp(trimmed);
+}
+/**
+ * Resolve a range from an optional preset and/or explicit from/to bounds.
+ * Explicit bounds win over the preset. All day boundaries are in `timeZone`
+ * (the tenant's), so the window lines up with the API's date buckets.
+ */
+export function resolveRange(preset, from, to, timeZone) {
+    const explicitFrom = parseBound(from, "from", timeZone);
+    const explicitTo = parseBound(to, "to", timeZone);
+    const now = Date.now();
+    const today = calendarDayIn(now, timeZone);
+    if (explicitFrom !== undefined || explicitTo !== undefined) {
+        const f = explicitFrom ?? startOfDayMs(today, timeZone);
+        const t = explicitTo ?? now;
+        if (f > t) {
+            throw new Error(`Invalid range: from (${fmtDay(f, timeZone)}) is after to (${fmtDay(t, timeZone)}).`);
+        }
+        return {
+            from: f,
+            to: t,
+            label: `${fmtDay(f, timeZone)} → ${fmtDay(t, timeZone)}`,
+        };
+    }
+    const startOfToday = startOfDayMs(today, timeZone);
+    switch (preset ?? "today") {
+        case "yesterday": {
+            const yesterday = addDays(today, -1);
+            return {
+                from: startOfDayMs(yesterday, timeZone),
+                to: startOfToday - 1,
+                label: "yesterday",
+            };
+        }
+        case "last_7_days":
+            // Calendar arithmetic, not `today - 6 * 86400000`: subtracting fixed
+            // milliseconds slips an hour across a DST change and lands mid-day.
+            return {
+                from: startOfDayMs(addDays(today, -6), timeZone),
+                to: now,
+                label: "last 7 days",
+            };
+        case "last_30_days":
+            return {
+                from: startOfDayMs(addDays(today, -29), timeZone),
+                to: now,
+                label: "last 30 days",
+            };
+        case "this_month":
+            return {
+                from: startOfDayMs({ y: today.y, m: today.m, d: 1 }, timeZone),
+                to: now,
+                label: "this month",
+            };
+        case "today":
+        default:
+            return { from: startOfToday, to: now, label: "today" };
+    }
+}
+/**
+ * Format an instant as `YYYY-MM-DD HH:mm` in the tenant timezone. Row timestamps
+ * have to agree with the date buckets stats are read in: a conversion at 23:30
+ * tenant-local rendered in UTC lands on the next day's row and reads as a
+ * missing conversion.
+ */
+export function formatInstant(ms, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    }).formatToParts(new Date(ms));
+    const get = (name) => parseInt(parts.find((p) => p.type === name)?.value ?? "0", 10);
+    const pad = (n) => String(n).padStart(2, "0");
+    // en-CA with hour12:false renders midnight as "24"; normalise it.
+    return (`${get("year")}-${pad(get("month"))}-${pad(get("day"))} ` +
+        `${pad(get("hour") % 24)}:${pad(get("minute"))}`);
+}
+//# sourceMappingURL=time.js.map

package/dist/lib/toolResult.js

@@ -0,0 +1,35 @@
+import { AffsetApiError } from "../client.js";
+/** Build a successful text tool result. */
+export function textResult(body) {
+    return { content: [{ type: "text", text: body }] };
+}
+/** Build an error tool result (isError: true). */
+export function errorResult(err) {
+    return { content: [{ type: "text", text: formatError(err) }], isError: true };
+}
+/** Build an error tool result from a plain string. */
+export function textError(body) {
+    return { content: [{ type: "text", text: body }], isError: true };
+}
+function formatError(err) {
+    if (!(err instanceof AffsetApiError)) {
+        return err instanceof Error ? err.message : String(err);
+    }
+    let message = `affset API error (${err.status}): ${err.message}`;
+    const body = err.body;
+    if (body && typeof body === "object" && "code" in body) {
+        const b = body;
+        if (b.code === "PLAN_LIMIT_REACHED" || b.code === "SUBSCRIPTION_REQUIRED") {
+            const bits = [
+                `code=${String(b.code)}`,
+                b.dimension != null ? `dimension=${String(b.dimension)}` : null,
+                b.current != null && b.limit != null ? `${b.current}/${b.limit}` : null,
+                b.min_plan_id != null ? `min_plan=${String(b.min_plan_id)}` : null,
+                b.plan_id != null ? `plan=${String(b.plan_id)}` : null,
+            ].filter(Boolean);
+            message += ` (${bits.join(", ")})`;
+        }
+    }
+    return message;
+}
+//# sourceMappingURL=toolResult.js.map

package/dist/lib/urls.js

@@ -0,0 +1,15 @@
+/** Validate http(s) URL; returns an error message or undefined when ok. */
+export function httpUrlError(value, label) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return `${label} is not a valid URL: ${value}`;
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return `${label} must be http(s), got ${parsed.protocol}`;
+    }
+    return undefined;
+}
+//# sourceMappingURL=urls.js.map

package/dist/lib/zones.js

@@ -0,0 +1,83 @@
+/**
+ * Zone lookup shared by every tool that needs a traffic source: campaign creation
+ * and both integration-URL tools all take an optional `zone_id` and auto-pick when
+ * the namespace has exactly one active zone.
+ */
+import { AffsetApiError } from "../client.js";
+import { mdCell } from "./format.js";
+const ZONE_CHOICES_LIMIT = 25;
+/**
+ * Resolve the zone to build URLs against. An explicit id is fetched directly — the
+ * paginated list must not be the arbiter of whether a zone exists.
+ */
+export async function resolveZone(client, zoneId) {
+    if (zoneId !== undefined) {
+        const explicitId = zoneId.trim();
+        if (!explicitId)
+            return { error: "zone_id cannot be blank." };
+        try {
+            const zone = await client.get(`/api/zones/${encodeURIComponent(explicitId)}`);
+            if (zone.status !== "active") {
+                return {
+                    zone,
+                    inactiveWarning: `⚠️ Zone \`${zone.id}\` is **${zone.status}** — both /serve and direct ` +
+                        "/track/click URLs return 404 until the zone is reactivated.",
+                };
+            }
+            return { zone };
+        }
+        catch (err) {
+            if (err instanceof AffsetApiError && err.status === 404) {
+                return { error: `Zone \`${explicitId}\` not found in this namespace.` };
+            }
+            throw err;
+        }
+    }
+    const { zones: active, total } = await listActiveZones(client);
+    if (total === 1 && active.length === 1) {
+        return { zone: active[0] };
+    }
+    if (total === 0) {
+        return {
+            error: "No active zones in this namespace. Create a zone for the traffic source first " +
+                "(its postback_url is where conversions are reported back), then pass its id as zone_id.",
+        };
+    }
+    return {
+        error: `Multiple active zones — pass zone_id to pick the traffic source:\n${zoneList(active, total)}`,
+    };
+}
+/** One filtered page is enough to auto-pick or show a bounded choice list. */
+async function listActiveZones(client) {
+    const res = await client.get("/api/zones", {
+        status: "active",
+        limit: ZONE_CHOICES_LIMIT,
+        offset: 0,
+        sort: "name",
+        order: "asc",
+    });
+    const zones = (res.zones ?? []).filter((zone) => zone.status === "active");
+    return { zones, total: res.pagination?.total ?? zones.length };
+}
+function zoneList(zones, total) {
+    const lines = zones.map((z) => `- \`${z.id}\` — ${mdCell(z.name)}${z.postback_url ? "" : " (no postback URL)"}`);
+    if (total > zones.length) {
+        lines.push(`- …and ${total - zones.length} more`);
+    }
+    return lines.join("\n");
+}
+/**
+ * The line every integration URL needs under it: without a postback URL on the zone,
+ * conversions never make it back to the traffic source and its optimizer stays blind.
+ */
+export function zonePostbackNote(zone) {
+    if (!zone.postback_url) {
+        return ("⚠️ no postback URL on this zone — set one with `update_zone` (include " +
+            "`{source_click_id}`) or the source will not see conversions");
+    }
+    if (!zone.postback_url.includes("{source_click_id}")) {
+        return `${mdCell(zone.postback_url)} — ⚠️ missing \`{source_click_id}\`, conversions cannot be attributed back`;
+    }
+    return "postback URL configured — conversions will be reported to the source";
+}
+//# sourceMappingURL=zones.js.map

package/dist/server.js

@@ -0,0 +1,316 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AffsetClient } from "./client.js";
+import { getStats, getStatsInputSchema, GET_STATS_DESCRIPTION } from "./tools/getStats.js";
+import { cutZones, cutZonesInputSchema, CUT_ZONES_DESCRIPTION } from "./tools/cutZones.js";
+import { createCampaign, createCampaignInputSchema, CREATE_CAMPAIGN_DESCRIPTION, } from "./tools/createCampaign.js";
+import { listCampaigns, listCampaignsInputSchema, LIST_CAMPAIGNS_DESCRIPTION, } from "./tools/listCampaigns.js";
+import { listZones, listZonesInputSchema, LIST_ZONES_DESCRIPTION } from "./tools/listZones.js";
+import { listTeam, listTeamInputSchema, LIST_TEAM_DESCRIPTION } from "./tools/listTeam.js";
+import { createZone, createZoneInputSchema, CREATE_ZONE_DESCRIPTION } from "./tools/createZone.js";
+import { getZoneUrl, getZoneUrlInputSchema, GET_ZONE_URL_DESCRIPTION } from "./tools/getZoneUrl.js";
+import { getTrackingLink, getTrackingLinkInputSchema, GET_TRACKING_LINK_DESCRIPTION, } from "./tools/getTrackingLink.js";
+import { updateZone, updateZoneInputSchema, UPDATE_ZONE_DESCRIPTION } from "./tools/updateZone.js";
+import { updateCampaign, updateCampaignInputSchema, UPDATE_CAMPAIGN_DESCRIPTION, } from "./tools/updateCampaign.js";
+import { setCampaignStatus, setCampaignStatusInputSchema, SET_CAMPAIGN_STATUS_DESCRIPTION, } from "./tools/setCampaignStatus.js";
+import { listPayoutRules, listPayoutRulesInputSchema, LIST_PAYOUT_RULES_DESCRIPTION, } from "./tools/listPayoutRules.js";
+import { setPayoutRule, setPayoutRuleInputSchema, SET_PAYOUT_RULE_DESCRIPTION, } from "./tools/setPayoutRule.js";
+import { deletePayoutRule, deletePayoutRuleInputSchema, DELETE_PAYOUT_RULE_DESCRIPTION, } from "./tools/deletePayoutRule.js";
+import { setPayoutGoal, setPayoutGoalInputSchema, SET_PAYOUT_GOAL_DESCRIPTION, } from "./tools/setPayoutGoal.js";
+import { listTargetingTypes, listTargetingTypesInputSchema, LIST_TARGETING_TYPES_DESCRIPTION, } from "./tools/listTargetingTypes.js";
+import { listTargetingRules, listTargetingRulesInputSchema, LIST_TARGETING_RULES_DESCRIPTION, } from "./tools/listTargetingRules.js";
+import { setTargetingRule, setTargetingRuleInputSchema, SET_TARGETING_RULE_DESCRIPTION, } from "./tools/setTargetingRule.js";
+import { removeTargetingRule, removeTargetingRuleInputSchema, REMOVE_TARGETING_RULE_DESCRIPTION, } from "./tools/removeTargetingRule.js";
+import { listSubLabels, listSubLabelsInputSchema, LIST_SUB_LABELS_DESCRIPTION, } from "./tools/listSubLabels.js";
+import { setSubLabels, setSubLabelsInputSchema, SET_SUB_LABELS_DESCRIPTION, } from "./tools/setSubLabels.js";
+import { listConversions, listConversionsInputSchema, LIST_CONVERSIONS_DESCRIPTION, } from "./tools/listConversions.js";
+import { whoami, whoamiInputSchema, WHOAMI_DESCRIPTION } from "./tools/whoami.js";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const { version: VERSION } = require("../package.json");
+/** Build the MCP server with the affset tools registered against `config`. */
+export function createServer(config) {
+    const client = new AffsetClient(config);
+    const server = new McpServer({
+        name: "affset-mcp",
+        version: VERSION,
+    });
+    // Registers every tool as normal, then immediately removes anything that isn't
+    // readOnlyHint:true when AFFSET_READ_ONLY is set — a mutation tool never has a
+    // chance to appear in tools/list or be called. See AFFSET_READ_ONLY in the README
+    // for why this exists (untrusted third-party data can reach model context via
+    // list_conversions/get_stats, so mutation tools are an injection blast-radius
+    // control, not just a UI nicety).
+    const registerTool = (name, toolConfig, cb) => {
+        const tool = server.registerTool(name, toolConfig, cb);
+        if (config.readOnly && toolConfig.annotations?.readOnlyHint !== true) {
+            tool.remove();
+        }
+        return tool;
+    };
+    registerTool("whoami", {
+        title: "Show the tenant this MCP is bound to",
+        description: WHOAMI_DESCRIPTION,
+        inputSchema: whoamiInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, () => whoami(client, config));
+    registerTool("get_stats", {
+        title: "Get affset stats",
+        description: GET_STATS_DESCRIPTION,
+        inputSchema: getStatsInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => getStats(client, args));
+    registerTool("list_campaigns", {
+        title: "List campaigns",
+        description: LIST_CAMPAIGNS_DESCRIPTION,
+        inputSchema: listCampaignsInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => listCampaigns(client, args));
+    registerTool("list_zones", {
+        title: "List zones",
+        description: LIST_ZONES_DESCRIPTION,
+        inputSchema: listZonesInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => listZones(client, args));
+    registerTool("list_team", {
+        title: "List team members",
+        description: LIST_TEAM_DESCRIPTION,
+        inputSchema: listTeamInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => listTeam(client, args));
+    registerTool("get_zone_url", {
+        title: "Get the zone URL for a traffic source",
+        description: GET_ZONE_URL_DESCRIPTION,
+        inputSchema: getZoneUrlInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => getZoneUrl(client, config, args));
+    registerTool("get_tracking_link", {
+        title: "Get a campaign's tracking link",
+        description: GET_TRACKING_LINK_DESCRIPTION,
+        inputSchema: getTrackingLinkInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => getTrackingLink(client, config, args));
+    registerTool("create_campaign", {
+        title: "Create a campaign",
+        description: CREATE_CAMPAIGN_DESCRIPTION,
+        inputSchema: createCampaignInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => createCampaign(client, config, args));
+    registerTool("update_campaign", {
+        title: "Update a campaign",
+        description: UPDATE_CAMPAIGN_DESCRIPTION,
+        inputSchema: updateCampaignInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => updateCampaign(client, args));
+    registerTool("set_campaign_status", {
+        title: "Run or pause a campaign",
+        description: SET_CAMPAIGN_STATUS_DESCRIPTION,
+        inputSchema: setCampaignStatusInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => setCampaignStatus(client, args));
+    registerTool("create_zone", {
+        title: "Create a zone",
+        description: CREATE_ZONE_DESCRIPTION,
+        inputSchema: createZoneInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => createZone(client, args));
+    registerTool("update_zone", {
+        title: "Update a zone",
+        description: UPDATE_ZONE_DESCRIPTION,
+        inputSchema: updateZoneInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => updateZone(client, args));
+    registerTool("cut_zones", {
+        title: "Cut underperforming zones",
+        description: CUT_ZONES_DESCRIPTION,
+        inputSchema: cutZonesInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => cutZones(client, args));
+    registerTool("list_payout_rules", {
+        title: "List payout rules",
+        description: LIST_PAYOUT_RULES_DESCRIPTION,
+        inputSchema: listPayoutRulesInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => listPayoutRules(client, args));
+    registerTool("set_payout_rule", {
+        title: "Set a payout rule",
+        description: SET_PAYOUT_RULE_DESCRIPTION,
+        inputSchema: setPayoutRuleInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => setPayoutRule(client, args));
+    registerTool("delete_payout_rule", {
+        title: "Delete a payout rule",
+        description: DELETE_PAYOUT_RULE_DESCRIPTION,
+        inputSchema: deletePayoutRuleInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => deletePayoutRule(client, args));
+    registerTool("set_payout_goal", {
+        title: "Set payout goal type",
+        description: SET_PAYOUT_GOAL_DESCRIPTION,
+        inputSchema: setPayoutGoalInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => setPayoutGoal(client, args));
+    registerTool("list_targeting_types", {
+        title: "List targeting rule types",
+        description: LIST_TARGETING_TYPES_DESCRIPTION,
+        inputSchema: listTargetingTypesInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, () => listTargetingTypes(client));
+    registerTool("list_targeting_rules", {
+        title: "List campaign targeting rules",
+        description: LIST_TARGETING_RULES_DESCRIPTION,
+        inputSchema: listTargetingRulesInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => listTargetingRules(client, args));
+    registerTool("set_targeting_rule", {
+        title: "Set a targeting rule",
+        description: SET_TARGETING_RULE_DESCRIPTION,
+        inputSchema: setTargetingRuleInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => setTargetingRule(client, args));
+    registerTool("remove_targeting_rule", {
+        title: "Remove a targeting rule",
+        description: REMOVE_TARGETING_RULE_DESCRIPTION,
+        inputSchema: removeTargetingRuleInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => removeTargetingRule(client, args));
+    registerTool("list_sub_labels", {
+        title: "List sub labels",
+        description: LIST_SUB_LABELS_DESCRIPTION,
+        inputSchema: listSubLabelsInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, () => listSubLabels(client));
+    registerTool("set_sub_labels", {
+        title: "Set sub labels",
+        description: SET_SUB_LABELS_DESCRIPTION,
+        inputSchema: setSubLabelsInputSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, (args) => setSubLabels(client, args));
+    registerTool("list_conversions", {
+        title: "List conversions",
+        description: LIST_CONVERSIONS_DESCRIPTION,
+        inputSchema: listConversionsInputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, (args) => listConversions(client, args));
+    return server;
+}
+//# sourceMappingURL=server.js.map