@agentforge-io/connectors-meta 0.1.0

package/dist/tools/messenger.js

@@ -0,0 +1,320 @@
+"use strict";
+/**
+ * Messenger (Page DMs) tools.
+ *
+ * Four tools covering the MVP scope for a Page-bound respondent:
+ *
+ *   1. messenger_list_threads    — Page inbox, newest first
+ *   2. messenger_list_messages   — messages in a thread
+ *   3. messenger_send_message    — send a message (24h window + tags)
+ *   4. messenger_mark_seen       — sender_action: mark thread as seen
+ *
+ * Token model:
+ *   - `ctx.getAccessToken()` returns the PAGE access token persisted at
+ *     connect-time. Same property as Instagram — the page token
+ *     authorizes both surfaces.
+ *   - `ctx.metadata.pageId` is the Page id (NOT the IG user id). Used
+ *     in every endpoint path here.
+ *
+ * Why so close to Instagram's shape (but a separate file):
+ *   - Conversations API is shared (same fields), so the response
+ *     parsing is similar. But the routing key is different (page id vs
+ *     IG user id), the platform discriminator is different, and the
+ *     send-message body has a Messenger-specific `messaging_type` +
+ *     `tag` set that doesn't exist on Instagram. Trying to share a
+ *     single send-tool implementation between them would mean a giant
+ *     conditional on platform; cleaner to fork.
+ *
+ * 24h messaging window (the Messenger-specific quirk):
+ *   - Inside 24h of the user's last message → `messaging_type=RESPONSE`
+ *     (free-form, no tag).
+ *   - Outside 24h → `messaging_type=MESSAGE_TAG` + an approved `tag`
+ *     (HUMAN_AGENT, ACCOUNT_UPDATE, CONFIRMED_EVENT_UPDATE,
+ *     POST_PURCHASE_UPDATE). Sending without a tag returns error
+ *     code 10 ("App does not have permission for this messaging").
+ *   - We expose `messagingType` + `tag` in the schema; defaults are
+ *     RESPONSE/null. The agent can pick MESSAGE_TAG when it knows it's
+ *     outside the window — the API is authoritative on the actual
+ *     decision.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messengerMarkSeenTool = exports.messengerSendMessageTool = exports.messengerListMessagesTool = exports.messengerListThreadsTool = void 0;
+const http_1 = require("../http");
+const _shared_1 = require("./_shared");
+exports.messengerListThreadsTool = {
+    definition: {
+        name: 'messenger_list_threads',
+        description: "List the Facebook Page's Messenger inbox threads, newest-updated " +
+            'first. Returns thread id, updated time, senders (PSID + name), ' +
+            'unread count, and the latest message preview. Use `cursor` from ' +
+            'a previous response to paginate.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Max threads (1-50, default 20).',
+                    minimum: 1,
+                    maximum: 50,
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'Pagination cursor from a previous call.',
+                },
+                unreadOnly: {
+                    type: 'boolean',
+                    description: 'When true, filter the results to threads with unread > 0. ' +
+                        'Default false.',
+                },
+            },
+        },
+    },
+    build: (ctx) => async (input) => {
+        const pageId = (0, _shared_1.resolvePageId)(ctx);
+        const accessToken = await ctx.getAccessToken();
+        const limit = Math.min(Math.max(Number(input.limit ?? 20), 1), 50);
+        const result = await (0, http_1.metaGet)({
+            accessToken,
+            path: `/${encodeURIComponent(pageId)}/conversations`,
+            query: {
+                platform: 'messenger',
+                fields: 'id,updated_time,unread_count,senders{id,name,email},messages.limit(1){id,message,from{id,name},created_time}',
+                limit,
+                after: input.cursor,
+            },
+        });
+        const threads = result.data.map((t) => ({
+            id: t.id,
+            updatedAt: t.updated_time,
+            unreadCount: t.unread_count ?? 0,
+            senders: t.senders?.data?.map((s) => ({
+                id: s.id,
+                name: s.name,
+                email: s.email,
+            })) ?? [],
+            latestMessage: t.messages?.data?.[0]
+                ? {
+                    id: t.messages.data[0].id,
+                    text: t.messages.data[0].message,
+                    fromId: t.messages.data[0].from?.id,
+                    fromName: t.messages.data[0].from?.name,
+                    createdAt: t.messages.data[0].created_time,
+                }
+                : null,
+        }));
+        // Client-side filter when the agent asked for unread-only. We can't
+        // push this to the API (Messenger conversations endpoint doesn't
+        // expose an `unread_only` query param) so we trim after the fetch.
+        const filtered = input.unreadOnly
+            ? threads.filter((t) => t.unreadCount > 0)
+            : threads;
+        return JSON.stringify({
+            threads: filtered,
+            pageInfo: {
+                nextCursor: result.paging?.cursors?.after,
+                hasNextPage: Boolean(result.paging?.next),
+            },
+        });
+    },
+};
+exports.messengerListMessagesTool = {
+    definition: {
+        name: 'messenger_list_messages',
+        description: 'List the messages in a Messenger thread, newest first. Returns ' +
+            'message id, text, sender id/name/email, created time, ' +
+            'attachment URLs, and event tags (e.g. inbound vs system).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                threadId: {
+                    type: 'string',
+                    description: 'Conversation id from `messenger_list_threads`.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Max messages (1-100, default 25).',
+                    minimum: 1,
+                    maximum: 100,
+                },
+            },
+            required: ['threadId'],
+        },
+    },
+    build: (ctx) => async (input) => {
+        if (!input.threadId || typeof input.threadId !== 'string') {
+            throw new Error('threadId is required (from messenger_list_threads).');
+        }
+        const accessToken = await ctx.getAccessToken();
+        const limit = Math.min(Math.max(Number(input.limit ?? 25), 1), 100);
+        const result = await (0, http_1.metaGet)({
+            accessToken,
+            path: `/${encodeURIComponent(input.threadId)}`,
+            query: {
+                fields: `messages.limit(${limit}){id,message,from{id,name,email},to{id,name},created_time,attachments{id,mime_type,name,file_url,image_data,video_data},tags}`,
+            },
+        });
+        return JSON.stringify({
+            messages: result.messages?.data?.map((m) => ({
+                id: m.id,
+                text: m.message,
+                fromId: m.from?.id,
+                fromName: m.from?.name,
+                fromEmail: m.from?.email,
+                toIds: m.to?.data?.map((t) => t.id),
+                createdAt: m.created_time,
+                attachments: m.attachments?.data?.map((a) => ({
+                    id: a.id,
+                    mimeType: a.mime_type,
+                    name: a.name,
+                    url: a.file_url ?? a.image_data?.url ?? a.video_data?.url,
+                })) ?? [],
+                tags: m.tags?.data?.map((t) => t.name) ?? [],
+            })) ?? [],
+        });
+    },
+};
+/** Approved Message Tags. Sending outside the 24h window requires
+ *  ONE of these in the body. Keep this list narrow to the tags Meta
+ *  actually approves in 2025 — `NON_PROMOTIONAL_SUBSCRIPTION` was
+ *  retired; using it returns code 10. */
+const MESSAGE_TAGS = [
+    'CONFIRMED_EVENT_UPDATE',
+    'POST_PURCHASE_UPDATE',
+    'ACCOUNT_UPDATE',
+    'HUMAN_AGENT',
+];
+exports.messengerSendMessageTool = {
+    definition: {
+        name: 'messenger_send_message',
+        description: 'Send a message to a user on Messenger via the Page. Inside 24h ' +
+            'of the user\'s last message, use `messagingType="RESPONSE"` ' +
+            "(free-form). Outside 24h, you must pass `messagingType=" +
+            '"MESSAGE_TAG"` + a `tag` value (HUMAN_AGENT is the catch-all ' +
+            'for live-agent replies — Meta approves it for most pages). ' +
+            'Sending outside 24h without a tag returns error code 10.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                recipientId: {
+                    type: 'string',
+                    description: 'Page-scoped Sender ID (PSID) of the recipient. Get it from ' +
+                        '`messenger_list_threads` senders[].id. Required when ' +
+                        '`threadId` is not set.',
+                },
+                threadId: {
+                    type: 'string',
+                    description: 'Conversation id (from `messenger_list_threads`). When set, ' +
+                        'goes to the same thread without needing the PSID.',
+                },
+                text: {
+                    type: 'string',
+                    description: 'Message body, ≤2000 chars.',
+                    maxLength: 2000,
+                },
+                messagingType: {
+                    type: 'string',
+                    enum: ['RESPONSE', 'UPDATE', 'MESSAGE_TAG'],
+                    description: 'Defaults to `RESPONSE` (inside-24h reply). Use ' +
+                        '`MESSAGE_TAG` + `tag` outside the window. `UPDATE` is for ' +
+                        'subscription-style notifications and rarely needed.',
+                },
+                tag: {
+                    type: 'string',
+                    enum: [...MESSAGE_TAGS],
+                    description: 'Required when `messagingType=MESSAGE_TAG`. Pick the value ' +
+                        'that matches the message purpose: HUMAN_AGENT for live-' +
+                        'support replies, ACCOUNT_UPDATE for changes to the user\'s ' +
+                        'account, CONFIRMED_EVENT_UPDATE for booking/event ' +
+                        'reminders, POST_PURCHASE_UPDATE for order status.',
+                },
+            },
+            required: ['text'],
+        },
+    },
+    build: (ctx) => async (input) => {
+        const pageId = (0, _shared_1.resolvePageId)(ctx);
+        const accessToken = await ctx.getAccessToken();
+        const text = String(input.text ?? '').trim();
+        if (!text)
+            throw new Error('text is required and must not be empty.');
+        const recipientId = input.recipientId;
+        const threadId = input.threadId;
+        if (!recipientId && !threadId) {
+            throw new Error('Either `recipientId` or `threadId` must be provided.');
+        }
+        const recipient = threadId
+            ? { thread_key: threadId }
+            : { id: recipientId };
+        const messagingType = input.messagingType ?? 'RESPONSE';
+        // Fail-fast on the easy-to-miss client-side requirement, before
+        // the round-trip. Meta's error message for missing tag is
+        // confusing ("App does not have permission") so we explain the
+        // real reason here.
+        if (messagingType === 'MESSAGE_TAG' && !input.tag) {
+            throw new Error('`tag` is required when messagingType=MESSAGE_TAG. Pick one of: ' +
+                MESSAGE_TAGS.join(', '));
+        }
+        if (input.tag && !MESSAGE_TAGS.includes(input.tag)) {
+            throw new Error(`Unknown tag "${input.tag}". Supported: ${MESSAGE_TAGS.join(', ')}`);
+        }
+        const result = await (0, http_1.metaPost)({
+            accessToken,
+            path: `/${encodeURIComponent(pageId)}/messages`,
+            body: {
+                recipient,
+                message: { text },
+                messaging_type: messagingType,
+                ...(input.tag ? { tag: input.tag } : {}),
+            },
+        });
+        return JSON.stringify({
+            messageId: result.message_id,
+            recipientId: result.recipient_id,
+        });
+    },
+};
+// ─── messenger_mark_seen ────────────────────────────────────────────────
+exports.messengerMarkSeenTool = {
+    definition: {
+        name: 'messenger_mark_seen',
+        description: 'Mark a Messenger thread as seen by the Page. Surfaces the blue ' +
+            '"Seen" indicator to the recipient — useful right after the ' +
+            'agent reads a thread but before it composes a reply, so the ' +
+            "user knows their message landed. Doesn't send any content.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                recipientId: {
+                    type: 'string',
+                    description: 'PSID of the recipient. Required when `threadId` is not set.',
+                },
+                threadId: {
+                    type: 'string',
+                    description: 'Conversation id (from `messenger_list_threads`). Either ' +
+                        'this or `recipientId` is required.',
+                },
+            },
+        },
+    },
+    build: (ctx) => async (input) => {
+        const pageId = (0, _shared_1.resolvePageId)(ctx);
+        const accessToken = await ctx.getAccessToken();
+        const recipientId = input.recipientId;
+        const threadId = input.threadId;
+        if (!recipientId && !threadId) {
+            throw new Error('Either `recipientId` or `threadId` must be provided.');
+        }
+        const recipient = threadId
+            ? { thread_key: threadId }
+            : { id: recipientId };
+        await (0, http_1.metaPost)({
+            accessToken,
+            path: `/${encodeURIComponent(pageId)}/messages`,
+            body: {
+                recipient,
+                sender_action: 'mark_seen',
+            },
+        });
+        return JSON.stringify({ ok: true });
+    },
+};

