@rnsk/toolkits 0.0.8 → 0.0.10

package/dist/toolkits/slack/tools/misc.d.ts

@@ -0,0 +1,42 @@
+export declare const slackCustomizeUnfurl: import("ai").Tool<{
+    metadata?: Record<string, any> | undefined;
+    source?: string | undefined;
+    channel?: string | undefined;
+    ts?: string | undefined;
+    slackToken?: string | undefined;
+    unfurlId?: string | undefined;
+    unfurls?: Record<string, any> | undefined;
+    userAuthRequired?: boolean | undefined;
+    userAuthUrl?: string | undefined;
+    userAuthMessage?: string | undefined;
+    userAuthBlocks?: Record<string, any>[] | undefined;
+}, any>;
+export declare const slackApiTest: import("ai").Tool<{
+    error?: string | undefined;
+    slackToken?: string | undefined;
+    foo?: string | undefined;
+}, any>;
+export declare const slackTestAuth: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackWhoAmI: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    data: {
+        user_id: any;
+        team_id: any;
+        user: any;
+        team: any;
+        url: any;
+        is_enterprise_install: any;
+    };
+    display_name: string | null;
+}>;
+export declare const slackRtmConnect: import("ai").Tool<{
+    slackToken?: string | undefined;
+    presenceSub?: boolean | undefined;
+    batchPresenceAware?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=misc.d.ts.map

package/dist/toolkits/slack/tools/misc.js

@@ -0,0 +1,127 @@
+// @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 slackCustomizeUnfurl = tool({
+    description: 'Customize link previews (unfurls) on a message: provide custom preview content per URL or empty objects to remove previews. Target by channel+ts, or by unfurl_id+source. Either unfurls or metadata is required.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().optional().describe('Channel ID (requires ts)'),
+        ts: z.string().optional().describe('Message ts (requires channel)'),
+        unfurlId: z.string().optional().describe('Link ID (requires source; alternative to channel+ts)'),
+        source: z.string().optional().describe("Link source: 'composer' or 'conversations_history' (requires unfurlId)"),
+        unfurls: z.record(z.any()).optional().describe('Map of URL to preview content (empty object removes the preview)'),
+        metadata: z.record(z.any()).optional().describe('Work-object metadata alternative to unfurls'),
+        userAuthRequired: z.boolean().optional().describe('Require user auth before unfurling a domain'),
+        userAuthUrl: z.string().optional().describe('Auth URL for the unfurl flow'),
+        userAuthMessage: z.string().optional().describe('Ephemeral prompt asking the user to authenticate'),
+        userAuthBlocks: z.array(z.record(z.any())).optional().describe('Block Kit auth invitation (richer alternative)'),
+    }),
+    execute: async ({ slackToken, ts, unfurlId, userAuthRequired, userAuthUrl, userAuthMessage, userAuthBlocks, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'chat.unfurl', {
+                ...rest,
+                ts,
+                unfurl_id: unfurlId,
+                user_auth_required: userAuthRequired,
+                user_auth_url: userAuthUrl,
+                user_auth_message: userAuthMessage,
+                user_auth_blocks: userAuthBlocks,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to customize unfurl');
+        }
+    },
+});
+export const slackApiTest = tool({
+    description: 'Test Slack API connectivity and auth. Pass foo to echo a value, or error to simulate an error response.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        foo: z.string().optional().describe('Arbitrary value echoed back in args'),
+        error: z.string().optional().describe('Error code to simulate, e.g. my_error'),
+    }),
+    execute: async ({ slackToken, foo, error }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'api.test', { foo, error });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to test API');
+        }
+    },
+});
+export const slackTestAuth = tool({
+    description: 'Verify authentication and get the caller identity (user, team, bot). Use first when diagnosing scope or token issues. Replaces the deprecated permission-scopes check.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'auth.test', {});
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to test auth');
+        }
+    },
+});
+export const slackWhoAmI = tool({
+    description: 'Return the connected account identity (user ID + workspace ID). User IDs are workspace-scoped, so both are included in the label.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+    }),
+    execute: async ({ slackToken }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const auth = await slackApi(slackToken, 'auth.test', {});
+            return {
+                data: {
+                    user_id: auth?.user_id,
+                    team_id: auth?.team_id,
+                    user: auth?.user,
+                    team: auth?.team,
+                    url: auth?.url,
+                    is_enterprise_install: auth?.is_enterprise_install,
+                },
+                display_name: auth?.user && auth?.team ? `${auth.user} @ ${auth.team}` : null,
+            };
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get identity');
+        }
+    },
+});
+export const slackRtmConnect = tool({
+    description: 'Start a Real Time Messaging session and get a WebSocket URL for persistent event streaming. Connect to the returned URL separately; the URL is short-lived.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        presenceSub: z.boolean().optional().describe('Only deliver presence events on subscription'),
+        batchPresenceAware: z.boolean().optional().describe('Batch presence deliveries (changes event shape)'),
+    }),
+    execute: async ({ slackToken, presenceSub, batchPresenceAware }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'rtm.connect', {
+                presence_sub: presenceSub,
+                batch_presence_aware: batchPresenceAware,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to start RTM session');
+        }
+    },
+});
+//# sourceMappingURL=misc.js.map

