@cashtokenai/meta-mcp-server 1.0.0

package/dist/tools/pages/get-insights.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGetAsPageViaInsightsApp } from "../shared.js";
+const PERIOD = z.enum(["day", "week", "days_28", "lifetime", "total_over_range"]);
+export const inputSchema = z
+    .object({
+    page_id: metaIdSchema,
+    metrics: z
+        .array(z.string())
+        .default([
+        // Metrics that Meta still supports as of v23 (2026).
+        // Several 2023/2024 deprecations removed: page_consumptions, page_fan_removes,
+        // page_actions_post_reactions_total, page_impressions_organic (use unique/paid combo instead).
+        "page_impressions",
+        "page_impressions_unique",
+        "page_impressions_paid",
+        "page_post_engagements",
+        "page_fans",
+        "page_fan_adds",
+        "page_views_total",
+        "page_video_views",
+        "page_video_views_paid",
+    ])
+        .describe("Page insight metrics. Not every metric supports every period — see https://developers.facebook.com/docs/graph-api/reference/v23.0/insights. Requires 'read_insights' scope."),
+    period: PERIOD.default("day"),
+    since: z.string().optional().describe("ISO date or Unix timestamp."),
+    until: z.string().optional().describe("ISO date or Unix timestamp."),
+})
+    .strict();
+export const definition = {
+    name: "meta_page_get_insights",
+    title: "Get Page-level insights",
+    description: `Reads Page-level metrics: impressions, reach, engagements, fan growth, page views, video views. Requires 'read_insights' scope. Pick the right period per metric — many accept only 'day' or 'days_28'.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("page", input.page_id, ctx.config);
+    return runGetAsPageViaInsightsApp(ctx, input.page_id, {
+        path: `${input.page_id}/insights`,
+        params: {
+            metric: input.metrics.join(","),
+            period: input.period,
+            since: input.since,
+            until: input.until,
+        },
+    });
+}

package/dist/tools/pages/get-post-insights.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    post_id: z.ZodString;
+    page_id: z.ZodOptional<z.ZodString>;
+    metrics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    post_id: string;
+    metrics: string[];
+    page_id?: string | undefined;
+}, {
+    post_id: string;
+    page_id?: string | undefined;
+    metrics?: string[] | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_get_post_insights";
+    readonly title: "Get insights for a single Page post";
+    readonly description: "Reads impressions, unique reach, paid vs. organic split, engaged users, click counts, reactions-by-type, and video view metrics for a single post.\n\nUses the parent Page's access token (auto-resolved from the '{page_id}_{post_id}' prefix; pass page_id explicitly if your post_id isn't in that form). Requires the system user to be assigned to the Page with 'View performance' or 'Analyze Page' tasks, plus 'read_insights' scope on the token.";
+    readonly inputSchema: {
+        post_id: z.ZodString;
+        page_id: z.ZodOptional<z.ZodString>;
+        metrics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/get-post-insights.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { errorResult, runGetAsPageViaInsightsApp } from "../shared.js";
+export const inputSchema = z
+    .object({
+    post_id: metaIdSchema.describe("Post ID. Meta uses the '{page_id}_{post_id}' format — pass it in full so the server can resolve the parent Page's access token automatically."),
+    page_id: metaIdSchema
+        .optional()
+        .describe("Optional explicit Page ID. Use when the post_id is not in the '{page_id}_{post_id}' form (rare)."),
+    metrics: z
+        .array(z.string())
+        .default([
+        "post_impressions",
+        "post_impressions_unique",
+        "post_impressions_paid",
+        "post_impressions_organic",
+        "post_engaged_users",
+        "post_clicks",
+        "post_reactions_by_type_total",
+        "post_video_views",
+        "post_video_views_unique",
+        "post_video_avg_time_watched",
+    ])
+        .describe("Post-level insight metrics. See https://developers.facebook.com/docs/graph-api/reference/v23.0/insights. Requires 'read_insights' scope. Note: Meta will reject the call if any single metric is invalid for the post type — narrow the list if you see (#100)."),
+})
+    .strict();
+export const definition = {
+    name: "meta_page_get_post_insights",
+    title: "Get insights for a single Page post",
+    description: `Reads impressions, unique reach, paid vs. organic split, engaged users, click counts, reactions-by-type, and video view metrics for a single post.
+
+Uses the parent Page's access token (auto-resolved from the '{page_id}_{post_id}' prefix; pass page_id explicitly if your post_id isn't in that form). Requires the system user to be assigned to the Page with 'View performance' or 'Analyze Page' tasks, plus 'read_insights' scope on the token.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    // Resolve the parent Page id either from an explicit input or from the
+    // '{page_id}_{post_id}' prefix of the post_id.
+    const parentPageId = input.page_id ?? input.post_id.split("_")[0];
+    if (!/^\d+$/.test(parentPageId)) {
+        return errorResult(new Error(`Could not infer parent Page ID from post_id '${input.post_id}'. Pass page_id explicitly.`));
+    }
+    return runGetAsPageViaInsightsApp(ctx, parentPageId, {
+        path: `${input.post_id}/insights`,
+        params: { metric: input.metrics.join(",") },
+    });
+}