package/dist/tools/whatsapp.d.ts

@@ -0,0 +1,39 @@
+/**
+ * WhatsApp Cloud outbound tools.
+ *
+ * Two tools — the connector is intentionally minimal because INBOUND
+ * lives in the platform's `WhatsAppModule` already (gateway webhook +
+ * inbox routing). This connector only adds the ability for an agent to
+ * INITIATE or REPLY outbound from a Cloud API phone number.
+ *
+ *   1. wa_send_text       — free-form text inside the 24h window
+ *   2. wa_send_template   — pre-approved template (any time)
+ *
+ * Token model:
+ *   - `ctx.getAccessToken()` returns the WhatsApp-scoped token persisted
+ *     at connect-time. Same Bearer flow as the rest of the Graph API.
+ *   - `ctx.metadata.waPhoneNumberId` is the PHONE NUMBER ID (NOT the
+ *     WABA id, NOT the human-readable phone number). Set by the
+ *     connect modal when the operator picks a phone from the WABA's
+ *     `phone_numbers[]` list.
+ *
+ * The 24h customer-service window:
+ *   - The Cloud API only accepts free-form text within 24h of the
+ *     customer's last inbound message. Outside that window, you MUST
+ *     send a TEMPLATE (pre-approved by Meta) — anything else returns
+ *     error code 131047 ("Re-engagement message").
+ *   - We expose this as two separate tools (`wa_send_text` vs
+ *     `wa_send_template`) instead of one polymorphic tool so the
+ *     agent's intent reads clearly in the trace + the schemas stay
+ *     focused. The runtime cost (one more tool slot) is dwarfed by
+ *     the clarity benefit.
+ *
+ * Number format:
+ *   - `to` is the recipient's phone in E.164 WITHOUT the `+` sign.
+ *     `573001234567` is correct; `+57 300 123 4567` returns code 131009.
+ *     We strip `+`, spaces, and dashes client-side and reject anything
+ *     that doesn't match the E.164-without-plus pattern.
+ */
+import type { ConnectorToolFactory } from '@agentforge-io/core';
+export declare const waSendTextTool: ConnectorToolFactory;
+export declare const waSendTemplateTool: ConnectorToolFactory;

