@praise25/meta-mcp-server 0.1.0

package/dist/tools/catalog/list-products.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { metaIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runList } from "../shared.js";
+export const inputSchema = z
+    .object({
+    catalog_id: metaIdSchema,
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "retailer_id",
+        "name",
+        "description",
+        "price",
+        "currency",
+        "availability",
+        "condition",
+        "brand",
+        "category",
+        "url",
+        "image_url",
+        "review_status",
+    ])
+        .describe("Product fields."),
+    filter: z
+        .string()
+        .optional()
+        .describe("JSON filter string, e.g. '{\"availability\":{\"eq\":\"out of stock\"}}'"),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_catalog_list_products",
+    title: "List products in a catalog",
+    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).`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    return runList(ctx, {
+        path: `${input.catalog_id}/products`,
+        params: {
+            fields: input.fields.join(","),
+            limit: input.limit,
+            after: input.after,
+            filter: input.filter,
+        },
+    }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { catalog_id: input.catalog_id });
+}

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

@@ -0,0 +1,54 @@
+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>;
+    business_id: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<["owned", "client", "both"]>>;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    limit: number;
+    auto_paginate: boolean;
+    business_id: string;
+    scope: "owned" | "client" | "both";
+    after?: string | undefined;
+}, {
+    business_id: string;
+    fields?: string[] | undefined;
+    limit?: number | undefined;
+    after?: string | undefined;
+    auto_paginate?: boolean | undefined;
+    scope?: "owned" | "client" | "both" | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_catalog_list";
+    readonly title: "List commerce catalogs under a business";
+    readonly description: "Lists product catalogs. Needs the Commerce / Catalog Management product added to the app and 'catalog_management' on the token.";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        business_id: z.ZodString;
+        scope: z.ZodDefault<z.ZodEnum<["owned", "client", "both"]>>;
+        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<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        business_id: string;
+        sections: Record<string, unknown>[];
+    };
+}>;

package/dist/tools/catalog/list.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runList } from "../shared.js";
+export const inputSchema = z
+    .object({
+    business_id: metaIdSchema,
+    scope: z.enum(["owned", "client", "both"]).default("owned"),
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "name",
+        "vertical",
+        "product_count",
+        "business",
+        "is_catalog_segment",
+        "feed_count",
+    ])
+        .describe("Catalog fields."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_catalog_list",
+    title: "List commerce catalogs under a business",
+    description: `Lists product catalogs. Needs the Commerce / Catalog Management product added to the app and 'catalog_management' on the token.`,
+    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);
+    const edges = input.scope === "both"
+        ? ["owned_product_catalogs", "client_product_catalogs"]
+        : [`${input.scope}_product_catalogs`];
+    const sections = [];
+    for (const edge of edges) {
+        const r = await runList(ctx, {
+            path: `${input.business_id}/${edge}`,
+            params: { fields: input.fields.join(","), limit: input.limit, after: input.after },
+        }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { edge });
+        sections.push(r.structuredContent ?? { edge, error: "no data" });
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify({ business_id: input.business_id, sections }, null, 2) }],
+        structuredContent: { business_id: input.business_id, sections },
+    };
+}

package/dist/tools/instagram/get-account.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    ig_user_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    ig_user_id: string;
+}, {
+    ig_user_id: string;
+    fields?: string[] | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_ig_get_account";
+    readonly title: "Get Instagram Business account profile";
+    readonly description: "Reads username, name, bio, website, follower/following counts, media_count, profile picture for an IG Business account.";
+    readonly inputSchema: {
+        ig_user_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/instagram/get-account.js

@@ -0,0 +1,34 @@
+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({
+    ig_user_id: metaIdSchema.describe("Instagram Business Account ID (from meta_ig_list_accounts)."),
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "username",
+        "name",
+        "biography",
+        "website",
+        "followers_count",
+        "follows_count",
+        "media_count",
+        "profile_picture_url",
+    ])
+        .describe("IG account profile fields."),
+})
+    .strict();
+export const definition = {
+    name: "meta_ig_get_account",
+    title: "Get Instagram Business account profile",
+    description: `Reads username, name, bio, website, follower/following counts, media_count, profile picture for an IG Business account.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("ig_user", input.ig_user_id, ctx.config);
+    return runGet(ctx, { path: input.ig_user_id, params: { fields: input.fields.join(",") } });
+}

