@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/discordbot/runtime-guilds.js

@@ -0,0 +1,464 @@
+import { Buffer } from "node:buffer";
+import { booleanString, looseArray, nullableBoolean, nullableInteger, nullableRawString, nullableString, objectArray, optionalBoolean, optionalInteger, optionalRawString, optionalRecord, optionalString, optionalStringArray, recordOrEmpty, } from "../../core/cast.js";
+import { jsonObject } from "../../core/request.js";
+import { providerInputError, requiredInputString } from "../provider-runtime.js";
+import { discordbotRequest, discordbotRequestJson, discordbotRequestJsonOrNull, discordbotRequestNoContent, requiredPath, } from "./runtime.js";
+export const guildActionHandlers = {
+    get_guild(input, context) {
+        return discordbotRequestJson({
+            path: guildPath(input),
+            query: { with_counts: booleanString(input.with_counts) },
+            context,
+        });
+    },
+    get_guild_preview(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/preview`, context });
+    },
+    modify_guild(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: guildPath(input),
+            body: jsonObject({
+                name: optionalString(input.name),
+                verification_level: nullableInteger(input.verification_level),
+                default_message_notifications: nullableInteger(input.default_message_notifications),
+                explicit_content_filter: nullableInteger(input.explicit_content_filter),
+                afk_channel_id: nullableString(input.afk_channel_id),
+                afk_timeout: optionalInteger(input.afk_timeout),
+                icon: nullableString(input.icon),
+                splash: nullableString(input.splash),
+                discovery_splash: nullableString(input.discovery_splash),
+                banner: nullableString(input.banner),
+                system_channel_id: nullableString(input.system_channel_id),
+                system_channel_flags: optionalInteger(input.system_channel_flags),
+                rules_channel_id: nullableString(input.rules_channel_id),
+                public_updates_channel_id: nullableString(input.public_updates_channel_id),
+                safety_alerts_channel_id: nullableString(input.safety_alerts_channel_id),
+                preferred_locale: nullableString(input.preferred_locale),
+                features: optionalStringArray(input.features),
+                description: nullableRawString(input.description),
+                premium_progress_bar_enabled: optionalBoolean(input.premium_progress_bar_enabled),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    list_guild_channels(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/channels`, context }).then((channels) => ({ channels }));
+    },
+    create_guild_channel(input, context) {
+        return discordbotRequestJson({
+            method: "POST",
+            path: `${guildPath(input)}/channels`,
+            body: jsonObject({
+                name: requiredInputString(input.name, "name"),
+                type: optionalInteger(input.type),
+                topic: channelTopic(input),
+                bitrate: optionalInteger(input.bitrate),
+                user_limit: optionalInteger(input.user_limit),
+                rate_limit_per_user: optionalInteger(input.rate_limit_per_user),
+                position: optionalInteger(input.position),
+                permission_overwrites: Array.isArray(input.permission_overwrites) ? input.permission_overwrites : undefined,
+                parent_id: optionalString(input.parent_id),
+                nsfw: optionalBoolean(input.nsfw),
+                rtc_region: nullableString(input.rtc_region),
+                video_quality_mode: optionalInteger(input.video_quality_mode),
+                default_auto_archive_duration: optionalInteger(input.default_auto_archive_duration),
+                default_reaction_emoji: optionalRecord(input.default_reaction_emoji),
+                available_tags: Array.isArray(input.available_tags) ? input.available_tags : undefined,
+                default_sort_order: optionalInteger(input.default_sort_order),
+                default_forum_layout: optionalInteger(input.default_forum_layout),
+                default_thread_rate_limit_per_user: optionalInteger(input.default_thread_rate_limit_per_user),
+                flags: optionalInteger(input.flags),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        }).then((channel) => ({ channel }));
+    },
+    modify_guild_channel_positions(input, context) {
+        return discordbotRequestNoContent({
+            method: "PATCH",
+            path: `${guildPath(input)}/channels`,
+            body: requiredPositions(input.positions).map((position) => jsonObject({
+                id: requiredInputString(position.id, "positions[].id"),
+                position: nullableInteger(position.position),
+                lock_permissions: nullableBoolean(position.lock_permissions),
+                parent_id: nullableString(position.parent_id),
+                flags: nullableInteger(position.flags),
+            })),
+            context,
+        });
+    },
+    list_active_guild_threads(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/threads/active`, context }).then((value) => {
+            const response = recordOrEmpty(value);
+            return { threads: looseArray(response.threads), members: looseArray(response.members) };
+        });
+    },
+    get_guild_member(input, context) {
+        return discordbotRequestJson({ path: memberPath(input), context });
+    },
+    list_guild_members(input, context) {
+        return discordbotRequestJson({
+            path: `${guildPath(input)}/members`,
+            query: { limit: optionalInteger(input.limit), after: optionalString(input.after) },
+            context,
+        }).then((members) => ({ members }));
+    },
+    search_guild_members(input, context) {
+        return discordbotRequestJson({
+            path: `${guildPath(input)}/members/search`,
+            query: {
+                query: requiredInputString(input.query, "query"),
+                limit: optionalInteger(input.limit),
+            },
+            context,
+        }).then((members) => ({ members }));
+    },
+    add_guild_member(input, context) {
+        return addGuildMember(input, context);
+    },
+    modify_guild_member(input, context) {
+        return discordbotRequestJsonOrNull({
+            method: "PATCH",
+            path: memberPath(input),
+            body: jsonObject({
+                nick: nullableRawString(input.nick),
+                roles: input.roles === null ? null : optionalStringArray(input.roles),
+                mute: nullableBoolean(input.mute),
+                deaf: nullableBoolean(input.deaf),
+                channel_id: nullableString(input.channel_id),
+                communication_disabled_until: nullableString(input.communication_disabled_until),
+                flags: nullableInteger(input.flags),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        }).then((member) => ({ member }));
+    },
+    modify_current_member(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: `${guildPath(input)}/members/@me`,
+            body: jsonObject({
+                nick: nullableRawString(input.nick),
+                avatar: nullableString(input.avatar),
+                banner: nullableString(input.banner),
+                bio: nullableRawString(input.bio),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    add_guild_member_role(input, context) {
+        return discordbotRequestNoContent({
+            method: "PUT",
+            path: `${memberPath(input)}/roles/${requiredPath(input.role_id, "role_id")}`,
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    remove_guild_member_role(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: `${memberPath(input)}/roles/${requiredPath(input.role_id, "role_id")}`,
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    remove_guild_member(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: memberPath(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    list_guild_bans(input, context) {
+        return discordbotRequestJson({
+            path: `${guildPath(input)}/bans`,
+            query: {
+                limit: optionalInteger(input.limit),
+                before: optionalString(input.before),
+                after: optionalString(input.after),
+            },
+            context,
+        }).then((bans) => ({ bans }));
+    },
+    get_guild_ban(input, context) {
+        return discordbotRequestJson({ path: banPath(input), context });
+    },
+    create_guild_ban(input, context) {
+        return discordbotRequestNoContent({
+            method: "PUT",
+            path: banPath(input),
+            body: jsonObject({ delete_message_seconds: optionalInteger(input.delete_message_seconds) }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    remove_guild_ban(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: banPath(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    bulk_guild_ban(input, context) {
+        const userIds = optionalStringArray(input.user_ids);
+        if (!userIds || userIds.length === 0) {
+            throw providerInputError("user_ids must be a non-empty array of user ids");
+        }
+        return discordbotRequestJson({
+            method: "POST",
+            path: `${guildPath(input)}/bulk-ban`,
+            body: jsonObject({
+                user_ids: userIds,
+                delete_message_seconds: optionalInteger(input.delete_message_seconds),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        }).then((value) => {
+            const response = recordOrEmpty(value);
+            return { banned_users: looseArray(response.banned_users), failed_users: looseArray(response.failed_users) };
+        });
+    },
+    list_guild_roles(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/roles`, context }).then((roles) => ({ roles }));
+    },
+    get_guild_role(input, context) {
+        return discordbotRequestJson({ path: rolePath(input), context });
+    },
+    get_guild_role_member_counts(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/roles/member-counts`, context }).then((counts) => ({
+            member_counts: recordOrEmpty(counts),
+        }));
+    },
+    create_guild_role(input, context) {
+        return discordbotRequestJson({
+            method: "POST",
+            path: `${guildPath(input)}/roles`,
+            body: roleBody(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    modify_guild_role_positions(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: `${guildPath(input)}/roles`,
+            body: requiredPositions(input.positions).map((position) => jsonObject({
+                id: requiredInputString(position.id, "positions[].id"),
+                position: nullableInteger(position.position),
+            })),
+            auditLogReason: input.audit_log_reason,
+            context,
+        }).then((roles) => ({ roles }));
+    },
+    modify_guild_role(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: rolePath(input),
+            body: roleBody(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    delete_guild_role(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: rolePath(input),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    get_guild_prune_count(input, context) {
+        return discordbotRequestJson({
+            path: `${guildPath(input)}/prune`,
+            query: {
+                days: optionalInteger(input.days),
+                include_roles: optionalStringArray(input.include_roles)?.join(","),
+            },
+            context,
+        });
+    },
+    begin_guild_prune(input, context) {
+        return discordbotRequestJson({
+            method: "POST",
+            path: `${guildPath(input)}/prune`,
+            body: jsonObject({
+                days: optionalInteger(input.days),
+                compute_prune_count: optionalBoolean(input.compute_prune_count),
+                include_roles: optionalStringArray(input.include_roles),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    list_guild_voice_regions(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/regions`, context }).then((regions) => ({ regions }));
+    },
+    list_guild_invites(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/invites`, context }).then((invites) => ({ invites }));
+    },
+    list_guild_integrations(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/integrations`, context }).then((integrations) => ({
+            integrations,
+        }));
+    },
+    delete_guild_integration(input, context) {
+        return discordbotRequestNoContent({
+            method: "DELETE",
+            path: `${guildPath(input)}/integrations/${requiredPath(input.integration_id, "integration_id")}`,
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    get_guild_widget_settings(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/widget`, context });
+    },
+    modify_guild_widget(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: `${guildPath(input)}/widget`,
+            body: jsonObject({
+                enabled: optionalBoolean(input.enabled),
+                channel_id: nullableString(input.channel_id),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    get_guild_widget(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/widget.json`, context });
+    },
+    get_guild_vanity_url(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/vanity-url`, context });
+    },
+    get_guild_widget_png(input, context) {
+        return getGuildWidgetPng(input, context);
+    },
+    get_guild_welcome_screen(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/welcome-screen`, context });
+    },
+    modify_guild_welcome_screen(input, context) {
+        return discordbotRequestJson({
+            method: "PATCH",
+            path: `${guildPath(input)}/welcome-screen`,
+            body: jsonObject({
+                enabled: nullableBoolean(input.enabled),
+                welcome_channels: input.welcome_channels === null
+                    ? null
+                    : Array.isArray(input.welcome_channels)
+                        ? input.welcome_channels
+                        : undefined,
+                description: nullableRawString(input.description),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    get_guild_onboarding(input, context) {
+        return discordbotRequestJson({ path: `${guildPath(input)}/onboarding`, context });
+    },
+    modify_guild_onboarding(input, context) {
+        return discordbotRequestJson({
+            method: "PUT",
+            path: `${guildPath(input)}/onboarding`,
+            body: jsonObject({
+                prompts: Array.isArray(input.prompts) ? input.prompts : undefined,
+                default_channel_ids: optionalStringArray(input.default_channel_ids),
+                enabled: optionalBoolean(input.enabled),
+                mode: optionalInteger(input.mode),
+            }),
+            auditLogReason: input.audit_log_reason,
+            context,
+        });
+    },
+    modify_guild_incident_actions(input, context) {
+        return discordbotRequestJson({
+            method: "PUT",
+            path: `${guildPath(input)}/incident-actions`,
+            body: jsonObject({
+                invites_disabled_until: nullableString(input.invites_disabled_until),
+                dms_disabled_until: nullableString(input.dms_disabled_until),
+            }),
+            context,
+        });
+    },
+};
+async function addGuildMember(input, context) {
+    // Discord answers 204 with no body when the user is already in the guild.
+    const member = await discordbotRequestJsonOrNull({
+        method: "PUT",
+        path: memberPath(input),
+        body: jsonObject({
+            access_token: requiredInputString(input.access_token, "access_token"),
+            nick: optionalRawString(input.nick),
+            roles: optionalStringArray(input.roles),
+            mute: optionalBoolean(input.mute),
+            deaf: optionalBoolean(input.deaf),
+        }),
+        context,
+    });
+    return { already_member: member === null, member };
+}
+async function getGuildWidgetPng(input, context) {
+    const guildId = requiredInputString(input.guild_id, "guild_id");
+    const response = await discordbotRequest({
+        path: `${guildPath(input)}/widget.png`,
+        query: { style: optionalString(input.style) },
+        context,
+        authenticated: false,
+    });
+    const buffer = Buffer.from(await response.arrayBuffer());
+    return {
+        filename: `discord-guild-${guildId}-widget-${optionalString(input.style) ?? "shield"}.png`,
+        mimeType: response.headers.get("content-type") ?? "image/png",
+        sizeBytes: buffer.byteLength,
+        dataBase64: buffer.toString("base64"),
+    };
+}
+/**
+ * Discord allows 4096 characters in the topic of a forum (15) or media (16) channel
+ * and 1024 in every other channel type, including the default text channel.
+ */
+function channelTopic(input) {
+    const topic = optionalRawString(input.topic);
+    const type = optionalInteger(input.type);
+    if (topic !== undefined && type !== 15 && type !== 16 && [...topic].length > 1024) {
+        throw providerInputError("topic must be at most 1024 characters unless type is 15 (forum) or 16 (media)");
+    }
+    return topic;
+}
+function roleBody(input) {
+    return jsonObject({
+        name: optionalRawString(input.name),
+        permissions: optionalString(input.permissions),
+        color: optionalInteger(input.color),
+        colors: optionalRecord(input.colors),
+        hoist: optionalBoolean(input.hoist),
+        icon: nullableString(input.icon),
+        unicode_emoji: nullableString(input.unicode_emoji),
+        mentionable: optionalBoolean(input.mentionable),
+    });
+}
+function requiredPositions(value) {
+    const positions = objectArray(value, "positions", providerInputError);
+    if (positions.length === 0) {
+        throw providerInputError("positions must not be empty");
+    }
+    return positions;
+}
+function guildPath(input) {
+    return `/guilds/${requiredPath(input.guild_id, "guild_id")}`;
+}
+function memberPath(input) {
+    return `${guildPath(input)}/members/${requiredPath(input.user_id, "user_id")}`;
+}
+function banPath(input) {
+    return `${guildPath(input)}/bans/${requiredPath(input.user_id, "user_id")}`;
+}
+function rolePath(input) {
+    return `${guildPath(input)}/roles/${requiredPath(input.role_id, "role_id")}`;
+}

package/src/providers/discordbot/runtime.d.ts

@@ -0,0 +1,42 @@
+export declare const discordProxyBaseUrl = "https://discord.com/api";
+export interface DiscordbotContext {
+    apiKey: string;
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}
+export type DiscordbotActionHandler = (input: Record<string, unknown>, context: DiscordbotContext) => Promise<unknown>;
+interface DiscordbotRequestOptions {
+    method?: string;
+    path: string;
+    query?: Record<string, unknown>;
+    /** JSON body. Discord's position endpoints take a top-level array. */
+    body?: Record<string, unknown> | unknown[];
+    context: DiscordbotContext;
+    authenticated?: boolean;
+    skipError?: boolean;
+    /** Sent as `X-Audit-Log-Reason` on endpoints that record one. */
+    auditLogReason?: unknown;
+}
+/** Send a Discord request and parse the JSON response body. */
+export declare function discordbotRequestJson(input: DiscordbotRequestOptions): Promise<unknown>;
+/**
+ * Send a Discord request whose success may be 200 with a JSON body or 204 with none,
+ * returning null for the 204.
+ */
+export declare function discordbotRequestJsonOrNull(input: DiscordbotRequestOptions): Promise<unknown>;
+/** Send a Discord request that answers with 204 No Content. */
+export declare function discordbotRequestNoContent(input: DiscordbotRequestOptions): Promise<{
+    success: true;
+}>;
+/** Send a Discord request, mapping non-2xx responses to provider errors unless `skipError` is set. */
+export declare function discordbotRequest(input: DiscordbotRequestOptions): Promise<Response>;
+/**
+ * Read a required snowflake input for use as one URL path segment. Only digits are
+ * accepted, because percent-encoding cannot keep an arbitrary id inside one segment:
+ * URL parsing resolves `.` and `..` as dot segments, and Discord decodes `%2F` into a
+ * path separator before routing. Either would send the request, with the same method
+ * and bot token, to another endpoint: `role_id: ".."` turns a role DELETE into one on
+ * the guild itself, and `user_id: "U/roles/R"` on Add Guild Member grants role R.
+ */
+export declare function requiredPath(value: unknown, field: string): string;
+export {};

package/src/providers/discordbot/runtime.js

@@ -0,0 +1,124 @@
+import { looseArray, optionalRecord, optionalString, recordOrEmpty } from "../../core/cast.js";
+import { jsonObject } from "../../core/request.js";
+import { providerInputError, ProviderRequestError, requiredInputString } from "../provider-runtime.js";
+// Pin actions to v10. An unversioned route goes to Discord's default version, which is
+// still the deprecated v6: 31-bit numeric permissions, no threads, and a 204 without the
+// member from Modify Guild Member.
+const discordRestBaseUrl = "https://discord.com/api/v10";
+// The proxy stays unversioned so existing proxy paths, including ones that already
+// start with a version such as /v10, keep resolving as before.
+export const discordProxyBaseUrl = "https://discord.com/api";
+/** Send a Discord request and parse the JSON response body. */
+export async function discordbotRequestJson(input) {
+    return readDiscordbotJson(await discordbotRequest(input));
+}
+/**
+ * Send a Discord request whose success may be 200 with a JSON body or 204 with none,
+ * returning null for the 204.
+ */
+export async function discordbotRequestJsonOrNull(input) {
+    const response = await discordbotRequest(input);
+    return response.status === 204 ? null : readDiscordbotJson(response);
+}
+/** Send a Discord request that answers with 204 No Content. */
+export async function discordbotRequestNoContent(input) {
+    await discordbotRequest(input);
+    return { success: true };
+}
+/** Send a Discord request, mapping non-2xx responses to provider errors unless `skipError` is set. */
+export async function discordbotRequest(input) {
+    const url = new URL(`${discordRestBaseUrl}${input.path}`);
+    for (const [key, value] of Object.entries(input.query ?? {})) {
+        if (value !== undefined) {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const headers = new Headers();
+    if (input.authenticated !== false) {
+        headers.set("authorization", `Bot ${input.context.apiKey}`);
+    }
+    if (input.body !== undefined) {
+        headers.set("content-type", "application/json");
+    }
+    const auditLogReason = optionalString(input.auditLogReason);
+    if (auditLogReason) {
+        // Discord reads the header as URL-encoded UTF-8.
+        headers.set("x-audit-log-reason", encodeURIComponent(auditLogReason));
+    }
+    const response = await input.context.fetcher(url, {
+        method: input.method,
+        headers,
+        body: input.body === undefined ? undefined : JSON.stringify(input.body),
+        signal: input.context.signal,
+    });
+    if (!input.skipError && !response.ok) {
+        throw await toDiscordbotError(response);
+    }
+    return response;
+}
+/**
+ * Read a required snowflake input for use as one URL path segment. Only digits are
+ * accepted, because percent-encoding cannot keep an arbitrary id inside one segment:
+ * URL parsing resolves `.` and `..` as dot segments, and Discord decodes `%2F` into a
+ * path separator before routing. Either would send the request, with the same method
+ * and bot token, to another endpoint: `role_id: ".."` turns a role DELETE into one on
+ * the guild itself, and `user_id: "U/roles/R"` on Add Guild Member grants role R.
+ */
+export function requiredPath(value, field) {
+    const segment = requiredInputString(value, field);
+    if (!/^\d+$/.test(segment)) {
+        throw providerInputError(`${field} must be a numeric Discord snowflake id`);
+    }
+    return segment;
+}
+async function readDiscordbotJson(response) {
+    try {
+        return (await response.json());
+    }
+    catch {
+        throw new ProviderRequestError(502, "Discord returned invalid JSON");
+    }
+}
+async function toDiscordbotError(response) {
+    const text = await response.text().catch(() => "");
+    let payload;
+    try {
+        payload = optionalRecord(JSON.parse(text));
+    }
+    catch { }
+    const message = optionalString(payload?.message) ??
+        optionalString(payload?.error_description) ??
+        optionalString(payload?.error) ??
+        text;
+    // A form error's message is only "Invalid Form Body"; the failing fields are in `errors`.
+    const formErrors = collectDiscordbotFormErrors(payload?.errors, "");
+    const resolvedMessage = formErrors.length > 0
+        ? `${message}: ${formErrors.join("; ")}`
+        : message || `Discord request failed with ${response.status}`;
+    const details = payload
+        ? jsonObject({ code: payload.code, errors: payload.errors, retry_after: payload.retry_after })
+        : undefined;
+    // Discord answers 403 when the bot lacks a guild or channel permission, such as
+    // "Missing Permissions" or "Missing Access". The token still works, so this must
+    // not read as authorization_failed, which clients treat as "reconnect".
+    if (response.status === 403) {
+        return new ProviderRequestError(403, resolvedMessage, details, "invalid_input");
+    }
+    return new ProviderRequestError(response.status, resolvedMessage, details);
+}
+/**
+ * Flatten Discord's form errors into `path: message` entries. Each failing JSON key,
+ * or array index, nests down to an `_errors` list of `{ code, message }`; an `_errors`
+ * list at the top level describes the request as a whole and has no path.
+ */
+function collectDiscordbotFormErrors(errors, path) {
+    return Object.entries(recordOrEmpty(errors)).flatMap(([key, value]) => {
+        if (key !== "_errors") {
+            return collectDiscordbotFormErrors(value, path ? `${path}.${key}` : key);
+        }
+        return looseArray(value).flatMap((item) => {
+            const message = optionalString(optionalRecord(item)?.message);
+            return message ? [path ? `${path}: ${message}` : message] : [];
+        });
+    });
+}

package/src/providers/drawio_mcp/executors.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialValidators, ProviderExecutors } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;

package/src/providers/drawio_mcp/executors.js

@@ -0,0 +1,19 @@
+import { isPrivateNetworkAccessAllowed } from "../../core/request.js";
+import { createProviderFetch, defineProviderExecutors, requireCustomCredential } from "../provider-runtime.js";
+import { createDrawioMcpContext, drawioMcpActionHandlers, validateDrawioMcpCredential } from "./runtime.js";
+const service = "drawio_mcp";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: drawioMcpActionHandlers,
+    async createContext(context, fetcher) {
+        const credential = await requireCustomCredential(context, service);
+        return createDrawioMcpContext(credential.values, fetcher, context.signal);
+    },
+    allowPrivateNetwork: isPrivateNetworkAccessAllowed,
+});
+export const credentialValidators = {
+    customCredential(input, { fetcher, signal }) {
+        const guardedFetcher = createProviderFetch({ fetch: fetcher, allowPrivateNetwork: isPrivateNetworkAccessAllowed });
+        return validateDrawioMcpCredential(input.values, guardedFetcher, signal);
+    },
+};

package/src/providers/drawio_mcp/runtime.d.ts

@@ -0,0 +1,8 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { McpToolOptions } from "../mcp-tools.ts";
+import type { ProviderActionHandlers, ProviderFetch, ProviderRuntimeHandler } from "../provider-runtime.ts";
+export declare const drawioMcpActionHandlers: ProviderActionHandlers<"drawio_mcp", ProviderRuntimeHandler<McpToolOptions>>;
+/** Resolve the MCP server a connection points at; a blank endpoint selects the hosted draw.io server. */
+export declare function createDrawioMcpContext(values: Record<string, string>, fetcher: ProviderFetch, signal?: AbortSignal): McpToolOptions;
+/** Confirm the endpoint serves the draw.io tools and derive a stable identity from the endpoint. */
+export declare function validateDrawioMcpCredential(values: Record<string, string>, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;