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

arcade_slack/critics.py

@@ -4,7 +4,7 @@ from arcade_evals import BinaryCritic
 
 
 class RelativeTimeBinaryCritic(BinaryCritic):
-    def evaluate(self, expected: Any, actual: Any) -> dict[str, float | bool]:
+    def evaluate(self, expected: Any, actual: Any) -> dict[str, Any]:
         """
         Evaluates whether the expected and actual relative time strings are equivalent after
         casting.

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

@@ -21,6 +21,7 @@ from arcade_slack.user_retrieval import (
 from arcade_slack.utils import (
     async_paginate,
     extract_conversation_metadata,
+    invite_users_to_conversation,
     populate_users_in_messages,
     raise_for_users_not_found,
 )
@@ -420,646 +421,96 @@ async def list_conversations(
     }
 
 
-##################################################################################
-# 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",
+            "channels:write",
+            "groups:write",
             "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(
+async def invite_users_to_channel(
     context: ToolContext,
-    conversation_id: Annotated[str, "The ID of the conversation to get history for"],
-    oldest_relative: Annotated[
+    channel_id: 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'"
-        ),
+        "The ID of the Slack channel or MPIM (multi-person direct message) to invite users to. "
+        "Provide exactly one of channel_id OR channel_name.",
     ] = 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[
+    channel_name: 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'"
-        ),
+        "The name of the channel to invite users to. Prefer providing a channel_id when "
+        "available for better performance. Note: MPIMs don't have names, so use channel_id "
+        "for MPIMs.",
     ] = 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'"
-        ),
+    user_ids: Annotated[
+        list[str] | None,
+        "The Slack user IDs of the people to invite. Up to 100 users may be listed. "
+        "Provide at least one of user_ids, usernames, or emails.",
     ] = 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'"
-        ),
+    usernames: Annotated[
+        list[str] | None,
+        "The Slack usernames of the people to invite. Prefer providing user_ids "
+        "and/or emails when available for better performance.",
     ] = 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'"
-        ),
+    emails: Annotated[
+        list[str] | None,
+        "The email addresses of the people to invite.",
     ] = 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.
+) -> Annotated[dict, "The response from inviting users to the conversation"]:
+    """Invite users to a Slack channel or MPIM (multi-person direct message).
 
-    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,
-    )
+    This tool invites specified users to join a Slack conversation. It works with:
+    - Public channels
+    - Private channels
+    - MPIMs (multi-person direct messages / group DMs)
 
+    You can specify users by their user IDs, usernames, or email addresses.
 
-@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.
+    Provide exactly one of channel_id or channel_name, and at least one of user_ids, usernames,
+    or emails.
 
