@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/cloudflare/tools/update-list.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareUpdateList = tool({
+    description: 'Update the description of a WAF list. Only the description can be changed — list items cannot be updated with this tool.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        accountId: z.string().describe('Account identifier owning the list'),
+        listId: z.string().describe('WAF list identifier to update'),
+        description: z.string().max(500).describe('New description for the list (max 500 chars)'),
+    }),
+    execute: async ({ cloudflareApiKey, accountId, listId, description }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'PUT', `/accounts/${accountId}/rules/lists/${listId}`, {
+                body: { description },
+            });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to update WAF list');
+        }
+    },
+});
+//# sourceMappingURL=update-list.js.map

package/dist/toolkits/cloudflare/tools/update-tunnel-configuration.d.ts

@@ -0,0 +1,7 @@
+export declare const cloudflareUpdateTunnelConfiguration: import("ai").Tool<{
+    config: Record<string, any>;
+    accountId: string;
+    tunnelId: string;
+    cloudflareApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=update-tunnel-configuration.d.ts.map

package/dist/toolkits/cloudflare/tools/update-tunnel-configuration.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareUpdateTunnelConfiguration = tool({
+    description: 'Replace the remotely-managed configuration (ingress rules and routing) of a Cloudflare Tunnel. This REPLACES the entire config — include all existing rules you want to keep plus a catch-all (service http_status:404) last. Incorrect config can break routing; confirm with the user first.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        accountId: z.string().describe('Account identifier where the tunnel resides'),
+        tunnelId: z.string().describe('Tunnel UUID to configure'),
+        config: z.record(z.any()).describe('Full tunnel config object with an ingress array mapping hostnames to origin services'),
+    }),
+    execute: async ({ cloudflareApiKey, accountId, tunnelId, config }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            if (!Array.isArray(config?.ingress) || config.ingress.length === 0) {
+                return { error: 'Config must include a non-empty ingress array of hostname-to-service rules.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'PUT', `/accounts/${accountId}/cfd_tunnel/${tunnelId}/configurations`, { body: { config } });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to update tunnel configuration');
+        }
+    },
+});
+//# sourceMappingURL=update-tunnel-configuration.js.map

package/dist/toolkits/cloudflare/tools/update-zone.d.ts

@@ -0,0 +1,8 @@
+export declare const cloudflareUpdateZone: import("ai").Tool<{
+    zoneId: string;
+    type?: "partial" | "full" | "secondary" | undefined;
+    cloudflareApiKey?: string | undefined;
+    paused?: boolean | undefined;
+    vanityNameServers?: string[] | undefined;
+}, any>;
+//# sourceMappingURL=update-zone.d.ts.map

package/dist/toolkits/cloudflare/tools/update-zone.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { cfRequest, toCfError } from './client.js';
+export const cloudflareUpdateZone = tool({
+    description: 'Update one property of an existing zone (pause/unpause, type, or vanity nameservers). Changes apply immediately — confirm the zone ID and change with the user first. Exactly one of paused, type, or vanityNameServers must be provided per call.',
+    inputSchema: z.object({
+        cloudflareApiKey: z.string().optional().describe('Injected by system; do not provide'),
+        zoneId: z.string().describe('Zone identifier to update'),
+        paused: z.boolean().optional().describe('True to pause the zone, false to unpause'),
+        type: z.enum(['full', 'partial', 'secondary']).optional().describe('Zone setup type'),
+        vanityNameServers: z.array(z.string()).optional().describe('Custom vanity nameservers'),
+    }),
+    execute: async ({ cloudflareApiKey, zoneId, paused, type, vanityNameServers }) => {
+        try {
+            if (!cloudflareApiKey) {
+                return { error: 'Cloudflare API key is required. Connect Cloudflare first.' };
+            }
+            const provided = [paused, type, vanityNameServers].filter((v) => v !== undefined);
+            if (provided.length !== 1) {
+                return { error: 'Provide exactly one of paused, type, or vanityNameServers per call.' };
+            }
+            return await cfRequest(cloudflareApiKey, 'PATCH', `/zones/${zoneId}`, {
+                body: { paused, type, vanity_name_servers: vanityNameServers },
+            });
+        }
+        catch (error) {
+            return toCfError(error, 'Failed to update zone');
+        }
+    },
+});
+//# sourceMappingURL=update-zone.js.map