package/dist/tools/whatsapp.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * WhatsApp Cloud outbound tools.
+ *
+ * Two tools — the connector is intentionally minimal because INBOUND
+ * lives in the platform's `WhatsAppModule` already (gateway webhook +
+ * inbox routing). This connector only adds the ability for an agent to
+ * INITIATE or REPLY outbound from a Cloud API phone number.
+ *
+ *   1. wa_send_text       — free-form text inside the 24h window
+ *   2. wa_send_template   — pre-approved template (any time)
+ *
+ * Token model:
+ *   - `ctx.getAccessToken()` returns the WhatsApp-scoped token persisted
+ *     at connect-time. Same Bearer flow as the rest of the Graph API.
+ *   - `ctx.metadata.waPhoneNumberId` is the PHONE NUMBER ID (NOT the
+ *     WABA id, NOT the human-readable phone number). Set by the
+ *     connect modal when the operator picks a phone from the WABA's
+ *     `phone_numbers[]` list.
+ *
+ * The 24h customer-service window:
+ *   - The Cloud API only accepts free-form text within 24h of the
+ *     customer's last inbound message. Outside that window, you MUST
+ *     send a TEMPLATE (pre-approved by Meta) — anything else returns
+ *     error code 131047 ("Re-engagement message").
+ *   - We expose this as two separate tools (`wa_send_text` vs
+ *     `wa_send_template`) instead of one polymorphic tool so the
+ *     agent's intent reads clearly in the trace + the schemas stay
+ *     focused. The runtime cost (one more tool slot) is dwarfed by
+ *     the clarity benefit.
+ *
+ * Number format:
+ *   - `to` is the recipient's phone in E.164 WITHOUT the `+` sign.
+ *     `573001234567` is correct; `+57 300 123 4567` returns code 131009.
+ *     We strip `+`, spaces, and dashes client-side and reject anything
+ *     that doesn't match the E.164-without-plus pattern.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waSendTemplateTool = exports.waSendTextTool = void 0;
+const http_1 = require("../http");
+const _shared_1 = require("./_shared");
+/**
+ * E.164 without the `+` — digits only, 8–15 length per the ITU spec.
+ * Cloud API rejects anything shorter or longer with code 131009.
+ */
+const WA_NUMBER_PATTERN = /^[1-9]\d{7,14}$/;
+function normalizeWaNumber(input) {
+    const raw = String(input ?? '');
+    const stripped = raw.replace(/[\s\-+()]/g, '');
+    if (!WA_NUMBER_PATTERN.test(stripped)) {
+        throw new Error(`"${raw}" is not a valid recipient phone number. Expected E.164 ` +
+            'digits without the leading "+", e.g. "573001234567" (8-15 ' +
+            'digits, first digit must be 1-9).');
+    }
+    return stripped;
+}
+exports.waSendTextTool = {
+    definition: {
+        name: 'wa_send_text',
+        description: 'Send a free-form text message via the connected WhatsApp Cloud ' +
+            'phone number. Only works when the recipient messaged the ' +
+            'business within the last 24 hours (the customer-service ' +
+            'window). Outside the window, Meta rejects with code 131047 — ' +
+            'use `wa_send_template` instead. Returns the WhatsApp message ' +
+            'id.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                to: {
+                    type: 'string',
+                    description: "Recipient phone in E.164 digits without the '+' sign " +
+                        '(e.g. "573001234567"). Spaces, dashes, and a leading + are ' +
+                        'stripped client-side before sending.',
+                },
+                text: {
+                    type: 'string',
+                    description: 'Message body, ≤4096 chars (Meta hard limit).',
+                    maxLength: 4096,
+                },
+                previewUrl: {
+                    type: 'boolean',
+                    description: 'When true and the body contains a URL, WhatsApp renders a ' +
+                        'link preview card. Default false.',
+                },
+                replyToMessageId: {
+                    type: 'string',
+                    description: 'Optional inbound message id to quote-reply. Surfaces as a ' +
+                        'quoted bubble in the WhatsApp UI. Get this from the ' +
+                        "inbound webhook's `messages[].id`.",
+                },
+            },
+            required: ['to', 'text'],
+        },
+    },
+    build: (ctx) => async (input) => {
+        const phoneId = (0, _shared_1.resolveWaPhoneId)(ctx);
+        const accessToken = await ctx.getAccessToken();
+        const to = normalizeWaNumber(input.to);
+        const text = String(input.text ?? '').trim();
+        if (!text)
+            throw new Error('text is required and must not be empty.');
+        const result = await (0, http_1.metaPost)({
+            accessToken,
+            path: `/${encodeURIComponent(phoneId)}/messages`,
+            body: {
+                messaging_product: 'whatsapp',
+                recipient_type: 'individual',
+                to,
+                type: 'text',
+                text: {
+                    body: text,
+                    preview_url: Boolean(input.previewUrl),
+                },
+                ...(input.replyToMessageId
+                    ? {
+                        context: { message_id: String(input.replyToMessageId) },
+                    }
+                    : {}),
+            },
+        });
+        return JSON.stringify({
+            messageId: result.messages?.[0]?.id,
+            to: result.contacts?.[0]?.wa_id,
+        });
+    },
+};
+exports.waSendTemplateTool = {
+    definition: {
+        name: 'wa_send_template',
+        description: 'Send a pre-approved WhatsApp template message. Use this OUTSIDE ' +
+            "the 24h customer-service window (or to start a new conversation " +
+            'with a customer who hasn\'t messaged the business yet). The ' +
+            'template must be APPROVED in WhatsApp Business Manager — ' +
+            'submitting un-approved names returns code 132001. Pass the ' +
+            'template name, language code, and the variables that fill the ' +
+            'template\'s `{{1}}`, `{{2}}` placeholders in order.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                to: {
+                    type: 'string',
+                    description: "Recipient phone in E.164 digits without '+' (e.g. '573001234567').",
+                },
+                templateName: {
+                    type: 'string',
+                    description: "Approved template name, e.g. 'order_confirmation'. Case " +
+                        'sensitive — must match exactly what was approved.',
+                },
+                languageCode: {
+                    type: 'string',
+                    description: 'Template language tag, e.g. "es", "en_US", "pt_BR". Must ' +
+                        'match the language the template was approved in.',
+                },
+                bodyVariables: {
+                    type: 'array',
+                    description: 'Positional text values that fill the template body\'s ' +
+                        '`{{1}}`, `{{2}}`, ... placeholders. Order matters. Omit ' +
+                        'when the template has no body variables.',
+                    items: { type: 'string' },
+                },
+                headerImageUrl: {
+                    type: 'string',
+                    description: 'When the template has an IMAGE header, pass the public ' +
+                        'URL of the image to render. Omit for text-only templates.',
+                },
+                components: {
+                    type: 'array',
+                    description: 'Advanced: pass the raw `components` array Meta expects ' +
+                        "when the template uses dynamic buttons, currency, " +
+                        'date_time, or other rich types. When set, this overrides ' +
+                        '`bodyVariables` + `headerImageUrl`. Shape is the same as ' +
+                        "the Cloud API's `template.components`.",
+                    items: { type: 'object' },
+                },
+            },
+            required: ['to', 'templateName', 'languageCode'],
+        },
+    },
+    build: (ctx) => async (input) => {
+        const phoneId = (0, _shared_1.resolveWaPhoneId)(ctx);
+        const accessToken = await ctx.getAccessToken();
+        const to = normalizeWaNumber(input.to);
+        const templateName = String(input.templateName ?? '').trim();
+        const languageCode = String(input.languageCode ?? '').trim();
+        if (!templateName)
+            throw new Error('templateName is required.');
+        if (!languageCode)
+            throw new Error('languageCode is required.');
+        // Two ways to build the `components` array:
+        //   1. Raw passthrough — when the caller already knows the Meta
+        //      shape (buttons, currency, date_time), they pass `components`
+        //      directly and we forward it verbatim.
+        //   2. Convenience — when the caller passes `bodyVariables` and/or
+        //      `headerImageUrl`, we build the components array for them so
+        //      the common case (text body with positional substitutions +
+        //      optional image header) doesn't require knowing the schema.
+        let components;
+        if (Array.isArray(input.components) && input.components.length > 0) {
+            components = input.components;
+        }
+        else {
+            const built = [];
+            if (typeof input.headerImageUrl === 'string' && input.headerImageUrl) {
+                built.push({
+                    type: 'header',
+                    parameters: [
+                        { type: 'image', image: { link: input.headerImageUrl } },
+                    ],
+                });
+            }
+            if (Array.isArray(input.bodyVariables) && input.bodyVariables.length > 0) {
+                built.push({
+                    type: 'body',
+                    parameters: input.bodyVariables.map((v) => ({
+                        type: 'text',
+                        text: String(v ?? ''),
+                    })),
+                });
+            }
+            components = built.length > 0 ? built : undefined;
+        }
+        const result = await (0, http_1.metaPost)({
+            accessToken,
+            path: `/${encodeURIComponent(phoneId)}/messages`,
+            body: {
+                messaging_product: 'whatsapp',
+                recipient_type: 'individual',
+                to,
+                type: 'template',
+                template: {
+                    name: templateName,
+                    language: { code: languageCode },
+                    ...(components ? { components } : {}),
+                },
+            },
+        });
+        return JSON.stringify({
+            messageId: result.messages?.[0]?.id,
+            to: result.contacts?.[0]?.wa_id,
+        });
+    },
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@agentforge-io/connectors-meta",
+  "version": "0.1.0",
+  "description": "Meta Graph API connectors for AgentForge — Instagram DMs/comments, Messenger Page DMs, Facebook Page posts/comments, WhatsApp Cloud outbound. One OAuth client → four independent connectors so the operator only grants the scopes the surface needs.",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:watch": "tsc -p tsconfig.build.json --watch",
+    "clean": "rm -rf dist *.tgz"
+  },
+  "peerDependencies": {
+    "@agentforge-io/core": "^3.3.0"
+  },
+  "devDependencies": {
+    "@agentforge-io/core": "*",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}