arcade-slack 1.2.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

arcade_slack/message_retrieval.py

@@ -1,7 +1,7 @@
 from datetime import datetime, timezone
 from typing import Any
 
-from arcade_tdk.errors import ToolExecutionError
+from arcade_tdk.errors import FatalToolError
 from slack_sdk.web.async_client import AsyncWebClient
 
 from arcade_slack.utils import (
@@ -30,7 +30,7 @@ async def retrieve_messages_in_conversation(
         error_message = "Cannot specify both 'latest_datetime' and 'latest_relative'."
 
     if error_message:
-        raise ToolExecutionError(error_message, developer_message=error_message)
+        raise FatalToolError(error_message, developer_message=error_message)
 
     current_unix_timestamp = int(datetime.now(timezone.utc).timestamp())
 

arcade_slack/tools/chat.py

@@ -418,648 +418,3 @@ async def list_conversations(
         ],
         "next_cursor": next_cursor,
     }
-
-
-##################################################################################
-# NOTE: The tools below are kept here for backwards compatibility. Prefer using: #
-# - send_message
-# - get_messages
-# - get_conversation_metadata
-# - get_users_in_conversation
-# - list_conversations
-##################################################################################
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:read",
-            "groups:read",
-            "mpim:read",
-            "im:read",
-            "users:read",
-            "users:read.email",
-            "chat:write",
-            # "mpim:write",
-            "im:write",
-        ],
-    )
-)
-async def send_dm_to_user(
-    context: ToolContext,
-    user_name: Annotated[
-        str,
-        (
-            "The Slack username of the person you want to message. "
-            "Slack usernames are ALWAYS lowercase."
-        ),
-    ],
-    message: Annotated[str, "The message you want to send"],
-) -> Annotated[dict, "The response from the Slack API"]:
-    """Send a direct message to a user in Slack.
-
-    This tool is deprecated. Use `Slack.SendMessage` instead.
-    """
-    return await send_message(  # type: ignore[no-any-return]
-        context=context,
-        usernames=[user_name],
-        message=message,
-    )
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:read",
-            "groups:read",
-            "mpim:read",
-            "im:read",
-            "users:read",
-            "users:read.email",
-            "chat:write",
-            # "mpim:write",
-            "im:write",
-        ],
-    )
-)
-async def send_message_to_channel(
-    context: ToolContext,
-    channel_name: Annotated[str, "The Slack channel name where you want to send the message. "],
-    message: Annotated[str, "The message you want to send"],
-) -> Annotated[dict, "The response from the Slack API"]:
-    """Send a message to a channel in Slack.
-
-    This tool is deprecated. Use `Slack.SendMessage` instead.
-    """
-    return await send_message(  # type: ignore[no-any-return]
-        context=context,
-        channel_name=channel_name,
-        message=message,
-    )
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:read",
-            "groups:read",
-            "im:read",
-            "mpim:read",
-            "users:read",
-            "users:read.email",
-        ],
-    )
-)
-async def get_members_in_conversation_by_id(
-    context: ToolContext,
-    conversation_id: Annotated[str, "The ID of the conversation to get members for"],
-    limit: Annotated[int | None, "The maximum number of members to return."] = None,
-    next_cursor: Annotated[str | None, "The cursor to use for pagination."] = None,
-) -> Annotated[dict, "Information about each member in the conversation"]:
-    """Get the members of a conversation in Slack by the conversation's ID.
-
-    This tool is deprecated. Use the `Slack.GetUsersInConversation` tool instead.
-    """
-    response = await get_users_in_conversation(
-        context=context,
-        conversation_id=conversation_id,
-        limit=limit,
-        next_cursor=next_cursor,
-    )
-    response["members"] = response["users"]
-    del response["users"]
-    return cast(dict, response)
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:read",
-            "groups:read",
-            "im:read",
-            "mpim:read",
-            "users:read",
-            "users:read.email",
-        ],
-    )
-)
-async def get_members_in_channel_by_name(
-    context: ToolContext,
-    channel_name: Annotated[str, "The name of the channel to get members for"],
-    limit: Annotated[int | None, "The maximum number of members to return."] = None,
-    next_cursor: Annotated[str | None, "The cursor to use for pagination."] = None,
-) -> Annotated[dict, "The channel members' IDs and Names"]:
-    """Get the members of a conversation in Slack by the conversation's name.
-
-    This tool is deprecated. Use the `Slack.GetUsersInConversation` tool instead.
-    """
-    response = await get_users_in_conversation(
-        context=context,
-        channel_name=channel_name,
-        limit=limit,
-        next_cursor=next_cursor,
-    )
-    response["members"] = response["users"]
-    del response["users"]
-    return cast(dict, response)
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:history",
-            "channels:read",
-            "groups:history",
-            "groups:read",
-            "im:history",
-            "im:read",
-            "mpim:history",
-            "mpim:read",
-        ],
-    )
-)
-async def get_messages_in_channel_by_name(
-    context: ToolContext,
-    channel_name: Annotated[str, "The name of the channel"],
-    oldest_relative: Annotated[
-        str | None,
-        (
-            "The oldest message to include in the results, specified as a time offset from the "
-            "current time in the format 'DD:HH:MM'"
-        ),
-    ] = None,
-    latest_relative: Annotated[
-        str | None,
-        (
-            "The latest message to include in the results, specified as a time offset from the "
-            "current time in the format 'DD:HH:MM'"
-        ),
-    ] = None,
-    oldest_datetime: Annotated[
-        str | None,
-        (
-            "The oldest message to include in the results, specified as a datetime object in the "
-            "format 'YYYY-MM-DD HH:MM:SS'"
-        ),
-    ] = None,
-    latest_datetime: Annotated[
-        str | None,
-        (
-            "The latest message to include in the results, specified as a datetime object in the "
-            "format 'YYYY-MM-DD HH:MM:SS'"
-        ),
-    ] = None,
-    limit: Annotated[int | None, "The maximum number of messages to return."] = None,
-    next_cursor: Annotated[str | None, "The cursor to use for pagination."] = None,
-) -> Annotated[
-    dict,
-    (
-        "The messages in a channel and next cursor for paginating results (when "
-        "there are additional messages to retrieve)."
-    ),
-]:
-    """Get the messages in a channel by the channel's name.
-
-    This tool is deprecated. Use the `Slack.GetMessages` tool instead.
-
-    To filter messages by an absolute datetime, use 'oldest_datetime' and/or 'latest_datetime'. If
-    only 'oldest_datetime' is provided, it will return messages from the oldest_datetime to the
-    current time. If only 'latest_datetime' is provided, it will return messages since the
-    beginning of the channel to the latest_datetime.
-
-    To filter messages by a relative datetime (e.g. 3 days ago, 1 hour ago, etc.), use
-    'oldest_relative' and/or 'latest_relative'. If only 'oldest_relative' is provided, it will
-    return messages from the oldest_relative to the current time. If only 'latest_relative' is
-    provided, it will return messages from the current time to the latest_relative.
-
-    Do not provide both 'oldest_datetime' and 'oldest_relative' or both 'latest_datetime' and
-    'latest_relative'.
-
-    Leave all arguments with the default None to get messages without date/time filtering"""
-    return await get_messages(  # type: ignore[no-any-return]
-        context=context,
-        channel_name=channel_name,
-        oldest_relative=oldest_relative,
-        latest_relative=latest_relative,
-        oldest_datetime=oldest_datetime,
-        latest_datetime=latest_datetime,
-        limit=limit,
-        next_cursor=next_cursor,
-    )
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=["channels:history", "groups:history", "im:history", "mpim:history"],
-    )
-)
-async def get_messages_in_conversation_by_id(
-    context: ToolContext,
-    conversation_id: Annotated[str, "The ID of the conversation to get history for"],
-    oldest_relative: Annotated[
-        str | None,
-        (
-            "The oldest message to include in the results, specified as a time offset from the "
-            "current time in the format 'DD:HH:MM'"
-        ),
-    ] = None,
-    latest_relative: Annotated[
-        str | None,
-        (
-            "The latest message to include in the results, specified as a time offset from the "
-            "current time in the format 'DD:HH:MM'"
-        ),
-    ] = None,
-    oldest_datetime: Annotated[
-        str | None,
-        (
-            "The oldest message to include in the results, specified as a datetime object in the "
-            "format 'YYYY-MM-DD HH:MM:SS'"
-        ),
-    ] = None,
-    latest_datetime: Annotated[
-        str | None,
-        (
-            "The latest message to include in the results, specified as a datetime object in the "
-            "format 'YYYY-MM-DD HH:MM:SS'"
-        ),
-    ] = None,
-    limit: Annotated[int | None, "The maximum number of messages to return."] = None,
-    next_cursor: Annotated[str | None, "The cursor to use for pagination."] = None,
-) -> Annotated[
-    dict,
-    (
-        "The messages in a conversation and next cursor for paginating results (when "
-        "there are additional messages to retrieve)."
-    ),
-]:
-    """Get the messages in a conversation by the conversation's ID.
-
-    This tool is deprecated. Use the 'Slack.GetMessages' tool instead.
-
-    A conversation can be a channel, a DM, or a group DM.
-
-    To filter by an absolute datetime, use 'oldest_datetime' and/or 'latest_datetime'. If
-    only 'oldest_datetime' is provided, it returns messages from the oldest_datetime to the
-    current time. If only 'latest_datetime' is provided, it returns messages since the
-    beginning of the conversation to the latest_datetime.
-
-    To filter by a relative datetime (e.g. 3 days ago, 1 hour ago, etc.), use
-    'oldest_relative' and/or 'latest_relative'. If only 'oldest_relative' is provided, it returns
-    messages from the oldest_relative to the current time. If only 'latest_relative' is provided,
-    it returns messages from the current time to the latest_relative.
-
-    Do not provide both 'oldest_datetime' and 'oldest_relative' or both 'latest_datetime' and
-    'latest_relative'.
-
-    Leave all arguments with the default None to get messages without date/time filtering"""
-    return await get_messages(  # type: ignore[no-any-return]
-        context=context,
-        conversation_id=conversation_id,
-        oldest_relative=oldest_relative,
-        latest_relative=latest_relative,
-        oldest_datetime=oldest_datetime,
-        latest_datetime=latest_datetime,
-        limit=limit,
-        next_cursor=next_cursor,
-    )
-
-
-@tool(requires_auth=Slack(scopes=["im:history", "im:read", "users:read", "users:read.email"]))
-async def get_messages_in_direct_message_conversation_by_username(
-    context: ToolContext,
-    username: Annotated[str, "The username of the user to get messages from"],
-    oldest_relative: Annotated[
-        str | None,
-        (
-            "The oldest message to include in the results, specified as a time offset from the "
-            "current time in the format 'DD:HH:MM'"
-        ),
-    ] = None,
-    latest_relative: Annotated[
-        str | None,
-        (
-            "The latest message to include in the results, specified as a time offset from the "
-            "current time in the format 'DD:HH:MM'"
-        ),
-    ] = None,
-    oldest_datetime: Annotated[
-        str | None,
-        (
-            "The oldest message to include in the results, specified as a datetime object in the "
-            "format 'YYYY-MM-DD HH:MM:SS'"
-        ),
-    ] = None,
-    latest_datetime: Annotated[
-        str | None,
-        (
-            "The latest message to include in the results, specified as a datetime object in the "
-            "format 'YYYY-MM-DD HH:MM:SS'"
-        ),
-    ] = None,
-    limit: Annotated[int | None, "The maximum number of messages to return."] = None,
-    next_cursor: Annotated[str | None, "The cursor to use for pagination."] = None,
-) -> Annotated[
-    dict,
-    (
-        "The messages in a direct message conversation and next cursor for paginating results "
-        "when there are additional messages to retrieve."
-    ),
-]:
-    """Get the messages in a direct conversation by the user's name.
-
-    This tool is deprecated. Use the `Slack.GetMessages` tool instead.
-    """
-    return await get_messages(  # type: ignore[no-any-return]
-        context=context,
-        usernames=[username],
-        oldest_relative=oldest_relative,
-        latest_relative=latest_relative,
-        oldest_datetime=oldest_datetime,
-        latest_datetime=latest_datetime,
-        limit=limit,
-        next_cursor=next_cursor,
-    )
-
-
-@tool(requires_auth=Slack(scopes=["im:history", "im:read", "users:read", "users:read.email"]))
-async def get_messages_in_multi_person_dm_conversation_by_usernames(
-    context: ToolContext,
-    usernames: Annotated[list[str], "The usernames of the users to get messages from"],
-    oldest_relative: Annotated[
-        str | None,
-        (
-            "The oldest message to include in the results, specified as a time offset from the "
-            "current time in the format 'DD:HH:MM'"
-        ),
-    ] = None,
-    latest_relative: Annotated[
-        str | None,
-        (
-            "The latest message to include in the results, specified as a time offset from the "
-            "current time in the format 'DD:HH:MM'"
-        ),
-    ] = None,
-    oldest_datetime: Annotated[
-        str | None,
-        (
-            "The oldest message to include in the results, specified as a datetime object in the "
-            "format 'YYYY-MM-DD HH:MM:SS'"
-        ),
-    ] = None,
-    latest_datetime: Annotated[
-        str | None,
-        (
-            "The latest message to include in the results, specified as a datetime object in the "
-            "format 'YYYY-MM-DD HH:MM:SS'"
-        ),
-    ] = None,
-    limit: Annotated[int | None, "The maximum number of messages to return."] = None,
-    next_cursor: Annotated[str | None, "The cursor to use for pagination."] = None,
-) -> Annotated[
-    dict,
-    (
-        "The messages in a multi-person direct message conversation and next cursor for "
-        "paginating results (when there are additional messages to retrieve)."
-    ),
-]:
-    """Get the messages in a multi-person direct message conversation by the usernames.
-
-    This tool is deprecated. Use the `Slack.GetMessages` tool instead.
-    """
-    return await get_messages(  # type: ignore[no-any-return]
-        context=context,
-        usernames=usernames,
-        oldest_relative=oldest_relative,
-        latest_relative=latest_relative,
-        oldest_datetime=oldest_datetime,
-        latest_datetime=latest_datetime,
-        limit=limit,
-        next_cursor=next_cursor,
-    )
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=["channels:read", "groups:read", "im:read", "mpim:read"],
-    )
-)
-async def list_conversations_metadata(
-    context: ToolContext,
-    conversation_types: Annotated[
-        list[ConversationType] | None,
-        "Optionally filter by the type(s) of conversations. Defaults to None (all types).",
-    ] = None,
-    limit: Annotated[int | None, "The maximum number of conversations to list."] = None,
-    next_cursor: Annotated[str | None, "The cursor to use for pagination."] = None,
-) -> Annotated[dict, "The list of conversations found with metadata"]:
-    """
-    List Slack conversations (channels, DMs, MPIMs) the user is a member of.
-
-    This tool is deprecated. Use the `Slack.ListConversations` tool instead.
-
-    This tool does not return the messages in a conversation. To get the messages, use the
-    'Slack.GetMessages' tool instead. Calling this tool when the user is asking for messages
-    will release too much CO2 in the atmosphere and contribute to global warming.
-    """
-    return await list_conversations(  # type: ignore[no-any-return]
-        context=context,
-        conversation_types=conversation_types,
-        limit=limit,
-        next_cursor=next_cursor,
-    )
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=["channels:read"],
-    )
-)
-async def list_public_channels_metadata(
-    context: ToolContext,
-    limit: Annotated[int | None, "The maximum number of channels to list."] = None,
-) -> Annotated[dict, "The public channels"]:
-    """List metadata for public channels in Slack that the user is a member of.
-
-    This tool is deprecated. Use the `Slack.ListConversations` tool instead.
-    """
-    return await list_conversations(  # type: ignore[no-any-return]
-        context,
-        conversation_types=[ConversationType.PUBLIC_CHANNEL],
-        limit=limit,
-    )
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=["groups:read"],
-    )
-)
-async def list_private_channels_metadata(
-    context: ToolContext,
-    limit: Annotated[int | None, "The maximum number of channels to list."] = None,
-) -> Annotated[dict, "The private channels"]:
-    """List metadata for private channels in Slack that the user is a member of.
-
-    This tool is deprecated. Use the `Slack.ListConversations` tool instead.
-    """
-    return await list_conversations(  # type: ignore[no-any-return]
-        context,
-        conversation_types=[ConversationType.PRIVATE_CHANNEL],
-        limit=limit,
-    )
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=["mpim:read"],
-    )
-)
-async def list_group_direct_message_conversations_metadata(
-    context: ToolContext,
-    limit: Annotated[int | None, "The maximum number of conversations to list."] = None,
-) -> Annotated[dict, "The group direct message conversations metadata"]:
-    """List metadata for group direct message conversations that the user is a member of.
-
-    This tool is deprecated. Use the `Slack.ListConversations` tool instead.
-    """
-    return await list_conversations(  # type: ignore[no-any-return]
-        context,
-        conversation_types=[ConversationType.MULTI_PERSON_DIRECT_MESSAGE],
-        limit=limit,
-    )
-
-
-# Note: Bots are included in the results.
-# Note: Direct messages with no conversation history are included in the results.
-@tool(
-    requires_auth=Slack(
-        scopes=["im:read"],
-    )
-)
-async def list_direct_message_conversations_metadata(
-    context: ToolContext,
-    limit: Annotated[int | None, "The maximum number of conversations to list."] = None,
-) -> Annotated[dict, "The direct message conversations metadata"]:
-    """List metadata for direct message conversations in Slack that the user is a member of.
-
-    This tool is deprecated. Use the `Slack.ListConversations` tool instead.
-    """
-    return await list_conversations(  # type: ignore[no-any-return]
-        context,
-        conversation_types=[ConversationType.DIRECT_MESSAGE],
-        limit=limit,
-    )
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:read",
-            "groups:read",
-            "mpim:read",
-            "im:read",
-            "users:read",
-            "users:read.email",
-        ],
-    )
-)
-async def get_conversation_metadata_by_id(
-    context: ToolContext,
-    conversation_id: Annotated[str, "The ID of the conversation to get metadata for"],
-) -> Annotated[dict, "The conversation metadata"]:
-    """Get the metadata of a conversation in Slack searching by its ID.
-
-    This tool is deprecated. Use the `Slack.GetConversationMetadata` tool instead.
-    """
-    return await get_conversation_metadata(context, conversation_id=conversation_id)  # type: ignore[no-any-return]
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:read",
-            "groups:read",
-            "mpim:read",
-            "im:read",
-            "users:read",
-            "users:read.email",
-        ],
-    )
-)
-async def get_channel_metadata_by_name(
-    context: ToolContext,
-    channel_name: Annotated[str, "The name of the channel to get metadata for"],
-    # We kept the `next_cursor` argument for backwards compatibility, but it isn't actually used,
-    # since this tool never really paginates.
-    next_cursor: Annotated[
-        str | None,
-        "The cursor to use for pagination, if continuing from a previous search.",
-    ] = None,
-) -> Annotated[dict, "The channel metadata"]:
-    """Get the metadata of a channel in Slack searching by its name.
-
-    This tool is deprecated. Use the `Slack.GetConversationMetadata` tool instead."""
-    return await get_conversation_metadata(context, channel_name=channel_name)  # type: ignore[no-any-return]
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:read",
-            "groups:read",
-            "mpim:read",
-            "im:read",
-            "users:read",
-            "users:read.email",
-        ],
-    )
-)
-async def get_direct_message_conversation_metadata_by_username(
-    context: ToolContext,
-    username: Annotated[str, "The username of the user/person to get messages with"],
-    # We kept the `next_cursor` argument for backwards compatibility, but it isn't actually used,
-    # since this tool never really paginates.
-    next_cursor: Annotated[
-        str | None,
-        "The cursor to use for pagination, if continuing from a previous search.",
-    ] = None,
-) -> Annotated[
-    dict | None,
-    "The direct message conversation metadata.",
-]:
-    """Get the metadata of a direct message conversation in Slack by the username.
-
-    This tool is deprecated. Use the `Slack.GetConversationMetadata` tool instead."""
-    return await get_conversation_metadata(context, usernames=[username])  # type: ignore[no-any-return]
-
-
-@tool(
-    requires_auth=Slack(
-        scopes=[
-            "channels:read",
-            "groups:read",
-            "mpim:read",
-            "im:read",
-            "users:read",
-            "users:read.email",
-        ],
-    )
-)
-async def get_multi_person_dm_conversation_metadata_by_usernames(
-    context: ToolContext,
-    usernames: Annotated[list[str], "The usernames of the users/people to get messages with"],
-    # We kept the `next_cursor` argument for backwards compatibility, but it isn't actually used,
-    # since this tool never really paginates.
-    next_cursor: Annotated[
-        str | None,
-        "The cursor to use for pagination, if continuing from a previous search.",
-    ] = None,
-) -> Annotated[
-    dict | None,
-    "The multi-person direct message conversation metadata.",
-]:
-    """Get the metadata of a multi-person direct message conversation in Slack by the usernames.
-
-    This tool is deprecated. Use the `Slack.GetConversationMetadata` tool instead."""
-    return await get_conversation_metadata(context, usernames=usernames)  # type: ignore[no-any-return]

