openclaw-groupme 0.4.2 → 0.4.3

package/dist/index.js

@@ -0,0 +1,14 @@
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { groupmePlugin } from "./src/channel.js";
+import { setGroupMeRuntime } from "./src/runtime.js";
+const plugin = {
+    id: "groupme",
+    name: "GroupMe",
+    description: "GroupMe channel plugin",
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        setGroupMeRuntime(api.runtime);
+        api.registerChannel({ plugin: groupmePlugin });
+    },
+};
+export default plugin;

package/dist/src/accounts.js

@@ -0,0 +1,119 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, } from "openclaw/plugin-sdk/account-id";
+const ENV_BOT_ID = "GROUPME_BOT_ID";
+const ENV_ACCESS_TOKEN = "GROUPME_ACCESS_TOKEN";
+const ENV_BOT_NAME = "GROUPME_BOT_NAME";
+const ENV_CALLBACK_URL = "GROUPME_CALLBACK_URL";
+const ENV_GROUP_ID = "GROUPME_GROUP_ID";
+const ENV_PUBLIC_DOMAIN = "GROUPME_PUBLIC_DOMAIN";
+export function readTrimmed(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function listConfiguredAccountIds(cfg) {
+    const accounts = cfg.channels?.groupme?.accounts;
+    if (!accounts || typeof accounts !== "object") {
+        return [];
+    }
+    const ids = new Set();
+    for (const key of Object.keys(accounts)) {
+        const normalized = normalizeAccountId(key);
+        if (normalized) {
+            ids.add(normalized);
+        }
+    }
+    return [...ids];
+}
+function resolveAccountConfig(cfg, accountId) {
+    const accounts = cfg.channels?.groupme?.accounts;
+    if (!accounts || typeof accounts !== "object") {
+        return undefined;
+    }
+    if (Object.hasOwn(accounts, accountId)) {
+        return accounts[accountId];
+    }
+    const hit = Object.keys(accounts).find((key) => normalizeAccountId(key) === accountId);
+    return hit ? accounts[hit] : undefined;
+}
+function mergeAccountConfig(cfg, accountId) {
+    const raw = (cfg.channels?.groupme ?? {});
+    const { accounts: _ignored, defaultAccount: _ignored2, ...base } = raw;
+    const account = accountId === DEFAULT_ACCOUNT_ID
+        ? {}
+        : (resolveAccountConfig(cfg, accountId) ?? {});
+    return {
+        ...base,
+        ...account,
+    };
+}
+export function listGroupMeAccountIds(cfg) {
+    const sorted = listConfiguredAccountIds(cfg).toSorted((a, b) => a.localeCompare(b));
+    return [
+        DEFAULT_ACCOUNT_ID,
+        ...sorted.filter((id) => id !== DEFAULT_ACCOUNT_ID),
+    ];
+}
+export function resolveDefaultGroupMeAccountId(cfg) {
+    const configuredDefault = readTrimmed(cfg.channels?.groupme?.defaultAccount);
+    if (configuredDefault) {
+        return normalizeAccountId(configuredDefault);
+    }
+    return DEFAULT_ACCOUNT_ID;
+}
+export function resolveGroupMeAccount(params) {
+    const normalizedRequested = normalizeAccountId(params.accountId);
+    const accountId = normalizedRequested ||
+        resolveDefaultGroupMeAccountId(params.cfg) ||
+        DEFAULT_ACCOUNT_ID;
+    const merged = mergeAccountConfig(params.cfg, accountId);
+    const baseEnabled = params.cfg.channels?.groupme?.enabled !== false;
+    const accountEnabled = merged.enabled !== false;
+    const enabled = baseEnabled && accountEnabled;
+    const isDefaultAccount = accountId === DEFAULT_ACCOUNT_ID;
+    const botId = readTrimmed(merged.botId) ||
+        (isDefaultAccount ? readTrimmed(process.env[ENV_BOT_ID]) : undefined) ||
+        "";
+    const accessToken = readTrimmed(merged.accessToken) ||
+        (isDefaultAccount
+            ? readTrimmed(process.env[ENV_ACCESS_TOKEN])
+            : undefined) ||
+        "";
+    const botName = readTrimmed(merged.botName) ||
+        (isDefaultAccount ? readTrimmed(process.env[ENV_BOT_NAME]) : undefined) ||
+        undefined;
+    const groupId = readTrimmed(merged.groupId) ||
+        (isDefaultAccount
+            ? readTrimmed(process.env[ENV_GROUP_ID])
+            : undefined) ||
+        undefined;
+    const callbackUrl = readTrimmed(merged.callbackUrl) ||
+        (isDefaultAccount
+            ? readTrimmed(process.env[ENV_CALLBACK_URL])
+            : undefined) ||
+        undefined;
+    const publicDomain = readTrimmed(merged.publicDomain) ||
+        (isDefaultAccount
+            ? readTrimmed(process.env[ENV_PUBLIC_DOMAIN])
+            : undefined) ||
+        undefined;
+    const config = {
+        ...merged,
+        botId,
+        accessToken,
+        botName,
+        groupId,
+        publicDomain,
+        callbackUrl,
+    };
+    return {
+        accountId,
+        name: readTrimmed(merged.name),
+        enabled,
+        configured: Boolean(botId),
+        botId,
+        accessToken,
+        config,
+    };
+}

package/dist/src/channel.js

@@ -0,0 +1,366 @@
+import { applyAccountNameToChannelSection, buildChannelConfigSchema, DEFAULT_ACCOUNT_ID, deleteAccountFromConfigSection, migrateBaseNameToDefaultAccount, missingTargetError, normalizeAccountId, registerPluginHttpRoute, setAccountEnabledInConfigSection, } from "openclaw/plugin-sdk";
+import { listGroupMeAccountIds, resolveDefaultGroupMeAccountId, resolveGroupMeAccount, } from "./accounts.js";
+import { GroupMeConfigSchema } from "./config-schema.js";
+import { createGroupMeWebhookHandler } from "./monitor.js";
+import { normalizeGroupMeAllowEntry, normalizeGroupMeTarget, looksLikeGroupMeTargetId, } from "./normalize.js";
+import { groupmeOnboardingAdapter } from "./onboarding.js";
+import { getGroupMeRuntime } from "./runtime.js";
+import { redactCallbackUrl, resolveGroupMeSecurity } from "./security.js";
+import { GROUPME_MAX_TEXT_LENGTH, sendGroupMeMedia, sendGroupMeText, } from "./send.js";
+const CHANNEL_ID = "groupme";
+function normalizeCallbackUrl(raw) {
+    const trimmed = raw?.trim() ?? "";
+    if (!trimmed) {
+        return "/groupme";
+    }
+    try {
+        const parsed = new URL(trimmed, "http://localhost");
+        return parsed.pathname || "/groupme";
+    }
+    catch {
+        const noQuery = trimmed.split("?")[0] ?? trimmed;
+        if (!noQuery) {
+            return "/groupme";
+        }
+        return noQuery.startsWith("/") ? noQuery : `/${noQuery}`;
+    }
+}
+function redactWebhookPath(account, callbackUrl) {
+    const normalized = callbackUrl?.trim() || "/groupme";
+    const security = resolveGroupMeSecurity(account.config);
+    if (!security.logging.redactSecrets) {
+        return normalized;
+    }
+    return redactCallbackUrl(normalized, security);
+}
+const meta = {
+    id: CHANNEL_ID,
+    label: "GroupMe",
+    selectionLabel: "GroupMe (Bot API)",
+    docsPath: "/channels/groupme",
+    docsLabel: "groupme",
+    blurb: "GroupMe bot webhook integration (group chats only).",
+    aliases: ["gm"],
+    order: 95,
+    quickstartAllowFrom: true,
+};
+export const groupmePlugin = {
+    id: CHANNEL_ID,
+    meta,
+    onboarding: groupmeOnboardingAdapter,
+    setup: {
+        resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+        applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+            cfg,
+            channelKey: "groupme",
+            accountId,
+            name,
+        }),
+        validateInput: ({ input }) => {
+            if (!input.token?.trim()) {
+                return "GroupMe Bot ID is required (--token <bot-id>)";
+            }
+            return null;
+        },
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            let next = applyAccountNameToChannelSection({
+                cfg,
+                channelKey: "groupme",
+                accountId,
+                name: input.name,
+            });
+            if (accountId !== DEFAULT_ACCOUNT_ID) {
+                next = migrateBaseNameToDefaultAccount({
+                    cfg: next,
+                    channelKey: "groupme",
+                });
+            }
+            const updates = { enabled: true };
+            if (input.token?.trim())
+                updates.botId = input.token.trim();
+            if (input.accessToken?.trim())
+                updates.accessToken = input.accessToken.trim();
+            if (input.webhookUrl?.trim()) {
+                updates.callbackUrl = input.webhookUrl.trim();
+            }
+            else if (input.webhookPath?.trim()) {
+                updates.callbackUrl = input.webhookPath.trim();
+            }
+            const section = (next.channels?.groupme ?? {});
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                return {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        groupme: {
+                            ...section,
+                            ...updates,
+                        },
+                    },
+                };
+            }
+            return {
+                ...next,
+                channels: {
+                    ...next.channels,
+                    groupme: {
+                        ...section,
+                        enabled: true,
+                        accounts: {
+                            ...(section.accounts ?? {}),
+                            [accountId]: {
+                                ...(section.accounts?.[accountId] ?? {}),
+                                ...updates,
+                            },
+                        },
+                    },
+                },
+            };
+        },
+        resolveBindingAccountId: ({ cfg, accountId }) => {
+            if (accountId)
+                return accountId;
+            const ids = listGroupMeAccountIds(cfg);
+            if (ids.length <= 1)
+                return DEFAULT_ACCOUNT_ID;
+            const section = cfg.channels?.groupme;
+            const explicitDefault = section?.defaultAccount?.trim();
+            return explicitDefault ? resolveDefaultGroupMeAccountId(cfg) : undefined;
+        },
+    },
+    capabilities: {
+        chatTypes: ["group"],
+        media: true,
+        blockStreaming: true,
+    },
+    reload: { configPrefixes: ["channels.groupme"] },
+    configSchema: buildChannelConfigSchema(GroupMeConfigSchema),
+    config: {
+        listAccountIds: (cfg) => listGroupMeAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveGroupMeAccount({ cfg: cfg, accountId }),
+        defaultAccountId: (cfg) => resolveDefaultGroupMeAccountId(cfg),
+        setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+            cfg: cfg,
+            sectionKey: CHANNEL_ID,
+            accountId,
+            enabled,
+            allowTopLevel: true,
+        }),
+        deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+            cfg: cfg,
+            sectionKey: CHANNEL_ID,
+            accountId,
+            clearBaseFields: [
+                "name",
+                "botId",
+                "accessToken",
+                "botName",
+                "groupId",
+                "publicDomain",
+                "callbackUrl",
+                "mentionPatterns",
+                "requireMention",
+                "historyLimit",
+                "allowFrom",
+                "textChunkLimit",
+                "responsePrefix",
+                "security",
+            ],
+        }),
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            botId: account.botId ? "***" : "",
+            publicDomain: account.config.publicDomain ?? "",
+            callbackUrl: redactWebhookPath(account, account.config.callbackUrl),
+        }),
+        resolveAllowFrom: ({ cfg, accountId }) => (resolveGroupMeAccount({ cfg: cfg, accountId }).config
+            .allowFrom ?? []).map((entry) => String(entry)),
+        formatAllowFrom: ({ allowFrom }) => allowFrom
+            .map((entry) => normalizeGroupMeAllowEntry(String(entry)))
+            .filter((entry) => Boolean(entry)),
+    },
+    groups: {
+        resolveRequireMention: ({ cfg, accountId }) => {
+            const account = resolveGroupMeAccount({
+                cfg: cfg,
+                accountId,
+            });
+            return account.config.requireMention ?? true;
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: (text, limit) => getGroupMeRuntime().channel.text.chunkMarkdownText(text, limit),
+        chunkerMode: "markdown",
+        textChunkLimit: GROUPME_MAX_TEXT_LENGTH,
+        resolveTarget: ({ to }) => {
+            const normalized = normalizeGroupMeTarget(to?.trim() ?? "");
+            if (!normalized) {
+                return {
+                    ok: false,
+                    error: missingTargetError("GroupMe", "<group-id>"),
+                };
+            }
+            return {
+                ok: true,
+                to: normalized,
+            };
+        },
+        sendText: async ({ cfg, to, text, accountId }) => {
+            const result = await sendGroupMeText({
+                cfg: cfg,
+                to,
+                text,
+                accountId,
+            });
+            return {
+                channel: CHANNEL_ID,
+                messageId: result.messageId,
+                timestamp: result.timestamp,
+            };
+        },
+        sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
+            if (!mediaUrl?.trim()) {
+                throw new Error("GroupMe media send requires a mediaUrl");
+            }
+            const result = await sendGroupMeMedia({
+                cfg: cfg,
+                to,
+                text,
+                mediaUrl,
+                accountId,
+            });
+            return {
+                channel: CHANNEL_ID,
+                messageId: result.messageId,
+                timestamp: result.timestamp,
+            };
+        },
+    },
+    messaging: {
+        normalizeTarget: normalizeGroupMeTarget,
+        targetResolver: {
+            looksLikeId: (raw) => looksLikeGroupMeTargetId(raw),
+            hint: "<group-id>",
+        },
+    },
+    resolver: {
+        resolveTargets: async ({ inputs, kind }) => {
+            return inputs.map((input) => {
+                const normalized = normalizeGroupMeTarget(input);
+                if (!normalized) {
+                    return {
+                        input,
+                        resolved: false,
+                        note: "empty target",
+                    };
+                }
+                return {
+                    input,
+                    resolved: true,
+                    id: normalized,
+                    name: normalized,
+                    note: kind === "user" ? "GroupMe bots are group-only" : undefined,
+                };
+            });
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async ({ cfg, accountId, query, limit }) => {
+            const account = resolveGroupMeAccount({
+                cfg: cfg,
+                accountId,
+            });
+            const q = query?.trim().toLowerCase() ?? "";
+            return (account.config.allowFrom ?? [])
+                .map((entry) => normalizeGroupMeAllowEntry(String(entry)))
+                .filter((entry) => Boolean(entry) && entry !== "*")
+                .filter((entry) => (q ? entry.toLowerCase().includes(q) : true))
+                .slice(0, limit && limit > 0 ? limit : undefined)
+                .map((id) => ({ kind: "user", id }));
+        },
+        listGroups: async () => [],
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            running: snapshot.running ?? false,
+            callbackUrl: snapshot.webhookPath ?? null,
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastInboundAt: snapshot.lastInboundAt ?? null,
+            lastOutboundAt: snapshot.lastOutboundAt ?? null,
+            lastError: snapshot.lastError ?? null,
+        }),
+        buildAccountSnapshot: ({ account, runtime }) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            botId: account.botId ? "***" : "",
+            tokenSource: account.accessToken ? "configured" : "none",
+            webhookPath: redactWebhookPath(account, account.config.callbackUrl),
+            running: runtime?.running ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastInboundAt: runtime?.lastInboundAt ?? null,
+            lastOutboundAt: runtime?.lastOutboundAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            mode: "webhook",
+        }),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            if (!account.configured) {
+                throw new Error(`GroupMe is not configured for account "${account.accountId}" (missing botId).`);
+            }
+            const callbackPath = normalizeCallbackUrl(account.config.callbackUrl);
+            const redactedCallbackPath = redactWebhookPath(account, account.config.callbackUrl ?? callbackPath);
+            const unregister = registerPluginHttpRoute({
+                path: callbackPath,
+                fallbackPath: "/groupme",
+                handler: createGroupMeWebhookHandler({
+                    account,
+                    config: ctx.cfg,
+                    runtime: ctx.runtime,
+                    statusSink: (patch) => ctx.setStatus({ accountId: account.accountId, ...patch }),
+                }),
+                pluginId: CHANNEL_ID,
+                accountId: account.accountId,
+                log: (message) => ctx.log?.info(message),
+            });
+            ctx.setStatus({
+                accountId: account.accountId,
+                running: true,
+                mode: "webhook",
+                webhookPath: redactedCallbackPath,
+                lastStartAt: Date.now(),
+                lastError: null,
+            });
+            ctx.log?.info(`[${account.accountId}] GroupMe webhook listening on ${redactedCallbackPath}`);
+            if (ctx.abortSignal.aborted) {
+                unregister();
+                return;
+            }
+            await new Promise((resolve) => {
+                ctx.abortSignal.addEventListener("abort", () => {
+                    unregister();
+                    resolve();
+                }, { once: true });
+            });
+        },
+    },
+};