package/dist/tools/instagram/get-audience-demographics.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    ig_user_id: z.ZodString;
+    metric: z.ZodDefault<z.ZodEnum<["follower_demographics", "engaged_audience_demographics", "reached_audience_demographics"]>>;
+    breakdown: z.ZodDefault<z.ZodEnum<["age", "gender", "country", "city", "audience_city"]>>;
+    metric_type: z.ZodDefault<z.ZodEnum<["total_value", "time_series"]>>;
+    timeframe: z.ZodDefault<z.ZodEnum<["last_14_days", "last_30_days", "last_90_days", "prev_month", "this_month", "this_week"]>>;
+}, "strict", z.ZodTypeAny, {
+    metric: "follower_demographics" | "engaged_audience_demographics" | "reached_audience_demographics";
+    ig_user_id: string;
+    breakdown: "age" | "gender" | "country" | "city" | "audience_city";
+    metric_type: "total_value" | "time_series";
+    timeframe: "this_month" | "last_14_days" | "last_30_days" | "last_90_days" | "prev_month" | "this_week";
+}, {
+    ig_user_id: string;
+    metric?: "follower_demographics" | "engaged_audience_demographics" | "reached_audience_demographics" | undefined;
+    breakdown?: "age" | "gender" | "country" | "city" | "audience_city" | undefined;
+    metric_type?: "total_value" | "time_series" | undefined;
+    timeframe?: "this_month" | "last_14_days" | "last_30_days" | "last_90_days" | "prev_month" | "this_week" | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_ig_get_audience_demographics";
+    readonly title: "Get IG audience demographics";
+    readonly description: "Reads demographic breakdown of an IG Business account's followers, engaged audience, or reached audience. Use breakdown='age'|'gender'|'country'|'city' to slice.\n\nRequires 'instagram_manage_insights'. Only IG Business accounts with at least 100 followers return data — below that threshold Meta returns empty results for privacy.";
+    readonly inputSchema: {
+        ig_user_id: z.ZodString;
+        metric: z.ZodDefault<z.ZodEnum<["follower_demographics", "engaged_audience_demographics", "reached_audience_demographics"]>>;
+        breakdown: z.ZodDefault<z.ZodEnum<["age", "gender", "country", "city", "audience_city"]>>;
+        metric_type: z.ZodDefault<z.ZodEnum<["total_value", "time_series"]>>;
+        timeframe: z.ZodDefault<z.ZodEnum<["last_14_days", "last_30_days", "last_90_days", "prev_month", "this_month", "this_week"]>>;
+    };
+    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/instagram/get-audience-demographics.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGet } from "../shared.js";
+const METRIC_TYPE = z.enum(["total_value", "time_series"]);
+const BREAKDOWN = z.enum(["age", "gender", "country", "city", "audience_city"]);
+export const inputSchema = z
+    .object({
+    ig_user_id: metaIdSchema,
+    metric: z
+        .enum([
+        "follower_demographics",
+        "engaged_audience_demographics",
+        "reached_audience_demographics",
+    ])
+        .default("follower_demographics")
+        .describe("Which audience cohort."),
+    breakdown: BREAKDOWN.default("age").describe("Demographic dimension."),
+    metric_type: METRIC_TYPE.default("total_value"),
+    timeframe: z
+        .enum(["last_14_days", "last_30_days", "last_90_days", "prev_month", "this_month", "this_week"])
+        .default("last_30_days")
+        .describe("Required for demographics metrics."),
+})
+    .strict();
+export const definition = {
+    name: "meta_ig_get_audience_demographics",
+    title: "Get IG audience demographics",
+    description: `Reads demographic breakdown of an IG Business account's followers, engaged audience, or reached audience. Use breakdown='age'|'gender'|'country'|'city' to slice.
+
+Requires 'instagram_manage_insights'. Only IG Business accounts with at least 100 followers return data — below that threshold Meta returns empty results for privacy.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("ig_user", input.ig_user_id, ctx.config);
+    return runGet(ctx, {
+        path: `${input.ig_user_id}/insights`,
+        params: {
+            metric: input.metric,
+            breakdown: input.breakdown,
+            metric_type: input.metric_type,
+            timeframe: input.timeframe,
+        },
+    });
+}

package/dist/tools/instagram/get-media-insights.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    media_id: z.ZodString;
+    metrics: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    metrics: string[];
+    media_id: string;
+}, {
+    media_id: string;
+    metrics?: string[] | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_ig_get_media_insights";
+    readonly title: "Get Instagram media insights";
+    readonly description: "Per-media metrics: reach, impressions, saves, likes, comments, shares, profile visits, follows-from-post. Requires 'instagram_manage_insights' scope.\n\nDifferent media types support different metric sets:\n- IMAGE/CAROUSEL_ALBUM: impressions, reach, saved, likes, comments, shares, profile_visits\n- VIDEO (Reels): plays, reach, likes, comments, shares, saved, total_interactions\n- STORY: impressions, reach, replies, exits, taps_forward, taps_back (use meta_ig_get_story_insights-style metrics)\n\nIf a metric is unsupported for the media type, Meta returns code 100 — retry with a narrower metric list.";
+    readonly inputSchema: {
+        media_id: 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/instagram/get-media-insights.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { metaIdSchema } from "../../helpers/schema.js";
+import { runGet } from "../shared.js";
+export const inputSchema = z
+    .object({
+    media_id: metaIdSchema.describe("IG media ID."),
+    metrics: z
+        .array(z.string())
+        .default([
+        "impressions",
+        "reach",
+        "saved",
+        "likes",
+        "comments",
+        "shares",
+        "total_interactions",
+        "profile_visits",
+        "follows",
+        "profile_activity",
+    ])
+        .describe("IG media metrics. For Reels prefer 'plays, reach, likes, comments, shares, saved, total_interactions'. Some metrics are media_type-specific — if a metric isn't supported for the media type, Meta returns an error."),
+})
+    .strict();
+export const definition = {
+    name: "meta_ig_get_media_insights",
+    title: "Get Instagram media insights",
+    description: `Per-media metrics: reach, impressions, saves, likes, comments, shares, profile visits, follows-from-post. Requires 'instagram_manage_insights' scope.
+
+Different media types support different metric sets:
+- IMAGE/CAROUSEL_ALBUM: impressions, reach, saved, likes, comments, shares, profile_visits
+- VIDEO (Reels): plays, reach, likes, comments, shares, saved, total_interactions
+- STORY: impressions, reach, replies, exits, taps_forward, taps_back (use meta_ig_get_story_insights-style metrics)
+
+If a metric is unsupported for the media type, Meta returns code 100 — retry with a narrower metric list.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    return runGet(ctx, {
+        path: `${input.media_id}/insights`,
+        params: { metric: input.metrics.join(",") },
+    });
+}

