@rnsk/toolkits 0.0.8 → 0.0.10

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

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

@@ -0,0 +1,123 @@
+// @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');
+export const discordListMyGuilds = tool({
+    description: 'List guilds the caller is in (partial objects with permissions and features). Use for server lists or membership checks. Needs the guilds scope.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        limit: z.number().min(1).max(200).optional().describe('Max guilds (1-200, default 200)'),
+        before: z.string().optional().describe('Guilds before this guild ID'),
+        after: z.string().optional().describe('Guilds after this guild ID'),
+        withCounts: z.boolean().optional().describe('Include approximate member/presence counts'),
+    }),
+    execute: async ({ discordToken, withCounts, ...rest }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            const guilds = await discordApi(discordToken, 'GET', '/users/@me/guilds', {
+                query: { ...rest, with_counts: withCounts },
+            });
+            return { guilds };
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to list guilds');
+        }
+    },
+});
+export const discordGetGuildTemplate = tool({
+    description: 'Get a guild template by code, including the serialized source guild (channels, roles). Use for server-creation blueprints.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        code: z.string().describe('Template code, e.g. asFz8FjydMJa'),
+    }),
+    execute: async ({ discordToken, code }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            return await discordApi(discordToken, 'GET', `/guilds/templates/${code}`);
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to get guild template');
+        }
+    },
+});
+export const discordGetGuildWidget = tool({
+    description: 'Get the public guild widget JSON (online members, voice channels, invite). The widget must be enabled in server settings.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        guildId: z.string().describe('Guild snowflake ID'),
+    }),
+    execute: async ({ discordToken, guildId }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            return await discordApi(discordToken, 'GET', `/guilds/${guildId}/widget.json`);
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to get guild widget');
+        }
+    },
+});
+export const discordGetGuildWidgetPng = tool({
+    description: 'Get a guild widget banner image URL (shield or banner1-4 style) for embedding on external sites. The widget must be enabled in server settings. Returns the public image URL (no auth needed to view).',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        guildId: z.string().describe('Guild snowflake ID'),
+        style: z.enum(['shield', 'banner1', 'banner2', 'banner3', 'banner4']).optional().describe('Widget visual style'),
+    }),
+    execute: async ({ discordToken, guildId, style }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            const url = `https://discord.com/api/v10/guilds/${guildId}/widget.png${style ? `?style=${style}` : ''}`;
+            const response = await fetch(url);
+            if (!response.ok) {
+                return { error: 'Failed to get guild widget image', details: { status: response.status } };
+            }
+            return {
+                name: `widget-${guildId}.png`,
+                mimetype: response.headers.get('content-type') ?? 'image/png',
+                url,
+                style: style ?? 'shield',
+            };
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to get guild widget image');
+        }
+    },
+});
+export const discordResolveInvite = tool({
+    description: 'Resolve an invite code (bare code, vanity URL, or full discord.gg URL) to guild/channel/event details. Null or partial responses mean expired, revoked, or inaccessible invites — do not infer membership from them.',
+    inputSchema: z.object({
+        discordToken: tokenField,
+        code: z.string().describe('Invite code or URL, e.g. discord-api or https://discord.gg/abc123xyz'),
+        withCounts: z.boolean().optional().describe('Include approximate member/presence counts'),
+        withExpiration: z.boolean().optional().describe('Include expires_at (usually returned anyway)'),
+        guildScheduledEventId: z.string().optional().describe('Include this scheduled event in the response'),
+    }),
+    execute: async ({ discordToken, code, withCounts, withExpiration, guildScheduledEventId }) => {
+        try {
+            const missing = requireToken(discordToken);
+            if (missing)
+                return missing;
+            const clean = code.split('?')[0].split('/').filter(Boolean).pop() ?? code;
+            return await discordApi(discordToken, 'GET', `/invites/${clean}`, {
+                query: {
+                    with_counts: withCounts,
+                    with_expiration: withExpiration,
+                    guild_scheduled_event_id: guildScheduledEventId,
+                },
+            });
+        }
+        catch (error) {
+            return toDiscordError(error, 'Failed to resolve invite');
+        }
+    },
+});
+//# sourceMappingURL=guilds.js.map