package/dist/tools/pages/get.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    page_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    page_id: string;
+}, {
+    page_id: string;
+    fields?: string[] | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_get";
+    readonly title: "Get Page details";
+    readonly description: "Full page profile snapshot: category, about, fan count, rating, engagement, linked IG Business account, cover/picture. Use as the 'know-your-page' call before fetching posts or insights.";
+    readonly inputSchema: {
+        page_id: z.ZodString;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/get.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGet } from "../shared.js";
+export const inputSchema = z
+    .object({
+    page_id: metaIdSchema,
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "name",
+        "username",
+        "category",
+        "category_list",
+        "about",
+        "description",
+        "fan_count",
+        "followers_count",
+        "verification_status",
+        "rating_count",
+        "overall_star_rating",
+        "link",
+        "website",
+        "phone",
+        "emails",
+        "location",
+        "single_line_address",
+        "engagement",
+        "talking_about_count",
+        "were_here_count",
+        "checkins",
+        "cover",
+        "picture.type(large)",
+        "instagram_business_account{id,username,name}",
+    ])
+        .describe("Page fields. Includes linked Instagram Business account when present."),
+})
+    .strict();
+export const definition = {
+    name: "meta_page_get",
+    title: "Get Page details",
+    description: `Full page profile snapshot: category, about, fan count, rating, engagement, linked IG Business account, cover/picture. Use as the 'know-your-page' call before fetching posts or insights.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("page", input.page_id, ctx.config);
+    return runGet(ctx, { path: input.page_id, params: { fields: input.fields.join(",") } });
+}

package/dist/tools/pages/list-posts.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    auto_paginate: z.ZodDefault<z.ZodBoolean>;
+    page_id: z.ZodString;
+    edge: z.ZodDefault<z.ZodEnum<["posts", "published_posts", "feed"]>>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    page_id: string;
+    limit: number;
+    auto_paginate: boolean;
+    edge: "posts" | "published_posts" | "feed";
+    since?: string | undefined;
+    until?: string | undefined;
+    after?: string | undefined;
+}, {
+    page_id: string;
+    fields?: string[] | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    limit?: number | undefined;
+    after?: string | undefined;
+    auto_paginate?: boolean | undefined;
+    edge?: "posts" | "published_posts" | "feed" | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_list_posts";
+    readonly title: "List Page posts";
+    readonly description: "Lists raw Facebook Page posts for ONE page, with reaction/comment/share counts. Supports since/until for a date window and returns post IDs for meta_page_get_post_insights.\n\nUSE FOR: drilling into a single specific Page's post list, or when you already have the page_id. For a cross-account content report (\"how many posts this week across all my accounts, by type, with comparison\") prefer meta_content_report — it walks every Page + Instagram account and classifies/aggregates automatically, no page_id needed.";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        page_id: z.ZodString;
+        edge: z.ZodDefault<z.ZodEnum<["posts", "published_posts", "feed"]>>;
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/list-posts.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runListAsPage } from "../shared.js";
+export const inputSchema = z
+    .object({
+    page_id: metaIdSchema,
+    edge: z
+        .enum(["posts", "published_posts", "feed"])
+        .default("published_posts")
+        .describe("'published_posts' is the standard edge. 'feed' includes user-posted items too."),
+    since: z.string().optional().describe("Unix timestamp or ISO date lower bound."),
+    until: z.string().optional().describe("Unix timestamp or ISO date upper bound."),
+    fields: z
+        .array(z.string())
+        .default([
+        // Note: 'subattachments' is deprecated as of Graph API v3.3+ for
+        // aggregate field expansion (#12 deprecate_post_aggregated_fields_for_attachement).
+        // Removed from default. Likewise 'is_published' and 'type' are
+        // deprecated for some post kinds — kept out of the default to keep
+        // the call shape valid across all post types. Re-add via the fields
+        // input if you need them and have verified the call still passes.
+        "id",
+        "message",
+        "created_time",
+        "updated_time",
+        "permalink_url",
+        "status_type",
+        "from",
+        "attachments{media_type,title,url}",
+        "reactions.summary(true).limit(0)",
+        "shares",
+        "comments.summary(true).limit(0)",
+    ])
+        .describe("Post fields. Default includes reaction + comment counts via summary. 'subattachments', 'is_published' and 'type' are excluded by default — Meta deprecated them on certain post types and including them rejects the whole call."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_page_list_posts",
+    title: "List Page posts",
+    description: `Lists raw Facebook Page posts for ONE page, with reaction/comment/share counts. Supports since/until for a date window and returns post IDs for meta_page_get_post_insights.
+
+USE FOR: drilling into a single specific Page's post list, or when you already have the page_id. For a cross-account content report ("how many posts this week across all my accounts, by type, with comparison") prefer meta_content_report — it walks every Page + Instagram account and classifies/aggregates automatically, no page_id needed.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("page", input.page_id, ctx.config);
+    // Page-level edges (/posts, /published_posts, /feed) require a Page access
+    // token, not the system-user token. runListAsPage resolves it first.
+    return runListAsPage(ctx, input.page_id, {
+        path: `${input.page_id}/${input.edge}`,
+        params: {
+            fields: input.fields.join(","),
+            limit: input.limit,
+            after: input.after,
+            since: input.since,
+            until: input.until,
+        },
+    }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { page_id: input.page_id, edge: input.edge });
+}

