arcade-slack 2.0.0__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/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,
 )
@@ -418,3 +419,98 @@ async def list_conversations(
         ],
         "next_cursor": next_cursor,
     }
+
+
+@tool(
+    requires_auth=Slack(
+        scopes=[
+            "channels:read",
+            "groups:read",
+            "channels:write",
+            "groups:write",
+            "users:read",
+            "users:read.email",
+        ],
+    )
+)
+async def invite_users_to_channel(
+    context: ToolContext,
+    channel_id: Annotated[
+        str | None,
+        "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,
+    channel_name: Annotated[
+        str | None,
+        "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,
+    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,
+    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,
+    emails: Annotated[
+        list[str] | None,
+        "The email addresses of the people to invite.",
+    ] = None,
+) -> Annotated[dict, "The response from inviting users to the conversation"]:
+    """Invite users to a Slack channel or MPIM (multi-person direct message).
+
+    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.
+
+    Provide exactly one of channel_id or channel_name, and at least one of user_ids, usernames,
+    or emails.
+
+    The tool will resolve usernames and emails to user IDs before inviting them.
+    Up to 100 users may be invited at once.
+    """
+    # 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."
+        )
+
+    auth_token = context.get_auth_token_or_empty()
+
+    # 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"]
+
+    # Use the shared helper to invite users
+    invite_result = await invite_users_to_conversation(
+        context=context,
+        conversation_id=cast(str, resolved_channel_id),
+        user_ids=user_ids,
+        usernames=usernames,
+        emails=emails,
+    )
+
+    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}"
+
+    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/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-2.0.0.dist-info → arcade_slack-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arcade_slack
-Version: 2.0.0
+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-2.0.0.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=ZSspuVfM0yeMMwMFL_M7DeoPnLnUgX_N4_eNPGc4oKk,2488
 arcade_slack/models.py,sha256=R0dze0YMQW_v_GqarA2F3ZMR3ueN_ant9K855N9uqlE,11958
 arcade_slack/user_retrieval.py,sha256=27PzjG4C_5B17-6hh6BjX7tCNOdAKnJ-tZ8sif6IKnY,6452
-arcade_slack/utils.py,sha256=z6G7GCDXn_7_TshQRx-rnhgmQG8eCQSND5It9_uvhmE,21776
+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=VA1JF5qSSOVb0_eIo4Dk3WoiA-bVP2BaQdqs-2XGeiQ,15171
+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=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,,
+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-2.0.0.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