@praise25/meta-mcp-server 0.1.0

package/dist/tools/ads/list-campaigns.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { adAccountIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runList } from "../shared.js";
+export const inputSchema = z
+    .object({
+    ad_account_id: adAccountIdSchema,
+    effective_status: z
+        .array(z.enum([
+        "ACTIVE",
+        "PAUSED",
+        "DELETED",
+        "PENDING_REVIEW",
+        "DISAPPROVED",
+        "PREAPPROVED",
+        "PENDING_BILLING_INFO",
+        "CAMPAIGN_PAUSED",
+        "ARCHIVED",
+        "IN_PROCESS",
+        "WITH_ISSUES",
+    ]))
+        .optional()
+        .describe("Filter by effective_status. Omit to list all."),
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "name",
+        "objective",
+        "effective_status",
+        "status",
+        "daily_budget",
+        "lifetime_budget",
+        "budget_remaining",
+        "buying_type",
+        "special_ad_categories",
+        "start_time",
+        "stop_time",
+        "created_time",
+        "updated_time",
+    ])
+        .describe("Campaign fields."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_ads_list_campaigns",
+    title: "List campaigns in an ad account",
+    description: `Lists campaigns with status, objective, budget, and schedule. Use effective_status to filter only ACTIVE campaigns, for example. Pair with meta_ads_get_insights at level='campaign' for performance metrics.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("ad_account", input.ad_account_id, ctx.config);
+    const params = {
+        fields: input.fields.join(","),
+        limit: input.limit,
+        after: input.after,
+    };
+    if (input.effective_status) {
+        params["effective_status"] = JSON.stringify(input.effective_status);
+    }
+    return runList(ctx, { path: `${input.ad_account_id}/campaigns`, params }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { ad_account_id: input.ad_account_id });
+}

package/dist/tools/ads/list-custom-audiences.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>;
+    ad_account_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    limit: number;
+    auto_paginate: boolean;
+    ad_account_id: string;
+    after?: string | undefined;
+}, {
+    ad_account_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_ads_list_custom_audiences";
+    readonly title: "List custom audiences (metadata only)";
+    readonly description: "Lists custom audiences attached to an ad account — names, subtype (CUSTOM, WEBSITE, LOOKALIKE, …), approximate size buckets, delivery status, data source. No member-level data is exposed.";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        ad_account_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/ads/list-custom-audiences.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { adAccountIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runList } from "../shared.js";
+export const inputSchema = z
+    .object({
+    ad_account_id: adAccountIdSchema,
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "name",
+        "description",
+        "subtype",
+        "approximate_count_lower_bound",
+        "approximate_count_upper_bound",
+        "delivery_status",
+        "operation_status",
+        "data_source",
+        "retention_days",
+        "time_created",
+        "time_updated",
+    ])
+        .describe("Metadata fields. No PII/member data is returned by this endpoint."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_ads_list_custom_audiences",
+    title: "List custom audiences (metadata only)",
+    description: `Lists custom audiences attached to an ad account — names, subtype (CUSTOM, WEBSITE, LOOKALIKE, …), approximate size buckets, delivery status, data source. No member-level data is exposed.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("ad_account", input.ad_account_id, ctx.config);
+    return runList(ctx, {
+        path: `${input.ad_account_id}/customaudiences`,
+        params: { fields: input.fields.join(","), limit: input.limit, after: input.after },
+    }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { ad_account_id: input.ad_account_id });
+}