package/dist/tools/instagram/list-accounts.d.ts

@@ -0,0 +1,33 @@
+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>;
+}, "strict", z.ZodTypeAny, {
+    limit: number;
+    auto_paginate: boolean;
+    after?: 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_ig_list_accounts";
+    readonly title: "List Instagram Business accounts reachable via Pages";
+    readonly description: "Walks the Pages visible to the token (/me/assigned_pages) and, for each, resolves the linked Instagram Business account via 'instagram_business_account'. This is the modern discovery path — the /owned_instagram_accounts business edge is unreliable.\n\nRequires 'instagram_basic' scope on the token and 'Analyze Instagram account' task on each IG.";
+    readonly inputSchema: {
+        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/instagram/list-accounts.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+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,
+})
+    .strict();
+export const definition = {
+    name: "meta_ig_list_accounts",
+    title: "List Instagram Business accounts reachable via Pages",
+    description: `Walks the Pages visible to the token (/me/assigned_pages) and, for each, resolves the linked Instagram Business account via 'instagram_business_account'. This is the modern discovery path — the /owned_instagram_accounts business edge is unreliable.
+
+Requires 'instagram_basic' scope on the token and 'Analyze Instagram account' task on each IG.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    try {
+        // First, list the pages assigned to the token.
+        const pagesPage = await ctx.graph.get({
+            path: "me/assigned_pages",
+            params: { fields: "id,name", limit: input.limit, after: input.after },
+        });
+        const pages = Array.isArray(pagesPage.data) ? pagesPage.data : [];
+        // Resolve IG in parallel.
+        const results = await Promise.all(pages.map(async (p) => {
+            try {
+                const d = await ctx.graph.get({
+                    path: p.id,
+                    params: { fields: "id,name,instagram_business_account{id,username,name}" },
+                });
+                return {
+                    page_id: p.id,
+                    page_name: p.name,
+                    instagram_business_account: d.instagram_business_account ?? null,
+                };
+            }
+            catch (err) {
+                const e = err instanceof MetaError ? err : new MetaError(err.message);
+                return { page_id: p.id, page_name: p.name, error: e.message, hint: e.hint };
+            }
+        }));
+        const linked = results.filter((r) => "instagram_business_account" in r && r.instagram_business_account);
+        const structured = {
+            pages_scanned: pages.length,
+            ig_accounts_found: linked.length,
+            links: results,
+            next_after: pagesPage.paging?.cursors?.after,
+        };
+        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/instagram/list-media.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>;
+    ig_user_id: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    fields: string[];
+    limit: number;
+    auto_paginate: boolean;
+    ig_user_id: string;
+    after?: string | undefined;
+}, {
+    ig_user_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_ig_list_media";
+    readonly title: "List Instagram media (posts, reels, stories)";
+    readonly description: "Lists media posted by an IG Business account. Includes caption, permalink, timestamp, like/comment counts. For per-media metrics (reach, impressions, saves, plays), pass each ID to meta_ig_get_media_insights.";
+    readonly inputSchema: {
+        limit: z.ZodDefault<z.ZodNumber>;
+        after: z.ZodOptional<z.ZodString>;
+        auto_paginate: z.ZodDefault<z.ZodBoolean>;
+        ig_user_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/instagram/list-media.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { assertAllowed } from "../../config.js";
+import { metaIdSchema, paginationShape } from "../../helpers/schema.js";
+import { runList } from "../shared.js";
+export const inputSchema = z
+    .object({
+    ig_user_id: metaIdSchema,
+    fields: z
+        .array(z.string())
+        .default([
+        "id",
+        "media_type",
+        "media_product_type",
+        "caption",
+        "media_url",
+        "thumbnail_url",
+        "permalink",
+        "timestamp",
+        "like_count",
+        "comments_count",
+        "is_comment_enabled",
+        "shortcode",
+        "owner",
+    ])
+        .describe("Media fields. For Reels add 'ig_id'; for carousels add 'children{...}'."),
+    ...paginationShape,
+})
+    .strict();
+export const definition = {
+    name: "meta_ig_list_media",
+    title: "List Instagram media (posts, reels, stories)",
+    description: `Lists media posted by an IG Business account. Includes caption, permalink, timestamp, like/comment counts. For per-media metrics (reach, impressions, saves, plays), pass each ID to meta_ig_get_media_insights.`,
+    inputSchema: inputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+};
+export async function handler(input, ctx) {
+    assertAllowed("ig_user", input.ig_user_id, ctx.config);
+    return runList(ctx, {
+        path: `${input.ig_user_id}/media`,
+        params: { fields: input.fields.join(","), limit: input.limit, after: input.after },
+    }, { auto_paginate: input.auto_paginate, after: input.after, limit: input.limit }, { ig_user_id: input.ig_user_id });
+}

package/dist/tools/meta/graph-read.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import type { ToolContext } from "../../context.js";
+export declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    api_version: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    params?: Record<string, string | number | boolean> | undefined;
+    api_version?: string | undefined;
+}, {
+    path: string;
+    params?: Record<string, string | number | boolean> | undefined;
+    api_version?: string | undefined;
+}>;
+export type Input = z.infer<typeof inputSchema>;
+export declare const definition: {
+    readonly name: "meta_graph_read";
+    readonly title: "Arbitrary read-only Graph API call";
+    readonly description: "Escape-hatch for arbitrary GET requests against the Meta Graph API.\n\nThis tool exists so the assistant can reach fields and endpoints that do not yet have a dedicated tool wrapper — without ever sending a write. The underlying HTTP client is hard-wired to GET only; POST/PUT/DELETE are refused before the request leaves the process.\n\nRules:\n- Do NOT include 'access_token' or 'appsecret_proof' in params — they are added automatically.\n- Do NOT prefix the path with the API version.\n- Prefer dedicated tools (meta_business_list_assets, meta_ads_get_insights, …) when they exist. Use this as a last resort.";
+    readonly inputSchema: {
+        path: z.ZodString;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        api_version: 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>;