@rnsk/toolkits 0.0.8 → 0.0.9

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

@@ -0,0 +1,187 @@
+// @ts-nocheck
+import { slackSendMessage, slackUpdateMessage, slackDeleteMessage, slackScheduleMessage, slackListScheduledMessages, slackDeleteScheduledMessage, slackGetMessagePermalink, slackSendMeMessage, slackSendEphemeralMessage, slackListUnreadChannelMessages, slackGetUnreadMessagesFromUser, } from './messages.js';
+import { slackListAllChannels, slackFindChannels, slackListConversations, slackGetConversationInfo, slackGetConversationMembers, slackGetConversationHistory, slackGetConversationReplies, slackCreateChannel, slackArchiveChannel, slackUnarchiveChannel, slackCloseDm, slackJoinConversation, slackLeaveConversation, slackRenameConversation, slackSetConversationTopic, slackSetConversationPurpose, slackMarkConversationRead, slackInviteUsersToChannel, slackRemoveUserFromConversation, slackOpenDm, } from './conversations.js';
+import { slackAdminSearchConversations, slackAdminCreateConversation, slackDeleteChannel, slackConvertChannelToPrivate, slackInviteUserToChannelAdmin, slackGetConversationPrefs, slackSetConversationPrefs, slackGetChannelWorkspaces, slackSetChannelWorkspaces, slackListChannelIdpGroups, } from './admin-conversations.js';
+import { slackListUsers, slackFindUsers, slackFindUserByEmail, slackGetUserInfo, slackGetUserProfile, slackSetUserProfile, slackGetUserPresence, slackSetUserPresence, slackEndDnd, slackEndSnooze, slackSetDndDuration, slackGetDndStatus, slackGetTeamDndStatus, slackDeleteUserPhoto, slackSetUserPhoto, slackGetUserIdentity, slackGetBotInfo, } from './users.js';
+import { slackAddEnterpriseUserToWorkspace, slackInviteUserToWorkspace, slackRemoveUserFromWorkspace, slackSetAdminUser, slackSetWorkspaceOwner, slackResetUserSessions, slackListWorkspaceUsers, } from './admin-users.js';
+import { slackGetTeamInfo, slackGetTeamProfile, slackListAuthTeams, slackListAvailableWorkspaces, slackCreateEnterpriseTeam, slackListEnterpriseTeams, slackListWorkspaceAdmins, slackListWorkspaceOwners, slackGetWorkspaceSettings, slackSetWorkspaceName, slackSetWorkspaceDescription, slackSetWorkspaceIcon, slackSetWorkspaceDefaultChannels, } from './teams.js';
+import { slackListFiles, slackGetFileInfo, slackDeleteFile, slackDeleteFileComment, slackShareFilePublicUrl, slackRevokeFilePublicUrl, slackDownloadFile, slackUploadFile, slackAddRemoteFile, slackGetRemoteFile, slackUpdateRemoteFile, slackRemoveRemoteFile, slackShareRemoteFile, slackListRemoteFiles, } from './files.js';
+import { slackAddReaction, slackRemoveReaction, slackGetReactions, slackListUserReactions, slackAddStar, slackRemoveStar, slackListStarredItems, slackPinItem, slackUnpinItem, slackListPinnedItems, } from './reactions-stars-pins.js';
+import { slackCreateReminder, slackGetReminder, slackListReminders, slackDeleteReminder, } from './reminders.js';
+import { slackSearchAll, slackSearchMessages, slackAssistantSearch, slackGetSearchInfo, } from './search.js';
+import { slackStartCall, slackGetCallInfo, slackUpdateCallInfo, slackEndCall, slackAddCallParticipants, slackRemoveCallParticipants, } from './calls.js';
+import { slackCreateCanvas, slackEditCanvas, slackDeleteCanvas, slackLookupCanvasSections, } from './canvas.js';
+import { slackCreateList, slackCreateListItem, slackGetListItem, slackListListItems, slackUpdateList, slackUpdateListItem, slackDeleteListItem, slackDeleteListItems, slackSetListAccess, slackDeleteListAccess, } from './slack-lists.js';
+import { slackCreateUserGroup, slackUpdateUserGroup, slackUpdateUserGroupMembers, slackListUserGroups, slackListUserGroupMembers, slackEnableUserGroup, slackDisableUserGroup, } from './usergroups.js';
+import { slackAddEmoji, slackAddEmojiAlias, slackRenameEmoji, slackRemoveEmoji, slackListCustomEmojis, slackListAdminEmoji, } from './emoji.js';
+import { slackListApprovedApps, slackListAppRequests, slackListRestrictedApps, slackRestrictApp, } from './admin-apps.js';
+import { slackListApprovedInvites, slackListDeniedInvites, slackListPendingInvites, } from './admin-invites.js';
+import { slackReadAuditLogs, slackGetAuditActions, slackGetAuditSchemas, slackGetScimConfig, } from './audit.js';
+import { slackCustomizeUnfurl, slackApiTest, slackTestAuth, slackWhoAmI, slackRtmConnect, } from './misc.js';
+export { slackSendMessage, slackUpdateMessage, slackDeleteMessage, slackScheduleMessage, slackListScheduledMessages, slackDeleteScheduledMessage, slackGetMessagePermalink, slackSendMeMessage, slackSendEphemeralMessage, slackListUnreadChannelMessages, slackGetUnreadMessagesFromUser, slackListAllChannels, slackFindChannels, slackListConversations, slackGetConversationInfo, slackGetConversationMembers, slackGetConversationHistory, slackGetConversationReplies, slackCreateChannel, slackArchiveChannel, slackUnarchiveChannel, slackCloseDm, slackJoinConversation, slackLeaveConversation, slackRenameConversation, slackSetConversationTopic, slackSetConversationPurpose, slackMarkConversationRead, slackInviteUsersToChannel, slackRemoveUserFromConversation, slackOpenDm, slackAdminSearchConversations, slackAdminCreateConversation, slackDeleteChannel, slackConvertChannelToPrivate, slackInviteUserToChannelAdmin, slackGetConversationPrefs, slackSetConversationPrefs, slackGetChannelWorkspaces, slackSetChannelWorkspaces, slackListChannelIdpGroups, slackListUsers, slackFindUsers, slackFindUserByEmail, slackGetUserInfo, slackGetUserProfile, slackSetUserProfile, slackGetUserPresence, slackSetUserPresence, slackEndDnd, slackEndSnooze, slackSetDndDuration, slackGetDndStatus, slackGetTeamDndStatus, slackDeleteUserPhoto, slackSetUserPhoto, slackGetUserIdentity, slackGetBotInfo, slackAddEnterpriseUserToWorkspace, slackInviteUserToWorkspace, slackRemoveUserFromWorkspace, slackSetAdminUser, slackSetWorkspaceOwner, slackResetUserSessions, slackListWorkspaceUsers, slackGetTeamInfo, slackGetTeamProfile, slackListAuthTeams, slackListAvailableWorkspaces, slackCreateEnterpriseTeam, slackListEnterpriseTeams, slackListWorkspaceAdmins, slackListWorkspaceOwners, slackGetWorkspaceSettings, slackSetWorkspaceName, slackSetWorkspaceDescription, slackSetWorkspaceIcon, slackSetWorkspaceDefaultChannels, slackListFiles, slackGetFileInfo, slackDeleteFile, slackDeleteFileComment, slackShareFilePublicUrl, slackRevokeFilePublicUrl, slackDownloadFile, slackUploadFile, slackAddRemoteFile, slackGetRemoteFile, slackUpdateRemoteFile, slackRemoveRemoteFile, slackShareRemoteFile, slackListRemoteFiles, slackAddReaction, slackRemoveReaction, slackGetReactions, slackListUserReactions, slackAddStar, slackRemoveStar, slackListStarredItems, slackPinItem, slackUnpinItem, slackListPinnedItems, slackCreateReminder, slackGetReminder, slackListReminders, slackDeleteReminder, slackSearchAll, slackSearchMessages, slackAssistantSearch, slackGetSearchInfo, slackStartCall, slackGetCallInfo, slackUpdateCallInfo, slackEndCall, slackAddCallParticipants, slackRemoveCallParticipants, slackCreateCanvas, slackEditCanvas, slackDeleteCanvas, slackLookupCanvasSections, slackCreateList, slackCreateListItem, slackGetListItem, slackListListItems, slackUpdateList, slackUpdateListItem, slackDeleteListItem, slackDeleteListItems, slackSetListAccess, slackDeleteListAccess, slackCreateUserGroup, slackUpdateUserGroup, slackUpdateUserGroupMembers, slackListUserGroups, slackListUserGroupMembers, slackEnableUserGroup, slackDisableUserGroup, slackAddEmoji, slackAddEmojiAlias, slackRenameEmoji, slackRemoveEmoji, slackListCustomEmojis, slackListAdminEmoji, slackListApprovedApps, slackListAppRequests, slackListRestrictedApps, slackRestrictApp, slackListApprovedInvites, slackListDeniedInvites, slackListPendingInvites, slackReadAuditLogs, slackGetAuditActions, slackGetAuditSchemas, slackGetScimConfig, slackCustomizeUnfurl, slackApiTest, slackTestAuth, slackWhoAmI, slackRtmConnect, };
+const R = 'slackToken';
+function t(tool, scope, name) {
+    return { name: name ?? tool?.name ?? 'unknown', description: tool?.description ?? '', tool, requiredAuth: R, scope };
+}
+export const slackTools = [
+    t(slackSendMessage, 'write', 'slackSendMessage'),
+    t(slackUpdateMessage, 'write', 'slackUpdateMessage'),
+    t(slackDeleteMessage, 'delete', 'slackDeleteMessage'),
+    t(slackScheduleMessage, 'write', 'slackScheduleMessage'),
+    t(slackListScheduledMessages, 'read', 'slackListScheduledMessages'),
+    t(slackDeleteScheduledMessage, 'delete', 'slackDeleteScheduledMessage'),
+    t(slackGetMessagePermalink, 'read', 'slackGetMessagePermalink'),
+    t(slackSendMeMessage, 'write', 'slackSendMeMessage'),
+    t(slackSendEphemeralMessage, 'write', 'slackSendEphemeralMessage'),
+    t(slackListUnreadChannelMessages, 'read', 'slackListUnreadChannelMessages'),
+    t(slackGetUnreadMessagesFromUser, 'read', 'slackGetUnreadMessagesFromUser'),
+    t(slackListAllChannels, 'read', 'slackListAllChannels'),
+    t(slackFindChannels, 'read', 'slackFindChannels'),
+    t(slackListConversations, 'read', 'slackListConversations'),
+    t(slackGetConversationInfo, 'read', 'slackGetConversationInfo'),
+    t(slackGetConversationMembers, 'read', 'slackGetConversationMembers'),
+    t(slackGetConversationHistory, 'read', 'slackGetConversationHistory'),
+    t(slackGetConversationReplies, 'read', 'slackGetConversationReplies'),
+    t(slackCreateChannel, 'write', 'slackCreateChannel'),
+    t(slackArchiveChannel, 'write', 'slackArchiveChannel'),
+    t(slackUnarchiveChannel, 'write', 'slackUnarchiveChannel'),
+    t(slackCloseDm, 'write', 'slackCloseDm'),
+    t(slackJoinConversation, 'write', 'slackJoinConversation'),
+    t(slackLeaveConversation, 'write', 'slackLeaveConversation'),
+    t(slackRenameConversation, 'write', 'slackRenameConversation'),
+    t(slackSetConversationTopic, 'write', 'slackSetConversationTopic'),
+    t(slackSetConversationPurpose, 'write', 'slackSetConversationPurpose'),
+    t(slackMarkConversationRead, 'write', 'slackMarkConversationRead'),
+    t(slackInviteUsersToChannel, 'write', 'slackInviteUsersToChannel'),
+    t(slackRemoveUserFromConversation, 'delete', 'slackRemoveUserFromConversation'),
+    t(slackOpenDm, 'write', 'slackOpenDm'),
+    t(slackAdminSearchConversations, 'read', 'slackAdminSearchConversations'),
+    t(slackAdminCreateConversation, 'write', 'slackAdminCreateConversation'),
+    t(slackDeleteChannel, 'delete', 'slackDeleteChannel'),
+    t(slackConvertChannelToPrivate, 'write', 'slackConvertChannelToPrivate'),
+    t(slackInviteUserToChannelAdmin, 'write', 'slackInviteUserToChannelAdmin'),
+    t(slackGetConversationPrefs, 'read', 'slackGetConversationPrefs'),
+    t(slackSetConversationPrefs, 'write', 'slackSetConversationPrefs'),
+    t(slackGetChannelWorkspaces, 'read', 'slackGetChannelWorkspaces'),
+    t(slackSetChannelWorkspaces, 'write', 'slackSetChannelWorkspaces'),
+    t(slackListChannelIdpGroups, 'read', 'slackListChannelIdpGroups'),
+    t(slackListUsers, 'read', 'slackListUsers'),
+    t(slackFindUsers, 'read', 'slackFindUsers'),
+    t(slackFindUserByEmail, 'read', 'slackFindUserByEmail'),
+    t(slackGetUserInfo, 'read', 'slackGetUserInfo'),
+    t(slackGetUserProfile, 'read', 'slackGetUserProfile'),
+    t(slackSetUserProfile, 'write', 'slackSetUserProfile'),
+    t(slackGetUserPresence, 'read', 'slackGetUserPresence'),
+    t(slackSetUserPresence, 'write', 'slackSetUserPresence'),
+    t(slackEndDnd, 'write', 'slackEndDnd'),
+    t(slackEndSnooze, 'write', 'slackEndSnooze'),
+    t(slackSetDndDuration, 'write', 'slackSetDndDuration'),
+    t(slackGetDndStatus, 'read', 'slackGetDndStatus'),
+    t(slackGetTeamDndStatus, 'read', 'slackGetTeamDndStatus'),
+    t(slackDeleteUserPhoto, 'delete', 'slackDeleteUserPhoto'),
+    t(slackSetUserPhoto, 'write', 'slackSetUserPhoto'),
+    t(slackGetUserIdentity, 'read', 'slackGetUserIdentity'),
+    t(slackGetBotInfo, 'read', 'slackGetBotInfo'),
+    t(slackAddEnterpriseUserToWorkspace, 'write', 'slackAddEnterpriseUserToWorkspace'),
+    t(slackInviteUserToWorkspace, 'write', 'slackInviteUserToWorkspace'),
+    t(slackRemoveUserFromWorkspace, 'delete', 'slackRemoveUserFromWorkspace'),
+    t(slackSetAdminUser, 'write', 'slackSetAdminUser'),
+    t(slackSetWorkspaceOwner, 'write', 'slackSetWorkspaceOwner'),
+    t(slackResetUserSessions, 'write', 'slackResetUserSessions'),
+    t(slackListWorkspaceUsers, 'read', 'slackListWorkspaceUsers'),
+    t(slackGetTeamInfo, 'read', 'slackGetTeamInfo'),
+    t(slackGetTeamProfile, 'read', 'slackGetTeamProfile'),
+    t(slackListAuthTeams, 'read', 'slackListAuthTeams'),
+    t(slackListAvailableWorkspaces, 'read', 'slackListAvailableWorkspaces'),
+    t(slackCreateEnterpriseTeam, 'write', 'slackCreateEnterpriseTeam'),
+    t(slackListEnterpriseTeams, 'read', 'slackListEnterpriseTeams'),
+    t(slackListWorkspaceAdmins, 'read', 'slackListWorkspaceAdmins'),
+    t(slackListWorkspaceOwners, 'read', 'slackListWorkspaceOwners'),
+    t(slackGetWorkspaceSettings, 'read', 'slackGetWorkspaceSettings'),
+    t(slackSetWorkspaceName, 'write', 'slackSetWorkspaceName'),
+    t(slackSetWorkspaceDescription, 'write', 'slackSetWorkspaceDescription'),
+    t(slackSetWorkspaceIcon, 'write', 'slackSetWorkspaceIcon'),
+    t(slackSetWorkspaceDefaultChannels, 'write', 'slackSetWorkspaceDefaultChannels'),
+    t(slackListFiles, 'read', 'slackListFiles'),
+    t(slackGetFileInfo, 'read', 'slackGetFileInfo'),
+    t(slackDeleteFile, 'delete', 'slackDeleteFile'),
+    t(slackDeleteFileComment, 'delete', 'slackDeleteFileComment'),
+    t(slackShareFilePublicUrl, 'write', 'slackShareFilePublicUrl'),
+    t(slackRevokeFilePublicUrl, 'write', 'slackRevokeFilePublicUrl'),
+    t(slackDownloadFile, 'read', 'slackDownloadFile'),
+    t(slackUploadFile, 'write', 'slackUploadFile'),
+    t(slackAddRemoteFile, 'write', 'slackAddRemoteFile'),
+    t(slackGetRemoteFile, 'read', 'slackGetRemoteFile'),
+    t(slackUpdateRemoteFile, 'write', 'slackUpdateRemoteFile'),
+    t(slackRemoveRemoteFile, 'delete', 'slackRemoveRemoteFile'),
+    t(slackShareRemoteFile, 'write', 'slackShareRemoteFile'),
+    t(slackListRemoteFiles, 'read', 'slackListRemoteFiles'),
+    t(slackAddReaction, 'write', 'slackAddReaction'),
+    t(slackRemoveReaction, 'delete', 'slackRemoveReaction'),
+    t(slackGetReactions, 'read', 'slackGetReactions'),
+    t(slackListUserReactions, 'read', 'slackListUserReactions'),
+    t(slackAddStar, 'write', 'slackAddStar'),
+    t(slackRemoveStar, 'delete', 'slackRemoveStar'),
+    t(slackListStarredItems, 'read', 'slackListStarredItems'),
+    t(slackPinItem, 'write', 'slackPinItem'),
+    t(slackUnpinItem, 'delete', 'slackUnpinItem'),
+    t(slackListPinnedItems, 'read', 'slackListPinnedItems'),
+    t(slackCreateReminder, 'write', 'slackCreateReminder'),
+    t(slackGetReminder, 'read', 'slackGetReminder'),
+    t(slackListReminders, 'read', 'slackListReminders'),
+    t(slackDeleteReminder, 'delete', 'slackDeleteReminder'),
+    t(slackSearchAll, 'read', 'slackSearchAll'),
+    t(slackSearchMessages, 'read', 'slackSearchMessages'),
+    t(slackAssistantSearch, 'read', 'slackAssistantSearch'),
+    t(slackGetSearchInfo, 'read', 'slackGetSearchInfo'),
+    t(slackStartCall, 'write', 'slackStartCall'),
+    t(slackGetCallInfo, 'read', 'slackGetCallInfo'),
+    t(slackUpdateCallInfo, 'write', 'slackUpdateCallInfo'),
+    t(slackEndCall, 'write', 'slackEndCall'),
+    t(slackAddCallParticipants, 'write', 'slackAddCallParticipants'),
+    t(slackRemoveCallParticipants, 'delete', 'slackRemoveCallParticipants'),
+    t(slackCreateCanvas, 'write', 'slackCreateCanvas'),
+    t(slackEditCanvas, 'write', 'slackEditCanvas'),
+    t(slackDeleteCanvas, 'delete', 'slackDeleteCanvas'),
+    t(slackLookupCanvasSections, 'read', 'slackLookupCanvasSections'),
+    t(slackCreateList, 'write', 'slackCreateList'),
+    t(slackCreateListItem, 'write', 'slackCreateListItem'),
+    t(slackGetListItem, 'read', 'slackGetListItem'),
+    t(slackListListItems, 'read', 'slackListListItems'),
+    t(slackUpdateList, 'write', 'slackUpdateList'),
+    t(slackUpdateListItem, 'write', 'slackUpdateListItem'),
+    t(slackDeleteListItem, 'delete', 'slackDeleteListItem'),
+    t(slackDeleteListItems, 'delete', 'slackDeleteListItems'),
+    t(slackSetListAccess, 'write', 'slackSetListAccess'),
+    t(slackDeleteListAccess, 'delete', 'slackDeleteListAccess'),
+    t(slackCreateUserGroup, 'write', 'slackCreateUserGroup'),
+    t(slackUpdateUserGroup, 'write', 'slackUpdateUserGroup'),
+    t(slackUpdateUserGroupMembers, 'write', 'slackUpdateUserGroupMembers'),
+    t(slackListUserGroups, 'read', 'slackListUserGroups'),
+    t(slackListUserGroupMembers, 'read', 'slackListUserGroupMembers'),
+    t(slackEnableUserGroup, 'write', 'slackEnableUserGroup'),
+    t(slackDisableUserGroup, 'write', 'slackDisableUserGroup'),
+    t(slackAddEmoji, 'write', 'slackAddEmoji'),
+    t(slackAddEmojiAlias, 'write', 'slackAddEmojiAlias'),
+    t(slackRenameEmoji, 'write', 'slackRenameEmoji'),
+    t(slackRemoveEmoji, 'delete', 'slackRemoveEmoji'),
+    t(slackListCustomEmojis, 'read', 'slackListCustomEmojis'),
+    t(slackListAdminEmoji, 'read', 'slackListAdminEmoji'),
+    t(slackListApprovedApps, 'read', 'slackListApprovedApps'),
+    t(slackListAppRequests, 'read', 'slackListAppRequests'),
+    t(slackListRestrictedApps, 'read', 'slackListRestrictedApps'),
+    t(slackRestrictApp, 'write', 'slackRestrictApp'),
+    t(slackListApprovedInvites, 'read', 'slackListApprovedInvites'),
+    t(slackListDeniedInvites, 'read', 'slackListDeniedInvites'),
+    t(slackListPendingInvites, 'read', 'slackListPendingInvites'),
+    t(slackReadAuditLogs, 'read', 'slackReadAuditLogs'),
+    t(slackGetAuditActions, 'read', 'slackGetAuditActions'),
+    t(slackGetAuditSchemas, 'read', 'slackGetAuditSchemas'),
+    t(slackGetScimConfig, 'read', 'slackGetScimConfig'),
+    t(slackCustomizeUnfurl, 'write', 'slackCustomizeUnfurl'),
+    t(slackApiTest, 'read', 'slackApiTest'),
+    t(slackTestAuth, 'read', 'slackTestAuth'),
+    t(slackWhoAmI, 'read', 'slackWhoAmI'),
+    t(slackRtmConnect, 'write', 'slackRtmConnect'),
+];
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,106 @@
+export declare const slackSendMessage: import("ai").Tool<{
+    channel: string;
+    blocks?: Record<string, any>[] | undefined;
+    slackToken?: string | undefined;
+    markdownText?: string | undefined;
+    fallbackText?: string | undefined;
+    threadTs?: string | undefined;
+    replyBroadcast?: boolean | undefined;
+    unfurlLinks?: boolean | undefined;
+    unfurlMedia?: boolean | undefined;
+}, any>;
+export declare const slackUpdateMessage: import("ai").Tool<{
+    channel: string;
+    ts: string;
+    blocks?: Record<string, any>[] | undefined;
+    slackToken?: string | undefined;
+    markdownText?: string | undefined;
+    fallbackText?: string | undefined;
+    replyBroadcast?: boolean | undefined;
+    asUser?: boolean | undefined;
+    fileIds?: string[] | undefined;
+}, any>;
+export declare const slackDeleteMessage: import("ai").Tool<{
+    channel: string;
+    ts?: string | undefined;
+    slackToken?: string | undefined;
+    asUser?: boolean | undefined;
+}, any>;
+export declare const slackScheduleMessage: import("ai").Tool<{
+    channel: string;
+    postAt: string;
+    blocks?: string | undefined;
+    text?: string | undefined;
+    parse?: string | undefined;
+    slackToken?: string | undefined;
+    markdownText?: string | undefined;
+    threadTs?: string | undefined;
+    replyBroadcast?: boolean | undefined;
+    unfurlLinks?: boolean | undefined;
+    unfurlMedia?: boolean | undefined;
+    attachments?: string | undefined;
+    linkNames?: boolean | undefined;
+}, any>;
+export declare const slackListScheduledMessages: import("ai").Tool<{
+    teamId?: string | undefined;
+    limit?: number | undefined;
+    latest?: string | undefined;
+    channel?: string | undefined;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    oldest?: string | undefined;
+}, any>;
+export declare const slackDeleteScheduledMessage: import("ai").Tool<{
+    channel: string;
+    scheduledMessageId: string;
+    slackToken?: string | undefined;
+    asUser?: boolean | undefined;
+}, any>;
+export declare const slackGetMessagePermalink: import("ai").Tool<{
+    channel: string;
+    messageTs: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSendMeMessage: import("ai").Tool<{
+    text: string;
+    channel: string;
+    slackToken?: string | undefined;
+}, any>;
+export declare const slackSendEphemeralMessage: import("ai").Tool<{
+    user: string;
+    channel: string;
+    blocks?: string | undefined;
+    username?: string | undefined;
+    text?: string | undefined;
+    parse?: string | undefined;
+    slackToken?: string | undefined;
+    markdownText?: string | undefined;
+    threadTs?: string | undefined;
+    asUser?: boolean | undefined;
+    attachments?: string | undefined;
+    linkNames?: boolean | undefined;
+    iconUrl?: string | undefined;
+    iconEmoji?: string | undefined;
+}, any>;
+export declare const slackListUnreadChannelMessages: import("ai").Tool<{
+    limit: number;
+    channel: string;
+    cursor?: string | undefined;
+    slackToken?: string | undefined;
+    includeAllMetadata?: boolean | undefined;
+}, any>;
+export declare const slackGetUnreadMessagesFromUser: import("ai").Tool<{
+    limit: number;
+    userId: string;
+    slackToken?: string | undefined;
+}, {
+    error: string;
+} | {
+    ok: boolean;
+    channel_id: any;
+    user_id: string;
+    unread_count: any;
+    messages: any;
+    has_more: any;
+}>;
+//# sourceMappingURL=messages.d.ts.map

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

@@ -0,0 +1,340 @@
+// @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 slackSendMessage = tool({
+    description: 'Post a message to a channel, DM, or private group. Provide exactly one of markdownText (normal Markdown) or blocks (raw Block Kit for interactive layouts). For DMs, resolve the user to a channel ID with slackOpenDm first. Not idempotent — duplicate calls post duplicates.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe("Channel ID or name (no '#' prefix). For DMs use the ID from slackOpenDm"),
+        markdownText: z.string().optional().describe('Message in standard Markdown. Do not combine with blocks'),
+        blocks: z.array(z.record(z.any())).optional().describe('Raw Block Kit JSON for interactive layouts'),
+        fallbackText: z.string().optional().describe('Plain-text notification fallback, only with blocks'),
+        threadTs: z.string().optional().describe('Parent message ts to reply in a thread'),
+        replyBroadcast: z.boolean().optional().describe('Also post a thread reply to the main channel'),
+        unfurlLinks: z.boolean().optional().describe('Unfurl text URLs'),
+        unfurlMedia: z.boolean().optional().describe('Show media previews from URLs'),
+    }),
+    execute: async ({ slackToken, channel, markdownText, blocks, fallbackText, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            if ((markdownText && blocks) || (!markdownText && !blocks)) {
+                return { error: 'Provide exactly one of markdownText or blocks.' };
+            }
+            return await slackApi(slackToken, 'chat.postMessage', {
+                channel: channel.startsWith('#') ? channel.slice(1) : channel,
+                markdown_text: markdownText,
+                blocks,
+                text: fallbackText,
+                thread_ts: rest.threadTs,
+                reply_broadcast: rest.replyBroadcast,
+                unfurl_links: rest.unfurlLinks,
+                unfurl_media: rest.unfurlMedia,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to send message');
+        }
+    },
+});
+export const slackUpdateMessage = tool({
+    description: 'Update a message by channel and timestamp. Provide exactly one of markdownText or blocks (raw Block Kit). Only messages posted by the caller can be edited.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID or name containing the message'),
+        ts: z.string().describe('Timestamp of the message to update'),
+        markdownText: z.string().optional().describe('Updated message in standard Markdown'),
+        blocks: z.array(z.record(z.any())).optional().describe('Raw Block Kit JSON for the updated message'),
+        fallbackText: z.string().optional().describe('Plain-text fallback, only with blocks'),
+        asUser: z.boolean().optional().describe('Update as the authenticated user'),
+        fileIds: z.array(z.string()).optional().describe('File IDs to attach (must already be uploaded)'),
+        replyBroadcast: z.boolean().optional().describe('Broadcast an updated thread reply to the channel'),
+    }),
+    execute: async ({ slackToken, channel, ts, markdownText, blocks, fallbackText, asUser, fileIds, replyBroadcast }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            if ((markdownText && blocks) || (!markdownText && !blocks)) {
+                return { error: 'Provide exactly one of markdownText or blocks.' };
+            }
+            return await slackApi(slackToken, 'chat.update', {
+                channel,
+                ts,
+                markdown_text: markdownText,
+                blocks,
+                text: fallbackText,
+                as_user: asUser,
+                file_ids: fileIds?.join(','),
+                reply_broadcast: replyBroadcast,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to update message');
+        }
+    },
+});
+export const slackDeleteMessage = tool({
+    description: 'Delete a message by channel and timestamp. The authenticated user or bot must be the original poster. Confirm with the user first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel, group, or DM ID containing the message'),
+        ts: z.string().optional().describe('Exact timestamp of the message to delete'),
+        asUser: z.boolean().optional().describe('Legacy: delete as the authed user (classic apps only)'),
+    }),
+    execute: async ({ slackToken, channel, ts, asUser }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'chat.delete', { channel, ts, as_user: asUser });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete message');
+        }
+    },
+});
+export const slackScheduleMessage = tool({
+    description: 'Schedule a message for a future time (Unix epoch seconds, max 120 days ahead). Provide markdownText, text, blocks (JSON string), or attachments (JSON string). Use slackListScheduledMessages to find the scheduled_message_id afterwards.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID or name to send to'),
+        postAt: z.string().describe('Future send time as Unix epoch seconds'),
+        markdownText: z.string().optional().describe('Message in Markdown'),
+        text: z.string().optional().describe('Plain-text message content'),
+        blocks: z.string().optional().describe('Block Kit layout as a JSON string'),
+        attachments: z.string().optional().describe('Legacy attachments as a JSON string'),
+        threadTs: z.string().optional().describe('Parent message ts for a scheduled thread reply'),
+        replyBroadcast: z.boolean().optional().describe('Broadcast a scheduled thread reply to the channel'),
+        parse: z.string().optional().describe("Text parsing: 'full' to auto-link mentions, 'none' otherwise"),
+        linkNames: z.boolean().optional().describe('Auto-link channel and user names (deprecated, prefer parse)'),
+        unfurlLinks: z.boolean().optional().describe('Unfurl text URLs (may be ignored for scheduled messages)'),
+        unfurlMedia: z.boolean().optional().describe('Show media previews (may be ignored for scheduled messages)'),
+    }),
+    execute: async ({ slackToken, channel, postAt, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'chat.scheduleMessage', {
+                channel,
+                post_at: postAt,
+                markdown_text: rest.markdownText,
+                text: rest.text,
+                blocks: rest.blocks,
+                attachments: rest.attachments,
+                thread_ts: rest.threadTs,
+                reply_broadcast: rest.replyBroadcast,
+                parse: rest.parse,
+                link_names: rest.linkNames,
+                unfurl_links: rest.unfurlLinks,
+                unfurl_media: rest.unfurlMedia,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to schedule message');
+        }
+    },
+});
+export const slackListScheduledMessages = tool({
+    description: 'List pending scheduled messages for a channel (or all accessible channels when omitted), optionally filtered by time range. Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().optional().describe('Channel ID or name; omit for all accessible channels'),
+        oldest: z.string().optional().describe('Earliest Unix timestamp (inclusive)'),
+        latest: z.string().optional().describe('Latest Unix timestamp (exclusive)'),
+        limit: z.number().min(1).max(1000).optional().describe('Messages per page'),
+        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, 'chat.scheduledMessages.list', { ...rest, team_id: teamId });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list scheduled messages');
+        }
+    },
+});
+export const slackDeleteScheduledMessage = tool({
+    description: 'Delete a pending scheduled message by channel and scheduled_message_id. Get the ID from slackListScheduledMessages.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel, group, or DM ID where the message is scheduled'),
+        scheduledMessageId: z.string().describe('ID from the chat.scheduleMessage response'),
+        asUser: z.boolean().optional().describe('Delete as the authed user (requires chat:write:user)'),
+    }),
+    execute: async ({ slackToken, channel, scheduledMessageId, asUser }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'chat.deleteScheduledMessage', {
+                channel,
+                scheduled_message_id: scheduledMessageId,
+                as_user: asUser,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to delete scheduled message');
+        }
+    },
+});
+export const slackGetMessagePermalink = tool({
+    description: 'Get a permalink URL for a message by channel ID and timestamp. Resolve channel names to IDs with slackFindChannels first.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID containing the message'),
+        messageTs: z.string().describe('Message ts value'),
+    }),
+    execute: async ({ slackToken, channel, messageTs }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'chat.getPermalink', { channel, message_ts: messageTs });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get message permalink');
+        }
+    },
+});
+export const slackSendMeMessage = tool({
+    description: "Send a '/me' action message to a channel, shown in third person (e.g. '*user is preparing for a meeting*'). Plain text only.",
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID, name, or @username for a DM'),
+        text: z.string().describe("Action text, e.g. 'is preparing for a meeting'"),
+    }),
+    execute: async ({ slackToken, channel, text }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'chat.meMessage', { channel, text });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to send me message');
+        }
+    },
+});
+export const slackSendEphemeralMessage = tool({
+    description: 'Send an ephemeral message visible only to one user in a channel. Both the bot and the target user must be channel members. Provide markdownText, text, blocks (JSON string), or attachments (JSON string).',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID or name'),
+        user: z.string().describe('User ID who will see the message'),
+        markdownText: z.string().optional().describe('Message in Markdown'),
+        text: z.string().optional().describe('Plain-text message (fallback for notifications)'),
+        blocks: z.string().optional().describe('Block Kit layout as a JSON string'),
+        attachments: z.string().optional().describe('Legacy attachments as a JSON string'),
+        threadTs: z.string().optional().describe('Parent message ts for a threaded ephemeral reply'),
+        parse: z.string().optional().describe("Use 'full' to auto-link mentions and channels"),
+        linkNames: z.boolean().optional().describe('Auto-link @mentions and #channels'),
+        asUser: z.boolean().optional().describe('Legacy: post as the authed user'),
+        username: z.string().optional().describe('Custom sender name (only when not posting as user)'),
+        iconUrl: z.string().optional().describe('Custom sender icon URL (only when not posting as user)'),
+        iconEmoji: z.string().optional().describe('Custom sender emoji (only when not posting as user)'),
+    }),
+    execute: async ({ slackToken, channel, user, markdownText, ...rest }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            return await slackApi(slackToken, 'chat.postEphemeral', {
+                channel,
+                user,
+                markdown_text: markdownText,
+                text: rest.text,
+                blocks: rest.blocks,
+                attachments: rest.attachments,
+                thread_ts: rest.threadTs,
+                parse: rest.parse,
+                link_names: rest.linkNames,
+                as_user: rest.asUser,
+                username: rest.username,
+                icon_url: rest.iconUrl,
+                icon_emoji: rest.iconEmoji,
+            });
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to send ephemeral message');
+        }
+    },
+});
+export const slackListUnreadChannelMessages = tool({
+    description: 'List unread messages in a channel for the authenticated user (main timeline only, not thread replies). Paginate with cursor.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        channel: z.string().describe('Channel ID to fetch unread messages from'),
+        limit: z.number().min(1).max(1000).optional().default(25).describe('Max messages to return'),
+        cursor: z.string().optional().describe('Pagination cursor from a previous response'),
+        includeAllMetadata: z.boolean().optional().describe('Return all message metadata'),
+    }),
+    execute: async ({ slackToken, channel, limit = 25, cursor, includeAllMetadata }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const info = await slackApi(slackToken, 'conversations.info', { channel });
+            const lastRead = info?.channel?.last_read;
+            const history = await slackApi(slackToken, 'conversations.history', {
+                channel,
+                oldest: lastRead,
+                limit,
+                cursor,
+                include_all_metadata: includeAllMetadata,
+            });
+            return { ...history, last_read: lastRead };
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to list unread channel messages');
+        }
+    },
+});
+export const slackGetUnreadMessagesFromUser = tool({
+    description: 'Get unread DMs from a specific user. Opens the DM, reads the read position, and fetches messages since then. Returns an empty messages array when nothing is unread. DMs only.',
+    inputSchema: z.object({
+        slackToken: tokenField,
+        userId: z.string().describe('User ID to check unread DMs from'),
+        limit: z.number().min(1).max(999).optional().default(25).describe('Max unread messages to return'),
+    }),
+    execute: async ({ slackToken, userId, limit = 25 }) => {
+        try {
+            const missing = requireToken(slackToken);
+            if (missing)
+                return missing;
+            const opened = await slackApi(slackToken, 'conversations.open', { users: userId });
+            const channelId = opened?.channel?.id;
+            if (!channelId) {
+                return { error: 'Could not open DM with user', details: opened };
+            }
+            const info = await slackApi(slackToken, 'conversations.info', { channel: channelId });
+            const lastRead = info?.channel?.last_read ?? '0';
+            const history = await slackApi(slackToken, 'conversations.history', {
+                channel: channelId,
+                oldest: lastRead,
+                limit,
+            });
+            const messages = (history?.messages ?? []).filter((m) => m.ts !== lastRead);
+            return {
+                ok: true,
+                channel_id: channelId,
+                user_id: userId,
+                unread_count: messages.length,
+                messages,
+                has_more: history?.has_more ?? false,
+            };
+        }
+        catch (error) {
+            return toSlackError(error, 'Failed to get unread messages from user');
+        }
+    },
+});
+//# sourceMappingURL=messages.js.map