-    This tool is deprecated. Use the `Slack.GetMessages` tool instead.
+    The tool will resolve usernames and emails to user IDs before inviting them.
+    Up to 100 users may be invited at once.
     """
-    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,
-    )
+    # XOR validation: exactly one of channel_id or channel_name must be provided
+    if not ((channel_id is None) ^ (channel_name is None)):
+        raise ToolExecutionError("Provide exactly one of channel_id OR channel_name.")
 
+    if not any([user_ids, usernames, emails]):
+        raise ToolExecutionError(
+            "Provide at least one of user_ids, usernames, or emails to invite."
+        )
 
-@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.
+    auth_token = context.get_auth_token_or_empty()
 
-    This tool is deprecated. Use the `Slack.ListConversations` tool instead.
+    # Resolve channel name to ID if needed
+    resolved_channel_id = channel_id
+    if not resolved_channel_id:
+        channel = await get_channel_by_name(auth_token, cast(str, channel_name))
+        resolved_channel_id = channel["id"]
 
-    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]
+    # Use the shared helper to invite users
+    invite_result = await invite_users_to_conversation(
         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",
-        ],
+        conversation_id=cast(str, resolved_channel_id),
+        user_ids=user_ids,
+        usernames=usernames,
+        emails=emails,
     )
-)
-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]
 
+    invited_channel = invite_result.get("channel", {})
+    channel_display = invited_channel.get("name", resolved_channel_id)
+    message = f"Successfully invited {invite_result['invited_count']} user(s) to {channel_display}"
 
-@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]
+    return {
+        "success": True,
+        "channel_id": resolved_channel_id,
+        "channel_name": invited_channel.get("name"),
+        "invited_user_ids": invite_result["invited_user_ids"],
+        "invited_count": invite_result["invited_count"],
+        "message": message,
+    }

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/utils.py

@@ -7,7 +7,8 @@ from datetime import datetime, timezone
 from typing import Any, cast
 
 from arcade_tdk import ToolContext
-from arcade_tdk.errors import RetryableToolError
+from arcade_tdk.errors import RetryableToolError, ToolExecutionError
+from slack_sdk.web.async_client import AsyncWebClient
 
 from arcade_slack.constants import (
     MAX_CONCURRENT_REQUESTS,
@@ -569,7 +570,7 @@ async def populate_users_in_messages(auth_token: str, messages: list[dict]) -> l
                     reaction["users"] = reaction_users
         # If any data is missing, just leave the message as it is
         except Exception as exc:
-            logger.exception(exc)  # noqa: TRY401
+            logger.exception(exc)
 
     return messages
 
@@ -613,3 +614,114 @@ def get_user_ids_from_messages(messages: list[dict]) -> list[str]:
                 user_ids.extend(reaction.get("users", []))
 
     return user_ids
+
+
+def format_invite_errors(errors: Any) -> str:
+    """Format error messages from Slack invite API partial errors."""
+    if isinstance(errors, list):
+        formatted_errors = []
+        for error in errors:
+            if isinstance(error, dict):
+                error_code = error.get("error") or error.get("code") or error.get("message")
+                user_id = error.get("user") or error.get("user_id")
+                if error_code and user_id:
+                    formatted_errors.append(f"{error_code} ({user_id})")
+                elif error_code:
+                    formatted_errors.append(str(error_code))
+                elif user_id:
+                    formatted_errors.append(f"unknown_error ({user_id})")
+                else:
+                    formatted_errors.append(str(error))
+            else:
+                formatted_errors.append(str(error))
+        if formatted_errors:
+            return ", ".join(formatted_errors)
+
+    return str(errors)
+
+
+def raise_for_invite_errors(errors: Any, conversation_id: str | None) -> None:
+    """Raise ToolExecutionError for partial invite errors from a 200 response.
+
+    Slack's conversations.invite API can return ok: true with an errors array
+    for partial failures. This function handles those cases.
+    """
+    if not errors:
+        return
+
+    error_message = format_invite_errors(errors)
+    raise ToolExecutionError(f"Failed to invite some users to conversation: {error_message}")
+
+
+async def invite_users_to_conversation(
+    context: ToolContext,
+    conversation_id: str,
+    user_ids: list[str] | None = None,
+    usernames: list[str] | None = None,
+    emails: list[str] | None = None,
+) -> dict[str, Any]:
+    """Internal helper to invite users to a conversation (channel or MPIM).
+
+    This function handles the core logic of resolving users and inviting them.
+    It does not wrap errors in try/except - SlackApiError exceptions will bubble
+    up to be handled by the SlackErrorAdapter.
+
+    Args:
+        context: The tool context
+        conversation_id: The ID of the conversation to invite users to
+        user_ids: Optional list of Slack user IDs
+        usernames: Optional list of Slack usernames
+        emails: Optional list of email addresses
+
+    Returns:
+        A dict with invited_user_ids and invited_count
+
+    Raises:
+        ToolExecutionError: If no valid users found or if partial errors occur
+    """
+    from arcade_slack.user_retrieval import get_users_by_id_username_or_email
+
+    # Resolve usernames and emails to user IDs
+    resolved_user_ids = user_ids.copy() if user_ids else []
+
+    if usernames or emails:
+        users = await get_users_by_id_username_or_email(
+            context=context,
+            usernames=usernames,
+            emails=emails,
+        )
+        resolved_user_ids.extend([user["id"] for user in users])
+
+    if not resolved_user_ids:
+        raise ToolExecutionError("No valid users found to invite to the conversation.")
+
+    # Remove duplicates
+    resolved_user_ids = list(set(resolved_user_ids))
+
+    # Limit to 100 users per Slack API requirements
+    if len(resolved_user_ids) > 100:
+        user_count = len(resolved_user_ids)
+        raise ToolExecutionError(
+            f"Cannot invite more than 100 users at once. You provided {user_count} users."
+        )
+
+    slack_client = AsyncWebClient(token=context.get_auth_token_or_empty())
+
+    # Slack expects a comma-separated string of user IDs
+    users_str = ",".join(resolved_user_ids)
+    response = await slack_client.conversations_invite(
+        channel=conversation_id,
+        users=users_str,
+    )
+
+    response_data = cast(dict[str, Any], response.data)
+
+    # Handle partial errors (200 response with errors array)
+    invite_errors = response_data.get("errors")
+    raise_for_invite_errors(invite_errors, conversation_id)
+
+    return {
+        "invited_user_ids": resolved_user_ids,
+        "invited_count": len(resolved_user_ids),
+        "channel": response_data.get("channel", {}),
+    }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arcade_slack
-Version: 1.2.1
+Version: 2.1.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.1.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
 arcade_slack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 arcade_slack/constants.py,sha256=ANAZOmNSqrbZHDqEvQfau7_91if9EeKV-G5D0VBB9vo,524
 arcade_slack/conversation_retrieval.py,sha256=VKc0Cc0k4UZ0OON_1l-HxWRzk_nSCzgoP5lgGyUxLFs,1902
-arcade_slack/critics.py,sha256=Sx0nOmvym4LFNX1gZ34ndHkAKAB--X1zRPePcbiVzDo,1209
+arcade_slack/critics.py,sha256=ZP3jxptwA-8hubUBdhO4cxHrtf_DUAcYt0-TVCXF2AQ,1200
 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/utils.py,sha256=z6G7GCDXn_7_TshQRx-rnhgmQG8eCQSND5It9_uvhmE,21776
+arcade_slack/user_retrieval.py,sha256=27PzjG4C_5B17-6hh6BjX7tCNOdAKnJ-tZ8sif6IKnY,6452
+arcade_slack/utils.py,sha256=WQXxUMB75GpYZkqhhXBc3NRZOYFlmGFrSM_aT2EtvUo,25840
 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=g7H9aJs8VZod-rMHSaSiAwBUKPY96jvib8DFlmvTTPE,18681
 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.1.0.dist-info/METADATA,sha256=lzqZsfeggbNG1lF-CJdX-T7BHXK0-jN2OZXSZFpMi54,1016
+arcade_slack-2.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+arcade_slack-2.1.0.dist-info/licenses/LICENSE,sha256=ixeE7aL9b2B-_ZYHTY1vQcJB4NufKeo-LWwKNObGDN0,1960
+arcade_slack-2.1.0.dist-info/RECORD,,

{arcade_slack-1.2.1.dist-info → arcade_slack-2.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any