@rnsk/toolkits 0.0.8 → 0.0.10

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

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

package/dist/toolkits/slack/icon.js

@@ -0,0 +1,20 @@
+const SVG = `<svg width="800px" height="800px" viewBox="-2.45 0 2452.5 2452.5" enable-background="new 0 0 2447.6 2452.5" xmlns="http://www.w3.org/2000/svg">
+
+<g clip-rule="evenodd" fill-rule="evenodd">
+
+<path d="m897.4 0c-135.3.1-244.8 109.9-244.7 245.2-.1 135.3 109.5 245.1 244.8 245.2h244.8v-245.1c.1-135.3-109.5-245.1-244.9-245.3.1 0 .1 0 0 0m0 654h-652.6c-135.3.1-244.9 109.9-244.8 245.2-.2 135.3 109.4 245.1 244.7 245.3h652.7c135.3-.1 244.9-109.9 244.8-245.2.1-135.4-109.5-245.2-244.8-245.3z" fill="#36c5f0"/>
+
+<path d="m2447.6 899.2c.1-135.3-109.5-245.1-244.8-245.2-135.3.1-244.9 109.9-244.8 245.2v245.3h244.8c135.3-.1 244.9-109.9 244.8-245.3zm-652.7 0v-654c.1-135.2-109.4-245-244.7-245.2-135.3.1-244.9 109.9-244.8 245.2v654c-.2 135.3 109.4 245.1 244.7 245.3 135.3-.1 244.9-109.9 244.8-245.3z" fill="#2eb67d"/>
+
+<path d="m1550.1 2452.5c135.3-.1 244.9-109.9 244.8-245.2.1-135.3-109.5-245.1-244.8-245.2h-244.8v245.2c-.1 135.2 109.5 245 244.8 245.2zm0-654.1h652.7c135.3-.1 244.9-109.9 244.8-245.2.2-135.3-109.4-245.1-244.7-245.3h-652.7c-135.3.1-244.9 109.9-244.8 245.2-.1 135.4 109.4 245.2 244.7 245.3z" fill="#ecb22e"/>
+
+<path d="m0 1553.2c-.1 135.3 109.5 245.1 244.8 245.2 135.3-.1 244.9-109.9 244.8-245.2v-245.2h-244.8c-135.3.1-244.9 109.9-244.8 245.2zm652.7 0v654c-.2 135.3 109.4 245.1 244.7 245.3 135.3-.1 244.9-109.9 244.8-245.2v-653.9c.2-135.3-109.4-245.1-244.7-245.3-135.4 0-244.9 109.8-244.8 245.1 0 0 0 .1 0 0" fill="#e01e5a"/>
+
+</g>
+
+</svg>`;
+export const SLACK_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/slack/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/slack/manifest.js

@@ -0,0 +1,93 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { SLACK_ICON } from './icon.js';
+import { slackTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'slack',
+    displayName: 'Slack',
+    shortDescription: 'Messages, channels, users, files, calls, and admin.',
+    category: 'Collaboration & Communication',
+    icon: SLACK_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'slackToken',
+        provider: {
+            slug: 'slack',
+            env: { clientId: 'SLACK_CLIENT_ID', clientSecret: 'SLACK_CLIENT_SECRET' },
+            authorizeUrl: 'https://slack.com/oauth/v2/authorize',
+            tokenUrl: 'https://slack.com/api/oauth.v2.access',
+            scopes: [
+                'channels:read',
+                'channels:write',
+                'groups:read',
+                'groups:write',
+                'im:read',
+                'im:write',
+                'mpim:read',
+                'mpim:write',
+                'chat:write',
+                'users:read',
+                'users:read.email',
+                'users:write',
+                'users.profile:read',
+                'users.profile:write',
+                'files:read',
+                'files:write',
+                'reactions:read',
+                'reactions:write',
+                'pins:read',
+                'pins:write',
+                'stars:read',
+                'stars:write',
+                'reminders:read',
+                'reminders:write',
+                'search:read',
+                'team:read',
+                'usergroups:read',
+                'usergroups:write',
+                'emoji:read',
+                'dnd:read',
+                'dnd:write',
+                'calls:read',
+                'calls:write',
+                'canvases:read',
+                'canvases:write',
+                'lists:read',
+                'lists:write',
+                'remote_files:read',
+                'remote_files:share',
+                'links:write',
+                'admin.teams:read',
+                'admin.teams:write',
+                'admin.users:read',
+                'admin.users:write',
+                'admin.conversations:read',
+                'admin.conversations:write',
+                'admin.apps:read',
+                'admin.apps:write',
+                'admin.invites:read',
+                'auditlogs:read',
+            ],
+            scopeSeparator: ',',
+            exchangeStyle: 'form',
+            connectDescription: 'Connect Slack to send messages, manage channels and users, search content, and administer workspaces. Admin and Enterprise Grid methods need a user token with admin scopes.',
+            callbackPath: '/api/auth/slack/callback',
+            stateCookie: 'slack_oauth_state',
+        },
+    },
+    allowedHosts: ['slack.com', 'api.slack.com', 'files.slack.com'],
+    tools: slackTools.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://slack.com',
+        docsUrl: 'https://docs.slack.dev/',
+        apiDocsUrl: 'https://docs.slack.dev/reference/methods/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/slack/tools/admin-apps.d.ts