package/dist/tools/business/list-assets.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    business_id: z.ZodString;
+    kinds: z.ZodDefault<z.ZodArray<z.ZodEnum<["ad_accounts", "pages", "instagram_accounts", "pixels", "product_catalogs", "whatsapp_business_accounts"]>, "many">>;
+    include_client: z.ZodDefault<z.ZodBoolean>;
+    per_kind_limit: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    business_id: string;
+    kinds: ("pages" | "ad_accounts" | "instagram_accounts" | "pixels" | "product_catalogs" | "whatsapp_business_accounts")[];
+    include_client: boolean;
+    per_kind_limit: number;
+}, {
+    business_id: string;
+    kinds?: ("pages" | "ad_accounts" | "instagram_accounts" | "pixels" | "product_catalogs" | "whatsapp_business_accounts")[] | undefined;
+    include_client?: boolean | undefined;
+    per_kind_limit?: number | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_business_list_assets";
+    readonly title: "List assets assigned to a Business Manager";
+    readonly description: "For a given business_id, enumerates the business assets the token can see in one call:\n- Ad accounts (owned + optionally client)\n- Facebook Pages (owned + optionally client)\n- Instagram Business accounts\n- Meta Pixels\n- Product catalogs\n- WhatsApp Business accounts (WABAs)\n\nEach section is fetched as a separate Graph call. Failures on individual sections do not abort the others — the response reports per-section success/error so the assistant can work around partial failures.\n\nUse this to discover IDs for downstream insight tools.";
+    readonly inputSchema: {
+        business_id: z.ZodString;
+        kinds: z.ZodDefault<z.ZodArray<z.ZodEnum<["ad_accounts", "pages", "instagram_accounts", "pixels", "product_catalogs", "whatsapp_business_accounts"]>, "many">>;
+        include_client: z.ZodDefault<z.ZodBoolean>;
+        per_kind_limit: z.ZodDefault<z.ZodNumber>;
+    };
+    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/business/list-assets.js

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { MetaError } from "../../errors.js";
+import { jsonBlock, toolResult } from "../../helpers/format.js";
+import { metaIdSchema } from "../../helpers/schema.js";
+const ASSET_KINDS = [
+    "ad_accounts",
+    "pages",
+    "instagram_accounts",
+    "pixels",
+    "product_catalogs",
+    "whatsapp_business_accounts",
+];
+export const inputSchema = z
+    .object({
+    business_id: metaIdSchema.describe("Business Manager ID (from meta_business_list)."),
+    kinds: z
+        .array(z.enum(ASSET_KINDS))
+        .default([...ASSET_KINDS])
+        .describe("Which asset edges to enumerate. Default: all."),
+    include_client: z
+        .boolean()
+        .default(false)
+        .describe("Also fetch client_* edges (assets the business has access to but does not own)."),
+    per_kind_limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(500)
+        .default(50)
+        .describe("Page size per asset kind."),
+})
+    .strict();
+export const definition = {
+    name: "meta_business_list_assets",
+    title: "List assets assigned to a Business Manager",
+    description: `For a given business_id, enumerates the business assets the token can see in one call:
+- Ad accounts (owned + optionally client)
+- Facebook Pages (owned + optionally client)
+- Instagram Business accounts
+- Meta Pixels
+- Product catalogs
+- WhatsApp Business accounts (WABAs)
+
+Each section is fetched as a separate Graph call. Failures on individual sections do not abort the others — the response reports per-section success/error so the assistant can work around partial failures.
+
+Use this to discover IDs for downstream insight tools.`,
+    inputSchema: inputSchema.shape,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+};
+const FIELDS = {
+    ad_accounts: "id,account_id,name,currency,timezone_name,account_status",
+    pages: "id,name,category,tasks,access_token",
+    instagram_accounts: "id,username",
+    pixels: "id,name,last_fired_time,is_unavailable",
+    product_catalogs: "id,name,vertical,product_count",
+    whatsapp_business_accounts: "id,name,currency,timezone_id",
+};
+const EDGE_NAME = {
+    ad_accounts: { owned: "owned_ad_accounts", client: "client_ad_accounts" },
+    pages: { owned: "owned_pages", client: "client_pages" },
+    // Graph exposes `owned_instagram_accounts` on the Business node but not a
+    // `client_instagram_accounts` edge. IG accounts linked to a Page are also
+    // discoverable via `GET /{page_id}?fields=instagram_business_account`.
+    instagram_accounts: { owned: "owned_instagram_accounts", client: null },
+    pixels: { owned: "owned_pixels", client: null },
+    product_catalogs: { owned: "owned_product_catalogs", client: "client_product_catalogs" },
+    whatsapp_business_accounts: { owned: "owned_whatsapp_business_accounts", client: "client_whatsapp_business_accounts" },
+};
+export async function handler(input, ctx) {
+    assertAllowed("business", input.business_id, ctx.config);
+    const scopes = input.include_client ? ["owned", "client"] : ["owned"];
+    const sections = {};
+    await Promise.all(input.kinds.flatMap((kind) => scopes.map(async (scope) => {
+        const edge = EDGE_NAME[kind][scope];
+        if (!edge)
+            return;
+        const section = (sections[kind] ??= []);
+        try {
+            const page = await ctx.graph.get({
+                path: `${input.business_id}/${edge}`,
+                params: { fields: FIELDS[kind], limit: input.per_kind_limit },
+            });
+            section.push({ scope, items: Array.isArray(page.data) ? page.data : [] });
+        }
+        catch (err) {
+            const e = err instanceof MetaError ? err : new MetaError(err.message);
+            section.push({ scope, error: e.message, hint: e.hint });
+        }
+    })));
+    // Fallback IG discovery: walk the surviving Pages and look up
+    // `instagram_business_account`. Meta increasingly hides IG behind the Page
+    // link rather than the Business node.
+    if (input.kinds.includes("instagram_accounts")) {
+        const pageSection = sections.pages ?? [];
+        const pageItems = pageSection.flatMap((s) => s.items ?? []);
+        const igFromPages = [];
+        await Promise.all(pageItems.map(async (p) => {
+            try {
+                const data = await ctx.graph.get({
+                    path: p.id,
+                    params: { fields: "id,name,instagram_business_account{id,username,name}" },
+                });
+                if (data.instagram_business_account) {
+                    igFromPages.push({
+                        id: data.instagram_business_account.id,
+                        name: data.instagram_business_account.name,
+                        username: data.instagram_business_account.username,
+                        category: `via page ${data.id} (${data.name ?? ""})`.trim(),
+                    });
+                }
+            }
+            catch {
+                /* non-fatal per-page */
+            }
+        }));
+        if (igFromPages.length > 0) {
+            (sections.instagram_accounts ??= []).push({
+                scope: "via_page",
+                items: igFromPages,
+                source: "page.instagram_business_account",
+            });
+        }
+    }
+    const structured = {
+        business_id: input.business_id,
+        scopes,
+        assets: sections,
+    };
+    return toolResult(structured, jsonBlock(structured));
+}

package/dist/tools/business/list-businesses.d.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    auto_paginate: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    limit: number;
+    auto_paginate: boolean;
+    after?: string | undefined;
+}, {
+    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_business_list";
+    readonly title: "List Meta businesses visible to the token";
+    readonly description: "Lists every Business Manager the configured access token can see — via GET /me/businesses.\n\nTypical usage: call this once at the start of a session to discover available business IDs, then pass the chosen ID to meta_business_list_assets / meta_business_list_system_users.\n\nRespects META_ALLOWED_BUSINESS_IDS: if set, filters the response to that allowlist.";
+    readonly inputSchema: {
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+    };
+    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/business/list-businesses.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { MetaError } from "../../errors.js";
+import { jsonBlock, toolError, toolResult } from "../../helpers/format.js";
+import { paginationShape } from "../../helpers/schema.js";
+export const inputSchema = z
+    .object({
+    ...paginationShape,
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "name",
+        "verification_status",
+        "primary_page",
+        "created_time",
+        "updated_time",
+        "timezone_id",
+    ])
+        .describe("Fields to request on each business."),
+})
+    .strict();
+export const definition = {
+    name: "meta_business_list",
+    title: "List Meta businesses visible to the token",
+    description: `Lists every Business Manager the configured access token can see — via GET /me/businesses.
+
+Typical usage: call this once at the start of a session to discover available business IDs, then pass the chosen ID to meta_business_list_assets / meta_business_list_system_users.
+
+Respects META_ALLOWED_BUSINESS_IDS: if set, filters the response to that allowlist.`,
+    inputSchema: inputSchema.shape,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+};
+export async function handler(input, ctx) {
+    try {
+        const params = {
+            fields: input.fields.join(","),
+            limit: input.limit,
+            after: input.after,
+        };
+        const opts = { path: "me/businesses", params };
+        const { data, pages, nextAfter } = input.auto_paginate
+            ? await ctx.graph.getAllPages(opts)
+            : await singlePage(ctx, opts);
+        const allowlist = ctx.config.allowedBusinessIds;
+        const filtered = allowlist ? data.filter((b) => allowlist.has(b.id)) : data;
+        // Sanity-check that whatever survived the allowlist is allowed.
+        for (const b of filtered)
+            assertAllowed("business", b.id, ctx.config);
+        const structured = {
+            count: filtered.length,
+            pages_fetched: pages,
+            next_after: nextAfter,
+            businesses: filtered,
+            filtered_by_allowlist: Boolean(allowlist),
+        };
+        return toolResult(structured, jsonBlock(structured));
+    }
+    catch (err) {
+        const e = err instanceof MetaError ? err : new MetaError(err.message);
+        return toolError(e.message, e.hint, {
+            code: e.code,
+            subcode: e.subcode,
+            fbtrace_id: e.fbtraceId,
+            http_status: e.httpStatus,
+        });
+    }
+}
+async function singlePage(ctx, opts) {
+    const page = await ctx.graph.get(opts);
+    return {
+        data: Array.isArray(page.data) ? page.data : [],
+        pages: 1,
+        nextAfter: page.paging?.cursors?.after,
+    };
+}

