@rnsk/toolkits 0.0.7 → 0.0.9

package/dist/toolkits/reddit/tools/retrieve-posts-from-subreddit.js

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditRetrievePostsFromSubreddit = tool({
+    description: 'Get posts from a public subreddit sorted by hot, new, top, rising, or controversial. Post data is nested under data.children[].data; paginate with the data.after cursor. Compare created_utc client-side for date filtering. Also covers new/top listings (set timeFilter for top/controversial windows).',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        subreddit: z.string().describe("Subreddit name without the 'r/' prefix, e.g. 'technology'"),
+        sort: z
+            .enum(['hot', 'new', 'top', 'rising', 'controversial'])
+            .optional()
+            .default('hot')
+            .describe('Sort order for posts'),
+        timeFilter: z
+            .enum(['hour', 'day', 'week', 'month', 'year', 'all'])
+            .optional()
+            .describe("Time window for 'top' and 'controversial' sorts"),
+        maxResults: z
+            .number()
+            .min(0)
+            .max(100)
+            .optional()
+            .default(5)
+            .describe('Max posts to return (max 100); 0 means maximum'),
+        after: z.string().optional().describe('Fullname cursor for the next page'),
+        before: z.string().optional().describe('Fullname cursor for the previous page'),
+        count: z.number().min(0).optional().describe('Number of items already seen (pagination)'),
+        show: z.string().optional().describe("Pass 'all' to include normally filtered items"),
+    }),
+    execute: async ({ redditToken, subreddit, sort = 'hot', timeFilter, maxResults = 5, after, before, count, show, }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, `/r/${subreddit}/${sort}`, {
+                t: timeFilter,
+                limit: maxResults === 0 ? 100 : maxResults,
+                after,
+                before,
+                count,
+                show,
+            });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to retrieve posts from subreddit', details: error.details };
+            }
+            return {
+                error: 'Error retrieving posts from subreddit',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=retrieve-posts-from-subreddit.js.map

package/dist/toolkits/reddit/tools/retrieve-specific-comment-or-post.d.ts

@@ -0,0 +1,25 @@
+export declare const redditRetrieveSpecificCommentOrPost: import("ai").Tool<{
+    id: string;
+    redditToken?: string | undefined;
+}, {
+    error: string;
+    things?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    things: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    things?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    things?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=retrieve-specific-comment-or-post.d.ts.map

package/dist/toolkits/reddit/tools/retrieve-specific-comment-or-post.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditRetrieveSpecificCommentOrPost = tool({
+    description: 'Get detailed information for a single comment or post by its fullname ID. Returns only that item without surrounding thread context — use redditRetrievePostComments for full discussions. Deleted or removed items may return empty payloads.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z
+            .string()
+            .describe("Fullname ID with type prefix (t1_ for comments, t3_ for posts), e.g. 't1_abc123'"),
+    }),
+    execute: async ({ redditToken, id }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            const data = await redditGet(redditToken, '/api/info', { id });
+            return { things: data?.data?.children ?? [] };
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to retrieve comment or post', details: error.details };
+            }
+            return {
+                error: 'Error retrieving comment or post',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=retrieve-specific-comment-or-post.js.map

package/dist/toolkits/reddit/tools/search-across-subreddits.d.ts

@@ -0,0 +1,12 @@
+export declare const redditSearchAcrossSubreddits: import("ai").Tool<{
+    sort: "new" | "comments" | "relevance" | "hot" | "top";
+    limit: number;
+    searchQuery: string;
+    restrictSr: boolean;
+    before?: string | undefined;
+    after?: string | undefined;
+    resultType?: ("user" | "link" | "sr")[] | undefined;
+    redditToken?: string | undefined;
+    timeFilter?: "all" | "year" | "month" | "day" | "hour" | "week" | undefined;
+}, any>;
+//# sourceMappingURL=search-across-subreddits.d.ts.map

package/dist/toolkits/reddit/tools/search-across-subreddits.js

@@ -0,0 +1,59 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditSearchAcrossSubreddits = tool({
+    description: 'Search Reddit for posts using a query with Reddit search operators (title:, author:, subreddit:, url:, site:, flair:). Supports sort, time windows, pagination via the after cursor, and restricting to posts (links).',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        searchQuery: z.string().describe('Search query; raw http(s) URLs are not allowed, use url: or site: operators'),
+        sort: z
+            .enum(['relevance', 'hot', 'new', 'top', 'comments'])
+            .optional()
+            .default('relevance')
+            .describe('Sort order for search results'),
+        timeFilter: z
+            .enum(['hour', 'day', 'week', 'month', 'year', 'all'])
+            .optional()
+            .describe('Restrict results to a time period'),
+        limit: z.number().min(1).max(100).optional().default(5).describe('Max results to return (max 100)'),
+        after: z.string().optional().describe('Pagination cursor for the next page'),
+        before: z.string().optional().describe('Pagination cursor for the previous page'),
+        restrictSr: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe('Confine the search to posts and comments within subreddits'),
+        resultType: z
+            .array(z.enum(['sr', 'link', 'user']))
+            .optional()
+            .describe("Content types to include; must include 'link' for post results"),
+    }),
+    execute: async ({ redditToken, searchQuery, sort = 'relevance', timeFilter, limit = 5, after, before, restrictSr = true, resultType, }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, '/search', {
+                q: searchQuery,
+                sort,
+                t: timeFilter,
+                limit,
+                after,
+                before,
+                restrict_sr: restrictSr,
+                type: resultType?.join(','),
+            });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to search Reddit', details: error.details };
+            }
+            return {
+                error: 'Error searching Reddit',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-across-subreddits.js.map

package/dist/toolkits/reddit/tools/search-subreddits.d.ts

@@ -0,0 +1,12 @@
+export declare const redditSearchSubreddits: import("ai").Tool<{
+    query: string;
+    sort: "activity" | "relevance";
+    limit: number;
+    count?: number | undefined;
+    show?: string | undefined;
+    before?: string | undefined;
+    after?: string | undefined;
+    redditToken?: string | undefined;
+    showUsers?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=search-subreddits.d.ts.map

package/dist/toolkits/reddit/tools/search-subreddits.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditGet } from './client.js';
+export const redditSearchSubreddits = tool({
+    description: 'Search for subreddits by title and description to find communities matching a topic or keyword. Returns subscriber counts, descriptions, and metadata. Supports pagination via after/before cursors.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        query: z.string().describe('Search query for subreddit titles and descriptions'),
+        sort: z
+            .enum(['relevance', 'activity'])
+            .optional()
+            .default('relevance')
+            .describe('Sort order for search results'),
+        limit: z.number().min(1).max(100).optional().default(25).describe('Max subreddits to return (max 100)'),
+        after: z.string().optional().describe('Fullname cursor for the next page'),
+        before: z.string().optional().describe('Fullname cursor for the previous page'),
+        count: z.number().min(0).optional().describe('Number of items already seen (pagination)'),
+        show: z.string().optional().describe("Pass 'all' to include normally filtered items"),
+        showUsers: z.boolean().optional().describe('Include matching users in the results'),
+    }),
+    execute: async ({ redditToken, query, sort = 'relevance', limit = 25, after, before, count, show, showUsers }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            return await redditGet(redditToken, '/subreddits/search', {
+                q: query,
+                sort,
+                limit,
+                after,
+                before,
+                count,
+                show,
+                show_users: showUsers,
+            });
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to search subreddits', details: error.details };
+            }
+            return {
+                error: 'Error searching subreddits',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-subreddits.js.map

package/dist/toolkits/reddit/tools/toggle-inbox-replies.d.ts

@@ -0,0 +1,34 @@
+export declare const redditToggleInboxReplies: import("ai").Tool<{
+    id: string;
+    state: boolean;
+    redditToken?: string | undefined;
+}, {
+    error: string;
+    success?: undefined;
+    id?: undefined;
+    state?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    id: string;
+    state: boolean;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    details: any;
+    success?: undefined;
+    id?: undefined;
+    state?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    success?: undefined;
+    id?: undefined;
+    state?: undefined;
+    details?: undefined;
+}>;
+//# sourceMappingURL=toggle-inbox-replies.d.ts.map

package/dist/toolkits/reddit/tools/toggle-inbox-replies.js

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { redditPost } from './client.js';
+export const redditToggleInboxReplies = tool({
+    description: 'Enable or disable inbox reply notifications for your own submission or comment. Provide the item fullname ID (t3_ for posts, t1_ for comments) and the desired state.',
+    inputSchema: z.object({
+        redditToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe("Fullname of your post or comment, e.g. 't3_abc123' or 't1_def456'"),
+        state: z.boolean().describe('True to receive inbox replies, false to mute them'),
+    }),
+    execute: async ({ redditToken, id, state }) => {
+        try {
+            if (!redditToken) {
+                return { error: 'Reddit token is required. Connect Reddit first.' };
+            }
+            await redditPost(redditToken, '/api/sendreplies', { id, state });
+            return { success: true, id, state };
+        }
+        catch (error) {
+            if (error?.details !== undefined) {
+                return { error: 'Failed to toggle inbox replies', details: error.details };
+            }
+            return {
+                error: 'Error toggling inbox replies',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=toggle-inbox-replies.js.map

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