@@ -0,0 +1,32 @@
+export declare const slackListApprovedApps: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    enterpriseId?: string | undefined;
+    certified?: boolean | undefined;
+}, any>;
+export declare const slackListAppRequests: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    enterpriseId?: string | undefined;
+    certified?: boolean | undefined;
+}, any>;
+export declare const slackListRestrictedApps: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    enterpriseId?: string | undefined;
+    certified?: boolean | undefined;
+}, any>;
+export declare const slackRestrictApp: import("ai").Tool<{
+    teamId?: string | undefined;
+    requestId?: string | undefined;
+    slackToken?: string | undefined;
+    enterpriseId?: string | undefined;
+    appId?: string | undefined;
+}, any>;
+//# sourceMappingURL=admin-apps.d.ts.map

package/dist/toolkits/slack/tools/admin-apps.js

@@ -0,0 +1,116 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackListApprovedApps = tool({
+    description: 'List apps approved for installation on an org or workspace (Enterprise Grid / Business+ admin). Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID (required with org-level tokens)'),
+        enterpriseId: z.string().optional().describe('Enterprise Grid org ID'),
+        certified: z.boolean().optional().describe('True for certified apps only, false to exclude them'),
+        limit: z.number().min(1).max(1000).optional().describe('Apps per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, enterpriseId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.apps.approved.list', {
+                ...rest,
+                team_id: teamId,
+                enterprise_id: enterpriseId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list approved apps');
+        }
+    },
+});
+export const slackListAppRequests = tool({
+    description: 'List pending app installation requests (who requested what). Requires admin.apps:read. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID'),
+        enterpriseId: z.string().optional().describe('Enterprise Grid org ID'),
+        certified: z.boolean().optional().describe('True for certified apps only, false to exclude them'),
+        limit: z.number().min(1).max(1000).optional().describe('Requests per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, enterpriseId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.apps.requests.list', {
+                ...rest,
+                team_id: teamId,
+                enterprise_id: enterpriseId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list app requests');
+        }
+    },
+});
+export const slackListRestrictedApps = tool({
+    description: 'List apps restricted from installation on an org or workspace. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID (Enterprise Grid filter)'),
+        enterpriseId: z.string().optional().describe('Enterprise Grid org ID filter'),
+        certified: z.boolean().optional().describe('True for certified apps only, false to exclude them'),
+        limit: z.number().min(1).max(1000).optional().describe('Apps per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, teamId, enterpriseId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.apps.restricted.list', {
+                ...rest,
+                team_id: teamId,
+                enterprise_id: enterpriseId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list restricted apps');
+        }
+    },
+});
+export const slackRestrictApp = tool({
+    description: 'Restrict an app from being installed. Provide app_id or request_id, plus team_id or enterprise_id. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        appId: z.string().optional().describe('App ID, e.g. A08U8HZHY0Y'),
+        requestId: z.string().optional().describe('App installation request ID, e.g. Ar1234567890'),
+        teamId: z.string().optional().describe('Workspace ID to restrict on'),
+        enterpriseId: z.string().optional().describe('Enterprise org ID to restrict on'),
+    }),
+    execute: async ({ slackToken, appId, requestId, teamId, enterpriseId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            if (!appId && !requestId) {
+                return { error: 'Provide appId or requestId.' };
+            }
+            if (!teamId && !enterpriseId) {
+                return { error: 'Provide teamId or enterpriseId.' };
+            }
+            return await slackApi(slackToken, 'admin.apps.restrict', {
+                app_id: appId,
+                request_id: requestId,
+                team_id: teamId,
+                enterprise_id: enterpriseId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to restrict app');
+        }
+    },
+});
+//# sourceMappingURL=admin-apps.js.map