package/dist/toolkits/discord/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const DISCORD_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/discord/icon.js

@@ -0,0 +1,12 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 -28.5 256 256" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" preserveAspectRatio="xMidYMid">
+    <g>
+        <path d="M216.856339,16.5966031 C200.285002,8.84328665 182.566144,3.2084988 164.041564,0 C161.766523,4.11318106 159.108624,9.64549908 157.276099,14.0464379 C137.583995,11.0849896 118.072967,11.0849896 98.7430163,14.0464379 C96.9108417,9.64549908 94.1925838,4.11318106 91.8971895,0 C73.3526068,3.2084988 55.6133949,8.86399117 39.0420583,16.6376612 C5.61752293,67.146514 -3.4433191,116.400813 1.08711069,164.955721 C23.2560196,181.510915 44.7403634,191.567697 65.8621325,198.148576 C71.0772151,190.971126 75.7283628,183.341335 79.7352139,175.300261 C72.104019,172.400575 64.7949724,168.822202 57.8887866,164.667963 C59.7209612,163.310589 61.5131304,161.891452 63.2445898,160.431257 C105.36741,180.133187 151.134928,180.133187 192.754523,160.431257 C194.506336,161.891452 196.298154,163.310589 198.110326,164.667963 C191.183787,168.842556 183.854737,172.420929 176.223542,175.320965 C180.230393,183.341335 184.861538,190.991831 190.096624,198.16893 C211.238746,191.588051 232.743023,181.531619 254.911949,164.955721 C260.227747,108.668201 245.831087,59.8662432 216.856339,16.5966031 Z M85.4738752,135.09489 C72.8290281,135.09489 62.4592217,123.290155 62.4592217,108.914901 C62.4592217,94.5396472 72.607595,82.7145587 85.4738752,82.7145587 C98.3405064,82.7145587 108.709962,94.5189427 108.488529,108.914901 C108.508531,123.290155 98.3405064,135.09489 85.4738752,135.09489 Z M170.525237,135.09489 C157.88039,135.09489 147.510584,123.290155 147.510584,108.914901 C147.510584,94.5396472 157.658606,82.7145587 170.525237,82.7145587 C183.391518,82.7145587 193.761324,94.5189427 193.539891,108.914901 C193.539891,123.290155 183.391518,135.09489 170.525237,135.09489 Z" fill="#5865F2" fill-rule="nonzero">
+
+</path>
+    </g>
+</svg>`;
+export const DISCORD_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/discord/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/discord/manifest.js

@@ -0,0 +1,52 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { DISCORD_ICON } from './icon.js';
+import { discordTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'discord',
+    displayName: 'Discord',
+    shortDescription: 'User identity, guilds, invites, apps, and entitlements.',
+    category: 'Collaboration & Communication',
+    icon: DISCORD_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'discordToken',
+        provider: {
+            slug: 'discord',
+            env: { clientId: 'DISCORD_CLIENT_ID', clientSecret: 'DISCORD_CLIENT_SECRET' },
+            authorizeUrl: 'https://discord.com/oauth2/authorize',
+            tokenUrl: 'https://discord.com/api/oauth2/token',
+            scopes: [
+                'identify',
+                'email',
+                'openid',
+                'connections',
+                'guilds',
+                'guilds.members.read',
+                'applications.commands.permissions.update',
+                'role_connections.write',
+                'applications.entitlements',
+            ],
+            scopeSeparator: ' ',
+            exchangeStyle: 'basic',
+            connectDescription: 'Connect Discord to read user identity, guilds, invites, and entitlements, and to manage application command permissions and role connections.',
+            callbackPath: '/api/auth/discord/callback',
+            stateCookie: 'discord_oauth_state',
+        },
+    },
+    allowedHosts: ['discord.com', 'cdn.discord.com'],
+    tools: discordTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.9',
+        homepage: 'https://discord.com',
+        docsUrl: 'https://docs.discord.com/developers/',
+        apiDocsUrl: 'https://docs.discord.com/developers/api-reference',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/discord/tools/applications.d.ts

@@ -0,0 +1,79 @@
+export declare const discordEditCommandPermissions: import("ai").Tool<{
+    guildId: string;
+    applicationId: string;
+    commandId: string;
+    permissions: {
+        type: number;
+        id: string;
+        permission: boolean;
+    }[];
+    discordToken?: string | undefined;
+}, any>;
+export declare const discordGetCommandPermissions: import("ai").Tool<{
+    guildId: string;
+    applicationId: string;
+    commandId: string;
+    discordToken?: string | undefined;
+}, any>;
+export declare const discordGetBatchCommandPermissions: import("ai").Tool<{
+    guildId: string;
+    applicationId: string;
+    discordToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    command_permissions: any;
+}>;
+export declare const discordGetMyEntitlements: import("ai").Tool<{
+    applicationId: string;
+    limit?: number | undefined;
+    before?: string | undefined;
+    after?: string | undefined;
+    discordToken?: string | undefined;
+    guildId?: string | undefined;
+    skuIds?: string[] | undefined;
+    excludeEnded?: boolean | undefined;
+    excludeDeleted?: boolean | undefined;
+}, {
+    error: string;
+} | {
+    entitlements: any[];
+}>;
+export declare const discordGetRoleConnection: import("ai").Tool<{
+    applicationId: string;
+    discordToken?: string | undefined;
+}, any>;
+export declare const discordUpdateRoleConnection: import("ai").Tool<{
+    applicationId: string;
+    metadata?: Record<string, string> | undefined;
+    discordToken?: string | undefined;
+    platformName?: string | undefined;
+    platformUsername?: string | undefined;
+}, any>;
+export declare const discordDeleteRoleConnection: import("ai").Tool<{
+    applicationId: string;
+    discordToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    success: boolean;
+    application_id: string;
+}>;
+export declare const discordGetSkuSubscription: import("ai").Tool<{
+    subscriptionId: string;
+    skuId: string;
+    discordToken?: string | undefined;
+}, any>;
+export declare const discordListSkuSubscriptions: import("ai").Tool<{
+    skuId: string;
+    limit?: number | undefined;
+    before?: string | undefined;
+    after?: string | undefined;
+    userId?: string | undefined;
+    discordToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    subscriptions: any;
+}>;
+//# sourceMappingURL=applications.d.ts.map

package/dist/toolkits/discord/tools/applications.js

@@ -0,0 +1,216 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { discordApi, toDiscordError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const permissionOverride = z.object({
+    id: z.string().describe('Role, user, or channel ID'),
+    type: z.number().describe('1 = role, 2 = user, 3 = channel'),
+    permission: z.boolean().describe('True to allow, false to disallow'),
+});
+export const discordEditCommandPermissions = tool({
+    description: 'Set permission overrides for an application command in a guild. Needs an OAuth2 Bearer token (bot tokens error) and MANAGE_GUILD + MANAGE_ROLES for the authorizing user.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        applicationId: z.string().describe('Application snowflake ID'),
+        guildId: z.string().describe('Guild snowflake ID'),
+        commandId: z.string().describe('Application command snowflake ID'),
+        permissions: z.array(permissionOverride).describe('Permission overrides to set'),
+    }),
+    execute: async ({ discordToken, applicationId, guildId, commandId, permissions }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            return await discordApi(discordToken, 'PUT', `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}/permissions`, { body: { permissions } });
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to edit command permissions');
+        }
+    },
+});
+export const discordGetCommandPermissions = tool({
+    description: 'Get permission overrides for one application command in a guild. Needs an OAuth2 Bearer token (bot tokens error).',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        applicationId: z.string().describe('Application snowflake ID'),
+        guildId: z.string().describe('Guild snowflake ID'),
+        commandId: z.string().describe('Application command snowflake ID'),
+    }),
+    execute: async ({ discordToken, applicationId, guildId, commandId }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            return await discordApi(discordToken, 'GET', `/applications/${applicationId}/guilds/${guildId}/commands/${commandId}/permissions`);
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to get command permissions');
+        }
+    },
+});
+export const discordGetBatchCommandPermissions = tool({
+    description: 'Get permission overrides for all commands of an application in a guild. Needs an OAuth2 Bearer token (bot tokens error).',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        applicationId: z.string().describe('Application snowflake ID'),
+        guildId: z.string().describe('Guild snowflake ID'),
+    }),
+    execute: async ({ discordToken, applicationId, guildId }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            const permissions = await discordApi(discordToken, 'GET', `/applications/${applicationId}/guilds/${guildId}/commands/permissions`);
+            return { command_permissions: permissions };
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to get command permissions');
+        }
+    },
+});
+export const discordGetMyEntitlements = tool({
+    description: 'List the caller entitlements for an application, with pagination and SKU filters. guild_id is filtered locally since the route has no such filter.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        applicationId: z.string().describe('Application snowflake ID'),
+        skuIds: z.array(z.string()).optional().describe('Filter to these SKU IDs'),
+        guildId: z.string().optional().describe('Keep only entitlements granted for this guild'),
+        limit: z.number().min(1).max(100).optional().describe('Max entitlements (1-100, default 100)'),
+        before: z.string().optional().describe('Entitlements before this entitlement ID'),
+        after: z.string().optional().describe('Entitlements after this entitlement ID'),
+        excludeEnded: z.boolean().optional().describe('Omit ended entitlements'),
+        excludeDeleted: z.boolean().optional().describe('Omit deleted entitlements (default true)'),
+    }),
+    execute: async ({ discordToken, applicationId, skuIds, guildId, limit, before, after, excludeEnded, excludeDeleted }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            const entitlements = await discordApi(discordToken, 'GET', `/users/@me/applications/${applicationId}/entitlements`, {
+                query: {
+                    sku_ids: skuIds,
+                    limit,
+                    before,
+                    after,
+                    exclude_ended: excludeEnded,
+                    exclude_deleted: excludeDeleted,
+                },
+            });
+            const list = Array.isArray(entitlements) ? entitlements : [];
+            return { entitlements: guildId ? list.filter((e) => e?.guild_id === guildId) : list };
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to get entitlements');
+        }
+    },
+});
+export const discordGetRoleConnection = tool({
+    description: 'Get the caller application role connection (platform name/username, metadata) for an application. Needs role_connections.write.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        applicationId: z.string().describe('Application snowflake ID'),
+    }),
+    execute: async ({ discordToken, applicationId }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            return await discordApi(discordToken, 'GET', `/users/@me/applications/${applicationId}/role-connection`);
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to get role connection');
+        }
+    },
+});
+export const discordUpdateRoleConnection = tool({
+    description: 'Update the caller application role connection (platform name/username, string-ified metadata). Needs role_connections.write.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        applicationId: z.string().describe('Application snowflake ID'),
+        platformName: z.string().optional().describe('Platform vanity name (max 50 chars)'),
+        platformUsername: z.string().optional().describe('Platform username (max 100 chars)'),
+        metadata: z.record(z.string()).optional().describe('Metadata keys mapped to string values'),
+    }),
+    execute: async ({ discordToken, applicationId, platformName, platformUsername, metadata }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            return await discordApi(discordToken, 'PUT', `/users/@me/applications/${applicationId}/role-connection`, {
+                body: {
+                    platform_name: platformName,
+                    platform_username: platformUsername,
+                    metadata,
+                },
+            });
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to update role connection');
+        }
+    },
+});
+export const discordDeleteRoleConnection = tool({
+    description: 'Delete the caller application role connection for an application, removing platform metadata. Confirm with the user first.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        applicationId: z.string().describe('Application snowflake ID'),
+    }),
+    execute: async ({ discordToken, applicationId }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            await discordApi(discordToken, 'DELETE', `/users/@me/applications/${applicationId}/role-connection`);
+            return { success: true, application_id: applicationId };
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to delete role connection');
+        }
+    },
+});
+export const discordGetSkuSubscription = tool({
+    description: 'Get one subscription by ID for a SKU, including status and current period.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        skuId: z.string().describe('SKU ID the subscription belongs to'),
+        subscriptionId: z.string().describe('Subscription ID to retrieve'),
+    }),
+    execute: async ({ discordToken, skuId, subscriptionId }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            return await discordApi(discordToken, 'GET', `/skus/${skuId}/subscriptions/${subscriptionId}`);
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to get SKU subscription');
+        }
+    },
+});
+export const discordListSkuSubscriptions = tool({
+    description: 'List subscriptions for a SKU with pagination. user_id filter is for bot tokens; omit it for OAuth2 user connections.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        skuId: z.string().describe('SKU ID to list subscriptions for'),
+        limit: z.number().min(1).max(100).optional().describe('Max subscriptions (1-100, default 100)'),
+        before: z.string().optional().describe('Subscriptions before this subscription ID'),
+        after: z.string().optional().describe('Subscriptions after this subscription ID'),
+        userId: z.string().optional().describe('Filter by user ID (bot tokens only)'),
+    }),
+    execute: async ({ discordToken, skuId, userId, ...rest }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            const subscriptions = await discordApi(discordToken, 'GET', `/skus/${skuId}/subscriptions`, {
+                query: { ...rest, user_id: userId },
+            });
+            return { subscriptions };
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to list SKU subscriptions');
+        }
+    },
+});
+//# sourceMappingURL=applications.js.map

package/dist/toolkits/discord/tools/client.d.ts

@@ -0,0 +1,22 @@
+export declare class DiscordApiError extends Error {
+    status: number;
+    details: unknown;
+    constructor(message: string, status: number, details: unknown);
+}
+export declare function discordApi(discordToken: string, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, options?: {
+    query?: Record<string, string | number | boolean | string[] | undefined>;
+    body?: unknown;
+}): Promise<any>;
+export declare function toDiscordError(error: unknown, label: string): {
+    error: string;
+    details: any;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+};
+export declare function requireToken(discordToken: string | undefined): {
+    error: string;
+} | null;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/discord/tools/client.js

@@ -0,0 +1,69 @@
+// @ts-nocheck
+const BASE_URL = 'https://discord.com/api/v10';
+export class DiscordApiError extends Error {
+    status;
+    details;
+    constructor(message, status, details) {
+        super(message);
+        this.status = status;
+        this.details = details;
+    }
+}
+function appendQuery(url, query) {
+    if (!query)
+        return;
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                url.searchParams.append(key, String(item));
+        }
+        else {
+            url.searchParams.set(key, String(value));
+        }
+    }
+}
+export async function discordApi(discordToken, method, path, options) {
+    const url = new URL(`${BASE_URL}${path}`);
+    appendQuery(url, options?.query);
+    const response = await fetch(url.toString(), {
+        method,
+        headers: {
+            Authorization: `Bearer ${discordToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    if (response.status === 204) {
+        return { success: true };
+    }
+    const text = await response.text();
+    let data = {};
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { raw: text };
+    }
+    if (!response.ok) {
+        throw new DiscordApiError(`Discord API request failed${data?.message ? `: ${data.message}` : ''}`, response.status, data);
+    }
+    return data;
+}
+export function toDiscordError(error, label) {
+    if (error?.details !== undefined) {
+        return { error: label, details: error.details };
+    }
+    return {
+        error: label.replace('Failed', 'Error').replace('failed', 'error'),
+        message: error instanceof Error ? error.message : 'Unknown error',
+    };
+}
+export function requireToken(discordToken) {
+    if (!discordToken) {
+        return { error: 'Discord token is required. Connect Discord first.' };
+    }
+    return null;
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/discord/tools/guilds.d.ts

@@ -0,0 +1,39 @@
+export declare const discordListMyGuilds: import("ai").Tool<{
+    limit?: number | undefined;
+    before?: string | undefined;
+    after?: string | undefined;
+    discordToken?: string | undefined;
+    withCounts?: boolean | undefined;
+}, {
+    error: string;
+} | {
+    guilds: any;
+}>;
+export declare const discordGetGuildTemplate: import("ai").Tool<{
+    code: string;
+    discordToken?: string | undefined;
+}, any>;
+export declare const discordGetGuildWidget: import("ai").Tool<{
+    guildId: string;
+    discordToken?: string | undefined;
+}, any>;
+export declare const discordGetGuildWidgetPng: import("ai").Tool<{
+    guildId: string;
+    style?: "shield" | "banner1" | "banner2" | "banner3" | "banner4" | undefined;
+    discordToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    name: string;
+    mimetype: string;
+    url: string;
+    style: "shield" | "banner1" | "banner2" | "banner3" | "banner4";
+}>;
+export declare const discordResolveInvite: import("ai").Tool<{
+    code: string;
+    discordToken?: string | undefined;
+    withCounts?: boolean | undefined;
+    withExpiration?: boolean | undefined;
+    guildScheduledEventId?: string | undefined;
+}, any>;
+//# sourceMappingURL=guilds.d.ts.map