package/dist/toolkits/slack/tools/reactions-stars-pins.d.ts

@@ -0,0 +1,69 @@
+export declare const slackAddReaction: import("ai").Tool<{
+    name: string;
+    timestamp: string;
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackRemoveReaction: import("ai").Tool<{
+    name: string;
+    file?: string | undefined;
+    timestamp?: string | undefined;
+    channel?: string | undefined;
+    slackToken?: string | undefined;
+    fileComment?: string | undefined;
+}, any>;
+export declare const slackGetReactions: import("ai").Tool<{
+    file?: string | undefined;
+    timestamp?: string | undefined;
+    channel?: string | undefined;
+    full?: boolean | undefined;
+    slackToken?: string | undefined;
+    fileComment?: string | undefined;
+}, any>;
+export declare const slackListUserReactions: import("ai").Tool<{
+    count?: number | undefined;
+    teamId?: string | undefined;
+    user?: string | undefined;
+    limit?: number | undefined;
+    page?: number | undefined;
+    cursor?: string | undefined;
+    full?: boolean | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackAddStar: import("ai").Tool<{
+    file?: string | undefined;
+    timestamp?: string | undefined;
+    channel?: string | undefined;
+    slackToken?: string | undefined;
+    fileComment?: string | undefined;
+}, any>;
+export declare const slackRemoveStar: import("ai").Tool<{
+    file?: string | undefined;
+    timestamp?: string | undefined;
+    channel?: string | undefined;
+    slackToken?: string | undefined;
+    fileComment?: string | undefined;
+}, any>;
+export declare const slackListStarredItems: import("ai").Tool<{
+    count?: number | undefined;
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    page?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackPinItem: import("ai").Tool<{
+    timestamp: string;
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackUnpinItem: import("ai").Tool<{
+    timestamp: string;
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListPinnedItems: import("ai").Tool<{
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=reactions-stars-pins.d.ts.map

package/dist/toolkits/slack/tools/reactions-stars-pins.js

@@ -0,0 +1,236 @@
+// @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 slackAddReaction = tool({
+    description: 'Add an emoji reaction to a message by channel and exact timestamp. The emoji must exist; use slackListCustomEmojis to verify. Skin tones append ::skin-tone-2..6.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID containing the message'),
+        timestamp: z.string().describe('Exact message ts, e.g. 1234567890.123456'),
+        name: z.string().describe("Emoji name without colons, e.g. 'thumbsup'"),
+    }),
+    execute: async ({ slackToken, channel, timestamp, name }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'reactions.add', { channel, timestamp, name });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to add reaction');
+        }
+    },
+});
+export const slackRemoveReaction = tool({
+    description: 'Remove an emoji reaction from a message, file, or file comment. Provide exactly one target: channel+timestamp, file, or fileComment.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        name: z.string().describe("Emoji name without colons, e.g. 'thumbsup'"),
+        channel: z.string().optional().describe('Channel ID (requires timestamp)'),
+        timestamp: z.string().optional().describe('Message ts (requires channel)'),
+        file: z.string().optional().describe('File ID'),
+        fileComment: z.string().optional().describe('File comment ID'),
+    }),
+    execute: async ({ slackToken, name, channel, timestamp, file, fileComment }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'reactions.remove', {
+                name,
+                channel,
+                timestamp,
+                file,
+                file_comment: fileComment,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to remove reaction');
+        }
+    },
+});
+export const slackGetReactions = tool({
+    description: 'Get reactions for a message, file, or file comment. Provide exactly one target: channel+timestamp, file, or fileComment. A missing reactions field means zero reactions.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().optional().describe('Channel ID (requires timestamp)'),
+        timestamp: z.string().optional().describe('Message ts (requires channel)'),
+        file: z.string().optional().describe('File ID'),
+        fileComment: z.string().optional().describe('File comment ID'),
+        full: z.boolean().optional().describe('Return the full user list per reaction'),
+    }),
+    execute: async ({ slackToken, channel, timestamp, file, fileComment, full }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'reactions.get', {
+                channel,
+                timestamp,
+                file,
+                file_comment: fileComment,
+                full,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get reactions');
+        }
+    },
+});
+export const slackListUserReactions = tool({
+    description: 'List reactions added by a user (defaults to caller). Paginate with cursor; page/count offer legacy pagination. Items repeat per reaction.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        user: z.string().optional().describe('User ID; omit for the caller'),
+        full: z.boolean().optional().describe('Include reactions on deleted items (larger payload)'),
+        limit: z.number().optional().describe('Max items (cursor pagination)'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        count: z.number().optional().describe('Items per page (legacy pagination)'),
+        page: z.number().optional().describe('Page number (legacy pagination)'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'reactions.list', { ...rest, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list user reactions');
+        }
+    },
+});
+export const slackAddStar = tool({
+    description: 'Star (save) a channel, file, file comment, or message. For messages provide channel+timestamp; otherwise file, fileComment, or channel alone.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().optional().describe('Channel ID (alone, or with timestamp for a message)'),
+        timestamp: z.string().optional().describe('Message ts (requires channel)'),
+        file: z.string().optional().describe('File ID'),
+        fileComment: z.string().optional().describe('File comment ID, e.g. Fc1234567890'),
+    }),
+    execute: async ({ slackToken, channel, timestamp, file, fileComment }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'stars.add', {
+                channel,
+                timestamp,
+                file,
+                file_comment: fileComment,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to add star');
+        }
+    },
+});
+export const slackRemoveStar = tool({
+    description: 'Remove a star from a channel, file, file comment, or message. Same targeting rules as slackAddStar.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().optional().describe('Channel ID (alone, or with timestamp for a message)'),
+        timestamp: z.string().optional().describe('Message ts (requires channel)'),
+        file: z.string().optional().describe('File ID'),
+        fileComment: z.string().optional().describe('File comment ID'),
+    }),
+    execute: async ({ slackToken, channel, timestamp, file, fileComment }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'stars.remove', {
+                channel,
+                timestamp,
+                file,
+                file_comment: fileComment,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to remove star');
+        }
+    },
+});
+export const slackListStarredItems = tool({
+    description: 'List items the caller starred (classic stars, not saved-for-later). Paginate with cursor (preferred) or page/count.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        count: z.number().optional().describe('Items per page'),
+        page: z.number().optional().describe('Page number'),
+        limit: z.number().optional().describe('Max items to return'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, teamId, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'stars.list', { ...rest, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list starred items');
+        }
+    },
+});
+export const slackPinItem = tool({
+    description: 'Pin a message to a channel by channel ID and exact timestamp. The message must not already be pinned.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID to pin in'),
+        timestamp: z.string().describe('Message ts, e.g. 1624464000.000200'),
+    }),
+    execute: async ({ slackToken, channel, timestamp }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'pins.add', { channel, timestamp });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to pin item');
+        }
+    },
+});
+export const slackUnpinItem = tool({
+    description: 'Unpin a message from a channel by channel ID and timestamp. Destructive — confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID holding the pin'),
+        timestamp: z.string().describe('Pinned message ts'),
+    }),
+    execute: async ({ slackToken, channel, timestamp }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'pins.remove', { channel, timestamp });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to unpin item');
+        }
+    },
+});
+export const slackListPinnedItems = tool({
+    description: 'List messages and files pinned to a channel. The caller must have channel access.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel, group, or DM ID'),
+    }),
+    execute: async ({ slackToken, channel }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'pins.list', { channel });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list pinned items');
+        }
+    },
+});
+//# sourceMappingURL=reactions-stars-pins.js.map