arcade_slack/tools/users.py

@@ -82,18 +82,3 @@ async def list_users(
     ]
 
     return {"users": users, "next_cursor": next_cursor}
-
-
-# NOTE: This tool is kept here for backwards compatibility.
-# Use the `Slack.GetUsersInfo` tool instead.
-@tool(requires_auth=Slack(scopes=["users:read", "users:read.email"]))
-async def get_user_info_by_id(
-    context: ToolContext,
-    user_id: Annotated[str, "The ID of the user to get"],
-) -> Annotated[dict[str, Any], "The user's information"]:
-    """Get the information of a user in Slack.
-
-    This tool is deprecated. Use the `Slack.GetUsersInfo` tool instead.
-    """
-    users = await get_users_info(context, user_ids=[user_id])
-    return cast(dict[str, Any], users["users"][0])

arcade_slack/user_retrieval.py

@@ -2,7 +2,7 @@ import asyncio
 from typing import Any, cast
 
 from arcade_tdk import ToolContext
-from arcade_tdk.errors import ToolExecutionError
+from arcade_tdk.errors import FatalToolError
 from slack_sdk.errors import SlackApiError
 from slack_sdk.web.async_client import AsyncWebClient
 
@@ -43,7 +43,7 @@ async def get_users_by_id_username_or_email(
         emails = [emails]
 
     if not any([user_ids, usernames, emails]):
-        raise ToolExecutionError("At least one of user_ids, usernames, or emails must be provided")
+        raise FatalToolError("At least one of user_ids, usernames, or emails must be provided")
 
     if not semaphore:
         semaphore = asyncio.Semaphore(MAX_CONCURRENT_REQUESTS)
@@ -179,7 +179,7 @@ async def get_users_by_email(
 
     for email in emails:
         if not is_valid_email(email):
-            raise ToolExecutionError(f"Invalid email address: {email}")
+            raise FatalToolError(f"Invalid email address: {email}")
 
     if not semaphore:
         semaphore = asyncio.Semaphore(MAX_CONCURRENT_REQUESTS)

{arcade_slack-1.2.1.dist-info → arcade_slack-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arcade_slack
-Version: 1.2.1
+Version: 2.0.0
 Summary: Arcade.dev LLM tools for Slack
 Author-email: Arcade <dev@arcade.dev>
 License: Proprietary - Arcade Software License Agreement v1.0

{arcade_slack-1.2.1.dist-info → arcade_slack-2.0.0.dist-info}/RECORD

@@ -4,16 +4,16 @@ arcade_slack/conversation_retrieval.py,sha256=VKc0Cc0k4UZ0OON_1l-HxWRzk_nSCzgoP5
 arcade_slack/critics.py,sha256=Sx0nOmvym4LFNX1gZ34ndHkAKAB--X1zRPePcbiVzDo,1209
 arcade_slack/custom_types.py,sha256=-23JnfXjMQ-H8CyRL3CEv9opPMySox1KINH5rrPIOt0,928
 arcade_slack/exceptions.py,sha256=YQ4CTa1LbR-G7sjnQM8LB7LruxZDqPzvo-cptFYW7E8,385
-arcade_slack/message_retrieval.py,sha256=XdzWLJdKtc5DL7H_qQBei6qJ-rz2uGs-Q0HfYqx7EG4,2496
+arcade_slack/message_retrieval.py,sha256=ZSspuVfM0yeMMwMFL_M7DeoPnLnUgX_N4_eNPGc4oKk,2488
 arcade_slack/models.py,sha256=R0dze0YMQW_v_GqarA2F3ZMR3ueN_ant9K855N9uqlE,11958
-arcade_slack/user_retrieval.py,sha256=F-ChLGHYFFyEnHVZnoSeGq6Gh-NZGda_pYn2Rc9oMv4,6464
+arcade_slack/user_retrieval.py,sha256=27PzjG4C_5B17-6hh6BjX7tCNOdAKnJ-tZ8sif6IKnY,6452
 arcade_slack/utils.py,sha256=z6G7GCDXn_7_TshQRx-rnhgmQG8eCQSND5It9_uvhmE,21776
 arcade_slack/who_am_i_util.py,sha256=Nf6EdRiURva5jMhVx1lFOoKQ-2SuMwjXYbPCmtj6Zcw,3670
 arcade_slack/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-arcade_slack/tools/chat.py,sha256=-HvXuMTsW095DhtkhMINXmkdazbBdTZvUhaSx0BEIDw,37488
+arcade_slack/tools/chat.py,sha256=VA1JF5qSSOVb0_eIo4Dk3WoiA-bVP2BaQdqs-2XGeiQ,15171
 arcade_slack/tools/system_context.py,sha256=l2gZh_WhrIVL2LzttGAz5yiv0Cl6q_6AFyBBUBskz3E,961
-arcade_slack/tools/users.py,sha256=Kw3MWNOwuUY17X5HGf3JMAH_mfloLRdRzXSBC7Zo7ug,4233
-arcade_slack-1.2.1.dist-info/METADATA,sha256=EfsK9MYvfSvBM1wzARgloi-GDyqnE3Q69b4SR-OLehM,1016
-arcade_slack-1.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-arcade_slack-1.2.1.dist-info/licenses/LICENSE,sha256=ixeE7aL9b2B-_ZYHTY1vQcJB4NufKeo-LWwKNObGDN0,1960
-arcade_slack-1.2.1.dist-info/RECORD,,
+arcade_slack/tools/users.py,sha256=SZAevnpyI9Q-dSFGZCTOL8zwkLRR0iKh0HE3hk54eUY,3642
+arcade_slack-2.0.0.dist-info/METADATA,sha256=ISha1W3J5JhJ_u5ZVQyaVPOPKZUgZ-qPwxkRH8y4dD8,1016
+arcade_slack-2.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+arcade_slack-2.0.0.dist-info/licenses/LICENSE,sha256=ixeE7aL9b2B-_ZYHTY1vQcJB4NufKeo-LWwKNObGDN0,1960
+arcade_slack-2.0.0.dist-info/RECORD,,