package/dist/tools/business/list-system-users.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    auto_paginate: z.ZodDefault<z.ZodBoolean>;
+    business_id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    limit: number;
+    auto_paginate: boolean;
+    business_id: string;
+    after?: string | undefined;
+}, {
+    business_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_business_list_system_users";
+    readonly title: "List system users attached to a business";
+    readonly description: "Lists the system-user (server/software) identities under a Business Manager.\n\nSystem users are non-human identities used for API access. This tool helps diagnose which identity owns the token in use (cross-reference with meta_token_inspect).\n\nReads /{business_id}/system_users.";
+    readonly inputSchema: {
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        business_id: 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/business/list-system-users.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { MetaError } from "../../errors.js";
+import { jsonBlock, toolError, toolResult } from "../../helpers/format.js";
+import { metaIdSchema, paginationShape } from "../../helpers/schema.js";
+export const inputSchema = z
+    .object({
+    business_id: metaIdSchema.describe("Business Manager ID."),
+    ...paginationShape,
+    fields: z
+        .array(z.string())
+        .default(["id", "name", "role", "finance_role", "ip_role"])
+        .describe("Fields to return for each system user."),
+})
+    .strict();
+export const definition = {
+    name: "meta_business_list_system_users",
+    title: "List system users attached to a business",
+    description: `Lists the system-user (server/software) identities under a Business Manager.
+
+System users are non-human identities used for API access. This tool helps diagnose which identity owns the token in use (cross-reference with meta_token_inspect).
+
+Reads /{business_id}/system_users.`,
+    inputSchema: inputSchema.shape,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+};
+export async function handler(input, ctx) {
+    assertAllowed("business", input.business_id, ctx.config);
+    try {
+        const opts = {
+            path: `${input.business_id}/system_users`,
+            params: {
+                fields: input.fields.join(","),
+                limit: input.limit,
+                after: input.after,
+            },
+        };
+        if (input.auto_paginate) {
+            const { data, pages, nextAfter } = await ctx.graph.getAllPages(opts);
+            const structured = {
+                business_id: input.business_id,
+                count: data.length,
+                pages_fetched: pages,
+                next_after: nextAfter,
+                system_users: data,
+            };
+            return toolResult(structured, jsonBlock(structured));
+        }
+        const page = await ctx.graph.get(opts);
+        const structured = {
+            business_id: input.business_id,
+            count: Array.isArray(page.data) ? page.data.length : 0,
+            pages_fetched: 1,
+            next_after: page.paging?.cursors?.after,
+            system_users: page.data ?? [],
+        };
+        return toolResult(structured, jsonBlock(structured));
+    }
+    catch (err) {
+        const e = err instanceof MetaError ? err : new MetaError(err.message);
+        return toolError(e.message, e.hint, {
+            code: e.code,
+            subcode: e.subcode,
+            fbtrace_id: e.fbtraceId,
+            http_status: e.httpStatus,
+        });
+    }
+}

package/dist/tools/catalog/get-diagnostics.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    catalog_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    catalog_id: string;
+}, {
+    catalog_id: string;
+    fields?: string[] | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_catalog_get_diagnostics";
+    readonly title: "Get catalog diagnostics";
+    readonly description: "Surfaces catalog issues: disapproved items, missing required fields, GTIN problems, image errors. Pair with meta_catalog_list_products to see affected items.";
+    readonly inputSchema: {
+        catalog_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/catalog/get-diagnostics.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGet } from "../shared.js";
+export const inputSchema = z
+    .object({
+    catalog_id: metaIdSchema,
+    fields: z
+        .array(z.string())
+        .default([
+        "diagnostics{severity,type,title,description,affected_items,affected_channels}",
+        "product_count",
+        "feed_count",
+    ])
+        .describe("Diagnostics fields. Meta surfaces issues like missing images, disapproved items, incomplete GTIN, etc."),
+})
+    .strict();
+export const definition = {
+    name: "meta_catalog_get_diagnostics",
+    title: "Get catalog diagnostics",
+    description: `Surfaces catalog issues: disapproved items, missing required fields, GTIN problems, image errors. Pair with meta_catalog_list_products to see affected items.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    return runGet(ctx, { path: input.catalog_id, params: { fields: input.fields.join(",") } });
+}

package/dist/tools/catalog/list-products.d.ts

@@ -0,0 +1,45 @@
+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>;
+    catalog_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    filter: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    limit: number;
+    auto_paginate: boolean;
+    catalog_id: string;
+    filter?: string | undefined;
+    after?: string | undefined;
+}, {
+    catalog_id: string;
+    filter?: string | undefined;
+    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_catalog_list_products";
+    readonly title: "List products in a catalog";
+    readonly description: "Lists products with name, retailer_id, price, availability, review_status. Filter by availability/category via the 'filter' param (raw JSON string per Meta spec).";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        catalog_id: z.ZodString;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        filter: 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>;