package/dist/toolkits/slack/tools/reminders.d.ts

@@ -0,0 +1,22 @@
+export declare const slackCreateReminder: import("ai").Tool<{
+    text: string;
+    time: string;
+    teamId?: string | undefined;
+    user?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackGetReminder: import("ai").Tool<{
+    reminder: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackListReminders: import("ai").Tool<{
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackDeleteReminder: import("ai").Tool<{
+    reminder: string;
+    teamId?: string | undefined;
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=reminders.d.ts.map

package/dist/toolkits/slack/tools/reminders.js

@@ -0,0 +1,83 @@
+// @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 slackCreateReminder = tool({
+    description: 'Create a reminder with text and time. Time accepts a Unix timestamp, seconds-from-now, or natural language (e.g. "in 15 minutes", "every Monday at 10am"). Only bot tokens can target other users.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        text: z.string().describe("Reminder text, e.g. 'Submit weekly report'"),
+        time: z.string().describe("When: Unix timestamp, seconds, or natural language"),
+        user: z.string().optional().describe('Recipient user ID (omit for self; bot tokens only)'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, text, time, user, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'reminders.add', { text, time, user, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to create reminder');
+        }
+    },
+});
+export const slackGetReminder = tool({
+    description: 'Get details for a reminder by ID (Rm-prefixed). Read-only.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        reminder: z.string().describe('Reminder ID, e.g. Rm12345678'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, reminder, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'reminders.info', { reminder, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get reminder');
+        }
+    },
+});
+export const slackListReminders = tool({
+    description: 'List reminders for the caller. An empty array is valid (no reminders), not an error. Match client-side on returned objects before deleting by ID.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'reminders.list', { team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list reminders');
+        }
+    },
+});
+export const slackDeleteReminder = tool({
+    description: 'Delete a reminder by ID. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        reminder: z.string().describe('Reminder ID, e.g. Rm1234567890'),
+        teamId: z.string().optional().describe('Workspace ID (org-level tokens only)'),
+    }),
+    execute: async ({ slackToken, reminder, teamId }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'reminders.delete', { reminder, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete reminder');
+        }
+    },
+});
+//# sourceMappingURL=reminders.js.map