package/dist/src/config-schema.js

@@ -0,0 +1,86 @@
+import { BlockStreamingCoalesceSchema, MarkdownConfigSchema, } from "openclaw/plugin-sdk";
+import { z } from "zod";
+const allowFromEntry = z.union([z.string(), z.number()]);
+const GroupMeReplaySchema = z
+    .object({
+    ttlSeconds: z.number().int().positive().optional(),
+    maxEntries: z.number().int().positive().optional(),
+})
+    .strict();
+const GroupMeRateLimitSchema = z
+    .object({
+    windowMs: z.number().int().positive().optional(),
+    maxRequestsPerIp: z.number().int().positive().optional(),
+    maxRequestsPerSender: z.number().int().positive().optional(),
+    maxConcurrent: z.number().int().positive().optional(),
+})
+    .strict();
+const GroupMeMediaSecuritySchema = z
+    .object({
+    allowPrivateNetworks: z.boolean().optional().default(false),
+    maxDownloadBytes: z.number().int().positive().optional(),
+    requestTimeoutMs: z.number().int().positive().optional(),
+    allowedMimePrefixes: z.array(z.string()).optional(),
+})
+    .strict();
+const GroupMeLoggingSecuritySchema = z
+    .object({
+    redactSecrets: z.boolean().optional().default(true),
+    logRejectedRequests: z.boolean().optional().default(true),
+})
+    .strict();
+const GroupMeCommandBypassSecuritySchema = z
+    .object({
+    requireAllowFrom: z.boolean().optional().default(true),
+    requireMentionForCommands: z.boolean().optional().default(false),
+})
+    .strict();
+const GroupMeProxySecuritySchema = z
+    .object({
+    trustedProxyCidrs: z.array(z.string()).optional(),
+    allowedPublicHosts: z.array(z.string()).optional(),
+    requireHttpsProto: z.boolean().optional().default(false),
+    rejectStatus: z
+        .union([z.literal(400), z.literal(403), z.literal(404)])
+        .optional(),
+})
+    .strict();
+const GroupMeSecuritySchema = z
+    .object({
+    replay: GroupMeReplaySchema.optional(),
+    rateLimit: GroupMeRateLimitSchema.optional(),
+    media: GroupMeMediaSecuritySchema.optional(),
+    logging: GroupMeLoggingSecuritySchema.optional(),
+    commandBypass: GroupMeCommandBypassSecuritySchema.optional(),
+    proxy: GroupMeProxySecuritySchema.optional(),
+})
+    .strict();
+export const GroupMeAccountSchemaBase = z
+    .object({
+    name: z.string().optional(),
+    enabled: z.boolean().optional(),
+    botId: z.string().optional(),
+    accessToken: z.string().optional(),
+    botName: z.string().optional(),
+    groupId: z.string().optional(),
+    publicDomain: z.string().optional(),
+    callbackUrl: z.string().optional(),
+    mentionPatterns: z.array(z.string()).optional(),
+    requireMention: z.boolean().optional().default(true),
+    historyLimit: z.number().int().nonnegative().optional(),
+    allowFrom: z.array(allowFromEntry).optional(),
+    markdown: MarkdownConfigSchema,
+    textChunkLimit: z.number().int().positive().optional(),
+    blockStreaming: z.boolean().optional(),
+    blockStreamingCoalesce: BlockStreamingCoalesceSchema.optional(),
+    responsePrefix: z.string().optional(),
+    mediaMaxMb: z.number().positive().optional(),
+    security: GroupMeSecuritySchema.optional(),
+})
+    .strict();
+export const GroupMeConfigSchema = GroupMeAccountSchemaBase.extend({
+    accounts: z
+        .record(z.string(), GroupMeAccountSchemaBase.optional())
+        .optional(),
+    defaultAccount: z.string().optional(),
+}).strict();

