@onebots/adapter-instagram 0.1.0

package/lib/index.js

@@ -0,0 +1,166 @@
+import { AdapterRegistry } from "onebots";
+import { InstagramAdapter } from "./adapter.js";
+import { INSTAGRAM_EVENT_TYPES, INSTAGRAM_WEBHOOK_FIELDS, instagramCapabilities, } from "./capabilities.js";
+export { InstagramAdapter };
+export { InstagramClient } from "./client.js";
+export { describeInstagramCapabilities, INSTAGRAM_EVENT_TYPES, INSTAGRAM_WEBHOOK_FIELDS, instagramCapabilities, } from "./capabilities.js";
+export { InstagramError } from "./errors.js";
+export { projectInstagramEvent } from "./events.js";
+export { compileInstagramMessage, projectApiMessage, projectWebhookMessage, } from "./messages.js";
+export { executeInstagramPlatformAction, INSTAGRAM_PLATFORM_ACTIONS, } from "./platform-actions.js";
+export { InstagramWebhookCodec } from "./webhook-codec.js";
+const INSTAGRAM_PERMISSIONS = [
+    "instagram_business_basic",
+    "instagram_business_manage_messages",
+    "instagram_business_manage_comments",
+    "Human Agent",
+];
+export const instagramSchema = {
+    account_id: {
+        type: "string",
+        required: true,
+        label: "账号标识",
+        description: "OneBots 内区分 Instagram Professional Account 的稳定标识",
+        ui: { section: "credentials" },
+    },
+    instagram_user_id: {
+        type: "string",
+        required: true,
+        label: "Instagram User ID",
+        pattern: /^\d+$/,
+        description: "Instagram Professional Account 的 Meta ID，不是 username",
+        ui: { section: "credentials" },
+    },
+    access_token: {
+        type: "string",
+        required: true,
+        label: "Instagram User Access Token",
+        sensitive: true,
+        description: "使用 Business Login for Instagram 签发；无需关联 Facebook Page",
+        ui: { section: "credentials" },
+    },
+    app_secret: {
+        type: "string",
+        label: "Meta App Secret",
+        sensitive: true,
+        description: "Webhook 签名校验必需，也用于 Graph appsecret_proof",
+        ui: { section: "credentials" },
+    },
+    verify_token: {
+        type: "string",
+        label: "Webhook Verify Token",
+        sensitive: true,
+        description: "与 Meta App Dashboard 中填写的自定义验证令牌完全一致",
+        ui: {
+            section: "credentials",
+            visibleWhen: { path: "receive_mode", oneOf: ["webhook"] },
+        },
+    },
+    declared_permissions: {
+        type: "array",
+        label: "已授予权限与功能",
+        choices: INSTAGRAM_PERMISSIONS.map(value => ({ value, label: value })),
+        allowCustomValues: true,
+        description: "用于动态收敛 Web 能力展示；Human Agent 是需单独审核的平台功能",
+        ui: {
+            widget: "choice-list",
+            section: "credentials",
+            itemLabel: "Permission / feature",
+            addLabel: "添加权限",
+        },
+    },
+    receive_mode: {
+        type: "string",
+        default: "webhook",
+        label: "事件接收方式",
+        choices: [
+            { value: "webhook", label: "Meta Webhook（挂载已有 Host）" },
+            { value: "manual", label: "手动 ingest(rawEvent)" },
+        ],
+        description: "两种方式共用同一个 Client、严格解析、去重与 canonical 投影",
+        ui: { section: "transport" },
+    },
+    http_path: {
+        type: "string",
+        label: "Webhook 挂载路径",
+        placeholder: "/instagram/{account_id}/events",
+        pattern: /^\/(?!\/)[^?#\u0000-\u001f\u007f]*$/,
+        description: "留空使用账号隔离路径；适配器不会另开监听端口",
+        ui: {
+            section: "transport",
+            visibleWhen: { path: "receive_mode", oneOf: ["webhook"] },
+        },
+    },
+    auto_subscribe: {
+        type: "boolean",
+        default: false,
+        label: "启动时订阅 Professional Account",
+        description: "调用 /{ig-user-id}/subscribed_apps",
+        ui: {
+            section: "transport",
+            visibleWhen: { path: "receive_mode", oneOf: ["webhook"] },
+        },
+    },
+    subscribed_fields: {
+        type: "array",
+        default: ["messages", "messaging_postbacks", "messaging_seen", "message_reactions"],
+        label: "Webhook Fields",
+        choices: INSTAGRAM_WEBHOOK_FIELDS.map(value => ({ value, label: value })),
+        description: "可逐项增减，并同步收敛账号实际能力；无需手写 JSON",
+        ui: {
+            widget: "choice-list",
+            section: "transport",
+            itemLabel: "Webhook field",
+            addLabel: "添加 field",
+            visibleWhen: { path: "receive_mode", oneOf: ["webhook"] },
+        },
+    },
+    event_types: {
+        type: "array",
+        default: [...INSTAGRAM_EVENT_TYPES],
+        label: "接收事件",
+        choices: INSTAGRAM_EVENT_TYPES.map(value => ({ value, label: value })),
+        description: "在 batch 展开后过滤；已接收事件仍完整保留原始 envelope",
+        ui: {
+            widget: "choice-list",
+            section: "filter",
+            itemLabel: "Instagram 事件",
+            addLabel: "添加事件",
+        },
+    },
+    api_version: {
+        type: "string",
+        default: "v25.0",
+        label: "Graph API Version",
+        pattern: /^v\d+\.\d+$/,
+        ui: { section: "advanced" },
+    },
+    api_origin: {
+        type: "string",
+        default: "https://graph.instagram.com",
+        label: "Graph API Origin",
+        description: "仅代理、测试或私有网关需要修改；生产应保持官方 HTTPS host",
+        ui: { section: "advanced" },
+    },
+    max_body_bytes: {
+        type: "number",
+        default: 10485760,
+        min: 1,
+        max: 52428800,
+        label: "Webhook Body 上限（bytes）",
+        ui: {
+            section: "advanced",
+            visibleWhen: { path: "receive_mode", oneOf: ["webhook"] },
+        },
+    },
+};
+AdapterRegistry.registerSchema("instagram", instagramSchema);
+AdapterRegistry.register("instagram", InstagramAdapter, {
+    name: "instagram",
+    displayName: "Instagram Messaging",
+    description: "Instagram Login、Send、Conversations、Profile、Webhook 与平台扩展适配器",
+    icon: "https://static.cdninstagram.com/rsrc.php/v4/yR/r/lam-fZmwmvn.png",
+    homepage: "https://www.postman.com/meta/instagram/overview",
+    author: "凉菜",
+    capabilities: instagramCapabilities,
+});

package/lib/messages.d.ts

@@ -0,0 +1,12 @@
+import type { CommonTypes } from "onebots";
+import type { InstagramApiMessage, InstagramMessage, InstagramOutgoingMessage } from "./types.js";
+export interface InstagramAttachmentUploader {
+    upload(type: "image" | "video" | "audio", source: {
+        blob: Blob;
+        filename: string;
+    }, reusable: boolean): Promise<string>;
+}
+/** 编译为一个 Instagram Send API message；不隐式拆分成多个 message_id。 */
+export declare function compileInstagramMessage(segments: readonly CommonTypes.Segment[], uploader: InstagramAttachmentUploader): Promise<InstagramOutgoingMessage>;
+export declare function projectWebhookMessage(message: InstagramMessage): CommonTypes.Segment[];
+export declare function projectApiMessage(message: InstagramApiMessage): CommonTypes.Segment[];

package/lib/messages.js

@@ -0,0 +1,177 @@
+import { InstagramError } from "./errors.js";
+import { assertHttpsUrl, requireArray, requireRecord, requireString } from "./validation.js";
+/** 编译为一个 Instagram Send API message；不隐式拆分成多个 message_id。 */
+export async function compileInstagramMessage(segments, uploader) {
+    const native = segments.filter(segment => segment.type === "instagram");
+    if (native.length) {
+        if (native.length !== 1 || segments.length !== 1) {
+            return invalid("instagram 原生段必须独占一条消息");
+        }
+        return structuredClone(requireRecord(native[0].data.message ?? native[0].data, "instagram.message"));
+    }
+    const replies = segments.filter(segment => segment.type === "reply");
+    const quickReplies = segments.filter(segment => segment.type === "instagram_quick_replies");
+    const media = segments.filter(segment => ["image", "video", "audio", "record"].includes(segment.type));
+    const unsupported = segments.filter(segment => ![
+        "text",
+        "reply",
+        "image",
+        "video",
+        "audio",
+        "record",
+        "instagram_quick_replies",
+    ].includes(segment.type));
+    if (unsupported.length)
+        return invalid(`不支持消息段 ${unsupported[0].type}`);
+    if (replies.length > 1)
+        return invalid("一条消息只能包含一个 reply 段");
+    if (quickReplies.length > 1)
+        return invalid("一条消息只能包含一组 quick replies");
+    if (media.length > 1)
+        return invalid("Instagram 单次 Send API 只支持一个媒体附件");
+    const text = segments
+        .filter(segment => segment.type === "text")
+        .map(segment => String(segment.data.text ?? ""))
+        .join("");
+    if (text && media.length) {
+        return invalid("Instagram 单次 Send API 不能同时发送文本和媒体，请拆成两条消息");
+    }
+    if (quickReplies.length && !text)
+        return invalid("quick replies 必须附着在文本消息上");
+    const message = {};
+    if (text)
+        message.text = text;
+    if (media.length)
+        message.attachment = await compileAttachment(media[0], uploader);
+    if (replies.length) {
+        message.reply_to = {
+            mid: firstString(replies[0].data, ["message_id", "id"], "reply"),
+        };
+    }
+    if (quickReplies.length) {
+        const items = requireArray(quickReplies[0].data.items ?? quickReplies[0].data.quick_replies, "instagram_quick_replies.items");
+        if (!items.length || items.length > 13) {
+            return invalid("Instagram quick replies 必须包含 1 到 13 项");
+        }
+        message.quick_replies = items.map((item, index) => validateQuickReply(item, `instagram_quick_replies.items[${index}]`));
+    }
+    if (!message.text && !message.attachment)
+        return invalid("消息没有可发送内容");
+    return message;
+}
+export function projectWebhookMessage(message) {
+    const segments = [];
+    const replyMid = message.reply_to?.mid;
+    if (typeof replyMid === "string" && replyMid) {
+        segments.push({ type: "reply", data: { id: replyMid } });
+    }
+    if (message.text)
+        segments.push({ type: "text", data: { text: message.text } });
+    for (const attachment of message.attachments || []) {
+        segments.push(projectWebhookAttachment(attachment));
+    }
+    if (message.quick_reply) {
+        segments.push({
+            type: "instagram_quick_reply",
+            data: { payload: message.quick_reply.payload },
+        });
+    }
+    if (message.referral) {
+        segments.push({ type: "instagram_referral", data: structuredClone(message.referral) });
+    }
+    if (message.reply_to && typeof replyMid !== "string") {
+        segments.push({ type: "instagram_reply_context", data: structuredClone(message.reply_to) });
+    }
+    return segments;
+}
+export function projectApiMessage(message) {
+    return message.message ? [{ type: "text", data: { text: message.message } }] : [];
+}
+async function compileAttachment(segment, uploader) {
+    const type = normalizeMediaType(segment.type);
+    const data = requireRecord(segment.data, `${segment.type}.data`);
+    const attachmentId = optionalString(data.attachment_id ?? data.id);
+    if (attachmentId)
+        return { type, payload: { attachment_id: attachmentId } };
+    if (data.path !== undefined) {
+        return invalid("消息媒体不读取宿主本地路径；请传 base64 data、HTTPS URL 或 attachment_id");
+    }
+    const remote = optionalString(data.url ?? data.file);
+    if (remote) {
+        return { type, payload: { url: assertHttpsUrl(remote, `${segment.type}.url`) } };
+    }
+    const encoded = optionalString(data.data);
+    if (!encoded)
+        return invalid(`${segment.type} 缺少 url/file、data 或 attachment_id`);
+    const materialized = decodeMediaData(encoded, optionalString(data.name ?? data.filename) || "attachment.bin", optionalString(data.mime_type ?? data.content_type));
+    const attachmentIdFromUpload = await uploader.upload(type, {
+        blob: new Blob([new Uint8Array(materialized.data)], {
+            type: materialized.contentType,
+        }),
+        filename: materialized.filename,
+    }, true);
+    return { type, payload: { attachment_id: attachmentIdFromUpload } };
+}
+function validateQuickReply(value, field) {
+    const item = structuredClone(requireRecord(value, field));
+    const contentType = requireString(item.content_type, `${field}.content_type`);
+    if (!["text", "user_phone_number", "user_email"].includes(contentType)) {
+        return invalid(`${field}.content_type 无效`);
+    }
+    if (contentType === "text") {
+        const title = requireString(item.title, `${field}.title`);
+        if ([...title].length > 20)
+            return invalid(`${field}.title 不能超过 20 个字符`);
+    }
+    requireString(item.payload, `${field}.payload`);
+    return item;
+}
+function projectWebhookAttachment(attachment) {
+    const type = ["image", "video", "audio"].includes(attachment.type)
+        ? attachment.type
+        : "instagram_attachment";
+    return {
+        type,
+        data: {
+            ...(typeof attachment.payload.url === "string" ? { url: attachment.payload.url } : {}),
+            instagram_attachment: structuredClone(attachment),
+        },
+    };
+}
+function decodeMediaData(source, filename, declaredType) {
+    const match = source.match(/^data:([^;,]+);base64,(.*)$/su);
+    const encoded = match ? match[2] : source;
+    if (!encoded || encoded.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(encoded)) {
+        return invalid("媒体 data 不是有效 base64");
+    }
+    const data = new Uint8Array(Buffer.from(encoded, "base64"));
+    if (!data.byteLength || data.byteLength > 25 * 1024 * 1024) {
+        return invalid("媒体 data 必须介于 1 byte 与 25 MiB");
+    }
+    const contentType = match?.[1] || declaredType || "application/octet-stream";
+    if (!/^[\w!#$&^.+-]+\/[\w!#$&^.+-]+$/u.test(contentType)) {
+        return invalid("媒体 content type 无效");
+    }
+    return { data, filename: safeFilename(filename), contentType };
+}
+function safeFilename(value) {
+    const filename = value.replace(/\\/gu, "/").split("/").at(-1) || "attachment.bin";
+    return filename.replace(/[\u0000-\u001f\u007f"\\]/gu, "_").slice(0, 255);
+}
+function normalizeMediaType(type) {
+    return type === "record" ? "audio" : type;
+}
+function firstString(data, fields, context) {
+    for (const field of fields) {
+        const value = optionalString(data[field]);
+        if (value)
+            return value;
+    }
+    return invalid(`${context} 缺少 ${fields.join("/")}`);
+}
+function optionalString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function invalid(message) {
+    throw InstagramError.invalid(`Instagram ${message}`);
+}

package/lib/platform-actions.d.ts

@@ -0,0 +1,4 @@
+import type { InstagramClient } from "./client.js";
+export declare const INSTAGRAM_PLATFORM_ACTIONS: import("@onebots/core").PlatformActionSet<"call_instagram_api" | "send_instagram_native" | "send_instagram_human_agent" | "send_instagram_private_reply" | "react_instagram_message" | "send_instagram_media_share" | "send_instagram_like_heart" | "list_instagram_conversations" | "find_instagram_conversation" | "get_instagram_conversation" | "get_instagram_messenger_profile" | "set_instagram_messenger_profile" | "delete_instagram_messenger_profile" | "upload_instagram_attachment" | "subscribe_instagram_webhooks" | "get_instagram_subscribed_apps" | "delete_instagram_webhook_subscription" | "list_instagram_welcome_message_flows" | "create_instagram_welcome_message_flow" | "update_instagram_welcome_message_flow" | "delete_instagram_welcome_message_flow">;
+export type InstagramPlatformAction = typeof INSTAGRAM_PLATFORM_ACTIONS extends ReadonlySet<infer T> ? T : never;
+export declare function executeInstagramPlatformAction(client: InstagramClient, action: string, params: Readonly<Record<string, unknown>>): Promise<unknown>;

package/lib/platform-actions.js

@@ -0,0 +1,259 @@
+import { definePlatformActionContract } from "onebots";
+import { parseAttachmentId, parseSuccess } from "./entities.js";
+import { InstagramError } from "./errors.js";
+import { INSTAGRAM_WEBHOOK_FIELDS, } from "./types.js";
+import { assertHttpsUrl, assertMetaId, assertNumericMetaId, requireArray, requireRecord, requireString, } from "./validation.js";
+const handlers = {
+    call_instagram_api: (client, params) => client.call(graphMethod(params.method), requireString(params.path, "path"), {
+        query: queryRecord(params.query),
+        body: params.body === undefined ? undefined : cloneValue(params.body, "body"),
+    }),
+    send_instagram_native: (client, params) => client.send(assertNumericMetaId(params.recipient_id, "recipient_id"), cloneMessage(params.message)),
+    send_instagram_human_agent: (client, params) => client.send(assertNumericMetaId(params.recipient_id, "recipient_id"), cloneMessage(params.message), { humanAgent: true }),
+    send_instagram_private_reply: (client, params) => client.sendPrivateReply(assertNumericMetaId(params.comment_id, "comment_id"), requireString(params.text, "text")),
+    react_instagram_message: (client, params) => client.react(assertNumericMetaId(params.recipient_id, "recipient_id"), assertMetaId(params.message_id, "message_id"), reactionAction(params.action)),
+    send_instagram_media_share: (client, params) => client.send(assertNumericMetaId(params.recipient_id, "recipient_id"), {
+        attachment: {
+            type: "MEDIA_SHARE",
+            payload: { id: assertNumericMetaId(params.media_id, "media_id") },
+        },
+    }),
+    send_instagram_like_heart: (client, params) => client.send(assertNumericMetaId(params.recipient_id, "recipient_id"), {
+        attachment: { type: "like_heart" },
+    }),
+    list_instagram_conversations: (client, params) => client.listConversations(optionalString(params.after, "after"), optionalLimit(params.limit)),
+    find_instagram_conversation: (client, params) => client.findConversation(assertNumericMetaId(params.user_id, "user_id")),
+    get_instagram_conversation: (client, params) => client.getConversation(assertMetaId(params.conversation_id, "conversation_id"), optionalMessageLimit(params.limit)),
+    get_instagram_messenger_profile: (client, params) => client.call("GET", `/${client.config.instagram_user_id}/messenger_profile`, {
+        query: { fields: profileFields(params.fields).join(",") },
+    }),
+    set_instagram_messenger_profile: (client, params) => client.call("POST", `/${client.config.instagram_user_id}/messenger_profile`, {
+        body: profileBody(params.profile),
+    }),
+    delete_instagram_messenger_profile: (client, params) => client.call("DELETE", `/${client.config.instagram_user_id}/messenger_profile`, {
+        body: { fields: profileFields(params.fields) },
+    }),
+    upload_instagram_attachment: async (client, params) => {
+        const attachmentId = await client.uploadAttachment(attachmentType(params.type), { url: assertHttpsUrl(params.url, "url") }, params.is_reusable !== false);
+        return { attachment_id: parseAttachmentId({ attachment_id: attachmentId }) };
+    },
+    subscribe_instagram_webhooks: async (client, params) => {
+        const fields = webhookFields(params.subscribed_fields);
+        return parseSuccess(await client.call("POST", `/${client.config.instagram_user_id}/subscribed_apps`, {
+            query: { subscribed_fields: fields.join(",") },
+        }), "subscribe Instagram webhook response");
+    },
+    get_instagram_subscribed_apps: client => client.call("GET", `/${client.config.instagram_user_id}/subscribed_apps`),
+    delete_instagram_webhook_subscription: async (client) => parseSuccess(await client.call("DELETE", `/${client.config.instagram_user_id}/subscribed_apps`), "delete Instagram webhook subscription response"),
+    list_instagram_welcome_message_flows: (client, params) => client.call("GET", `/${client.config.instagram_user_id}/welcome_message_flows`, {
+        query: { flow_id: optionalMetaId(params.flow_id, "flow_id") },
+    }),
+    create_instagram_welcome_message_flow: (client, params) => client.call("POST", `/${client.config.instagram_user_id}/welcome_message_flows`, {
+        body: welcomeFlow(params.flow, false),
+    }),
+    update_instagram_welcome_message_flow: (client, params) => client.call("POST", `/${client.config.instagram_user_id}/welcome_message_flows`, {
+        query: { flow_id: assertMetaId(params.flow_id, "flow_id") },
+        body: welcomeFlow(params.flow, true),
+    }),
+    delete_instagram_welcome_message_flow: async (client, params) => parseSuccess(await client.call("DELETE", `/${client.config.instagram_user_id}/welcome_message_flows`, {
+        query: { flow_id: assertMetaId(params.flow_id, "flow_id") },
+    }), "delete Instagram welcome message flow response"),
+};
+const parameters = {
+    call_instagram_api: ["method", "path", "query", "body"],
+    send_instagram_native: ["recipient_id", "message"],
+    send_instagram_human_agent: ["recipient_id", "message"],
+    send_instagram_private_reply: ["comment_id", "text"],
+    react_instagram_message: ["recipient_id", "message_id", "action"],
+    send_instagram_media_share: ["recipient_id", "media_id"],
+    send_instagram_like_heart: ["recipient_id"],
+    list_instagram_conversations: ["after", "limit"],
+    find_instagram_conversation: ["user_id"],
+    get_instagram_conversation: ["conversation_id", "limit"],
+    get_instagram_messenger_profile: ["fields"],
+    set_instagram_messenger_profile: ["profile"],
+    delete_instagram_messenger_profile: ["fields"],
+    upload_instagram_attachment: ["type", "url", "is_reusable"],
+    subscribe_instagram_webhooks: ["subscribed_fields"],
+    get_instagram_subscribed_apps: [],
+    delete_instagram_webhook_subscription: [],
+    list_instagram_welcome_message_flows: ["flow_id"],
+    create_instagram_welcome_message_flow: ["flow"],
+    update_instagram_welcome_message_flow: ["flow_id", "flow"],
+    delete_instagram_welcome_message_flow: ["flow_id"],
+};
+const actions = definePlatformActionContract(handlers, parameters, {
+    unsupported: action => new InstagramError(`未知 Instagram 平台动作: ${action}`, {
+        code: "INSTAGRAM_ACTION_NOT_FOUND",
+        status: 404,
+    }),
+    unexpectedParameter: (action, parameter) => InstagramError.invalid(`Instagram 动作 ${action} 不接受参数 ${parameter}`),
+});
+export const INSTAGRAM_PLATFORM_ACTIONS = actions.actions;
+export async function executeInstagramPlatformAction(client, action, params) {
+    return actions.execute(client, action, params);
+}
+function graphMethod(value) {
+    if (value === "GET" || value === "POST" || value === "DELETE")
+        return value;
+    throw InstagramError.invalid("method 必须是 GET、POST 或 DELETE");
+}
+function queryRecord(value) {
+    if (value === undefined)
+        return undefined;
+    const query = requireRecord(value, "query");
+    const result = {};
+    for (const [key, item] of Object.entries(query)) {
+        if (typeof item === "string" ||
+            typeof item === "number" ||
+            typeof item === "boolean" ||
+            item === undefined) {
+            result[key] = item;
+        }
+        else if (Array.isArray(item) && item.every(entry => typeof entry === "string")) {
+            result[key] = item;
+        }
+        else {
+            throw InstagramError.invalid(`query.${key} 类型无效`);
+        }
+    }
+    return result;
+}
+function cloneValue(value, field) {
+    try {
+        return structuredClone(value);
+    }
+    catch (error) {
+        throw InstagramError.invalid(`${field} 必须是可结构化克隆的数据`, {
+            cause: String(error),
+        });
+    }
+}
+function cloneMessage(value) {
+    return structuredClone(requireRecord(value, "message"));
+}
+function stringList(value, field) {
+    const values = requireArray(value, field).map((item, index) => requireString(item, `${field}[${index}]`));
+    if (!values.length)
+        throw InstagramError.invalid(`${field} 不能为空`);
+    if (new Set(values).size !== values.length) {
+        throw InstagramError.invalid(`${field} 不能包含重复项`);
+    }
+    return values;
+}
+function webhookFields(value) {
+    const fields = stringList(value, "subscribed_fields");
+    const supported = new Set(INSTAGRAM_WEBHOOK_FIELDS);
+    if (fields.some(field => !supported.has(field))) {
+        throw InstagramError.invalid("subscribed_fields 包含当前 Instagram API 未定义字段");
+    }
+    return fields;
+}
+function profileFields(value) {
+    const fields = stringList(value, "fields");
+    if (fields.some(field => field !== "persistent_menu" && field !== "ice_breakers")) {
+        throw InstagramError.invalid("Messenger Profile fields 仅支持 persistent_menu 与 ice_breakers");
+    }
+    return fields;
+}
+function profileBody(value) {
+    const profile = structuredClone(requireRecord(value, "profile"));
+    const allowed = new Set(["platform", "persistent_menu", "ice_breakers"]);
+    const unexpected = Object.keys(profile).find(field => !allowed.has(field));
+    if (unexpected)
+        throw InstagramError.invalid(`profile 不接受字段 ${unexpected}`);
+    if (profile.platform !== undefined && profile.platform !== "instagram") {
+        throw InstagramError.invalid("profile.platform 必须是 instagram");
+    }
+    if (profile.persistent_menu === undefined && profile.ice_breakers === undefined) {
+        throw InstagramError.invalid("profile 必须包含 persistent_menu 或 ice_breakers");
+    }
+    if (profile.persistent_menu !== undefined) {
+        profile.persistent_menu = requireArray(profile.persistent_menu, "profile.persistent_menu").map((item, index) => profileLocale(item, `profile.persistent_menu[${index}]`));
+    }
+    if (profile.ice_breakers !== undefined) {
+        const iceBreakers = requireArray(profile.ice_breakers, "profile.ice_breakers");
+        if (!iceBreakers.length || iceBreakers.length > 4) {
+            throw InstagramError.invalid("profile.ice_breakers 必须包含 1 到 4 项");
+        }
+        profile.ice_breakers = iceBreakers.map((item, index) => profileIceBreaker(item, `profile.ice_breakers[${index}]`));
+    }
+    return { ...profile, platform: "instagram" };
+}
+function profileLocale(value, field) {
+    const locale = structuredClone(requireRecord(value, field));
+    requireString(locale.locale, `${field}.locale`);
+    const actions = requireArray(locale.call_to_actions, `${field}.call_to_actions`);
+    if (!actions.length)
+        throw InstagramError.invalid(`${field}.call_to_actions 不能为空`);
+    locale.call_to_actions = actions.map((item, index) => profileMenuAction(item, `${field}.call_to_actions[${index}]`));
+    return locale;
+}
+function profileMenuAction(value, field) {
+    const action = structuredClone(requireRecord(value, field));
+    const type = requireString(action.type, `${field}.type`);
+    requireString(action.title, `${field}.title`);
+    if (type === "postback")
+        requireString(action.payload, `${field}.payload`);
+    else if (type === "web_url")
+        action.url = assertHttpsUrl(action.url, `${field}.url`);
+    else
+        throw InstagramError.invalid(`${field}.type 必须是 postback 或 web_url`);
+    return action;
+}
+function profileIceBreaker(value, field) {
+    const action = structuredClone(requireRecord(value, field));
+    requireString(action.question, `${field}.question`);
+    requireString(action.payload, `${field}.payload`);
+    return action;
+}
+function welcomeFlow(value, updating) {
+    const flow = structuredClone(requireRecord(value, "flow"));
+    const name = requireString(flow.name, "flow.name");
+    const messages = requireArray(flow.welcome_message_flow, "flow.welcome_message_flow").map((item, index) => structuredClone(requireRecord(item, `flow.welcome_message_flow[${index}]`)));
+    if (!messages.length)
+        throw InstagramError.invalid("flow.welcome_message_flow 不能为空");
+    if (updating && flow.eligible_platforms !== undefined) {
+        throw InstagramError.invalid("更新 Welcome Message Flow 时不接受 eligible_platforms");
+    }
+    return updating
+        ? { ...flow, name, welcome_message_flow: messages }
+        : {
+            ...flow,
+            name,
+            welcome_message_flow: messages,
+            eligible_platforms: ["instagram"],
+        };
+}
+function optionalString(value, field) {
+    return value === undefined ? undefined : requireString(value, field);
+}
+function optionalMetaId(value, field) {
+    return value === undefined ? undefined : assertMetaId(value, field);
+}
+function optionalLimit(value) {
+    if (value === undefined)
+        return 25;
+    if (!Number.isSafeInteger(value) || Number(value) < 1 || Number(value) > 100) {
+        throw InstagramError.invalid("limit 必须是 1 到 100 的安全整数");
+    }
+    return Number(value);
+}
+function optionalMessageLimit(value) {
+    if (value === undefined)
+        return 20;
+    if (!Number.isSafeInteger(value) || Number(value) < 1 || Number(value) > 20) {
+        throw InstagramError.invalid("message limit 必须是 1 到 20 的安全整数");
+    }
+    return Number(value);
+}
+function attachmentType(value) {
+    if (value === "image" || value === "video" || value === "audio")
+        return value;
+    throw InstagramError.invalid("attachment type 必须是 image、video 或 audio");
+}
+function reactionAction(value) {
+    if (value === "react" || value === "unreact")
+        return value;
+    throw InstagramError.invalid("reaction action 必须是 react 或 unreact");
+}