package/dist/toolkits/slack/tools/search.d.ts

@@ -0,0 +1,49 @@
+export declare const slackSearchAll: import("ai").Tool<{
+    query: string;
+    sort?: string | undefined;
+    count?: number | undefined;
+    teamId?: string | undefined;
+    page?: number | undefined;
+    slackToken?: string | undefined;
+    sortDir?: string | undefined;
+    highlight?: boolean | undefined;
+}, any>;
+export declare const slackSearchMessages: import("ai").Tool<{
+    query: string;
+    sort?: string | undefined;
+    count?: number | undefined;
+    teamId?: string | undefined;
+    page?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    sortDir?: string | undefined;
+    highlight?: boolean | undefined;
+    autoPaginate?: boolean | undefined;
+}, any>;
+export declare const slackAssistantSearch: import("ai").Tool<{
+    query: string;
+    sort?: string | undefined;
+    limit?: number | undefined;
+    before?: number | undefined;
+    after?: number | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    sortDir?: string | undefined;
+    includeBots?: boolean | undefined;
+    highlight?: boolean | undefined;
+    contentTypes?: string | undefined;
+    channelTypes?: string | undefined;
+    modifiers?: string | undefined;
+    termClauses?: string[] | undefined;
+    includeDeletedUsers?: boolean | undefined;
+    includeMessageBlocks?: boolean | undefined;
+    includeContextMessages?: boolean | undefined;
+    includeArchivedChannels?: boolean | undefined;
+    disableSemanticSearch?: boolean | undefined;
+    contextChannelId?: string | undefined;
+    actionToken?: string | undefined;
+}, any>;
+export declare const slackGetSearchInfo: import("ai").Tool<{
+    slackToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=search.d.ts.map