package/dist/tools/pages/list-reviews.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    auto_paginate: z.ZodDefault<z.ZodBoolean>;
+    page_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    page_id: string;
+    limit: number;
+    auto_paginate: boolean;
+    after?: string | undefined;
+}, {
+    page_id: string;
+    fields?: string[] | undefined;
+    limit?: number | undefined;
+    after?: string | undefined;
+    auto_paginate?: boolean | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_list_reviews";
+    readonly title: "List Page ratings / reviews";
+    readonly description: "Lists ratings and reviews (where the Page supports recommendations). Requires 'pages_read_user_content' scope. Useful for sentiment analysis and customer-experience reporting.";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        page_id: z.ZodString;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/list-reviews.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runListAsPage } from "../shared.js";
+export const inputSchema = z
+    .object({
+    page_id: metaIdSchema,
+    fields: z
+        .array(z.string())
+        .default([
+        "created_time",
+        "reviewer",
+        "rating",
+        "recommendation_type",
+        "review_text",
+        "has_rating",
+        "has_review",
+        "open_graph_story",
+    ])
+        .describe("Review fields."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_page_list_reviews",
+    title: "List Page ratings / reviews",
+    description: `Lists ratings and reviews (where the Page supports recommendations). Requires 'pages_read_user_content' scope. Useful for sentiment analysis and customer-experience reporting.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("page", input.page_id, ctx.config);
+    return runListAsPage(ctx, input.page_id, {
+        path: `${input.page_id}/ratings`,
+        params: { fields: input.fields.join(","), limit: input.limit, after: input.after },
+    }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { page_id: input.page_id });
+}

package/dist/tools/pages/list-videos.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    auto_paginate: z.ZodDefault<z.ZodBoolean>;
+    page_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    page_id: string;
+    limit: number;
+    auto_paginate: boolean;
+    after?: string | undefined;
+}, {
+    page_id: string;
+    fields?: string[] | undefined;
+    limit?: number | undefined;
+    after?: string | undefined;
+    auto_paginate?: boolean | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_list_videos";
+    readonly title: "List Page videos";
+    readonly description: "Lists videos uploaded to a Page (including live broadcasts). Pair with meta_page_get_post_insights on the owning post for video-view analytics, or drill into individual video IDs for per-video metrics.";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        page_id: z.ZodString;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/list-videos.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runListAsPage } from "../shared.js";
+export const inputSchema = z
+    .object({
+    page_id: metaIdSchema,
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "title",
+        "description",
+        "created_time",
+        "updated_time",
+        "length",
+        "permalink_url",
+        "source",
+        "status",
+        "views",
+        "live_status",
+    ])
+        .describe("Video fields."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_page_list_videos",
+    title: "List Page videos",
+    description: `Lists videos uploaded to a Page (including live broadcasts). Pair with meta_page_get_post_insights on the owning post for video-view analytics, or drill into individual video IDs for per-video metrics.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("page", input.page_id, ctx.config);
+    return runListAsPage(ctx, input.page_id, {
+        path: `${input.page_id}/videos`,
+        params: { fields: input.fields.join(","), limit: input.limit, after: input.after },
+    }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { page_id: input.page_id });
+}

package/dist/tools/pages/list.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    auto_paginate: z.ZodDefault<z.ZodBoolean>;
+    source: z.ZodDefault<z.ZodEnum<["assigned", "accounts"]>>;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    limit: number;
+    auto_paginate: boolean;
+    source: "assigned" | "accounts";
+    after?: string | undefined;
+}, {
+    fields?: string[] | undefined;
+    limit?: number | undefined;
+    after?: string | undefined;
+    auto_paginate?: boolean | undefined;
+    source?: "assigned" | "accounts" | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_page_list";
+    readonly title: "List Pages visible to the token";
+    readonly description: "Lists Facebook Pages this token/system-user can read. 'assigned' is the modern path for system users; 'accounts' is the classic /me/accounts edge (works for regular users).";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        source: z.ZodDefault<z.ZodEnum<["assigned", "accounts"]>>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pages/list.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { paginationShape } from "../../helpers/schema.js";
+import { runList } from "../shared.js";
+export const inputSchema = z
+    .object({
+    source: z
+        .enum(["assigned", "accounts"])
+        .default("assigned")
+        .describe("'assigned' → /me/assigned_pages (system-user-specific). 'accounts' → /me/accounts (classic Pages edge)."),
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "name",
+        "category",
+        "category_list",
+        "about",
+        "fan_count",
+        "followers_count",
+        "verification_status",
+        "link",
+        "website",
+        "tasks",
+    ])
+        .describe("Page fields."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_page_list",
+    title: "List Pages visible to the token",
+    description: `Lists Facebook Pages this token/system-user can read. 'assigned' is the modern path for system users; 'accounts' is the classic /me/accounts edge (works for regular users).`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    const path = input.source === "assigned" ? "me/assigned_pages" : "me/accounts";
+    return runList(ctx, { path, params: { fields: input.fields.join(","), limit: input.limit, after: input.after } }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { source: input.source });
+}

package/dist/tools/pixels/get-stats.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    pixel_id: z.ZodString;
+    aggregation: z.ZodDefault<z.ZodEnum<["event", "browser_type", "device_os", "event_source", "url"]>>;
+    start_time: z.ZodOptional<z.ZodString>;
+    end_time: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    pixel_id: string;
+    aggregation: "url" | "event" | "browser_type" | "device_os" | "event_source";
+    start_time?: string | undefined;
+    end_time?: string | undefined;
+    event?: string | undefined;
+}, {
+    pixel_id: string;
+    start_time?: string | undefined;
+    end_time?: string | undefined;
+    event?: string | undefined;
+    aggregation?: "url" | "event" | "browser_type" | "device_os" | "event_source" | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_pixel_get_stats";
+    readonly title: "Get pixel event stats";
+    readonly description: "Reads aggregated pixel event counts via /{pixel_id}/stats. Use aggregation='event' to see which events are firing, 'device_os' or 'browser_type' to profile traffic, 'url' to see top-firing pages. Useful for spotting CAPI drop-off versus browser events.";
+    readonly inputSchema: {
+        pixel_id: z.ZodString;
+        aggregation: z.ZodDefault<z.ZodEnum<["event", "browser_type", "device_os", "event_source", "url"]>>;
+        start_time: z.ZodOptional<z.ZodString>;
+        end_time: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodString>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: true;
+        readonly destructiveHint: false;
+        readonly idempotentHint: true;
+        readonly openWorldHint: true;
+    };
+};
+export declare function handler(input: Input, ctx: ToolContext): Promise<import("../../helpers/format.js").ToolTextResult>;

package/dist/tools/pixels/get-stats.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGet } from "../shared.js";
+const AGGREGATION = z.enum(["event", "browser_type", "device_os", "event_source", "url"]);
+export const inputSchema = z
+    .object({
+    pixel_id: metaIdSchema,
+    aggregation: AGGREGATION.default("event").describe("How to slice the stats."),
+    start_time: z.string().optional().describe("ISO date / Unix timestamp — start of window."),
+    end_time: z.string().optional().describe("ISO date / Unix timestamp — end of window."),
+    event: z
+        .string()
+        .optional()
+        .describe("Filter to one event name, e.g. 'Purchase', 'AddToCart'."),
+})
+    .strict();
+export const definition = {
+    name: "meta_pixel_get_stats",
+    title: "Get pixel event stats",
+    description: `Reads aggregated pixel event counts via /{pixel_id}/stats. Use aggregation='event' to see which events are firing, 'device_os' or 'browser_type' to profile traffic, 'url' to see top-firing pages. Useful for spotting CAPI drop-off versus browser events.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    return runGet(ctx, {
+        path: `${input.pixel_id}/stats`,
+        params: {
+            aggregation: input.aggregation,
+            start_time: input.start_time,
+            end_time: input.end_time,
+            event: input.event,
+        },
+    });
+}