package/dist/src/groupme-api.js

@@ -0,0 +1,80 @@
+const GROUPME_API_BASE = "https://api.groupme.com/v3";
+async function readApiError(response) {
+    const fallback = `GroupMe API error: ${response.status} ${response.statusText}`;
+    try {
+        const payload = (await response.json());
+        const errors = payload?.meta?.errors;
+        if (Array.isArray(errors) && errors.length > 0) {
+            const text = errors
+                .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+                .filter(Boolean)
+                .join("; ");
+            if (text) {
+                return `${fallback} (${text})`;
+            }
+        }
+    }
+    catch {
+        // Ignore JSON parse errors; fall back to generic status text.
+    }
+    return fallback;
+}
+function readGroupsResponse(payload) {
+    const response = payload?.response;
+    if (!Array.isArray(response)) {
+        throw new Error("GroupMe groups fetch returned an invalid payload");
+    }
+    return response;
+}
+function readBotResponse(payload) {
+    const bot = payload?.response?.bot;
+    if (!bot) {
+        throw new Error("GroupMe bot creation returned an invalid payload");
+    }
+    return bot;
+}
+export async function fetchGroups(accessToken) {
+    const groups = [];
+    let page = 1;
+    while (true) {
+        const url = new URL(`${GROUPME_API_BASE}/groups`);
+        url.searchParams.set("token", accessToken);
+        url.searchParams.set("per_page", "100");
+        url.searchParams.set("omit", "memberships");
+        url.searchParams.set("page", String(page));
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(await readApiError(response));
+        }
+        const payload = await response.json();
+        const pageGroups = readGroupsResponse(payload);
+        if (pageGroups.length === 0) {
+            break;
+        }
+        groups.push(...pageGroups);
+        page += 1;
+    }
+    return groups;
+}
+export async function createBot(params) {
+    const url = new URL(`${GROUPME_API_BASE}/bots`);
+    url.searchParams.set("token", params.accessToken);
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            bot: {
+                name: params.name,
+                group_id: params.groupId,
+                callback_url: params.callbackUrl,
+                active: true,
+            },
+        }),
+    });
+    if (!response.ok) {
+        const apiError = await readApiError(response);
+        throw new Error(`GroupMe bot creation failed: ${apiError}`);
+    }
+    const payload = await response.json();
+    return readBotResponse(payload);
+}