package/dist/toolkits/slack/tools/admin-conversations.d.ts

@@ -0,0 +1,62 @@
+export declare const slackAdminSearchConversations: import("ai").Tool<{
+    query?: string | undefined;
+    sort?: "created" | "name" | "relevant" | "member_count" | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    teamIds?: string | undefined;
+    connectedTeamIds?: string | undefined;
+    searchChannelTypes?: "private" | "public" | "archived" | "private_exclude" | "im" | "mpim" | "ext_shared" | "org_shared" | "exclude_archived" | "multi_workspace" | "org_wide" | "external_shared" | undefined;
+    sortDir?: "asc" | "desc" | undefined;
+    totalCountOnly?: boolean | undefined;
+}, any>;
+export declare const slackAdminCreateConversation: import("ai").Tool<{
+    name: string;
+    isPrivate: boolean;
+    description?: string | undefined;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    orgWide?: boolean | undefined;
+}, any>;
+export declare const slackDeleteChannel: import("ai").Tool<{
+    channelId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackConvertChannelToPrivate: import("ai").Tool<{
+    channelId: string;
+    name?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackInviteUserToChannelAdmin: import("ai").Tool<{
+    channelId: string;
+    userIds: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetConversationPrefs: import("ai").Tool<{
+    channelId: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetConversationPrefs: import("ai").Tool<{
+    channelId: string;
+    prefs: Record<string, any>;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetChannelWorkspaces: import("ai").Tool<{
+    channelId: string;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSetChannelWorkspaces: import("ai").Tool<{
+    channelId: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+    targetTeamIds?: string | undefined;
+    orgChannel?: boolean | undefined;
+}, any>;
+export declare const slackListChannelIdpGroups: import("ai").Tool<{
+    channelId: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=admin-conversations.d.ts.map

package/dist/toolkits/slack/tools/admin-conversations.js

@@ -0,0 +1,246 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slackApi, toSlackError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+export const slackAdminSearchConversations = tool({
+    description: 'Search public or private channels across an Enterprise Grid org by name and type. Enterprise Grid only.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        query: z.string().optional().describe('Channel name to search for'),
+        teamIds: z.string().optional().describe('Comma-separated workspace IDs to search'),
+        connectedTeamIds: z.string().optional().describe('Comma-separated external org team IDs to search'),
+        searchChannelTypes: z
+            .enum(['public', 'private', 'private_exclude', 'im', 'mpim', 'ext_shared', 'org_shared', 'archived', 'exclude_archived', 'multi_workspace', 'org_wide', 'external_shared'])
+            .optional()
+            .describe('Channel type to include or exclude'),
+        sort: z.enum(['relevant', 'name', 'member_count', 'created']).optional().describe('Sort method'),
+        sortDir: z.enum(['asc', 'desc']).optional().describe('Sort direction'),
+        limit: z.number().min(1).max(20).optional().describe('Max results (1-20, default 10)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        totalCountOnly: z.boolean().optional().describe('Return only the total count, no channel data'),
+    }),
+    execute: async ({ slackToken, teamIds, connectedTeamIds, searchChannelTypes, sortDir, totalCountOnly, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.search', {
+                ...rest,
+                team_ids: teamIds,
+                connected_team_ids: connectedTeamIds,
+                search_channel_types: searchChannelTypes,
+                sort_dir: sortDir,
+                total_count_only: totalCountOnly,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to search conversations');
+        }
+    },
+});
+export const slackAdminCreateConversation = tool({
+    description: 'Create a channel via the Admin API (Enterprise Grid). Set orgWide=true for an org-wide channel, otherwise teamId is required. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        name: z.string().describe('Channel name: unique, lowercase, max 80 chars, no spaces'),
+        isPrivate: z.boolean().describe('True for private, false for public'),
+        teamId: z.string().optional().describe('Workspace ID (required unless orgWide is true)'),
+        orgWide: z.boolean().optional().describe('Make the channel available org-wide'),
+        description: z.string().optional().describe('Channel description'),
+    }),
+    execute: async ({ slackToken, name, isPrivate, teamId, orgWide, description }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.create', {
+                name,
+                is_private: isPrivate,
+                team_id: teamId,
+                org_wide: orgWide,
+                description,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create conversation');
+        }
+    },
+});
+export const slackDeleteChannel = tool({
+    description: 'Permanently delete a public or private channel and all its messages and files (Enterprise Grid admin). Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to delete'),
+    }),
+    execute: async ({ slackToken, channelId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.delete', { channel_id: channelId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete channel');
+        }
+    },
+});
+export const slackConvertChannelToPrivate = tool({
+    description: 'Convert a public channel to private via the Admin API. Enterprise Grid only, irreversible via API. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Public channel ID to convert'),
+        name: z.string().optional().describe('Only used when converting an MPIM'),
+    }),
+    execute: async ({ slackToken, channelId, name }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.convertToPrivate', {
+                channel_id: channelId,
+                name,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to convert channel to private');
+        }
+    },
+});
+export const slackInviteUserToChannelAdmin = tool({
+    description: 'Invite users to a channel via the Admin API (Enterprise Grid). The caller must be a channel member. For regular workspaces use slackInviteUsersToChannel.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to invite users to'),
+        userIds: z.string().describe("Comma-separated user IDs, e.g. 'U123,U456' (max 1000)"),
+    }),
+    execute: async ({ slackToken, channelId, userIds }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.invite', {
+                channel_id: channelId,
+                user_ids: userIds,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to invite users to channel');
+        }
+    },
+});
+export const slackGetConversationPrefs = tool({
+    description: 'Get posting/thread/mention/huddle preferences for a channel. Enterprise Grid oriented.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to get preferences for'),
+    }),
+    execute: async ({ slackToken, channelId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.getConversationPrefs', {
+                channel_id: channelId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get conversation preferences');
+        }
+    },
+});
+export const slackSetConversationPrefs = tool({
+    description: 'Set posting permissions for a channel (who can post/thread, @channel/@here, huddles). Pass prefs as a JSON string, e.g. {"who_can_post":"type:admin"}. Enterprise Grid oriented.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to set preferences for'),
+        prefs: z.record(z.any()).describe('Preferences object (who_can_post, can_thread, can_huddle, enable_at_channel, enable_at_here)'),
+    }),
+    execute: async ({ slackToken, channelId, prefs }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.setConversationPrefs', {
+                channel_id: channelId,
+                prefs: JSON.stringify(prefs),
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set conversation preferences');
+        }
+    },
+});
+export const slackGetChannelWorkspaces = tool({
+    description: 'List workspaces a channel is connected to within an Enterprise Grid org. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to inspect'),
+        limit: z.number().min(1).max(1000).optional().describe('Items per page (max 1000)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+    }),
+    execute: async ({ slackToken, channelId, limit, cursor }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.getTeams', {
+                channel_id: channelId,
+                limit,
+                cursor,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get channel workspaces');
+        }
+    },
+});
+export const slackSetChannelWorkspaces = tool({
+    description: 'Set which Enterprise Grid workspaces connect to a channel (share a channel with workspaces, or convert to an org channel). Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Channel ID to share'),
+        teamId: z.string().optional().describe('Owning workspace; omit for cross-workspace shared channels'),
+        targetTeamIds: z.string().optional().describe('Comma-separated workspace IDs to share with'),
+        orgChannel: z.boolean().optional().describe('Convert the channel to an org channel'),
+    }),
+    execute: async ({ slackToken, channelId, teamId, targetTeamIds, orgChannel }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.setTeams', {
+                channel_id: channelId,
+                team_id: teamId,
+                target_team_ids: targetTeamIds,
+                org_channel: orgChannel,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to set channel workspaces');
+        }
+    },
+});
+export const slackListChannelIdpGroups = tool({
+    description: 'List IDP groups allowlisted on a private channel (only members of these groups may access it). Enterprise Grid with IDP groups enabled.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channelId: z.string().describe('Private channel ID'),
+        teamId: z.string().optional().describe('Workspace ID for workspace-specific channels'),
+    }),
+    execute: async ({ slackToken, channelId, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'admin.conversations.restrictAccess.listGroups', {
+                channel_id: channelId,
+                team_id: teamId,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list channel IDP groups');
+        }
+    },
+});
+//# sourceMappingURL=admin-conversations.js.map

package/dist/toolkits/slack/tools/admin-invites.d.ts

@@ -0,0 +1,19 @@
+export declare const slackListApprovedInvites: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListDeniedInvites: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListPendingInvites: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=admin-invites.d.ts.map